1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 *	Original driver code supplied by Multi-Tech
   4 *
   5 *	Changes
   6 *	1/9/98	alan@lxorguk.ukuu.org.uk
   7 *					Merge to 2.0.x kernel tree
   8 *					Obtain and use official major/minors
   9 *					Loader switched to a misc device
  10 *					(fixed range check bug as a side effect)
  11 *					Printk clean up
  12 *	9/12/98	alan@lxorguk.ukuu.org.uk
  13 *					Rough port to 2.1.x
  14 *
  15 *	10/6/99 sameer			Merged the ISA and PCI drivers to
  16 *					a new unified driver.
  17 *
  18 *	3/9/99	sameer			Added support for ISI4616 cards.
  19 *
  20 *	16/9/99	sameer			We do not force RTS low anymore.
  21 *					This is to prevent the firmware
  22 *					from getting confused.
  23 *
  24 *	26/10/99 sameer			Cosmetic changes:The driver now
  25 *					dumps the Port Count information
  26 *					along with I/O address and IRQ.
  27 *
  28 *	13/12/99 sameer			Fixed the problem with IRQ sharing.
  29 *
  30 *	10/5/00  sameer			Fixed isicom_shutdown_board()
  31 *					to not lower DTR on all the ports
  32 *					when the last port on the card is
  33 *					closed.
  34 *
  35 *	10/5/00  sameer			Signal mask setup command added
  36 *					to  isicom_setup_port and
  37 *					isicom_shutdown_port.
  38 *
  39 *	24/5/00  sameer			The driver is now SMP aware.
  40 *
  41 *
  42 *	27/11/00 Vinayak P Risbud	Fixed the Driver Crash Problem
  43 *
  44 *
  45 *	03/01/01  anil .s		Added support for resetting the
  46 *					internal modems on ISI cards.
  47 *
  48 *	08/02/01  anil .s		Upgraded the driver for kernel
  49 *					2.4.x
  50 *
  51 *	11/04/01  Kevin			Fixed firmware load problem with
  52 *					ISIHP-4X card
  53 *
  54 *	30/04/01  anil .s		Fixed the remote login through
  55 *					ISI port problem. Now the link
  56 *					does not go down before password
  57 *					prompt.
  58 *
  59 *	03/05/01  anil .s		Fixed the problem with IRQ sharing
  60 *					among ISI-PCI cards.
  61 *
  62 *	03/05/01  anil .s		Added support to display the version
  63 *					info during insmod as well as module
  64 *					listing by lsmod.
  65 *
  66 *	10/05/01  anil .s		Done the modifications to the source
  67 *					file and Install script so that the
  68 *					same installation can be used for
  69 *					2.2.x and 2.4.x kernel.
  70 *
  71 *	06/06/01  anil .s		Now we drop both dtr and rts during
  72 *					shutdown_port as well as raise them
  73 *					during isicom_config_port.
  74 *
  75 *	09/06/01 acme@conectiva.com.br	use capable, not suser, do
  76 *					restore_flags on failure in
  77 *					isicom_send_break, verify put_user
  78 *					result
  79 *
  80 *	11/02/03  ranjeeth		Added support for 230 Kbps and 460 Kbps
  81 *					Baud index extended to 21
  82 *
  83 *	20/03/03  ranjeeth		Made to work for Linux Advanced server.
  84 *					Taken care of license warning.
  85 *
  86 *	10/12/03  Ravindra		Made to work for Fedora Core 1 of
  87 *					Red Hat Distribution
  88 *
  89 *	06/01/05  Alan Cox 		Merged the ISI and base kernel strands
  90 *					into a single 2.6 driver
  91 *
  92 *	***********************************************************
  93 *
  94 *	To use this driver you also need the support package. You
  95 *	can find this in RPM format on
  96 *		ftp://ftp.linux.org.uk/pub/linux/alan
  97 *
  98 *	You can find the original tools for this direct from Multitech
  99 *		ftp://ftp.multitech.com/ISI-Cards/
 100 *
 101 *	Having installed the cards the module options (/etc/modprobe.d/)
 102 *
 103 *	options isicom   io=card1,card2,card3,card4 irq=card1,card2,card3,card4
 104 *
 105 *	Omit those entries for boards you don't have installed.
 106 *
 107 *	TODO
 108 *		Merge testing
 109 *		64-bit verification
 110 */
 111
 112#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 113
 114#include <linux/module.h>
 115#include <linux/firmware.h>
 116#include <linux/kernel.h>
 117#include <linux/tty.h>
 118#include <linux/tty_flip.h>
 119#include <linux/termios.h>
 120#include <linux/fs.h>
 121#include <linux/sched.h>
 122#include <linux/serial.h>
 123#include <linux/mm.h>
 124#include <linux/interrupt.h>
 125#include <linux/timer.h>
 126#include <linux/delay.h>
 127#include <linux/ioport.h>
 128#include <linux/slab.h>
 129
 130#include <linux/uaccess.h>
 131#include <linux/io.h>
 132
 133#include <linux/pci.h>
 134
 135#include <linux/isicom.h>
 136
 137#define InterruptTheCard(base) outw(0, (base) + 0xc)
 138#define ClearInterrupt(base) inw((base) + 0x0a)
 139
 140#ifdef DEBUG
 141#define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
 142#else
 143#define isicom_paranoia_check(a, b, c) 0
 144#endif
 145
 146static int isicom_probe(struct pci_dev *, const struct pci_device_id *);
 147static void isicom_remove(struct pci_dev *);
 148
 149static const struct pci_device_id isicom_pci_tbl[] = {
 150	{ PCI_DEVICE(VENDOR_ID, 0x2028) },
 151	{ PCI_DEVICE(VENDOR_ID, 0x2051) },
 152	{ PCI_DEVICE(VENDOR_ID, 0x2052) },
 153	{ PCI_DEVICE(VENDOR_ID, 0x2053) },
 154	{ PCI_DEVICE(VENDOR_ID, 0x2054) },
 155	{ PCI_DEVICE(VENDOR_ID, 0x2055) },
 156	{ PCI_DEVICE(VENDOR_ID, 0x2056) },
 157	{ PCI_DEVICE(VENDOR_ID, 0x2057) },
 158	{ PCI_DEVICE(VENDOR_ID, 0x2058) },
 159	{ 0 }
 160};
 161MODULE_DEVICE_TABLE(pci, isicom_pci_tbl);
 162
 163static struct pci_driver isicom_driver = {
 164	.name		= "isicom",
 165	.id_table	= isicom_pci_tbl,
 166	.probe		= isicom_probe,
 167	.remove		= isicom_remove
 168};
 169
 170static int prev_card = 3;	/*	start servicing isi_card[0]	*/
 171static struct tty_driver *isicom_normal;
 172
 173static void isicom_tx(struct timer_list *unused);
 174static void isicom_start(struct tty_struct *tty);
 175
 176static DEFINE_TIMER(tx, isicom_tx);
 177
 178/*   baud index mappings from linux defns to isi */
 179
 180static signed char linuxb_to_isib[] = {
 181	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 16, 17, 18, 19, 20, 21
 182};
 183
 184struct	isi_board {
 185	unsigned long		base;
 186	int			irq;
 187	unsigned char		port_count;
 188	unsigned short		status;
 189	unsigned short		port_status; /* each bit for each port */
 190	unsigned short		shift_count;
 191	struct isi_port		*ports;
 192	signed char		count;
 193	spinlock_t		card_lock; /* Card wide lock 11/5/00 -sameer */
 194	unsigned long		flags;
 195	unsigned int		index;
 196};
 197
 198struct	isi_port {
 199	unsigned short		magic;
 200	struct tty_port		port;
 201	u16			channel;
 202	u16			status;
 203	struct isi_board	*card;
 204	unsigned char		*xmit_buf;
 205	int			xmit_head;
 206	int			xmit_tail;
 207	int			xmit_cnt;
 208};
 209
 210static struct isi_board isi_card[BOARD_COUNT];
 211static struct isi_port  isi_ports[PORT_COUNT];
 212
 213/*
 214 *	Locking functions for card level locking. We need to own both
 215 *	the kernel lock for the card and have the card in a position that
 216 *	it wants to talk.
 217 */
 218
 219static int WaitTillCardIsFree(unsigned long base)
 220{
 221	unsigned int count = 0;
 222
 223	while (!(inw(base + 0xe) & 0x1) && count++ < 100)
 224		mdelay(1);
 225
 226	return !(inw(base + 0xe) & 0x1);
 227}
 228
 229static int lock_card(struct isi_board *card)
 230{
 231	unsigned long base = card->base;
 232	unsigned int retries, a;
 233
 234	for (retries = 0; retries < 10; retries++) {
 235		spin_lock_irqsave(&card->card_lock, card->flags);
 236		for (a = 0; a < 10; a++) {
 237			if (inw(base + 0xe) & 0x1)
 238				return 1;
 239			udelay(10);
 240		}
 241		spin_unlock_irqrestore(&card->card_lock, card->flags);
 242		msleep(10);
 243	}
 244	pr_warn("Failed to lock Card (0x%lx)\n", card->base);
 245
 246	return 0;	/* Failed to acquire the card! */
 247}
 248
 249static void unlock_card(struct isi_board *card)
 250{
 251	spin_unlock_irqrestore(&card->card_lock, card->flags);
 252}
 253
 254/*
 255 *  ISI Card specific ops ...
 256 */
 257
 258/* card->lock HAS to be held */
 259static void raise_dtr(struct isi_port *port)
 260{
 261	struct isi_board *card = port->card;
 262	unsigned long base = card->base;
 263	u16 channel = port->channel;
 264
 265	if (WaitTillCardIsFree(base))
 266		return;
 267
 268	outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 269	outw(0x0504, base);
 270	InterruptTheCard(base);
 271	port->status |= ISI_DTR;
 272}
 273
 274/* card->lock HAS to be held */
 275static void drop_dtr(struct isi_port *port)
 276{
 277	struct isi_board *card = port->card;
 278	unsigned long base = card->base;
 279	u16 channel = port->channel;
 280
 281	if (WaitTillCardIsFree(base))
 282		return;
 283
 284	outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 285	outw(0x0404, base);
 286	InterruptTheCard(base);
 287	port->status &= ~ISI_DTR;
 288}
 289
 290/* card->lock HAS to be held */
 291static inline void raise_rts(struct isi_port *port)
 292{
 293	struct isi_board *card = port->card;
 294	unsigned long base = card->base;
 295	u16 channel = port->channel;
 296
 297	if (WaitTillCardIsFree(base))
 298		return;
 299
 300	outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 301	outw(0x0a04, base);
 302	InterruptTheCard(base);
 303	port->status |= ISI_RTS;
 304}
 305
 306/* card->lock HAS to be held */
 307static inline void drop_rts(struct isi_port *port)
 308{
 309	struct isi_board *card = port->card;
 310	unsigned long base = card->base;
 311	u16 channel = port->channel;
 312
 313	if (WaitTillCardIsFree(base))
 314		return;
 315
 316	outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 317	outw(0x0804, base);
 318	InterruptTheCard(base);
 319	port->status &= ~ISI_RTS;
 320}
 321
 322/* card->lock MUST NOT be held */
 323
 324static void isicom_dtr_rts(struct tty_port *port, int on)
 325{
 326	struct isi_port *ip = container_of(port, struct isi_port, port);
 327	struct isi_board *card = ip->card;
 328	unsigned long base = card->base;
 329	u16 channel = ip->channel;
 330
 331	if (!lock_card(card))
 332		return;
 333
 334	if (on) {
 335		outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 336		outw(0x0f04, base);
 337		InterruptTheCard(base);
 338		ip->status |= (ISI_DTR | ISI_RTS);
 339	} else {
 340		outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 341		outw(0x0C04, base);
 342		InterruptTheCard(base);
 343		ip->status &= ~(ISI_DTR | ISI_RTS);
 344	}
 345	unlock_card(card);
 346}
 347
 348/* card->lock HAS to be held */
 349static void drop_dtr_rts(struct isi_port *port)
 350{
 351	struct isi_board *card = port->card;
 352	unsigned long base = card->base;
 353	u16 channel = port->channel;
 354
 355	if (WaitTillCardIsFree(base))
 356		return;
 357
 358	outw(0x8000 | (channel << card->shift_count) | 0x02, base);
 359	outw(0x0c04, base);
 360	InterruptTheCard(base);
 361	port->status &= ~(ISI_RTS | ISI_DTR);
 362}
 363
 364/*
 365 *	ISICOM Driver specific routines ...
 366 *
 367 */
 368
 369static inline int __isicom_paranoia_check(struct isi_port const *port,
 370	char *name, const char *routine)
 371{
 372	if (!port) {
 373		pr_warn("Warning: bad isicom magic for dev %s in %s\n",
 374			name, routine);
 375		return 1;
 376	}
 377	if (port->magic != ISICOM_MAGIC) {
 378		pr_warn("Warning: NULL isicom port for dev %s in %s\n",
 379			name, routine);
 380		return 1;
 381	}
 382
 383	return 0;
 384}
 385
 386/*
 387 *	Transmitter.
 388 *
 389 *	We shovel data into the card buffers on a regular basis. The card
 390 *	will do the rest of the work for us.
 391 */
 392
 393static void isicom_tx(struct timer_list *unused)
 394{
 395	unsigned long flags, base;
 396	unsigned int retries;
 397	short count = (BOARD_COUNT-1), card;
 398	short txcount, wrd, residue, word_count, cnt;
 399	struct isi_port *port;
 400	struct tty_struct *tty;
 401
 402	/*	find next active board	*/
 403	card = (prev_card + 1) & 0x0003;
 404	while (count-- > 0) {
 405		if (isi_card[card].status & BOARD_ACTIVE)
 406			break;
 407		card = (card + 1) & 0x0003;
 408	}
 409	if (!(isi_card[card].status & BOARD_ACTIVE))
 410		goto sched_again;
 411
 412	prev_card = card;
 413
 414	count = isi_card[card].port_count;
 415	port = isi_card[card].ports;
 416	base = isi_card[card].base;
 417
 418	spin_lock_irqsave(&isi_card[card].card_lock, flags);
 419	for (retries = 0; retries < 100; retries++) {
 420		if (inw(base + 0xe) & 0x1)
 421			break;
 422		udelay(2);
 423	}
 424	if (retries >= 100)
 425		goto unlock;
 426
 427	tty = tty_port_tty_get(&port->port);
 428	if (tty == NULL)
 429		goto put_unlock;
 430
 431	for (; count > 0; count--, port++) {
 432		/* port not active or tx disabled to force flow control */
 433		if (!tty_port_initialized(&port->port) ||
 434			!(port->status & ISI_TXOK))
 435			continue;
 436
 437		txcount = min_t(short, TX_SIZE, port->xmit_cnt);
 438		if (txcount <= 0 || tty->stopped || tty->hw_stopped)
 439			continue;
 440
 441		if (!(inw(base + 0x02) & (1 << port->channel)))
 442			continue;
 443
 444		pr_debug("txing %d bytes, port%d.\n",
 445			 txcount, port->channel + 1);
 446		outw((port->channel << isi_card[card].shift_count) | txcount,
 447			base);
 448		residue = NO;
 449		wrd = 0;
 450		while (1) {
 451			cnt = min_t(int, txcount, (SERIAL_XMIT_SIZE
 452					- port->xmit_tail));
 453			if (residue == YES) {
 454				residue = NO;
 455				if (cnt > 0) {
 456					wrd |= (port->port.xmit_buf[port->xmit_tail]
 457									<< 8);
 458					port->xmit_tail = (port->xmit_tail + 1)
 459						& (SERIAL_XMIT_SIZE - 1);
 460					port->xmit_cnt--;
 461					txcount--;
 462					cnt--;
 463					outw(wrd, base);
 464				} else {
 465					outw(wrd, base);
 466					break;
 467				}
 468			}
 469			if (cnt <= 0)
 470				break;
 471			word_count = cnt >> 1;
 472			outsw(base, port->port.xmit_buf+port->xmit_tail, word_count);
 473			port->xmit_tail = (port->xmit_tail
 474				+ (word_count << 1)) & (SERIAL_XMIT_SIZE - 1);
 475			txcount -= (word_count << 1);
 476			port->xmit_cnt -= (word_count << 1);
 477			if (cnt & 0x0001) {
 478				residue = YES;
 479				wrd = port->port.xmit_buf[port->xmit_tail];
 480				port->xmit_tail = (port->xmit_tail + 1)
 481					& (SERIAL_XMIT_SIZE - 1);
 482				port->xmit_cnt--;
 483				txcount--;
 484			}
 485		}
 486
 487		InterruptTheCard(base);
 488		if (port->xmit_cnt <= 0)
 489			port->status &= ~ISI_TXOK;
 490		if (port->xmit_cnt <= WAKEUP_CHARS)
 491			tty_wakeup(tty);
 492	}
 493
 494put_unlock:
 495	tty_kref_put(tty);
 496unlock:
 497	spin_unlock_irqrestore(&isi_card[card].card_lock, flags);
 498	/*	schedule another tx for hopefully in about 10ms	*/
 499sched_again:
 500	mod_timer(&tx, jiffies + msecs_to_jiffies(10));
 501}
 502
 503/*
 504 *	Main interrupt handler routine
 505 */
 506
 507static irqreturn_t isicom_interrupt(int irq, void *dev_id)
 508{
 509	struct isi_board *card = dev_id;
 510	struct isi_port *port;
 511	struct tty_struct *tty;
 512	unsigned long base;
 513	u16 header, word_count, count, channel;
 514	short byte_count;
 515	unsigned char *rp;
 516
 517	if (!card || !(card->status & FIRMWARE_LOADED))
 518		return IRQ_NONE;
 519
 520	base = card->base;
 521
 522	/* did the card interrupt us? */
 523	if (!(inw(base + 0x0e) & 0x02))
 524		return IRQ_NONE;
 525
 526	spin_lock(&card->card_lock);
 527
 528	/*
 529	 * disable any interrupts from the PCI card and lower the
 530	 * interrupt line
 531	 */
 532	outw(0x8000, base+0x04);
 533	ClearInterrupt(base);
 534
 535	inw(base);		/* get the dummy word out */
 536	header = inw(base);
 537	channel = (header & 0x7800) >> card->shift_count;
 538	byte_count = header & 0xff;
 539
 540	if (channel + 1 > card->port_count) {
 541		pr_warn("%s(0x%lx): %d(channel) > port_count\n",
 542			__func__, base, channel + 1);
 543		outw(0x0000, base+0x04); /* enable interrupts */
 544		spin_unlock(&card->card_lock);
 545		return IRQ_HANDLED;
 546	}
 547	port = card->ports + channel;
 548	if (!tty_port_initialized(&port->port)) {
 549		outw(0x0000, base+0x04); /* enable interrupts */
 550		spin_unlock(&card->card_lock);
 551		return IRQ_HANDLED;
 552	}
 553
 554	tty = tty_port_tty_get(&port->port);
 555	if (tty == NULL) {
 556		while (byte_count > 1) {
 557			inw(base);
 558			byte_count -= 2;
 559		}
 560		if (byte_count & 0x01)
 561			inw(base);
 562		outw(0x0000, base+0x04); /* enable interrupts */
 563		spin_unlock(&card->card_lock);
 564		return IRQ_HANDLED;
 565	}
 566
 567	if (header & 0x8000) {		/* Status Packet */
 568		header = inw(base);
 569		switch (header & 0xff) {
 570		case 0:	/* Change in EIA signals */
 571			if (tty_port_check_carrier(&port->port)) {
 572				if (port->status & ISI_DCD) {
 573					if (!(header & ISI_DCD)) {
 574					/* Carrier has been lost  */
 575						pr_debug("%s: DCD->low.\n",
 576							 __func__);
 577						port->status &= ~ISI_DCD;
 578						tty_hangup(tty);
 579					}
 580				} else if (header & ISI_DCD) {
 581				/* Carrier has been detected */
 582					pr_debug("%s: DCD->high.\n",
 583						__func__);
 584					port->status |= ISI_DCD;
 585					wake_up_interruptible(&port->port.open_wait);
 586				}
 587			} else {
 588				if (header & ISI_DCD)
 589					port->status |= ISI_DCD;
 590				else
 591					port->status &= ~ISI_DCD;
 592			}
 593
 594			if (tty_port_cts_enabled(&port->port)) {
 595				if (tty->hw_stopped) {
 596					if (header & ISI_CTS) {
 597						tty->hw_stopped = 0;
 598						/* start tx ing */
 599						port->status |= (ISI_TXOK
 600							| ISI_CTS);
 601						tty_wakeup(tty);
 602					}
 603				} else if (!(header & ISI_CTS)) {
 604					tty->hw_stopped = 1;
 605					/* stop tx ing */
 606					port->status &= ~(ISI_TXOK | ISI_CTS);
 607				}
 608			} else {
 609				if (header & ISI_CTS)
 610					port->status |= ISI_CTS;
 611				else
 612					port->status &= ~ISI_CTS;
 613			}
 614
 615			if (header & ISI_DSR)
 616				port->status |= ISI_DSR;
 617			else
 618				port->status &= ~ISI_DSR;
 619
 620			if (header & ISI_RI)
 621				port->status |= ISI_RI;
 622			else
 623				port->status &= ~ISI_RI;
 624
 625			break;
 626
 627		case 1:	/* Received Break !!! */
 628			tty_insert_flip_char(&port->port, 0, TTY_BREAK);
 629			if (port->port.flags & ASYNC_SAK)
 630				do_SAK(tty);
 631			tty_flip_buffer_push(&port->port);
 632			break;
 633
 634		case 2:	/* Statistics		 */
 635			pr_debug("%s: stats!!!\n", __func__);
 636			break;
 637
 638		default:
 639			pr_debug("%s: Unknown code in status packet.\n",
 640				 __func__);
 641			break;
 642		}
 643	} else {				/* Data   Packet */
 644		count = tty_prepare_flip_string(&port->port, &rp,
 645				byte_count & ~1);
 646		pr_debug("%s: Can rx %d of %d bytes.\n",
 647			 __func__, count, byte_count);
 648		word_count = count >> 1;
 649		insw(base, rp, word_count);
 650		byte_count -= (word_count << 1);
 651		if (count & 0x0001) {
 652			tty_insert_flip_char(&port->port, inw(base) & 0xff,
 653				TTY_NORMAL);
 654			byte_count -= 2;
 655		}
 656		if (byte_count > 0) {
 657			pr_debug("%s(0x%lx:%d): Flip buffer overflow! dropping bytes...\n",
 658				 __func__, base, channel + 1);
 659		/* drain out unread xtra data */
 660		while (byte_count > 0) {
 661				inw(base);
 662				byte_count -= 2;
 663			}
 664		}
 665		tty_flip_buffer_push(&port->port);
 666	}
 667	outw(0x0000, base+0x04); /* enable interrupts */
 668	spin_unlock(&card->card_lock);
 669	tty_kref_put(tty);
 670
 671	return IRQ_HANDLED;
 672}
 673
 674static void isicom_config_port(struct tty_struct *tty)
 675{
 676	struct isi_port *port = tty->driver_data;
 677	struct isi_board *card = port->card;
 678	unsigned long baud;
 679	unsigned long base = card->base;
 680	u16 channel_setup, channel = port->channel,
 681		shift_count = card->shift_count;
 682	unsigned char flow_ctrl;
 683
 684	/* FIXME: Switch to new tty baud API */
 685	baud = C_BAUD(tty);
 686	if (baud & CBAUDEX) {
 687		baud &= ~CBAUDEX;
 688
 689		/*  if CBAUDEX bit is on and the baud is set to either 50 or 75
 690		 *  then the card is programmed for 57.6Kbps or 115Kbps
 691		 *  respectively.
 692		 */
 693
 694		/* 1,2,3,4 => 57.6, 115.2, 230, 460 kbps resp. */
 695		if (baud < 1 || baud > 4)
 696			tty->termios.c_cflag &= ~CBAUDEX;
 697		else
 698			baud += 15;
 699	}
 700	if (baud == 15) {
 701
 702		/*  the ASYNC_SPD_HI and ASYNC_SPD_VHI options are set
 703		 *  by the set_serial_info ioctl ... this is done by
 704		 *  the 'setserial' utility.
 705		 */
 706
 707		if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 708			baud++; /*  57.6 Kbps */
 709		if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 710			baud += 2; /*  115  Kbps */
 711		if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
 712			baud += 3; /* 230 kbps*/
 713		if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
 714			baud += 4; /* 460 kbps*/
 715	}
 716	if (linuxb_to_isib[baud] == -1) {
 717		/* hang up */
 718		drop_dtr(port);
 719		return;
 720	} else
 721		raise_dtr(port);
 722
 723	if (WaitTillCardIsFree(base) == 0) {
 724		outw(0x8000 | (channel << shift_count) | 0x03, base);
 725		outw(linuxb_to_isib[baud] << 8 | 0x03, base);
 726		channel_setup = 0;
 727		switch (C_CSIZE(tty)) {
 728		case CS5:
 729			channel_setup |= ISICOM_CS5;
 730			break;
 731		case CS6:
 732			channel_setup |= ISICOM_CS6;
 733			break;
 734		case CS7:
 735			channel_setup |= ISICOM_CS7;
 736			break;
 737		case CS8:
 738			channel_setup |= ISICOM_CS8;
 739			break;
 740		}
 741
 742		if (C_CSTOPB(tty))
 743			channel_setup |= ISICOM_2SB;
 744		if (C_PARENB(tty)) {
 745			channel_setup |= ISICOM_EVPAR;
 746			if (C_PARODD(tty))
 747				channel_setup |= ISICOM_ODPAR;
 748		}
 749		outw(channel_setup, base);
 750		InterruptTheCard(base);
 751	}
 752	tty_port_set_check_carrier(&port->port, !C_CLOCAL(tty));
 753
 754	/* flow control settings ...*/
 755	flow_ctrl = 0;
 756	tty_port_set_cts_flow(&port->port, C_CRTSCTS(tty));
 757	if (C_CRTSCTS(tty))
 758		flow_ctrl |= ISICOM_CTSRTS;
 759	if (I_IXON(tty))
 760		flow_ctrl |= ISICOM_RESPOND_XONXOFF;
 761	if (I_IXOFF(tty))
 762		flow_ctrl |= ISICOM_INITIATE_XONXOFF;
 763
 764	if (WaitTillCardIsFree(base) == 0) {
 765		outw(0x8000 | (channel << shift_count) | 0x04, base);
 766		outw(flow_ctrl << 8 | 0x05, base);
 767		outw((STOP_CHAR(tty)) << 8 | (START_CHAR(tty)), base);
 768		InterruptTheCard(base);
 769	}
 770
 771	/*	rx enabled -> enable port for rx on the card	*/
 772	if (C_CREAD(tty)) {
 773		card->port_status |= (1 << channel);
 774		outw(card->port_status, base + 0x02);
 775	}
 776}
 777
 778/* open et all */
 779
 780static inline void isicom_setup_board(struct isi_board *bp)
 781{
 782	int channel;
 783	struct isi_port *port;
 784
 785	bp->count++;
 786	if (!(bp->status & BOARD_INIT)) {
 787		port = bp->ports;
 788		for (channel = 0; channel < bp->port_count; channel++, port++)
 789			drop_dtr_rts(port);
 790	}
 791	bp->status |= BOARD_ACTIVE | BOARD_INIT;
 792}
 793
 794/* Activate and thus setup board are protected from races against shutdown
 795   by the tty_port mutex */
 796
 797static int isicom_activate(struct tty_port *tport, struct tty_struct *tty)
 798{
 799	struct isi_port *port = container_of(tport, struct isi_port, port);
 800	struct isi_board *card = port->card;
 801	unsigned long flags;
 802
 803	if (tty_port_alloc_xmit_buf(tport) < 0)
 804		return -ENOMEM;
 805
 806	spin_lock_irqsave(&card->card_lock, flags);
 807	isicom_setup_board(card);
 808
 809	port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
 810
 811	/*	discard any residual data	*/
 812	if (WaitTillCardIsFree(card->base) == 0) {
 813		outw(0x8000 | (port->channel << card->shift_count) | 0x02,
 814				card->base);
 815		outw(((ISICOM_KILLTX | ISICOM_KILLRX) << 8) | 0x06, card->base);
 816		InterruptTheCard(card->base);
 817	}
 818	isicom_config_port(tty);
 819	spin_unlock_irqrestore(&card->card_lock, flags);
 820
 821	return 0;
 822}
 823
 824static int isicom_carrier_raised(struct tty_port *port)
 825{
 826	struct isi_port *ip = container_of(port, struct isi_port, port);
 827	return (ip->status & ISI_DCD)?1 : 0;
 828}
 829
 830static struct tty_port *isicom_find_port(struct tty_struct *tty)
 831{
 832	struct isi_port *port;
 833	struct isi_board *card;
 834	unsigned int board;
 835	int line = tty->index;
 836
 837	board = BOARD(line);
 838	card = &isi_card[board];
 839
 840	if (!(card->status & FIRMWARE_LOADED))
 841		return NULL;
 842
 843	/*  open on a port greater than the port count for the card !!! */
 844	if (line > ((board * 16) + card->port_count - 1))
 845		return NULL;
 846
 847	port = &isi_ports[line];
 848	if (isicom_paranoia_check(port, tty->name, "isicom_open"))
 849		return NULL;
 850
 851	return &port->port;
 852}
 853
 854static int isicom_open(struct tty_struct *tty, struct file *filp)
 855{
 856	struct isi_port *port;
 857	struct tty_port *tport;
 858
 859	tport = isicom_find_port(tty);
 860	if (tport == NULL)
 861		return -ENODEV;
 862	port = container_of(tport, struct isi_port, port);
 863
 864	tty->driver_data = port;
 865	return tty_port_open(tport, tty, filp);
 866}
 867
 868/* close et all */
 869
 870/* card->lock HAS to be held */
 871static void isicom_shutdown_port(struct isi_port *port)
 872{
 873	struct isi_board *card = port->card;
 874
 875	if (--card->count < 0) {
 876		pr_debug("%s: bad board(0x%lx) count %d.\n",
 877			 __func__, card->base, card->count);
 878		card->count = 0;
 879	}
 880	/* last port was closed, shutdown that board too */
 881	if (!card->count)
 882		card->status &= BOARD_ACTIVE;
 883}
 884
 885static void isicom_flush_buffer(struct tty_struct *tty)
 886{
 887	struct isi_port *port = tty->driver_data;
 888	struct isi_board *card = port->card;
 889	unsigned long flags;
 890
 891	if (isicom_paranoia_check(port, tty->name, "isicom_flush_buffer"))
 892		return;
 893
 894	spin_lock_irqsave(&card->card_lock, flags);
 895	port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
 896	spin_unlock_irqrestore(&card->card_lock, flags);
 897
 898	tty_wakeup(tty);
 899}
 900
 901static void isicom_shutdown(struct tty_port *port)
 902{
 903	struct isi_port *ip = container_of(port, struct isi_port, port);
 904	struct isi_board *card = ip->card;
 905	unsigned long flags;
 906
 907	/* indicate to the card that no more data can be received
 908	   on this port */
 909	spin_lock_irqsave(&card->card_lock, flags);
 910	card->port_status &= ~(1 << ip->channel);
 911	outw(card->port_status, card->base + 0x02);
 912	isicom_shutdown_port(ip);
 913	spin_unlock_irqrestore(&card->card_lock, flags);
 914	tty_port_free_xmit_buf(port);
 915}
 916
 917static void isicom_close(struct tty_struct *tty, struct file *filp)
 918{
 919	struct isi_port *ip = tty->driver_data;
 920	struct tty_port *port;
 921
 922	if (ip == NULL)
 923		return;
 924
 925	port = &ip->port;
 926	if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
 927		return;
 928	tty_port_close(port, tty, filp);
 929}
 930
 931/* write et all */
 932static int isicom_write(struct tty_struct *tty,	const unsigned char *buf,
 933	int count)
 934{
 935	struct isi_port *port = tty->driver_data;
 936	struct isi_board *card = port->card;
 937	unsigned long flags;
 938	int cnt, total = 0;
 939
 940	if (isicom_paranoia_check(port, tty->name, "isicom_write"))
 941		return 0;
 942
 943	spin_lock_irqsave(&card->card_lock, flags);
 944
 945	while (1) {
 946		cnt = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt
 947				- 1, SERIAL_XMIT_SIZE - port->xmit_head));
 948		if (cnt <= 0)
 949			break;
 950
 951		memcpy(port->port.xmit_buf + port->xmit_head, buf, cnt);
 952		port->xmit_head = (port->xmit_head + cnt) & (SERIAL_XMIT_SIZE
 953			- 1);
 954		port->xmit_cnt += cnt;
 955		buf += cnt;
 956		count -= cnt;
 957		total += cnt;
 958	}
 959	if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped)
 960		port->status |= ISI_TXOK;
 961	spin_unlock_irqrestore(&card->card_lock, flags);
 962	return total;
 963}
 964
 965/* put_char et all */
 966static int isicom_put_char(struct tty_struct *tty, unsigned char ch)
 967{
 968	struct isi_port *port = tty->driver_data;
 969	struct isi_board *card = port->card;
 970	unsigned long flags;
 971
 972	if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
 973		return 0;
 974
 975	spin_lock_irqsave(&card->card_lock, flags);
 976	if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
 977		spin_unlock_irqrestore(&card->card_lock, flags);
 978		return 0;
 979	}
 980
 981	port->port.xmit_buf[port->xmit_head++] = ch;
 982	port->xmit_head &= (SERIAL_XMIT_SIZE - 1);
 983	port->xmit_cnt++;
 984	spin_unlock_irqrestore(&card->card_lock, flags);
 985	return 1;
 986}
 987
 988/* flush_chars et all */
 989static void isicom_flush_chars(struct tty_struct *tty)
 990{
 991	struct isi_port *port = tty->driver_data;
 992
 993	if (isicom_paranoia_check(port, tty->name, "isicom_flush_chars"))
 994		return;
 995
 996	if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
 997			!port->port.xmit_buf)
 998		return;
 999
