git.oblomov.eu Git - linux-2.6/blob - 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         int bits;
1102         char new_config2;
1103         char new_config3 = 0;
1104         char tmp_byte;
1105         int index;
1106         int rcv_buff, xmit_buff;
1107         unsigned long offset;
1108         unsigned long flags;
1109
1110         spin_lock_irqsave(&port->lock, flags);
1111         trace(ICOM_PORT, "CHANGE_SPEED", 0);
1112
1113         cflag = termios->c_cflag;
1114         iflag = termios->c_iflag;
1115
1116         new_config2 = ICOM_ACFG_DRIVE1;
1117
1118         /* byte size and parity */
1119         switch (cflag & CSIZE) {
1120         case CS5:               /* 5 bits/char */
1121                 new_config2 |= ICOM_ACFG_5BPC;
1122                 bits = 7;
1123                 break;
1124         case CS6:               /* 6 bits/char */
1125                 new_config2 |= ICOM_ACFG_6BPC;
1126                 bits = 8;
1127                 break;
1128         case CS7:               /* 7 bits/char */
1129                 new_config2 |= ICOM_ACFG_7BPC;
1130                 bits = 9;
1131                 break;
1132         case CS8:               /* 8 bits/char */
1133                 new_config2 |= ICOM_ACFG_8BPC;
1134                 bits = 10;
1135                 break;
1136         default:
1137                 bits = 10;
1138                 break;
1139         }
1140         if (cflag & CSTOPB) {
1141                 /* 2 stop bits */
1142                 new_config2 |= ICOM_ACFG_2STOP_BIT;
1143                 bits++;
1144         }
1145         if (cflag & PARENB) {
1146                 /* parity bit enabled */
1147                 new_config2 |= ICOM_ACFG_PARITY_ENAB;
1148                 trace(ICOM_PORT, "PARENB", 0);
1149                 bits++;
1150         }
1151         if (cflag & PARODD) {
1152                 /* odd parity */
1153                 new_config2 |= ICOM_ACFG_PARITY_ODD;
1154                 trace(ICOM_PORT, "PARODD", 0);
1155         }
1156
1157         /* Determine divisor based on baud rate */
1158         baud = uart_get_baud_rate(port, termios, old_termios,
1159                                   icom_acfg_baud[0],
1160                                   icom_acfg_baud[BAUD_TABLE_LIMIT]);
1161         if (!baud)
1162                 baud = 9600;    /* B0 transition handled in rs_set_termios */
1163
1164         for (index = 0; index < BAUD_TABLE_LIMIT; index++) {
1165                 if (icom_acfg_baud[index] == baud) {
1166                         new_config3 = index;
1167                         break;
1168                 }
1169         }
1170
1171         uart_update_timeout(port, cflag, baud);
1172
1173         /* CTS flow control flag and modem status interrupts */
1174         tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1175         if (cflag & CRTSCTS)
1176                 tmp_byte |= HDLC_HDW_FLOW;
1177         else
1178                 tmp_byte &= ~HDLC_HDW_FLOW;
1179         writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1180
1181         /*
1182          * Set up parity check flag
1183          */
1184         ICOM_PORT->read_status_mask = SA_FLAGS_OVERRUN | SA_FL_RCV_DONE;
1185         if (iflag & INPCK)
1186                 ICOM_PORT->read_status_mask |=
1187                     SA_FLAGS_FRAME_ERROR | SA_FLAGS_PARITY_ERROR;
1188
1189         if ((iflag & BRKINT) || (iflag & PARMRK))
1190                 ICOM_PORT->read_status_mask |= SA_FLAGS_BREAK_DET;
1191
1192         /*
1193          * Characters to ignore
1194          */
1195         ICOM_PORT->ignore_status_mask = 0;
1196         if (iflag & IGNPAR)
1197                 ICOM_PORT->ignore_status_mask |=
1198                     SA_FLAGS_PARITY_ERROR | SA_FLAGS_FRAME_ERROR;
1199         if (iflag & IGNBRK) {
1200                 ICOM_PORT->ignore_status_mask |= SA_FLAGS_BREAK_DET;
1201                 /*
1202                  * If we're ignore parity and break indicators, ignore
1203                  * overruns too.  (For real raw support).
1204                  */
1205                 if (iflag & IGNPAR)
1206                         ICOM_PORT->ignore_status_mask |= SA_FLAGS_OVERRUN;
1207         }
1208
1209         /*
1210          * !!! ignore all characters if CREAD is not set
1211          */
1212         if ((cflag & CREAD) == 0)
1213                 ICOM_PORT->ignore_status_mask |= SA_FL_RCV_DONE;
1214
1215         /* Turn off Receiver to prepare for reset */
1216         writeb(CMD_RCV_DISABLE, &ICOM_PORT->dram->CmdReg);
1217
1218         for (index = 0; index < 10; index++) {
1219                 if (readb(&ICOM_PORT->dram->PrevCmdReg) == 0x00) {
1220                         break;
1221                 }
1222         }
1223
1224         /* clear all current buffers of data */
1225         for (rcv_buff = 0; rcv_buff < NUM_RBUFFS; rcv_buff++) {
1226                 ICOM_PORT->statStg->rcv[rcv_buff].flags = 0;
1227                 ICOM_PORT->statStg->rcv[rcv_buff].leLength = 0;
1228                 ICOM_PORT->statStg->rcv[rcv_buff].WorkingLength =
1229                     (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
1230         }
1231
1232         for (xmit_buff = 0; xmit_buff < NUM_XBUFFS; xmit_buff++) {
1233                 ICOM_PORT->statStg->xmit[xmit_buff].flags = 0;
1234         }
1235
1236         /* activate changes and start xmit and receiver here */
1237         /* Enable the receiver */
1238         writeb(new_config3, &(ICOM_PORT->dram->async_config3));
1239         writeb(new_config2, &(ICOM_PORT->dram->async_config2));
1240         tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1241         tmp_byte |= HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL;
1242         writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1243         writeb(0x04, &(ICOM_PORT->dram->FlagFillIdleTimer));    /* 0.5 seconds */
1244         writeb(0xFF, &(ICOM_PORT->dram->ier));  /* enable modem signal interrupts */
1245
1246         /* reset processor */
1247         writeb(CMD_RESTART, &ICOM_PORT->dram->CmdReg);
1248
1249         for (index = 0; index < 10; index++) {
1250                 if (readb(&ICOM_PORT->dram->CmdReg) == 0x00) {
1251                         break;
1252                 }
1253         }
1254
1255         /* Enable Transmitter and Reciever */
1256         offset =
1257             (unsigned long) &ICOM_PORT->statStg->rcv[0] -
1258             (unsigned long) ICOM_PORT->statStg;
1259         writel(ICOM_PORT->statStg_pci + offset,
1260                &ICOM_PORT->dram->RcvStatusAddr);
1261         ICOM_PORT->next_rcv = 0;
1262         ICOM_PORT->put_length = 0;
1263         *ICOM_PORT->xmitRestart = 0;
1264         writel(ICOM_PORT->xmitRestart_pci,
1265                &ICOM_PORT->dram->XmitStatusAddr);
1266         trace(ICOM_PORT, "XR_ENAB", 0);
1267         writeb(CMD_XMIT_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1268
1269         spin_unlock_irqrestore(&port->lock, flags);
1270 }
1271
1272 static const char *icom_type(struct uart_port *port)
1273 {
1274         return "icom";
1275 }
1276
1277 static void icom_release_port(struct uart_port *port)
1278 {
1279 }
1280
1281 static int icom_request_port(struct uart_port *port)
1282 {
1283         return 0;
1284 }
1285
1286 static void icom_config_port(struct uart_port *port, int flags)
1287 {
1288         port->type = PORT_ICOM;
1289 }
1290
1291 static struct uart_ops icom_ops = {
1292         .tx_empty = icom_tx_empty,
1293         .set_mctrl = icom_set_mctrl,
1294         .get_mctrl = icom_get_mctrl,
1295         .stop_tx = icom_stop_tx,
1296         .start_tx = icom_start_tx,
1297         .send_xchar = icom_send_xchar,
1298         .stop_rx = icom_stop_rx,
1299         .enable_ms = icom_enable_ms,
1300         .break_ctl = icom_break,
1301         .startup = icom_open,
1302         .shutdown = icom_close,
1303         .set_termios = icom_set_termios,
1304         .type = icom_type,
1305         .release_port = icom_release_port,
1306         .request_port = icom_request_port,
1307         .config_port = icom_config_port,
1308 };
1309
1310 #define ICOM_CONSOLE NULL
1311
1312 static struct uart_driver icom_uart_driver = {
1313         .owner = THIS_MODULE,
1314         .driver_name = ICOM_DRIVER_NAME,
1315         .dev_name = "ttyA",
1316         .major = ICOM_MAJOR,
1317         .minor = ICOM_MINOR_START,
1318         .nr = NR_PORTS,
1319         .cons = ICOM_CONSOLE,
1320 };
1321
1322 static int __devinit icom_init_ports(struct icom_adapter *icom_adapter)
1323 {
1324         u32 subsystem_id = icom_adapter->subsystem_id;
1325         int retval = 0;
1326         int i;
1327         struct icom_port *icom_port;
1328
1329         if (icom_adapter->version == ADAPTER_V1) {
1330                 icom_adapter->numb_ports = 2;
1331
1332                 for (i = 0; i < 2; i++) {
1333                         icom_port = &icom_adapter->port_info[i];
1334                         icom_port->port = i;
1335                         icom_port->status = ICOM_PORT_ACTIVE;
1336                         icom_port->imbed_modem = ICOM_UNKNOWN;
1337                 }
1338         } else {
1339                 if (subsystem_id == PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL) {
1340                         icom_adapter->numb_ports = 4;
1341
1342                         for (i = 0; i < 4; i++) {
1343                                 icom_port = &icom_adapter->port_info[i];
1344
1345                                 icom_port->port = i;
1346                                 icom_port->status = ICOM_PORT_ACTIVE;
1347                                 icom_port->imbed_modem = ICOM_IMBED_MODEM;
1348                         }
1349                 } else {
1350                         icom_adapter->numb_ports = 4;
1351
1352                         icom_adapter->port_info[0].port = 0;
1353                         icom_adapter->port_info[0].status = ICOM_PORT_ACTIVE;
1354
1355                         if (subsystem_id ==
1356                             PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM) {
1357                                 icom_adapter->port_info[0].imbed_modem = ICOM_IMBED_MODEM;
1358                         } else {
1359                                 icom_adapter->port_info[0].imbed_modem = ICOM_RVX;
1360                         }
1361
1362                         icom_adapter->port_info[1].status = ICOM_PORT_OFF;
1363
1364                         icom_adapter->port_info[2].port = 2;
1365                         icom_adapter->port_info[2].status = ICOM_PORT_ACTIVE;
1366                         icom_adapter->port_info[2].imbed_modem = ICOM_RVX;
1367                         icom_adapter->port_info[3].status = ICOM_PORT_OFF;
1368                 }
1369         }
1370
1371         return retval;
1372 }
1373
1374 static void icom_port_active(struct icom_port *icom_port, struct icom_adapter *icom_adapter, int port_num)
1375 {
1376         if (icom_adapter->version == ADAPTER_V1) {
1377                 icom_port->global_reg = icom_adapter->base_addr + 0x4000;
1378                 icom_port->int_reg = icom_adapter->base_addr +
1379                     0x4004 + 2 - 2 * port_num;
1380         } else {
1381                 icom_port->global_reg = icom_adapter->base_addr + 0x8000;
1382                 if (icom_port->port < 2)
1383                         icom_port->int_reg = icom_adapter->base_addr +
1384                             0x8004 + 2 - 2 * icom_port->port;
1385                 else
1386                         icom_port->int_reg = icom_adapter->base_addr +
1387                             0x8024 + 2 - 2 * (icom_port->port - 2);
1388         }
1389 }
1390 static int __devinit icom_load_ports(struct icom_adapter *icom_adapter)
1391 {
1392         struct icom_port *icom_port;
1393         int port_num;
1394         int retval;
1395
1396         for (port_num = 0; port_num < icom_adapter->numb_ports; port_num++) {
1397
1398                 icom_port = &icom_adapter->port_info[port_num];
1399
1400                 if (icom_port->status == ICOM_PORT_ACTIVE) {
1401                         icom_port_active(icom_port, icom_adapter, port_num);
1402                         icom_port->dram = icom_adapter->base_addr +
1403                                         0x2000 * icom_port->port;
1404
1405                         icom_port->adapter = icom_adapter;
1406
1407                         /* get port memory */
1408                         if ((retval = get_port_memory(icom_port)) != 0) {
1409                                 dev_err(&icom_port->adapter->pci_dev->dev,
1410                                         "Memory allocation for port FAILED\n");
1411                         }
1412                 }
1413         }
1414         return 0;
1415 }
1416
1417 static int __devinit icom_alloc_adapter(struct icom_adapter
1418                                         **icom_adapter_ref)
1419 {
1420         int adapter_count = 0;
1421         struct icom_adapter *icom_adapter;
1422         struct icom_adapter *cur_adapter_entry;
1423         struct list_head *tmp;
1424
1425         icom_adapter = (struct icom_adapter *)
1426             kzalloc(sizeof(struct icom_adapter), GFP_KERNEL);
1427
1428         if (!icom_adapter) {
1429                 return -ENOMEM;
1430         }
1431
1432         list_for_each(tmp, &icom_adapter_head) {
1433                 cur_adapter_entry =
1434                     list_entry(tmp, struct icom_adapter,
1435                                icom_adapter_entry);
1436                 if (cur_adapter_entry->index != adapter_count) {
1437                         break;
1438                 }
1439                 adapter_count++;
1440         }
1441
1442         icom_adapter->index = adapter_count;
1443         list_add_tail(&icom_adapter->icom_adapter_entry, tmp);
1444
1445         *icom_adapter_ref = icom_adapter;
1446         return 0;
1447 }
1448
1449 static void icom_free_adapter(struct icom_adapter *icom_adapter)
1450 {
1451         list_del(&icom_adapter->icom_adapter_entry);
1452         kfree(icom_adapter);
1453 }
1454
1455 static void icom_remove_adapter(struct icom_adapter *icom_adapter)
1456 {
1457         struct icom_port *icom_port;
1458         int index;
1459
1460         for (index = 0; index < icom_adapter->numb_ports; index++) {
1461                 icom_port = &icom_adapter->port_info[index];
1462
1463                 if (icom_port->status == ICOM_PORT_ACTIVE) {
1464                         dev_info(&icom_adapter->pci_dev->dev,
1465                                  "Device removed\n");
1466
1467                         uart_remove_one_port(&icom_uart_driver,
1468                                              &icom_port->uart_port);
1469
1470                         /* be sure that DTR and RTS are dropped */
1471                         writeb(0x00, &icom_port->dram->osr);
1472
1473                         /* Wait 0.1 Sec for simple Init to complete */
1474                         msleep(100);
1475
1476                         /* Stop proccessor */
1477                         stop_processor(icom_port);
1478
1479                         free_port_memory(icom_port);
1480                 }
1481         }
1482
1483         free_irq(icom_adapter->pci_dev->irq, (void *) icom_adapter);
1484         iounmap(icom_adapter->base_addr);
1485         icom_free_adapter(icom_adapter);
1486         pci_release_regions(icom_adapter->pci_dev);
1487 }
1488
1489 static void icom_kref_release(struct kref *kref)
1490 {
1491         struct icom_adapter *icom_adapter;
1492
1493         icom_adapter = to_icom_adapter(kref);
1494         icom_remove_adapter(icom_adapter);
1495 }
1496
1497 static int __devinit icom_probe(struct pci_dev *dev,
1498                                 const struct pci_device_id *ent)
1499 {
1500         int index;
1501         unsigned int command_reg;
1502         int retval;
1503         struct icom_adapter *icom_adapter;
1504         struct icom_port *icom_port;
1505
1506         retval = pci_enable_device(dev);
1507         if (retval) {
1508                 dev_err(&dev->dev, "Device enable FAILED\n");
1509                 return retval;
1510         }
1511
1512         if ( (retval = pci_request_regions(dev, "icom"))) {
1513                  dev_err(&dev->dev, "pci_request_regions FAILED\n");
1514                  pci_disable_device(dev);
1515                  return retval;
1516          }
1517
1518         pci_set_master(dev);
1519
1520         if ( (retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg))) {
1521                 dev_err(&dev->dev, "PCI Config read FAILED\n");
1522                 return retval;
1523         }
1524
1525         pci_write_config_dword(dev, PCI_COMMAND,
1526                 command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER
1527                 | PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
1528
1529         if (ent->driver_data == ADAPTER_V1) {
1530                 pci_write_config_dword(dev, 0x44, 0x8300830A);
1531          } else {
1532                 pci_write_config_dword(dev, 0x44, 0x42004200);
1533                 pci_write_config_dword(dev, 0x48, 0x42004200);
1534          }
1535
1536
1537         retval = icom_alloc_adapter(&icom_adapter);
1538         if (retval) {
1539                  dev_err(&dev->dev, "icom_alloc_adapter FAILED\n");
1540                  retval = -EIO;
1541                  goto probe_exit0;
1542         }
1543
1544          icom_adapter->base_addr_pci = pci_resource_start(dev, 0);
1545          icom_adapter->pci_dev = dev;
1546          icom_adapter->version = ent->driver_data;
1547          icom_adapter->subsystem_id = ent->subdevice;
1548
1549
1550         retval = icom_init_ports(icom_adapter);
1551         if (retval) {
1552                 dev_err(&dev->dev, "Port configuration failed\n");
1553                 goto probe_exit1;
1554         }
1555
1556          icom_adapter->base_addr = ioremap(icom_adapter->base_addr_pci,
1557                                                 pci_resource_len(dev, 0));
1558
1559         if (!icom_adapter->base_addr)
1560                 goto probe_exit1;
1561
1562          /* save off irq and request irq line */
1563          if ( (retval = request_irq(dev->irq, icom_interrupt,
1564                                    IRQF_DISABLED | IRQF_SHARED, ICOM_DRIVER_NAME,
1565                                    (void *) icom_adapter))) {
1566                   goto probe_exit2;
1567          }
1568
1569         retval = icom_load_ports(icom_adapter);
1570
1571         for (index = 0; index < icom_adapter->numb_ports; index++) {
1572                 icom_port = &icom_adapter->port_info[index];
1573
1574                 if (icom_port->status == ICOM_PORT_ACTIVE) {
1575                         icom_port->uart_port.irq = icom_port->adapter->pci_dev->irq;
1576                         icom_port->uart_port.type = PORT_ICOM;
1577                         icom_port->uart_port.iotype = UPIO_MEM;
1578                         icom_port->uart_port.membase =
1579                                                (char *) icom_adapter->base_addr_pci;
1580                         icom_port->uart_port.fifosize = 16;
1581                         icom_port->uart_port.ops = &icom_ops;
1582                         icom_port->uart_port.line =
1583                         icom_port->port + icom_adapter->index * 4;
1584                         if (uart_add_one_port (&icom_uart_driver, &icom_port->uart_port)) {
1585                                 icom_port->status = ICOM_PORT_OFF;
1586                                 dev_err(&dev->dev, "Device add failed\n");
1587                          } else
1588                                 dev_info(&dev->dev, "Device added\n");
1589                 }
1590         }
1591
1592         kref_init(&icom_adapter->kref);
1593         return 0;
1594
1595 probe_exit2:
1596         iounmap(icom_adapter->base_addr);
1597 probe_exit1:
1598         icom_free_adapter(icom_adapter);
1599
1600 probe_exit0:
1601         pci_release_regions(dev);
1602         pci_disable_device(dev);
1603
1604         return retval;
1605
1606
1607 }
1608
1609 static void __devexit icom_remove(struct pci_dev *dev)
1610 {
1611         struct icom_adapter *icom_adapter;
1612         struct list_head *tmp;
1613
1614         list_for_each(tmp, &icom_adapter_head) {
1615                 icom_adapter = list_entry(tmp, struct icom_adapter,
1616                                           icom_adapter_entry);
1617                 if (icom_adapter->pci_dev == dev) {
1618                         kref_put(&icom_adapter->kref, icom_kref_release);
1619                         return;
1620                 }
1621         }
1622
1623         dev_err(&dev->dev, "Unable to find device to remove\n");
1624 }
1625
1626 static struct pci_driver icom_pci_driver = {
1627         .name = ICOM_DRIVER_NAME,
1628         .id_table = icom_pci_table,
1629         .probe = icom_probe,
1630         .remove = __devexit_p(icom_remove),
1631 };
1632
1633 static int __init icom_init(void)
1634 {
1635         int ret;
1636
1637         spin_lock_init(&icom_lock);
1638
1639         ret = uart_register_driver(&icom_uart_driver);
1640         if (ret)
1641                 return ret;
1642
1643         ret = pci_register_driver(&icom_pci_driver);
1644
1645         if (ret < 0)
1646                 uart_unregister_driver(&icom_uart_driver);
1647
1648         return ret;
1649 }
1650
1651 static void __exit icom_exit(void)
1652 {
1653         pci_unregister_driver(&icom_pci_driver);
1654         uart_unregister_driver(&icom_uart_driver);
1655 }
1656
1657 module_init(icom_init);
1658 module_exit(icom_exit);
1659
1660 #ifdef ICOM_TRACE
1661 static inline void trace(struct icom_port *icom_port, char *trace_pt,
1662                   unsigned long trace_data)
1663 {
1664         dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
1665                  icom_port->port, trace_pt, trace_data);
1666 }
1667 #endif
1668
1669 MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1670 MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1671 MODULE_SUPPORTED_DEVICE
1672     ("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
1673 MODULE_LICENSE("GPL");
1674