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