1000	/* this tells the transmitter to consider this port for
1001	   data output to the card ... that's the best we can do. */
1002	port->status |= ISI_TXOK;
1003}
1004
1005/* write_room et all */
1006static int isicom_write_room(struct tty_struct *tty)
1007{
1008	struct isi_port *port = tty->driver_data;
1009	int free;
1010
1011	if (isicom_paranoia_check(port, tty->name, "isicom_write_room"))
1012		return 0;
1013
1014	free = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1015	if (free < 0)
1016		free = 0;
1017	return free;
1018}
1019
1020/* chars_in_buffer et all */
1021static int isicom_chars_in_buffer(struct tty_struct *tty)
1022{
1023	struct isi_port *port = tty->driver_data;
1024	if (isicom_paranoia_check(port, tty->name, "isicom_chars_in_buffer"))
1025		return 0;
1026	return port->xmit_cnt;
1027}
1028
1029/* ioctl et all */
1030static int isicom_send_break(struct tty_struct *tty, int length)
1031{
1032	struct isi_port *port = tty->driver_data;
1033	struct isi_board *card = port->card;
1034	unsigned long base = card->base;
1035
1036	if (length == -1)
1037		return -EOPNOTSUPP;
1038
1039	if (!lock_card(card))
1040		return -EINVAL;
1041
1042	outw(0x8000 | ((port->channel) << (card->shift_count)) | 0x3, base);
1043	outw((length & 0xff) << 8 | 0x00, base);
1044	outw((length & 0xff00u), base);
1045	InterruptTheCard(base);
1046
1047	unlock_card(card);
1048	return 0;
1049}
1050
1051static int isicom_tiocmget(struct tty_struct *tty)
1052{
1053	struct isi_port *port = tty->driver_data;
1054	/* just send the port status */
1055	u16 status = port->status;
1056
1057	if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1058		return -ENODEV;
1059
1060	return  ((status & ISI_RTS) ? TIOCM_RTS : 0) |
1061		((status & ISI_DTR) ? TIOCM_DTR : 0) |
1062		((status & ISI_DCD) ? TIOCM_CAR : 0) |
1063		((status & ISI_DSR) ? TIOCM_DSR : 0) |
1064		((status & ISI_CTS) ? TIOCM_CTS : 0) |
1065		((status & ISI_RI ) ? TIOCM_RI  : 0);
1066}
1067
1068static int isicom_tiocmset(struct tty_struct *tty,
1069					unsigned int set, unsigned int clear)
1070{
1071	struct isi_port *port = tty->driver_data;
1072	unsigned long flags;
1073
1074	if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1075		return -ENODEV;
1076
1077	spin_lock_irqsave(&port->card->card_lock, flags);
1078	if (set & TIOCM_RTS)
1079		raise_rts(port);
1080	if (set & TIOCM_DTR)
1081		raise_dtr(port);
1082
1083	if (clear & TIOCM_RTS)
1084		drop_rts(port);
1085	if (clear & TIOCM_DTR)
1086		drop_dtr(port);
1087	spin_unlock_irqrestore(&port->card->card_lock, flags);
1088
1089	return 0;
1090}
1091
1092static int isicom_set_serial_info(struct tty_struct *tty,
1093					struct serial_struct *ss)
1094{
1095	struct isi_port *port = tty->driver_data;
1096	int reconfig_port;
1097
1098	if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1099		return -ENODEV;
1100
1101	mutex_lock(&port->port.mutex);
1102	reconfig_port = ((port->port.flags & ASYNC_SPD_MASK) !=
1103		(ss->flags & ASYNC_SPD_MASK));
1104
1105	if (!capable(CAP_SYS_ADMIN)) {
1106		if ((ss->close_delay != port->port.close_delay) ||
1107				(ss->closing_wait != port->port.closing_wait) ||
1108				((ss->flags & ~ASYNC_USR_MASK) !=
1109				(port->port.flags & ~ASYNC_USR_MASK))) {
1110			mutex_unlock(&port->port.mutex);
1111			return -EPERM;
1112		}
1113		port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1114				(ss->flags & ASYNC_USR_MASK));
1115	} else {
1116		port->port.close_delay = ss->close_delay;
1117		port->port.closing_wait = ss->closing_wait;
1118		port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1119				(ss->flags & ASYNC_FLAGS));
1120	}
1121	if (reconfig_port) {
1122		unsigned long flags;
1123		spin_lock_irqsave(&port->card->card_lock, flags);
1124		isicom_config_port(tty);
1125		spin_unlock_irqrestore(&port->card->card_lock, flags);
1126	}
1127	mutex_unlock(&port->port.mutex);
1128	return 0;
1129}
1130
1131static int isicom_get_serial_info(struct tty_struct *tty,
1132	struct serial_struct *ss)
1133{
1134	struct isi_port *port = tty->driver_data;
1135
1136	if (isicom_paranoia_check(port, tty->name, "isicom_ioctl"))
1137		return -ENODEV;
1138
1139	mutex_lock(&port->port.mutex);
1140/*	ss->type = ? */
1141	ss->line = port - isi_ports;
1142	ss->port = port->card->base;
1143	ss->irq = port->card->irq;
1144	ss->flags = port->port.flags;
1145/*	ss->baud_base = ? */
1146	ss->close_delay = port->port.close_delay;
1147	ss->closing_wait = port->port.closing_wait;
1148	mutex_unlock(&port->port.mutex);
1149	return 0;
1150}
1151
1152/* set_termios et all */
1153static void isicom_set_termios(struct tty_struct *tty,
1154	struct ktermios *old_termios)
1155{
1156	struct isi_port *port = tty->driver_data;
1157	unsigned long flags;
1158
1159	if (isicom_paranoia_check(port, tty->name, "isicom_set_termios"))
1160		return;
1161
1162	if (tty->termios.c_cflag == old_termios->c_cflag &&
1163			tty->termios.c_iflag == old_termios->c_iflag)
1164		return;
1165
1166	spin_lock_irqsave(&port->card->card_lock, flags);
1167	isicom_config_port(tty);
1168	spin_unlock_irqrestore(&port->card->card_lock, flags);
1169
1170	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
1171		tty->hw_stopped = 0;
1172		isicom_start(tty);
1173	}
1174}
1175
1176/* throttle et all */
1177static void isicom_throttle(struct tty_struct *tty)
1178{
1179	struct isi_port *port = tty->driver_data;
1180	struct isi_board *card = port->card;
1181
1182	if (isicom_paranoia_check(port, tty->name, "isicom_throttle"))
1183		return;
1184
1185	/* tell the card that this port cannot handle any more data for now */
1186	card->port_status &= ~(1 << port->channel);
1187	outw(card->port_status, card->base + 0x02);
1188}
1189
1190/* unthrottle et all */
1191static void isicom_unthrottle(struct tty_struct *tty)
1192{
1193	struct isi_port *port = tty->driver_data;
1194	struct isi_board *card = port->card;
1195
1196	if (isicom_paranoia_check(port, tty->name, "isicom_unthrottle"))
1197		return;
1198
1199	/* tell the card that this port is ready to accept more data */
1200	card->port_status |= (1 << port->channel);
1201	outw(card->port_status, card->base + 0x02);
1202}
1203
1204/* stop et all */
1205static void isicom_stop(struct tty_struct *tty)
1206{
1207	struct isi_port *port = tty->driver_data;
1208
1209	if (isicom_paranoia_check(port, tty->name, "isicom_stop"))
1210		return;
1211
1212	/* this tells the transmitter not to consider this port for
1213	   data output to the card. */
1214	port->status &= ~ISI_TXOK;
1215}
1216
1217/* start et all */
1218static void isicom_start(struct tty_struct *tty)
1219{
1220	struct isi_port *port = tty->driver_data;
1221
1222	if (isicom_paranoia_check(port, tty->name, "isicom_start"))
1223		return;
1224
1225	/* this tells the transmitter to consider this port for
1226	   data output to the card. */
1227	port->status |= ISI_TXOK;
1228}
1229
1230static void isicom_hangup(struct tty_struct *tty)
1231{
1232	struct isi_port *port = tty->driver_data;
1233
1234	if (isicom_paranoia_check(port, tty->name, "isicom_hangup"))
1235		return;
1236	tty_port_hangup(&port->port);
1237}
1238
1239
1240/*
1241 * Driver init and deinit functions
1242 */
1243
1244static const struct tty_operations isicom_ops = {
1245	.open			= isicom_open,
1246	.close			= isicom_close,
1247	.write			= isicom_write,
1248	.put_char		= isicom_put_char,
1249	.flush_chars		= isicom_flush_chars,
1250	.write_room		= isicom_write_room,
1251	.chars_in_buffer	= isicom_chars_in_buffer,
1252	.set_termios		= isicom_set_termios,
1253	.throttle		= isicom_throttle,
1254	.unthrottle		= isicom_unthrottle,
1255	.stop			= isicom_stop,
1256	.start			= isicom_start,
1257	.hangup			= isicom_hangup,
1258	.flush_buffer		= isicom_flush_buffer,
1259	.tiocmget		= isicom_tiocmget,
1260	.tiocmset		= isicom_tiocmset,
1261	.break_ctl		= isicom_send_break,
1262	.get_serial		= isicom_get_serial_info,
1263	.set_serial		= isicom_set_serial_info,
1264};
1265
1266static const struct tty_port_operations isicom_port_ops = {
1267	.carrier_raised		= isicom_carrier_raised,
1268	.dtr_rts		= isicom_dtr_rts,
1269	.activate		= isicom_activate,
1270	.shutdown		= isicom_shutdown,
1271};
1272
1273static int reset_card(struct pci_dev *pdev,
1274	const unsigned int card, unsigned int *signature)
1275{
1276	struct isi_board *board = pci_get_drvdata(pdev);
1277	unsigned long base = board->base;
1278	unsigned int sig, portcount = 0;
1279	int retval = 0;
1280
1281	dev_dbg(&pdev->dev, "ISILoad:Resetting Card%d at 0x%lx\n", card + 1,
1282		base);
1283
1284	inw(base + 0x8);
1285
1286	msleep(10);
1287
1288	outw(0, base + 0x8); /* Reset */
1289
1290	msleep(1000);
1291
1292	sig = inw(base + 0x4) & 0xff;
1293
1294	if (sig != 0xa5 && sig != 0xbb && sig != 0xcc && sig != 0xdd &&
1295			sig != 0xee) {
1296		dev_warn(&pdev->dev, "ISILoad:Card%u reset failure (Possible "
1297			"bad I/O Port Address 0x%lx).\n", card + 1, base);
1298		dev_dbg(&pdev->dev, "Sig=0x%x\n", sig);
1299		retval = -EIO;
1300		goto end;
1301	}
1302
1303	msleep(10);
1304
1305	portcount = inw(base + 0x2);
1306	if (!(inw(base + 0xe) & 0x1) || (portcount != 0 && portcount != 4 &&
1307				portcount != 8 && portcount != 16)) {
1308		dev_err(&pdev->dev, "ISILoad:PCI Card%d reset failure.\n",
1309			card + 1);
1310		retval = -EIO;
1311		goto end;
1312	}
1313
1314	switch (sig) {
1315	case 0xa5:
1316	case 0xbb:
1317	case 0xdd:
1318		board->port_count = (portcount == 4) ? 4 : 8;
1319		board->shift_count = 12;
1320		break;
1321	case 0xcc:
1322	case 0xee:
1323		board->port_count = 16;
1324		board->shift_count = 11;
1325		break;
1326	}
1327	dev_info(&pdev->dev, "-Done\n");
1328	*signature = sig;
1329
1330end:
1331	return retval;
1332}
1333
1334static int load_firmware(struct pci_dev *pdev,
1335	const unsigned int index, const unsigned int signature)
1336{
1337	struct isi_board *board = pci_get_drvdata(pdev);
1338	const struct firmware *fw;
1339	unsigned long base = board->base;
1340	unsigned int a;
1341	u16 word_count, status;
1342	int retval = -EIO;
1343	char *name;
1344	u8 *data;
1345
1346	struct stframe {
1347		u16	addr;
1348		u16	count;
1349		u8	data[0];
1350	} *frame;
1351
1352	switch (signature) {
1353	case 0xa5:
1354		name = "isi608.bin";
1355		break;
1356	case 0xbb:
1357		name = "isi608em.bin";
1358		break;
1359	case 0xcc:
1360		name = "isi616em.bin";
1361		break;
1362	case 0xdd:
1363		name = "isi4608.bin";
1364		break;
1365	case 0xee:
1366		name = "isi4616.bin";
1367		break;
1368	default:
1369		dev_err(&pdev->dev, "Unknown signature.\n");
1370		goto end;
1371	}
1372
1373	retval = request_firmware(&fw, name, &pdev->dev);
1374	if (retval)
1375		goto end;
1376
1377	retval = -EIO;
1378
1379	for (frame = (struct stframe *)fw->data;
1380			frame < (struct stframe *)(fw->data + fw->size);
1381			frame = (struct stframe *)((u8 *)(frame + 1) +
1382				frame->count)) {
1383		if (WaitTillCardIsFree(base))
1384			goto errrelfw;
1385
1386		outw(0xf0, base);	/* start upload sequence */
1387		outw(0x00, base);
1388		outw(frame->addr, base); /* lsb of address */
1389
1390		word_count = frame->count / 2 + frame->count % 2;
1391		outw(word_count, base);
1392		InterruptTheCard(base);
1393
1394		udelay(100); /* 0x2f */
1395
1396		if (WaitTillCardIsFree(base))
1397			goto errrelfw;
1398
1399		status = inw(base + 0x4);
1400		if (status != 0) {
1401			dev_warn(&pdev->dev, "Card%d rejected load header:\n"
1402				 "Address:0x%x\n"
1403				 "Count:0x%x\n"
1404				 "Status:0x%x\n",
1405				 index + 1, frame->addr, frame->count, status);
1406			goto errrelfw;
1407		}
1408		outsw(base, frame->data, word_count);
1409
1410		InterruptTheCard(base);
1411
1412		udelay(50); /* 0x0f */
1413
1414		if (WaitTillCardIsFree(base))
1415			goto errrelfw;
1416
1417		status = inw(base + 0x4);
1418		if (status != 0) {
1419			dev_err(&pdev->dev, "Card%d got out of sync.Card "
1420				"Status:0x%x\n", index + 1, status);
1421			goto errrelfw;
1422		}
1423	}
1424
1425/* XXX: should we test it by reading it back and comparing with original like
1426 * in load firmware package? */
1427	for (frame = (struct stframe *)fw->data;
1428			frame < (struct stframe *)(fw->data + fw->size);
1429			frame = (struct stframe *)((u8 *)(frame + 1) +
1430				frame->count)) {
1431		if (WaitTillCardIsFree(base))
1432			goto errrelfw;
1433
1434		outw(0xf1, base); /* start download sequence */
1435		outw(0x00, base);
1436		outw(frame->addr, base); /* lsb of address */
1437
1438		word_count = (frame->count >> 1) + frame->count % 2;
1439		outw(word_count + 1, base);
1440		InterruptTheCard(base);
1441
1442		udelay(50); /* 0xf */
1443
1444		if (WaitTillCardIsFree(base))
1445			goto errrelfw;
1446
1447		status = inw(base + 0x4);
1448		if (status != 0) {
1449			dev_warn(&pdev->dev, "Card%d rejected verify header:\n"
1450				 "Address:0x%x\n"
1451				 "Count:0x%x\n"
1452				 "Status: 0x%x\n",
1453				 index + 1, frame->addr, frame->count, status);
1454			goto errrelfw;
1455		}
1456
1457		data = kmalloc_array(word_count, 2, GFP_KERNEL);
1458		if (data == NULL) {
1459			dev_err(&pdev->dev, "Card%d, firmware upload "
1460				"failed, not enough memory\n", index + 1);
1461			goto errrelfw;
1462		}
1463		inw(base);
1464		insw(base, data, word_count);
1465		InterruptTheCard(base);
1466
1467		for (a = 0; a < frame->count; a++)
1468			if (data[a] != frame->data[a]) {
1469				kfree(data);
1470				dev_err(&pdev->dev, "Card%d, firmware upload "
1471					"failed\n", index + 1);
1472				goto errrelfw;
1473			}
1474		kfree(data);
1475
1476		udelay(50); /* 0xf */
1477
1478		if (WaitTillCardIsFree(base))
1479			goto errrelfw;
1480
1481		status = inw(base + 0x4);
1482		if (status != 0) {
1483			dev_err(&pdev->dev, "Card%d verify got out of sync. "
1484				"Card Status:0x%x\n", index + 1, status);
1485			goto errrelfw;
1486		}
1487	}
1488
1489	/* xfer ctrl */
1490	if (WaitTillCardIsFree(base))
1491		goto errrelfw;
1492
1493	outw(0xf2, base);
1494	outw(0x800, base);
1495	outw(0x0, base);
1496	outw(0x0, base);
1497	InterruptTheCard(base);
1498	outw(0x0, base + 0x4); /* for ISI4608 cards */
1499
1500	board->status |= FIRMWARE_LOADED;
1501	retval = 0;
1502
1503errrelfw:
1504	release_firmware(fw);
1505end:
1506	return retval;
1507}
1508
1509/*
1510 *	Insmod can set static symbols so keep these static
1511 */
1512static unsigned int card_count;
1513
1514static int isicom_probe(struct pci_dev *pdev,
1515	const struct pci_device_id *ent)
1516{
1517	unsigned int signature, index;
1518	int retval = -EPERM;
1519	struct isi_board *board = NULL;
1520
1521	if (card_count >= BOARD_COUNT)
1522		goto err;
1523
1524	retval = pci_enable_device(pdev);
1525	if (retval) {
1526		dev_err(&pdev->dev, "failed to enable\n");
1527		goto err;
1528	}
1529
1530	dev_info(&pdev->dev, "ISI PCI Card(Device ID 0x%x)\n", ent->device);
1531
1532	/* allot the first empty slot in the array */
1533	for (index = 0; index < BOARD_COUNT; index++) {
1534		if (isi_card[index].base == 0) {
1535			board = &isi_card[index];
1536			break;
1537		}
1538	}
1539	if (index == BOARD_COUNT) {
1540		retval = -ENODEV;
1541		goto err_disable;
1542	}
1543
1544	board->index = index;
1545	board->base = pci_resource_start(pdev, 3);
1546	board->irq = pdev->irq;
1547	card_count++;
1548
1549	pci_set_drvdata(pdev, board);
1550
1551	retval = pci_request_region(pdev, 3, ISICOM_NAME);
1552	if (retval) {
1553		dev_err(&pdev->dev, "I/O Region 0x%lx-0x%lx is busy. Card%d "
1554			"will be disabled.\n", board->base, board->base + 15,
1555			index + 1);
1556		retval = -EBUSY;
1557		goto errdec;
1558	}
1559
1560	retval = request_irq(board->irq, isicom_interrupt,
1561			IRQF_SHARED, ISICOM_NAME, board);
1562	if (retval < 0) {
1563		dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1564			"Card%d will be disabled.\n", board->irq, index + 1);
1565		goto errunrr;
1566	}
1567
1568	retval = reset_card(pdev, index, &signature);
1569	if (retval < 0)
1570		goto errunri;
1571
1572	retval = load_firmware(pdev, index, signature);
1573	if (retval < 0)
1574		goto errunri;
1575
1576	for (index = 0; index < board->port_count; index++) {
1577		struct tty_port *tport = &board->ports[index].port;
1578		tty_port_init(tport);
1579		tport->ops = &isicom_port_ops;
1580		tport->close_delay = 50 * HZ/100;
1581		tport->closing_wait = 3000 * HZ/100;
1582		tty_port_register_device(tport, isicom_normal,
1583				board->index * 16 + index, &pdev->dev);
1584	}
1585
1586	return 0;
1587
1588errunri:
1589	free_irq(board->irq, board);
1590errunrr:
1591	pci_release_region(pdev, 3);
1592errdec:
1593	board->base = 0;
1594	card_count--;
1595err_disable:
1596	pci_disable_device(pdev);
1597err:
1598	return retval;
1599}
1600
1601static void isicom_remove(struct pci_dev *pdev)
1602{
1603	struct isi_board *board = pci_get_drvdata(pdev);
1604	unsigned int i;
1605
1606	for (i = 0; i < board->port_count; i++) {
1607		tty_unregister_device(isicom_normal, board->index * 16 + i);
1608		tty_port_destroy(&board->ports[i].port);
1609	}
1610
1611	free_irq(board->irq, board);
1612	pci_release_region(pdev, 3);
1613	board->base = 0;
1614	card_count--;
1615	pci_disable_device(pdev);
1616}
1617
1618static int __init isicom_init(void)
1619{
1620	int retval, idx, channel;
1621	struct isi_port *port;
1622
1623	for (idx = 0; idx < BOARD_COUNT; idx++) {
1624		port = &isi_ports[idx * 16];
1625		isi_card[idx].ports = port;
1626		spin_lock_init(&isi_card[idx].card_lock);
1627		for (channel = 0; channel < 16; channel++, port++) {
1628			port->magic = ISICOM_MAGIC;
1629			port->card = &isi_card[idx];
1630			port->channel = channel;
1631			port->status = 0;
1632			/*  . . .  */
1633		}
1634		isi_card[idx].base = 0;
1635		isi_card[idx].irq = 0;
1636	}
1637
1638	/* tty driver structure initialization */
1639	isicom_normal = alloc_tty_driver(PORT_COUNT);
1640	if (!isicom_normal) {
1641		retval = -ENOMEM;
1642		goto error;
1643	}
1644
1645	isicom_normal->name 			= "ttyM";
1646	isicom_normal->major			= ISICOM_NMAJOR;
1647	isicom_normal->minor_start		= 0;
1648	isicom_normal->type			= TTY_DRIVER_TYPE_SERIAL;
1649	isicom_normal->subtype			= SERIAL_TYPE_NORMAL;
1650	isicom_normal->init_termios		= tty_std_termios;
1651	isicom_normal->init_termios.c_cflag	= B9600 | CS8 | CREAD | HUPCL |
1652		CLOCAL;
1653	isicom_normal->flags			= TTY_DRIVER_REAL_RAW |
1654		TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK;
1655	tty_set_operations(isicom_normal, &isicom_ops);
1656
1657	retval = tty_register_driver(isicom_normal);
1658	if (retval) {
1659		pr_debug("Couldn't register the dialin driver\n");
1660		goto err_puttty;
1661	}
1662
1663	retval = pci_register_driver(&isicom_driver);
1664	if (retval < 0) {
1665		pr_err("Unable to register pci driver.\n");
1666		goto err_unrtty;
1667	}
1668
1669	mod_timer(&tx, jiffies + 1);
1670
1671	return 0;
1672err_unrtty:
1673	tty_unregister_driver(isicom_normal);
1674err_puttty:
1675	put_tty_driver(isicom_normal);
1676error:
1677	return retval;
1678}
1679
1680static void __exit isicom_exit(void)
1681{
1682	del_timer_sync(&tx);
1683
1684	pci_unregister_driver(&isicom_driver);
1685	tty_unregister_driver(isicom_normal);
1686	put_tty_driver(isicom_normal);
1687}
1688
1689module_init(isicom_init);
1690module_exit(isicom_exit);
1691
1692MODULE_AUTHOR("MultiTech");
1693MODULE_DESCRIPTION("Driver for the ISI series of cards by MultiTech");
1694MODULE_LICENSE("GPL");
1695MODULE_FIRMWARE("isi608.bin");
1696MODULE_FIRMWARE("isi608em.bin");
1697MODULE_FIRMWARE("isi616em.bin");
1698MODULE_FIRMWARE("isi4608.bin");
1699MODULE_FIRMWARE("isi4616.bin");