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