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"); 1700