drivers/serial/icom.c

   1 /*
   2   * icom.c
   3   *
   4   * Copyright (C) 2001 IBM Corporation. All rights reserved.
   5   *
   6   * Serial device driver.
   7   *
   8   * Based on code from serial.c
   9   *
  10   * This program is free software; you can redistribute it and/or modify
  11   * it under the terms of the GNU General Public License as published by
  12   * the Free Software Foundation; either version 2 of the License, or
  13   * (at your option) any later version.
  14   *
  15   * This program is distributed in the hope that it will be useful,
  16   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18   * GNU General Public License for more details.
  19   *
  20   * You should have received a copy of the GNU General Public License
  21   * along with this program; if not, write to the Free Software
  22   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  23   *
  24   */
  25 #define SERIAL_DO_RESTART
  26 #include <linux/module.h>
  27 #include <linux/kernel.h>
  28 #include <linux/errno.h>
  29 #include <linux/signal.h>
  30 #include <linux/timer.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/tty.h>
  33 #include <linux/termios.h>
  34 #include <linux/fs.h>
  35 #include <linux/tty_flip.h>
  36 #include <linux/serial.h>
  37 #include <linux/serial_reg.h>
  38 #include <linux/major.h>
  39 #include <linux/string.h>
  40 #include <linux/fcntl.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/ioport.h>
  43 #include <linux/mm.h>
  44 #include <linux/slab.h>
  45 #include <linux/init.h>
  46 #include <linux/delay.h>
  47 #include <linux/pci.h>
  48 #include <linux/vmalloc.h>
  49 #include <linux/smp.h>
  50 #include <linux/spinlock.h>
  51 #include <linux/kref.h>
  52 #include <linux/firmware.h>
  53 #include <linux/bitops.h>
  54
  55 #include <asm/system.h>
  56 #include <asm/io.h>
  57 #include <asm/irq.h>
  58 #include <asm/uaccess.h>
  59
  60 #include "icom.h"
  61
  62 /*#define ICOM_TRACE             enable port trace capabilities */
  63
  64 #define ICOM_DRIVER_NAME "icom"
  65 #define ICOM_VERSION_STR "1.3.1"
  66 #define NR_PORTS               128
  67 #define ICOM_PORT ((struct icom_port *)port)
  68 #define to_icom_adapter(d) container_of(d, struct icom_adapter, kref)
  69
  70 static const struct pci_device_id icom_pci_table[] = {
  71         {
  72                 .vendor = PCI_VENDOR_ID_IBM,
  73                 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1,
  74                 .subvendor = PCI_ANY_ID,
  75                 .subdevice = PCI_ANY_ID,
  76                 .driver_data = ADAPTER_V1,
  77         },
  78         {
  79                 .vendor = PCI_VENDOR_ID_IBM,
  80                 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
  81                 .subvendor = PCI_VENDOR_ID_IBM,
  82                 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX,
  83                 .driver_data = ADAPTER_V2,
  84         },
  85         {
  86                 .vendor = PCI_VENDOR_ID_IBM,
  87                 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
  88                 .subvendor = PCI_VENDOR_ID_IBM,
  89                 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM,
  90                 .driver_data = ADAPTER_V2,
  91         },
  92         {
  93                 .vendor = PCI_VENDOR_ID_IBM,
  94                 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
  95                 .subvendor = PCI_VENDOR_ID_IBM,
  96                 .subdevice = PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL,
  97                 .driver_data = ADAPTER_V2,
  98         },
  99         {
 100                 .vendor = PCI_VENDOR_ID_IBM,
 101                 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
 102                 .subvendor = PCI_VENDOR_ID_IBM,
 103                 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM_PCIE,
 104                 .driver_data = ADAPTER_V2,
 105         },
 106         {}
 107 };
 108
 109 struct lookup_proc_table start_proc[4] = {
 110         {NULL, ICOM_CONTROL_START_A},
 111         {NULL, ICOM_CONTROL_START_B},
 112         {NULL, ICOM_CONTROL_START_C},
 113         {NULL, ICOM_CONTROL_START_D}
 114 };
 115
 116
 117 struct lookup_proc_table stop_proc[4] = {
 118         {NULL, ICOM_CONTROL_STOP_A},
 119         {NULL, ICOM_CONTROL_STOP_B},
 120         {NULL, ICOM_CONTROL_STOP_C},
 121         {NULL, ICOM_CONTROL_STOP_D}
 122 };
 123
 124 struct lookup_int_table int_mask_tbl[4] = {
 125         {NULL, ICOM_INT_MASK_PRC_A},
 126         {NULL, ICOM_INT_MASK_PRC_B},
 127         {NULL, ICOM_INT_MASK_PRC_C},
 128         {NULL, ICOM_INT_MASK_PRC_D},
 129 };
 130
 131
 132 MODULE_DEVICE_TABLE(pci, icom_pci_table);
 133
 134 static LIST_HEAD(icom_adapter_head);
 135
 136 /* spinlock for adapter initialization and changing adapter operations */
 137 static spinlock_t icom_lock;
 138
 139 #ifdef ICOM_TRACE
 140 static inline void trace(struct icom_port *, char *, unsigned long) {};
 141 #else
 142 static inline void trace(struct icom_port *icom_port, char *trace_pt, unsigned long trace_data) {};
 143 #endif
 144 static void icom_kref_release(struct kref *kref);
 145
 146 static void free_port_memory(struct icom_port *icom_port)
 147 {
 148         struct pci_dev *dev = icom_port->adapter->pci_dev;
 149
 150         trace(icom_port, "RET_PORT_MEM", 0);
 151         if (icom_port->recv_buf) {
 152                 pci_free_consistent(dev, 4096, icom_port->recv_buf,
 153                                     icom_port->recv_buf_pci);
 154                 icom_port->recv_buf = NULL;
 155         }
 156         if (icom_port->xmit_buf) {
 157                 pci_free_consistent(dev, 4096, icom_port->xmit_buf,
 158                                     icom_port->xmit_buf_pci);
 159                 icom_port->xmit_buf = NULL;
 160         }
 161         if (icom_port->statStg) {
 162                 pci_free_consistent(dev, 4096, icom_port->statStg,
 163                                     icom_port->statStg_pci);
 164                 icom_port->statStg = NULL;
 165         }
 166
 167         if (icom_port->xmitRestart) {
 168                 pci_free_consistent(dev, 4096, icom_port->xmitRestart,
 169                                     icom_port->xmitRestart_pci);
 170                 icom_port->xmitRestart = NULL;
 171         }
 172 }
 173
 174 static int __devinit get_port_memory(struct icom_port *icom_port)
 175 {
 176         int index;
 177         unsigned long stgAddr;
 178         unsigned long startStgAddr;
 179         unsigned long offset;
 180         struct pci_dev *dev = icom_port->adapter->pci_dev;
 181
 182         icom_port->xmit_buf =
 183             pci_alloc_consistent(dev, 4096, &icom_port->xmit_buf_pci);
 184         if (!icom_port->xmit_buf) {
 185                 dev_err(&dev->dev, "Can not allocate Transmit buffer\n");
 186                 return -ENOMEM;
 187         }
 188
 189         trace(icom_port, "GET_PORT_MEM",
 190               (unsigned long) icom_port->xmit_buf);
 191
 192         icom_port->recv_buf =
 193             pci_alloc_consistent(dev, 4096, &icom_port->recv_buf_pci);
 194         if (!icom_port->recv_buf) {
 195                 dev_err(&dev->dev, "Can not allocate Receive buffer\n");
 196                 free_port_memory(icom_port);
 197                 return -ENOMEM;
 198         }
 199         trace(icom_port, "GET_PORT_MEM",
 200               (unsigned long) icom_port->recv_buf);
 201
 202         icom_port->statStg =
 203             pci_alloc_consistent(dev, 4096, &icom_port->statStg_pci);
 204         if (!icom_port->statStg) {
 205                 dev_err(&dev->dev, "Can not allocate Status buffer\n");
 206                 free_port_memory(icom_port);
 207                 return -ENOMEM;
 208         }
 209         trace(icom_port, "GET_PORT_MEM",
 210               (unsigned long) icom_port->statStg);
 211
 212         icom_port->xmitRestart =
 213             pci_alloc_consistent(dev, 4096, &icom_port->xmitRestart_pci);
 214         if (!icom_port->xmitRestart) {
 215                 dev_err(&dev->dev,
 216                         "Can not allocate xmit Restart buffer\n");
 217                 free_port_memory(icom_port);
 218                 return -ENOMEM;
 219         }
 220
 221         memset(icom_port->statStg, 0, 4096);
 222
 223         /* FODs: Frame Out Descriptor Queue, this is a FIFO queue that
 224            indicates that frames are to be transmitted
 225         */
 226
 227         stgAddr = (unsigned long) icom_port->statStg;
 228         for (index = 0; index < NUM_XBUFFS; index++) {
 229                 trace(icom_port, "FOD_ADDR", stgAddr);
 230                 stgAddr = stgAddr + sizeof(icom_port->statStg->xmit[0]);
 231                 if (index < (NUM_XBUFFS - 1)) {
 232                         memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
 233                         icom_port->statStg->xmit[index].leLengthASD =
 234                             (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
 235                         trace(icom_port, "FOD_ADDR", stgAddr);
 236                         trace(icom_port, "FOD_XBUFF",
 237                               (unsigned long) icom_port->xmit_buf);
 238                         icom_port->statStg->xmit[index].leBuffer =
 239                             cpu_to_le32(icom_port->xmit_buf_pci);
 240                 } else if (index == (NUM_XBUFFS - 1)) {
 241                         memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
 242                         icom_port->statStg->xmit[index].leLengthASD =
 243                             (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
 244                         trace(icom_port, "FOD_XBUFF",
 245                               (unsigned long) icom_port->xmit_buf);
 246                         icom_port->statStg->xmit[index].leBuffer =
 247                             cpu_to_le32(icom_port->xmit_buf_pci);
 248                 } else {
 249                         memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
 250                 }
 251         }
 252         /* FIDs */
 253         startStgAddr = stgAddr;
 254
 255         /* fill in every entry, even if no buffer */
 256         for (index = 0; index <  NUM_RBUFFS; index++) {
 257                 trace(icom_port, "FID_ADDR", stgAddr);
 258                 stgAddr = stgAddr + sizeof(icom_port->statStg->rcv[0]);
 259                 icom_port->statStg->rcv[index].leLength = 0;
 260                 icom_port->statStg->rcv[index].WorkingLength =
 261                     (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
 262                 if (index < (NUM_RBUFFS - 1) ) {
 263                         offset = stgAddr - (unsigned long) icom_port->statStg;
 264                         icom_port->statStg->rcv[index].leNext =
 265                               cpu_to_le32(icom_port-> statStg_pci + offset);
 266                         trace(icom_port, "FID_RBUFF",
 267                               (unsigned long) icom_port->recv_buf);
 268                         icom_port->statStg->rcv[index].leBuffer =
 269                             cpu_to_le32(icom_port->recv_buf_pci);
 270                 } else if (index == (NUM_RBUFFS -1) ) {
 271                         offset = startStgAddr - (unsigned long) icom_port->statStg;
 272                         icom_port->statStg->rcv[index].leNext =
 273                             cpu_to_le32(icom_port-> statStg_pci + offset);
 274                         trace(icom_port, "FID_RBUFF",
 275                               (unsigned long) icom_port->recv_buf + 2048);
 276                         icom_port->statStg->rcv[index].leBuffer =
 277                             cpu_to_le32(icom_port->recv_buf_pci + 2048);
 278                 } else {
 279                         icom_port->statStg->rcv[index].leNext = 0;
 280                         icom_port->statStg->rcv[index].leBuffer = 0;
 281                 }
 282         }
 283
 284         return 0;
 285 }
 286
 287 static void stop_processor(struct icom_port *icom_port)
 288 {
 289         unsigned long temp;
 290         unsigned long flags;
 291         int port;
 292
 293         spin_lock_irqsave(&icom_lock, flags);
 294
 295         port = icom_port->port;
 296         if (port == 0 || port == 1)
 297                 stop_proc[port].global_control_reg = &icom_port->global_reg->control;
 298         else
 299                 stop_proc[port].global_control_reg = &icom_port->global_reg->control_2;
 300
 301
 302         if (port < 4) {
 303                 temp = readl(stop_proc[port].global_control_reg);
 304                 temp =
 305                         (temp & ~start_proc[port].processor_id) | stop_proc[port].processor_id;
 306                 writel(temp, stop_proc[port].global_control_reg);
 307
 308                 /* write flush */
 309                 readl(stop_proc[port].global_control_reg);
 310         } else {
 311                 dev_err(&icom_port->adapter->pci_dev->dev,
 312                         "Invalid port assignment\n");
 313         }
 314
 315         spin_unlock_irqrestore(&icom_lock, flags);
 316 }
 317
 318 static void start_processor(struct icom_port *icom_port)
 319 {
 320         unsigned long temp;
 321         unsigned long flags;
 322         int port;
 323
 324         spin_lock_irqsave(&icom_lock, flags);
 325
 326         port = icom_port->port;
 327         if (port == 0 || port == 1)
 328                 start_proc[port].global_control_reg = &icom_port->global_reg->control;
 329         else
 330                 start_proc[port].global_control_reg = &icom_port->global_reg->control_2;
 331         if (port < 4) {
 332                 temp = readl(start_proc[port].global_control_reg);
 333                 temp =
 334                         (temp & ~stop_proc[port].processor_id) | start_proc[port].processor_id;
 335                 writel(temp, start_proc[port].global_control_reg);
 336
 337                 /* write flush */
 338                 readl(start_proc[port].global_control_reg);
 339         } else {
 340                 dev_err(&icom_port->adapter->pci_dev->dev,
 341                         "Invalid port assignment\n");
 342         }
 343
 344         spin_unlock_irqrestore(&icom_lock, flags);
 345 }
 346
 347 static void load_code(struct icom_port *icom_port)
 348 {
 349         const struct firmware *fw;
 350         char __iomem *iram_ptr;
 351         int index;
 352         int status = 0;
 353         void __iomem *dram_ptr = icom_port->dram;
 354         dma_addr_t temp_pci;
 355         unsigned char *new_page = NULL;
 356         unsigned char cable_id = NO_CABLE;
 357         struct pci_dev *dev = icom_port->adapter->pci_dev;
 358
 359         /* Clear out any pending interrupts */
 360         writew(0x3FFF, icom_port->int_reg);
 361
 362         trace(icom_port, "CLEAR_INTERRUPTS", 0);
 363
 364         /* Stop processor */
 365         stop_processor(icom_port);
 366
 367         /* Zero out DRAM */
 368         memset_io(dram_ptr, 0, 512);
 369
 370         /* Load Call Setup into Adapter */
 371         if (request_firmware(&fw, "icom_call_setup.bin", &dev->dev) < 0) {
 372                 dev_err(&dev->dev,"Unable to load icom_call_setup.bin firmware image\n");
 373                 status = -1;
 374                 goto load_code_exit;
 375         }
 376
 377         if (fw->size > ICOM_DCE_IRAM_OFFSET) {
 378                 dev_err(&dev->dev, "Invalid firmware image for icom_call_setup.bin found.\n");
 379                 release_firmware(fw);
 380                 status = -1;
 381                 goto load_code_exit;
 382         }
 383
 384         iram_ptr = (char __iomem *)icom_port->dram + ICOM_IRAM_OFFSET;
 385         for (index = 0; index < fw->size; index++)
 386                 writeb(fw->data[index], &iram_ptr[index]);
 387
 388         release_firmware(fw);
 389
 390         /* Load Resident DCE portion of Adapter */
 391         if (request_firmware(&fw, "icom_res_dce.bin", &dev->dev) < 0) {
 392                 dev_err(&dev->dev,"Unable to load icom_res_dce.bin firmware image\n");
 393                 status = -1;
 394                 goto load_code_exit;
 395         }
 396
 397         if (fw->size > ICOM_IRAM_SIZE) {
 398                 dev_err(&dev->dev, "Invalid firmware image for icom_res_dce.bin found.\n");
 399                 release_firmware(fw);
 400                 status = -1;
 401                 goto load_code_exit;
 402         }
 403
 404         iram_ptr = (char __iomem *) icom_port->dram + ICOM_IRAM_OFFSET;
 405         for (index = ICOM_DCE_IRAM_OFFSET; index < fw->size; index++)
 406                 writeb(fw->data[index], &iram_ptr[index]);
 407
 408         release_firmware(fw);
 409
 410         /* Set Hardware level */
 411         if ((icom_port->adapter->version | ADAPTER_V2) == ADAPTER_V2)
 412                 writeb(V2_HARDWARE, &(icom_port->dram->misc_flags));
 413
 414         /* Start the processor in Adapter */
 415         start_processor(icom_port);
 416
 417         writeb((HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL),
 418                &(icom_port->dram->HDLCConfigReg));
 419         writeb(0x04, &(icom_port->dram->FlagFillIdleTimer));    /* 0.5 seconds */
 420         writeb(0x00, &(icom_port->dram->CmdReg));
 421         writeb(0x10, &(icom_port->dram->async_config3));
 422         writeb((ICOM_ACFG_DRIVE1 | ICOM_ACFG_NO_PARITY | ICOM_ACFG_8BPC |
 423                 ICOM_ACFG_1STOP_BIT), &(icom_port->dram->async_config2));
 424
 425         /*Set up data in icom DRAM to indicate where personality
 426          *code is located and its length.
 427          */
 428         new_page = pci_alloc_consistent(dev, 4096, &temp_pci);
 429
 430         if (!new_page) {
 431                 dev_err(&dev->dev, "Can not allocate DMA buffer\n");
 432                 status = -1;
 433                 goto load_code_exit;
 434         }
 435
 436         if (request_firmware(&fw, "icom_asc.bin", &dev->dev) < 0) {
 437                 dev_err(&dev->dev,"Unable to load icom_asc.bin firmware image\n");
 438                 status = -1;
 439                 goto load_code_exit;
 440         }
 441
 442         if (fw->size > ICOM_DCE_IRAM_OFFSET) {
 443                 dev_err(&dev->dev, "Invalid firmware image for icom_asc.bin found.\n");
 444                 release_firmware(fw);
 445                 status = -1;
 446                 goto load_code_exit;
 447         }
 448
 449         for (index = 0; index < fw->size; index++)
 450                 new_page[index] = fw->data[index];
 451
 452         release_firmware(fw);
 453
 454         writeb((char) ((fw->size + 16)/16), &icom_port->dram->mac_length);
 455         writel(temp_pci, &icom_port->dram->mac_load_addr);
 456
 457         /*Setting the syncReg to 0x80 causes adapter to start downloading
 458            the personality code into adapter instruction RAM.
 459            Once code is loaded, it will begin executing and, based on
 460            information provided above, will start DMAing data from
 461            shared memory to adapter DRAM.
 462          */
 463         /* the wait loop below verifies this write operation has been done
 464            and processed
 465         */
 466         writeb(START_DOWNLOAD, &icom_port->dram->sync);
 467
 468         /* Wait max 1 Sec for data download and processor to start */
 469         for (index = 0; index < 10; index++) {
 470                 msleep(100);
 471                 if (readb(&icom_port->dram->misc_flags) & ICOM_HDW_ACTIVE)
 472                         break;
 473         }
 474
 475         if (index == 10)
 476                 status = -1;
 477
 478         /*
 479          * check Cable ID
 480          */
 481         cable_id = readb(&icom_port->dram->cable_id);
 482
 483         if (cable_id & ICOM_CABLE_ID_VALID) {
 484                 /* Get cable ID into the lower 4 bits (standard form) */
 485                 cable_id = (cable_id & ICOM_CABLE_ID_MASK) >> 4;
 486                 icom_port->cable_id = cable_id;
 487         } else {
 488                 dev_err(&dev->dev,"Invalid or no cable attached\n");
 489                 icom_port->cable_id = NO_CABLE;
 490         }
 491
 492       load_code_exit:
 493
 494         if (status != 0) {
 495                 /* Clear out any pending interrupts */
 496                 writew(0x3FFF, icom_port->int_reg);
 497
 498                 /* Turn off port */
 499                 writeb(ICOM_DISABLE, &(icom_port->dram->disable));
 500
 501                 /* Stop processor */
 502                 stop_processor(icom_port);
 503
 504                 dev_err(&icom_port->adapter->pci_dev->dev,"Port not opertional\n");
 505         }
 506
 507       if (new_page != NULL)
 508               pci_free_consistent(dev, 4096, new_page, temp_pci);
 509 }
 510
 511 static int startup(struct icom_port *icom_port)
 512 {
 513         unsigned long temp;
 514         unsigned char cable_id, raw_cable_id;
 515         unsigned long flags;
 516         int port;
 517
 518         trace(icom_port, "STARTUP", 0);
 519
 520         if (!icom_port->dram) {
 521                 /* should NEVER be NULL */
 522                 dev_err(&icom_port->adapter->pci_dev->dev,
 523                         "Unusable Port, port configuration missing\n");
 524                 return -ENODEV;
 525         }
 526
 527         /*
 528          * check Cable ID
 529          */
 530         raw_cable_id = readb(&icom_port->dram->cable_id);
 531         trace(icom_port, "CABLE_ID", raw_cable_id);
 532
 533         /* Get cable ID into the lower 4 bits (standard form) */
 534         cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
 535
 536         /* Check for valid Cable ID */
 537         if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
 538             (cable_id != icom_port->cable_id)) {
 539
 540                 /* reload adapter code, pick up any potential changes in cable id */
 541                 load_code(icom_port);
 542
 543                 /* still no sign of cable, error out */
 544                 raw_cable_id = readb(&icom_port->dram->cable_id);
 545                 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
 546                 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
 547                     (icom_port->cable_id == NO_CABLE))
 548                         return -EIO;
 549         }
 550
 551         /*
 552          * Finally, clear and  enable interrupts
 553          */
 554         spin_lock_irqsave(&icom_lock, flags);
 555         port = icom_port->port;
 556         if (port == 0 || port == 1)
 557                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
 558         else
 559                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
 560
 561         if (port == 0 || port == 2)
 562                 writew(0x00FF, icom_port->int_reg);
 563         else
 564                 writew(0x3F00, icom_port->int_reg);
 565         if (port < 4) {
 566                 temp = readl(int_mask_tbl[port].global_int_mask);
 567                 writel(temp & ~int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
 568
 569                 /* write flush */
 570                 readl(int_mask_tbl[port].global_int_mask);
 571         } else {
 572                 dev_err(&icom_port->adapter->pci_dev->dev,
 573                         "Invalid port assignment\n");
 574         }
 575
 576         spin_unlock_irqrestore(&icom_lock, flags);
 577         return 0;
 578 }
 579
 580 static void shutdown(struct icom_port *icom_port)
 581 {
 582         unsigned long temp;
 583         unsigned char cmdReg;
 584         unsigned long flags;
 585         int port;
 586
 587         spin_lock_irqsave(&icom_lock, flags);
 588         trace(icom_port, "SHUTDOWN", 0);
 589
 590         /*
 591          * disable all interrupts
 592          */
 593         port = icom_port->port;
 594         if (port == 0 || port == 1)
 595                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
 596         else
 597                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
 598
 599         if (port < 4) {
 600                 temp = readl(int_mask_tbl[port].global_int_mask);
 601                 writel(temp | int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
 602
 603                 /* write flush */
 604                 readl(int_mask_tbl[port].global_int_mask);
 605         } else {
 606                 dev_err(&icom_port->adapter->pci_dev->dev,
 607                         "Invalid port assignment\n");
 608         }
 609         spin_unlock_irqrestore(&icom_lock, flags);
 610
 611         /*
 612          * disable break condition
 613          */
 614         cmdReg = readb(&icom_port->dram->CmdReg);
 615         if ((cmdReg | CMD_SND_BREAK) == CMD_SND_BREAK) {
 616                 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
 617         }
 618 }
 619
 620 static int icom_write(struct uart_port *port)
 621 {
 622         unsigned long data_count;
 623         unsigned char cmdReg;
 624         unsigned long offset;
 625         int temp_tail = port->info->xmit.tail;
 626
 627         trace(ICOM_PORT, "WRITE", 0);
 628
 629         if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
 630             SA_FLAGS_READY_TO_XMIT) {
 631                 trace(ICOM_PORT, "WRITE_FULL", 0);
 632                 return 0;
 633         }
 634
 635         data_count = 0;
 636         while ((port->info->xmit.head != temp_tail) &&
 637                (data_count <= XMIT_BUFF_SZ)) {
 638
 639                 ICOM_PORT->xmit_buf[data_count++] =
 640                     port->info->xmit.buf[temp_tail];
 641
 642                 temp_tail++;
 643                 temp_tail &= (UART_XMIT_SIZE - 1);
 644         }
 645
 646         if (data_count) {
 647                 ICOM_PORT->statStg->xmit[0].flags =
 648                     cpu_to_le16(SA_FLAGS_READY_TO_XMIT);
 649                 ICOM_PORT->statStg->xmit[0].leLength =
 650                     cpu_to_le16(data_count);
 651                 offset =
 652                     (unsigned long) &ICOM_PORT->statStg->xmit[0] -
 653                     (unsigned long) ICOM_PORT->statStg;
 654                 *ICOM_PORT->xmitRestart =
 655                     cpu_to_le32(ICOM_PORT->statStg_pci + offset);
 656                 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
 657                 writeb(cmdReg | CMD_XMIT_RCV_ENABLE,
 658                        &ICOM_PORT->dram->CmdReg);
 659                 writeb(START_XMIT, &ICOM_PORT->dram->StartXmitCmd);
 660                 trace(ICOM_PORT, "WRITE_START", data_count);
 661                 /* write flush */
 662                 readb(&ICOM_PORT->dram->StartXmitCmd);
 663         }
 664
 665         return data_count;
 666 }
 667
 668 static inline void check_modem_status(struct icom_port *icom_port)
 669 {
 670         static char old_status = 0;
 671         char delta_status;
 672         unsigned char status;
 673
 674         spin_lock(&icom_port->uart_port.lock);
 675
 676         /*modem input register */
 677         status = readb(&icom_port->dram->isr);
 678         trace(icom_port, "CHECK_MODEM", status);
 679         delta_status = status ^ old_status;
 680         if (delta_status) {
 681                 if (delta_status & ICOM_RI)
 682                         icom_port->uart_port.icount.rng++;
 683                 if (delta_status & ICOM_DSR)
 684                         icom_port->uart_port.icount.dsr++;
 685                 if (delta_status & ICOM_DCD)
 686                         uart_handle_dcd_change(&icom_port->uart_port,
 687                                                delta_status & ICOM_DCD);
 688                 if (delta_status & ICOM_CTS)
 689                         uart_handle_cts_change(&icom_port->uart_port,
 690                                                delta_status & ICOM_CTS);
 691
 692                 wake_up_interruptible(&icom_port->uart_port.info->
 693                                       delta_msr_wait);
 694                 old_status = status;
 695         }
 696         spin_unlock(&icom_port->uart_port.lock);
 697 }
 698
 699 static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 700 {
 701         unsigned short int count;
 702         int i;
 703
 704         if (port_int_reg & (INT_XMIT_COMPLETED)) {
 705                 trace(icom_port, "XMIT_COMPLETE", 0);
 706
 707                 /* clear buffer in use bit */
 708                 icom_port->statStg->xmit[0].flags &=
 709                         cpu_to_le16(~SA_FLAGS_READY_TO_XMIT);
 710
 711                 count = (unsigned short int)
 712                         cpu_to_le16(icom_port->statStg->xmit[0].leLength);
 713                 icom_port->uart_port.icount.tx += count;
 714
 715                 for (i=0; i<count &&
 716                         !uart_circ_empty(&icom_port->uart_port.info->xmit); i++) {
 717
 718                         icom_port->uart_port.info->xmit.tail++;
 719                         icom_port->uart_port.info->xmit.tail &=
 720                                 (UART_XMIT_SIZE - 1);
 721                 }
 722
 723                 if (!icom_write(&icom_port->uart_port))
 724                         /* activate write queue */
 725                         uart_write_wakeup(&icom_port->uart_port);
 726         } else
 727                 trace(icom_port, "XMIT_DISABLED", 0);
 728 }
 729
 730 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 731 {
 732         short int count, rcv_buff;
 733         struct tty_struct *tty = icom_port->uart_port.info->port.tty;
 734         unsigned short int status;
 735         struct uart_icount *icount;
 736         unsigned long offset;
 737         unsigned char flag;
 738
 739         trace(icom_port, "RCV_COMPLETE", 0);
 740         rcv_buff = icom_port->next_rcv;
 741
 742         status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
 743         while (status & SA_FL_RCV_DONE) {
 744                 int first = -1;
 745
 746                 trace(icom_port, "FID_STATUS", status);
 747                 count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
 748
 749                 count = tty_buffer_request_room(tty, count);
 750                 trace(icom_port, "RCV_COUNT", count);
 751
 752                 trace(icom_port, "REAL_COUNT", count);
 753
 754                 offset =
 755                         cpu_to_le32(icom_port->statStg->rcv[rcv_buff].leBuffer) -
 756                         icom_port->recv_buf_pci;
 757
 758                 /* Block copy all but the last byte as this may have status */
 759                 if (count > 0) {
 760                         first = icom_port->recv_buf[offset];
 761                         tty_insert_flip_string(tty, icom_port->recv_buf + offset, count - 1);
 762                 }
 763
 764                 icount = &icom_port->uart_port.icount;
 765                 icount->rx += count;
 766
 767                 /* Break detect logic */
 768                 if ((status & SA_FLAGS_FRAME_ERROR)
 769                     && first == 0) {
 770                         status &= ~SA_FLAGS_FRAME_ERROR;
 771                         status |= SA_FLAGS_BREAK_DET;
 772                         trace(icom_port, "BREAK_DET", 0);
 773                 }
 774
 775                 flag = TTY_NORMAL;
 776
 777                 if (status &
 778                     (SA_FLAGS_BREAK_DET | SA_FLAGS_PARITY_ERROR |
 779                      SA_FLAGS_FRAME_ERROR | SA_FLAGS_OVERRUN)) {
 780
 781                         if (status & SA_FLAGS_BREAK_DET)
 782                                 icount->brk++;
 783                         if (status & SA_FLAGS_PARITY_ERROR)
 784                                 icount->parity++;
 785                         if (status & SA_FLAGS_FRAME_ERROR)
 786                                 icount->frame++;
 787                         if (status & SA_FLAGS_OVERRUN)
 788                                 icount->overrun++;
 789
 790                         /*
 791                          * Now check to see if character should be
 792                          * ignored, and mask off conditions which
 793                          * should be ignored.
 794                          */
 795                         if (status & icom_port->ignore_status_mask) {
 796                                 trace(icom_port, "IGNORE_CHAR", 0);
 797                                 goto ignore_char;
 798                         }
 799
 800                         status &= icom_port->read_status_mask;
 801
 802                         if (status & SA_FLAGS_BREAK_DET) {
 803                                 flag = TTY_BREAK;
 804                         } else if (status & SA_FLAGS_PARITY_ERROR) {
 805                                 trace(icom_port, "PARITY_ERROR", 0);
 806                                 flag = TTY_PARITY;
 807                         } else if (status & SA_FLAGS_FRAME_ERROR)
 808                                 flag = TTY_FRAME;
 809
 810                 }
 811
 812                 tty_insert_flip_char(tty, *(icom_port->recv_buf + offset + count - 1), flag);
 813
 814                 if (status & SA_FLAGS_OVERRUN)
 815                         /*
 816                          * Overrun is special, since it's
 817                          * reported immediately, and doesn't
 818                          * affect the current character
 819                          */
 820                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 821 ignore_char:
 822                 icom_port->statStg->rcv[rcv_buff].flags = 0;
 823                 icom_port->statStg->rcv[rcv_buff].leLength = 0;
 824                 icom_port->statStg->rcv[rcv_buff].WorkingLength =
 825                         (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
 826
 827                 rcv_buff++;
 828                 if (rcv_buff == NUM_RBUFFS)
 829                         rcv_buff = 0;
 830
 831                 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
 832         }
 833         icom_port->next_rcv = rcv_buff;
 834         tty_flip_buffer_push(tty);
 835 }
 836
 837 static void process_interrupt(u16 port_int_reg,
 838                               struct icom_port *icom_port)
 839 {
 840
 841         spin_lock(&icom_port->uart_port.lock);
 842         trace(icom_port, "INTERRUPT", port_int_reg);
 843
 844         if (port_int_reg & (INT_XMIT_COMPLETED | INT_XMIT_DISABLED))
 845                 xmit_interrupt(port_int_reg, icom_port);
 846
 847         if (port_int_reg & INT_RCV_COMPLETED)
 848                 recv_interrupt(port_int_reg, icom_port);
 849
 850         spin_unlock(&icom_port->uart_port.lock);
 851 }
 852
 853 static irqreturn_t icom_interrupt(int irq, void *dev_id)
 854 {
 855         void __iomem * int_reg;
 856         u32 adapter_interrupts;
 857         u16 port_int_reg;
 858         struct icom_adapter *icom_adapter;
 859         struct icom_port *icom_port;
 860
 861         /* find icom_port for this interrupt */
 862         icom_adapter = (struct icom_adapter *) dev_id;
 863
 864         if ((icom_adapter->version | ADAPTER_V2) == ADAPTER_V2) {
 865                 int_reg = icom_adapter->base_addr + 0x8024;
 866
 867                 adapter_interrupts = readl(int_reg);
 868
 869                 if (adapter_interrupts & 0x00003FFF) {
 870                         /* port 2 interrupt,  NOTE:  for all ADAPTER_V2, port 2 will be active */
 871                         icom_port = &icom_adapter->port_info[2];
 872                         port_int_reg = (u16) adapter_interrupts;
 873                         process_interrupt(port_int_reg, icom_port);
 874                         check_modem_status(icom_port);
 875                 }
 876                 if (adapter_interrupts & 0x3FFF0000) {
 877                         /* port 3 interrupt */
 878                         icom_port = &icom_adapter->port_info[3];
 879                         if (icom_port->status == ICOM_PORT_ACTIVE) {
 880                                 port_int_reg =
 881                                     (u16) (adapter_interrupts >> 16);
 882                                 process_interrupt(port_int_reg, icom_port);
 883                                 check_modem_status(icom_port);
 884                         }
 885                 }
 886
 887                 /* Clear out any pending interrupts */
 888                 writel(adapter_interrupts, int_reg);
 889
 890                 int_reg = icom_adapter->base_addr + 0x8004;
 891         } else {
 892                 int_reg = icom_adapter->base_addr + 0x4004;
 893         }
 894
 895         adapter_interrupts = readl(int_reg);
 896
 897         if (adapter_interrupts & 0x00003FFF) {
 898                 /* port 0 interrupt, NOTE:  for all adapters, port 0 will be active */
 899                 icom_port = &icom_adapter->port_info[0];
 900                 port_int_reg = (u16) adapter_interrupts;
 901                 process_interrupt(port_int_reg, icom_port);
 902                 check_modem_status(icom_port);
 903         }
 904         if (adapter_interrupts & 0x3FFF0000) {
 905                 /* port 1 interrupt */
 906                 icom_port = &icom_adapter->port_info[1];
 907                 if (icom_port->status == ICOM_PORT_ACTIVE) {
 908                         port_int_reg = (u16) (adapter_interrupts >> 16);
 909                         process_interrupt(port_int_reg, icom_port);
 910                         check_modem_status(icom_port);
 911                 }
 912         }
 913
 914         /* Clear out any pending interrupts */
 915         writel(adapter_interrupts, int_reg);
 916
 917         /* flush the write */
 918         adapter_interrupts = readl(int_reg);
 919
 920         return IRQ_HANDLED;
 921 }
 922
 923 /*
 924  * ------------------------------------------------------------------
 925  * Begin serial-core API
 926  * ------------------------------------------------------------------
 927  */
 928 static unsigned int icom_tx_empty(struct uart_port *port)
 929 {
 930         int ret;
 931         unsigned long flags;
 932
 933         spin_lock_irqsave(&port->lock, flags);
 934         if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
 935             SA_FLAGS_READY_TO_XMIT)
 936                 ret = TIOCSER_TEMT;
 937         else
 938                 ret = 0;
 939
 940         spin_unlock_irqrestore(&port->lock, flags);
 941         return ret;
 942 }
 943
 944 static void icom_set_mctrl(struct uart_port *port, unsigned int mctrl)
 945 {
 946         unsigned char local_osr;
 947
 948         trace(ICOM_PORT, "SET_MODEM", 0);
 949         local_osr = readb(&ICOM_PORT->dram->osr);
 950
 951         if (mctrl & TIOCM_RTS) {
 952                 trace(ICOM_PORT, "RAISE_RTS", 0);
 953                 local_osr |= ICOM_RTS;
 954         } else {
 955                 trace(ICOM_PORT, "LOWER_RTS", 0);
 956                 local_osr &= ~ICOM_RTS;
 957         }
 958
 959         if (mctrl & TIOCM_DTR) {
 960                 trace(ICOM_PORT, "RAISE_DTR", 0);
 961                 local_osr |= ICOM_DTR;
 962         } else {
 963                 trace(ICOM_PORT, "LOWER_DTR", 0);
 964                 local_osr &= ~ICOM_DTR;
 965         }
 966
 967         writeb(local_osr, &ICOM_PORT->dram->osr);
 968 }
 969
 970 static unsigned int icom_get_mctrl(struct uart_port *port)
 971 {
 972         unsigned char status;
 973         unsigned int result;
 974
 975         trace(ICOM_PORT, "GET_MODEM", 0);
 976
 977         status = readb(&ICOM_PORT->dram->isr);
 978
 979         result = ((status & ICOM_DCD) ? TIOCM_CAR : 0)
 980             | ((status & ICOM_RI) ? TIOCM_RNG : 0)
 981             | ((status & ICOM_DSR) ? TIOCM_DSR : 0)
 982             | ((status & ICOM_CTS) ? TIOCM_CTS : 0);
 983         return result;
 984 }
 985
 986 static void icom_stop_tx(struct uart_port *port)
 987 {
 988         unsigned char cmdReg;
 989
 990         trace(ICOM_PORT, "STOP", 0);
 991         cmdReg = readb(&ICOM_PORT->dram->CmdReg);
 992         writeb(cmdReg | CMD_HOLD_XMIT, &ICOM_PORT->dram->CmdReg);
 993 }
 994
 995 static void icom_start_tx(struct uart_port *port)
 996 {
 997         unsigned char cmdReg;
 998
 999         trace(ICOM_PORT, "START", 0);
1000         cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1001         if ((cmdReg & CMD_HOLD_XMIT) == CMD_HOLD_XMIT)
1002                 writeb(cmdReg & ~CMD_HOLD_XMIT,
1003                        &ICOM_PORT->dram->CmdReg);
1004
1005         icom_write(port);
1006 }
1007
1008 static void icom_send_xchar(struct uart_port *port, char ch)
1009 {
1010         unsigned char xdata;
1011         int index;
1012         unsigned long flags;
1013
1014         trace(ICOM_PORT, "SEND_XCHAR", ch);
1015
1016         /* wait .1 sec to send char */
1017         for (index = 0; index < 10; index++) {
1018                 spin_lock_irqsave(&port->lock, flags);
1019                 xdata = readb(&ICOM_PORT->dram->xchar);
1020                 if (xdata == 0x00) {
1021                         trace(ICOM_PORT, "QUICK_WRITE", 0);
1022                         writeb(ch, &ICOM_PORT->dram->xchar);
1023
1024                         /* flush write operation */
1025                         xdata = readb(&ICOM_PORT->dram->xchar);
1026                         spin_unlock_irqrestore(&port->lock, flags);
1027                         break;
1028                 }
1029                 spin_unlock_irqrestore(&port->lock, flags);
1030                 msleep(10);
1031         }
1032 }
1033
1034 static void icom_stop_rx(struct uart_port *port)
1035 {
1036         unsigned char cmdReg;
1037
1038         cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1039         writeb(cmdReg & ~CMD_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1040 }
1041
1042 static void icom_enable_ms(struct uart_port *port)
1043 {
1044         /* no-op */
1045 }
1046
1047 static void icom_break(struct uart_port *port, int break_state)
1048 {
1049         unsigned char cmdReg;
1050         unsigned long flags;
1051
1052         spin_lock_irqsave(&port->lock, flags);
1053         trace(ICOM_PORT, "BREAK", 0);
1054         cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1055         if (break_state == -1) {
1056                 writeb(cmdReg | CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1057         } else {
1058                 writeb(cmdReg & ~CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1059         }
1060         spin_unlock_irqrestore(&port->lock, flags);
1061 }
1062
1063 static int icom_open(struct uart_port *port)
1064 {
1065         int retval;
1066
1067         kref_get(&ICOM_PORT->adapter->kref);
1068         retval = startup(ICOM_PORT);
1069
1070         if (retval) {
1071                 kref_put(&ICOM_PORT->adapter->kref, icom_kref_release);
1072                 trace(ICOM_PORT, "STARTUP_ERROR", 0);
1073                 return retval;
1074         }
1075
1076         return 0;
1077 }
1078
1079 static void icom_close(struct uart_port *port)
1080 {
1081         unsigned char cmdReg;
1082
1083         trace(ICOM_PORT, "CLOSE", 0);
1084
1085         /* stop receiver */
1086         cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1087         writeb(cmdReg & (unsigned char) ~CMD_RCV_ENABLE,
1088                &ICOM_PORT->dram->CmdReg);
1089
1090         shutdown(ICOM_PORT);
1091
1092         kref_put(&ICOM_PORT->adapter->kref, icom_kref_release);
1093 }
1094
1095 static void icom_set_termios(struct uart_port *port,
1096                              struct ktermios *termios,
1097                              struct ktermios *old_termios)
1098 {
1099         int baud;
1100         unsigned cflag, iflag;
1101         char new_config2;
1102         char new_config3 = 0;
1103         char tmp_byte;
1104         int index;
1105         int rcv_buff, xmit_buff;
1106         unsigned long offset;
1107         unsigned long flags;
1108
1109         spin_lock_irqsave(&port->lock, flags);
1110         trace(ICOM_PORT, "CHANGE_SPEED", 0);
1111
1112         cflag = termios->c_cflag;
1113         iflag = termios->c_iflag;
1114
1115         new_config2 = ICOM_ACFG_DRIVE1;
1116
1117         /* byte size and parity */
1118         switch (cflag & CSIZE) {
1119         case CS5:               /* 5 bits/char */
1120                 new_config2 |= ICOM_ACFG_5BPC;
1121                 break;
1122         case CS6:               /* 6 bits/char */
1123                 new_config2 |= ICOM_ACFG_6BPC;
1124                 break;
1125         case CS7:               /* 7 bits/char */
1126                 new_config2 |= ICOM_ACFG_7BPC;
1127                 break;
1128         case CS8:               /* 8 bits/char */
1129                 new_config2 |= ICOM_ACFG_8BPC;
1130                 break;
1131         default:
1132                 break;
1133         }
1134         if (cflag & CSTOPB) {
1135                 /* 2 stop bits */
1136                 new_config2 |= ICOM_ACFG_2STOP_BIT;
1137         }
1138         if (cflag & PARENB) {
1139                 /* parity bit enabled */
1140                 new_config2 |= ICOM_ACFG_PARITY_ENAB;
1141                 trace(ICOM_PORT, "PARENB", 0);
1142         }
1143         if (cflag & PARODD) {
1144                 /* odd parity */
1145                 new_config2 |= ICOM_ACFG_PARITY_ODD;
1146                 trace(ICOM_PORT, "PARODD", 0);
1147         }
1148
1149         /* Determine divisor based on baud rate */
1150         baud = uart_get_baud_rate(port, termios, old_termios,
1151                                   icom_acfg_baud[0],
1152                                   icom_acfg_baud[BAUD_TABLE_LIMIT]);
1153         if (!baud)
1154                 baud = 9600;    /* B0 transition handled in rs_set_termios */
1155
1156         for (index = 0; index < BAUD_TABLE_LIMIT; index++) {
1157                 if (icom_acfg_baud[index] == baud) {
1158                         new_config3 = index;
1159                         break;
1160                 }
1161         }
1162
1163         uart_update_timeout(port, cflag, baud);
1164
1165         /* CTS flow control flag and modem status interrupts */
1166         tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1167         if (cflag & CRTSCTS)
1168                 tmp_byte |= HDLC_HDW_FLOW;
1169         else
1170                 tmp_byte &= ~HDLC_HDW_FLOW;
1171         writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1172
1173         /*
1174          * Set up parity check flag
1175          */
1176         ICOM_PORT->read_status_mask = SA_FLAGS_OVERRUN | SA_FL_RCV_DONE;
1177         if (iflag & INPCK)
1178                 ICOM_PORT->read_status_mask |=
1179                     SA_FLAGS_FRAME_ERROR | SA_FLAGS_PARITY_ERROR;
1180
1181         if ((iflag & BRKINT) || (iflag & PARMRK))
1182                 ICOM_PORT->read_status_mask |= SA_FLAGS_BREAK_DET;
1183
1184         /*
1185          * Characters to ignore
1186          */
1187         ICOM_PORT->ignore_status_mask = 0;
1188         if (iflag & IGNPAR)
1189                 ICOM_PORT->ignore_status_mask |=
1190                     SA_FLAGS_PARITY_ERROR | SA_FLAGS_FRAME_ERROR;
1191         if (iflag & IGNBRK) {
1192                 ICOM_PORT->ignore_status_mask |= SA_FLAGS_BREAK_DET;
1193                 /*
1194                  * If we're ignore parity and break indicators, ignore
1195                  * overruns too.  (For real raw support).
1196                  */
1197                 if (iflag & IGNPAR)
1198                         ICOM_PORT->ignore_status_mask |= SA_FLAGS_OVERRUN;
1199         }
1200
1201         /*
1202          * !!! ignore all characters if CREAD is not set
1203          */
1204         if ((cflag & CREAD) == 0)
1205                 ICOM_PORT->ignore_status_mask |= SA_FL_RCV_DONE;
1206
1207         /* Turn off Receiver to prepare for reset */
1208         writeb(CMD_RCV_DISABLE, &ICOM_PORT->dram->CmdReg);
1209
1210         for (index = 0; index < 10; index++) {
1211                 if (readb(&ICOM_PORT->dram->PrevCmdReg) == 0x00) {
1212                         break;
1213                 }
1214         }
1215
1216         /* clear all current buffers of data */
1217         for (rcv_buff = 0; rcv_buff < NUM_RBUFFS; rcv_buff++) {
1218                 ICOM_PORT->statStg->rcv[rcv_buff].flags = 0;
1219                 ICOM_PORT->statStg->rcv[rcv_buff].leLength = 0;
1220                 ICOM_PORT->statStg->rcv[rcv_buff].WorkingLength =
1221                     (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
1222         }
1223
1224         for (xmit_buff = 0; xmit_buff < NUM_XBUFFS; xmit_buff++) {
1225                 ICOM_PORT->statStg->xmit[xmit_buff].flags = 0;
1226         }
1227
1228         /* activate changes and start xmit and receiver here */
1229         /* Enable the receiver */
1230         writeb(new_config3, &(ICOM_PORT->dram->async_config3));
1231         writeb(new_config2, &(ICOM_PORT->dram->async_config2));
1232         tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1233         tmp_byte |= HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL;
1234         writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1235         writeb(0x04, &(ICOM_PORT->dram->FlagFillIdleTimer));    /* 0.5 seconds */
1236         writeb(0xFF, &(ICOM_PORT->dram->ier));  /* enable modem signal interrupts */
1237
1238         /* reset processor */
1239         writeb(CMD_RESTART, &ICOM_PORT->dram->CmdReg);
1240
1241         for (index = 0; index < 10; index++) {
1242                 if (readb(&ICOM_PORT->dram->CmdReg) == 0x00) {
1243                         break;
1244                 }
1245         }
1246
1247         /* Enable Transmitter and Reciever */
1248         offset =
1249             (unsigned long) &ICOM_PORT->statStg->rcv[0] -
1250             (unsigned long) ICOM_PORT->statStg;
1251         writel(ICOM_PORT->statStg_pci + offset,
1252                &ICOM_PORT->dram->RcvStatusAddr);
1253         ICOM_PORT->next_rcv = 0;
1254         ICOM_PORT->put_length = 0;
1255         *ICOM_PORT->xmitRestart = 0;
1256         writel(ICOM_PORT->xmitRestart_pci,
1257                &ICOM_PORT->dram->XmitStatusAddr);
1258         trace(ICOM_PORT, "XR_ENAB", 0);
1259         writeb(CMD_XMIT_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1260
1261         spin_unlock_irqrestore(&port->lock, flags);
1262 }
1263
1264 static const char *icom_type(struct uart_port *port)
1265 {
1266         return "icom";
1267 }
1268
1269 static void icom_release_port(struct uart_port *port)
1270 {
1271 }
1272
1273 static int icom_request_port(struct uart_port *port)
1274 {
1275         return 0;
1276 }
1277
1278 static void icom_config_port(struct uart_port *port, int flags)
1279 {
1280         port->type = PORT_ICOM;
1281 }
1282
1283 static struct uart_ops icom_ops = {
1284         .tx_empty = icom_tx_empty,
1285         .set_mctrl = icom_set_mctrl,
1286         .get_mctrl = icom_get_mctrl,
1287         .stop_tx = icom_stop_tx,
1288         .start_tx = icom_start_tx,
1289         .send_xchar = icom_send_xchar,
1290         .stop_rx = icom_stop_rx,
1291         .enable_ms = icom_enable_ms,
1292         .break_ctl = icom_break,
1293         .startup = icom_open,
1294         .shutdown = icom_close,
1295         .set_termios = icom_set_termios,
1296         .type = icom_type,
1297         .release_port = icom_release_port,
1298         .request_port = icom_request_port,
1299         .config_port = icom_config_port,
1300 };
1301
1302 #define ICOM_CONSOLE NULL
1303
1304 static struct uart_driver icom_uart_driver = {
1305         .owner = THIS_MODULE,
1306         .driver_name = ICOM_DRIVER_NAME,
1307         .dev_name = "ttyA",
1308         .major = ICOM_MAJOR,
1309         .minor = ICOM_MINOR_START,
1310         .nr = NR_PORTS,
1311         .cons = ICOM_CONSOLE,
1312 };
1313
1314 static int __devinit icom_init_ports(struct icom_adapter *icom_adapter)
1315 {
1316         u32 subsystem_id = icom_adapter->subsystem_id;
1317         int i;
1318         struct icom_port *icom_port;
1319
1320         if (icom_adapter->version == ADAPTER_V1) {
1321                 icom_adapter->numb_ports = 2;
1322
1323                 for (i = 0; i < 2; i++) {
1324                         icom_port = &icom_adapter->port_info[i];
1325                         icom_port->port = i;
1326                         icom_port->status = ICOM_PORT_ACTIVE;
1327                         icom_port->imbed_modem = ICOM_UNKNOWN;
1328                 }
1329         } else {
1330                 if (subsystem_id == PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL) {
1331                         icom_adapter->numb_ports = 4;
1332
1333                         for (i = 0; i < 4; i++) {
1334                                 icom_port = &icom_adapter->port_info[i];
1335
1336                                 icom_port->port = i;
1337                                 icom_port->status = ICOM_PORT_ACTIVE;
1338                                 icom_port->imbed_modem = ICOM_IMBED_MODEM;
1339                         }
1340                 } else {
1341                         icom_adapter->numb_ports = 4;
1342
1343                         icom_adapter->port_info[0].port = 0;
1344                         icom_adapter->port_info[0].status = ICOM_PORT_ACTIVE;
1345
1346                         if (subsystem_id ==
1347                             PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM) {
1348                                 icom_adapter->port_info[0].imbed_modem = ICOM_IMBED_MODEM;
1349                         } else {
1350                                 icom_adapter->port_info[0].imbed_modem = ICOM_RVX;
1351                         }
1352
1353                         icom_adapter->port_info[1].status = ICOM_PORT_OFF;
1354
1355                         icom_adapter->port_info[2].port = 2;
1356                         icom_adapter->port_info[2].status = ICOM_PORT_ACTIVE;
1357                         icom_adapter->port_info[2].imbed_modem = ICOM_RVX;
1358                         icom_adapter->port_info[3].status = ICOM_PORT_OFF;
1359                 }
1360         }
1361
1362         return 0;
1363 }
1364
1365 static void icom_port_active(struct icom_port *icom_port, struct icom_adapter *icom_adapter, int port_num)
1366 {
1367         if (icom_adapter->version == ADAPTER_V1) {
1368                 icom_port->global_reg = icom_adapter->base_addr + 0x4000;
1369                 icom_port->int_reg = icom_adapter->base_addr +
1370                     0x4004 + 2 - 2 * port_num;
1371         } else {
1372                 icom_port->global_reg = icom_adapter->base_addr + 0x8000;
1373                 if (icom_port->port < 2)
1374                         icom_port->int_reg = icom_adapter->base_addr +
1375                             0x8004 + 2 - 2 * icom_port->port;
1376                 else
1377                         icom_port->int_reg = icom_adapter->base_addr +
1378                             0x8024 + 2 - 2 * (icom_port->port - 2);
1379         }
1380 }
1381 static int __devinit icom_load_ports(struct icom_adapter *icom_adapter)
1382 {
1383         struct icom_port *icom_port;
1384         int port_num;
1385
1386         for (port_num = 0; port_num < icom_adapter->numb_ports; port_num++) {
1387
1388                 icom_port = &icom_adapter->port_info[port_num];
1389
1390                 if (icom_port->status == ICOM_PORT_ACTIVE) {
1391                         icom_port_active(icom_port, icom_adapter, port_num);
1392                         icom_port->dram = icom_adapter->base_addr +
1393                                         0x2000 * icom_port->port;
1394
1395                         icom_port->adapter = icom_adapter;
1396
1397                         /* get port memory */
1398                         if (get_port_memory(icom_port) != 0) {
1399                                 dev_err(&icom_port->adapter->pci_dev->dev,
1400                                         "Memory allocation for port FAILED\n");
1401                         }
1402                 }
1403         }
1404         return 0;
1405 }
1406
1407 static int __devinit icom_alloc_adapter(struct icom_adapter
1408                                         **icom_adapter_ref)
1409 {
1410         int adapter_count = 0;
1411         struct icom_adapter *icom_adapter;
1412         struct icom_adapter *cur_adapter_entry;
1413         struct list_head *tmp;
1414
1415         icom_adapter = (struct icom_adapter *)
1416             kzalloc(sizeof(struct icom_adapter), GFP_KERNEL);
1417
1418         if (!icom_adapter) {
1419                 return -ENOMEM;
1420         }
1421
1422         list_for_each(tmp, &icom_adapter_head) {
1423                 cur_adapter_entry =
1424                     list_entry(tmp, struct icom_adapter,
1425                                icom_adapter_entry);
1426                 if (cur_adapter_entry->index != adapter_count) {
1427                         break;
1428                 }
1429                 adapter_count++;
1430         }
1431
1432         icom_adapter->index = adapter_count;
1433         list_add_tail(&icom_adapter->icom_adapter_entry, tmp);
1434
1435         *icom_adapter_ref = icom_adapter;
1436         return 0;
1437 }
1438
1439 static void icom_free_adapter(struct icom_adapter *icom_adapter)
1440 {
1441         list_del(&icom_adapter->icom_adapter_entry);
1442         kfree(icom_adapter);
1443 }
1444
1445 static void icom_remove_adapter(struct icom_adapter *icom_adapter)
1446 {
1447         struct icom_port *icom_port;
1448         int index;
1449
1450         for (index = 0; index < icom_adapter->numb_ports; index++) {
1451                 icom_port = &icom_adapter->port_info[index];
1452
1453                 if (icom_port->status == ICOM_PORT_ACTIVE) {
1454                         dev_info(&icom_adapter->pci_dev->dev,
1455                                  "Device removed\n");
1456
1457                         uart_remove_one_port(&icom_uart_driver,
1458                                              &icom_port->uart_port);
1459
1460                         /* be sure that DTR and RTS are dropped */
1461                         writeb(0x00, &icom_port->dram->osr);
1462
1463                         /* Wait 0.1 Sec for simple Init to complete */
1464                         msleep(100);
1465
1466                         /* Stop proccessor */
1467                         stop_processor(icom_port);
1468
1469                         free_port_memory(icom_port);
1470                 }
1471         }
1472
1473         free_irq(icom_adapter->pci_dev->irq, (void *) icom_adapter);
1474         iounmap(icom_adapter->base_addr);
1475         pci_release_regions(icom_adapter->pci_dev);
1476         icom_free_adapter(icom_adapter);
1477 }
1478
1479 static void icom_kref_release(struct kref *kref)
1480 {
1481         struct icom_adapter *icom_adapter;
1482
1483         icom_adapter = to_icom_adapter(kref);
1484         icom_remove_adapter(icom_adapter);
1485 }
1486
1487 static int __devinit icom_probe(struct pci_dev *dev,
1488                                 const struct pci_device_id *ent)
1489 {
1490         int index;
1491         unsigned int command_reg;
1492         int retval;
1493         struct icom_adapter *icom_adapter;
1494         struct icom_port *icom_port;
1495
1496         retval = pci_enable_device(dev);
1497         if (retval) {
1498                 dev_err(&dev->dev, "Device enable FAILED\n");
1499                 return retval;
1500         }
1501
1502         if ( (retval = pci_request_regions(dev, "icom"))) {
1503                  dev_err(&dev->dev, "pci_request_regions FAILED\n");
1504                  pci_disable_device(dev);
1505                  return retval;
1506          }
1507
1508         pci_set_master(dev);
1509
1510         if ( (retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg))) {
1511                 dev_err(&dev->dev, "PCI Config read FAILED\n");
1512                 return retval;
1513         }
1514
1515         pci_write_config_dword(dev, PCI_COMMAND,
1516                 command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER
1517                 | PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
1518
1519         if (ent->driver_data == ADAPTER_V1) {
1520                 pci_write_config_dword(dev, 0x44, 0x8300830A);
1521          } else {
1522                 pci_write_config_dword(dev, 0x44, 0x42004200);
1523                 pci_write_config_dword(dev, 0x48, 0x42004200);
1524          }
1525
1526
1527         retval = icom_alloc_adapter(&icom_adapter);
1528         if (retval) {
1529                  dev_err(&dev->dev, "icom_alloc_adapter FAILED\n");
1530                  retval = -EIO;
1531                  goto probe_exit0;
1532         }
1533
1534          icom_adapter->base_addr_pci = pci_resource_start(dev, 0);
1535          icom_adapter->pci_dev = dev;
1536          icom_adapter->version = ent->driver_data;
1537          icom_adapter->subsystem_id = ent->subdevice;
1538
1539
1540         retval = icom_init_ports(icom_adapter);
1541         if (retval) {
1542                 dev_err(&dev->dev, "Port configuration failed\n");
1543                 goto probe_exit1;
1544         }
1545
1546          icom_adapter->base_addr = ioremap(icom_adapter->base_addr_pci,
1547                                                 pci_resource_len(dev, 0));
1548
1549         if (!icom_adapter->base_addr)
1550                 goto probe_exit1;
1551
1552          /* save off irq and request irq line */
1553          if ( (retval = request_irq(dev->irq, icom_interrupt,
1554                                    IRQF_DISABLED | IRQF_SHARED, ICOM_DRIVER_NAME,
1555                                    (void *) icom_adapter))) {
1556                   goto probe_exit2;
1557          }
1558
1559         retval = icom_load_ports(icom_adapter);
1560
1561         for (index = 0; index < icom_adapter->numb_ports; index++) {
1562                 icom_port = &icom_adapter->port_info[index];
1563
1564                 if (icom_port->status == ICOM_PORT_ACTIVE) {
1565                         icom_port->uart_port.irq = icom_port->adapter->pci_dev->irq;
1566                         icom_port->uart_port.type = PORT_ICOM;
1567                         icom_port->uart_port.iotype = UPIO_MEM;
1568                         icom_port->uart_port.membase =
1569                                                (char *) icom_adapter->base_addr_pci;
1570                         icom_port->uart_port.fifosize = 16;
1571                         icom_port->uart_port.ops = &icom_ops;
1572                         icom_port->uart_port.line =
1573                         icom_port->port + icom_adapter->index * 4;
1574                         if (uart_add_one_port (&icom_uart_driver, &icom_port->uart_port)) {
1575                                 icom_port->status = ICOM_PORT_OFF;
1576                                 dev_err(&dev->dev, "Device add failed\n");
1577                          } else
1578                                 dev_info(&dev->dev, "Device added\n");
1579                 }
1580         }
1581
1582         kref_init(&icom_adapter->kref);
1583         return 0;
1584
1585 probe_exit2:
1586         iounmap(icom_adapter->base_addr);
1587 probe_exit1:
1588         icom_free_adapter(icom_adapter);
1589
1590 probe_exit0:
1591         pci_release_regions(dev);
1592         pci_disable_device(dev);
1593
1594         return retval;
1595
1596
1597 }
1598
1599 static void __devexit icom_remove(struct pci_dev *dev)
1600 {
1601         struct icom_adapter *icom_adapter;
1602         struct list_head *tmp;
1603
1604         list_for_each(tmp, &icom_adapter_head) {
1605                 icom_adapter = list_entry(tmp, struct icom_adapter,
1606                                           icom_adapter_entry);
1607                 if (icom_adapter->pci_dev == dev) {
1608                         kref_put(&icom_adapter->kref, icom_kref_release);
1609                         return;
1610                 }
1611         }
1612
1613         dev_err(&dev->dev, "Unable to find device to remove\n");
1614 }
1615
1616 static struct pci_driver icom_pci_driver = {
1617         .name = ICOM_DRIVER_NAME,
1618         .id_table = icom_pci_table,
1619         .probe = icom_probe,
1620         .remove = __devexit_p(icom_remove),
1621 };
1622
1623 static int __init icom_init(void)
1624 {
1625         int ret;
1626
1627         spin_lock_init(&icom_lock);
1628
1629         ret = uart_register_driver(&icom_uart_driver);
1630         if (ret)
1631                 return ret;
1632
1633         ret = pci_register_driver(&icom_pci_driver);
1634
1635         if (ret < 0)
1636                 uart_unregister_driver(&icom_uart_driver);
1637
1638         return ret;
1639 }
1640
1641 static void __exit icom_exit(void)
1642 {
1643         pci_unregister_driver(&icom_pci_driver);
1644         uart_unregister_driver(&icom_uart_driver);
1645 }
1646
1647 module_init(icom_init);
1648 module_exit(icom_exit);
1649
1650 #ifdef ICOM_TRACE
1651 static inline void trace(struct icom_port *icom_port, char *trace_pt,
1652                   unsigned long trace_data)
1653 {
1654         dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
1655                  icom_port->port, trace_pt, trace_data);
1656 }
1657 #endif
1658
1659 MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1660 MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1661 MODULE_SUPPORTED_DEVICE
1662     ("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
1663 MODULE_LICENSE("GPL");
1664