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 *icom_port, char *trace_pt,
 141                         unsigned long trace_data)
 142 {
 143         dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
 144         icom_port->port, trace_pt, trace_data);
 145 }
 146 #else
 147 static inline void trace(struct icom_port *icom_port, char *trace_pt, unsigned long trace_data) {};
 148 #endif
 149 static void icom_kref_release(struct kref *kref);
 150
 151 static void free_port_memory(struct icom_port *icom_port)
 152 {
 153         struct pci_dev *dev = icom_port->adapter->pci_dev;
 154
 155         trace(icom_port, "RET_PORT_MEM", 0);
 156         if (icom_port->recv_buf) {
 157                 pci_free_consistent(dev, 4096, icom_port->recv_buf,
 158                                     icom_port->recv_buf_pci);
 159                 icom_port->recv_buf = NULL;
 160         }
 161         if (icom_port->xmit_buf) {
 162                 pci_free_consistent(dev, 4096, icom_port->xmit_buf,
 163                                     icom_port->xmit_buf_pci);
 164                 icom_port->xmit_buf = NULL;
 165         }
 166         if (icom_port->statStg) {
 167                 pci_free_consistent(dev, 4096, icom_port->statStg,
 168                                     icom_port->statStg_pci);
 169                 icom_port->statStg = NULL;
 170         }
 171
 172         if (icom_port->xmitRestart) {
 173                 pci_free_consistent(dev, 4096, icom_port->xmitRestart,
 174                                     icom_port->xmitRestart_pci);
 175                 icom_port->xmitRestart = NULL;
 176         }
 177 }
 178
 179 static int __devinit get_port_memory(struct icom_port *icom_port)
 180 {
 181         int index;
 182         unsigned long stgAddr;
 183         unsigned long startStgAddr;
 184         unsigned long offset;
 185         struct pci_dev *dev = icom_port->adapter->pci_dev;
 186
 187         icom_port->xmit_buf =
 188             pci_alloc_consistent(dev, 4096, &icom_port->xmit_buf_pci);
 189         if (!icom_port->xmit_buf) {
 190                 dev_err(&dev->dev, "Can not allocate Transmit buffer\n");
 191                 return -ENOMEM;
 192         }
 193
 194         trace(icom_port, "GET_PORT_MEM",
 195               (unsigned long) icom_port->xmit_buf);
 196
 197         icom_port->recv_buf =
 198             pci_alloc_consistent(dev, 4096, &icom_port->recv_buf_pci);
 199         if (!icom_port->recv_buf) {
 200                 dev_err(&dev->dev, "Can not allocate Receive buffer\n");
 201                 free_port_memory(icom_port);
 202                 return -ENOMEM;
 203         }
 204         trace(icom_port, "GET_PORT_MEM",
 205               (unsigned long) icom_port->recv_buf);
 206
 207         icom_port->statStg =
 208             pci_alloc_consistent(dev, 4096, &icom_port->statStg_pci);
 209         if (!icom_port->statStg) {
 210                 dev_err(&dev->dev, "Can not allocate Status buffer\n");
 211                 free_port_memory(icom_port);
 212                 return -ENOMEM;
 213         }
 214         trace(icom_port, "GET_PORT_MEM",
 215               (unsigned long) icom_port->statStg);
 216
 217         icom_port->xmitRestart =
 218             pci_alloc_consistent(dev, 4096, &icom_port->xmitRestart_pci);
 219         if (!icom_port->xmitRestart) {
 220                 dev_err(&dev->dev,
 221                         "Can not allocate xmit Restart buffer\n");
 222                 free_port_memory(icom_port);
 223                 return -ENOMEM;
 224         }
 225
 226         memset(icom_port->statStg, 0, 4096);
 227
 228         /* FODs: Frame Out Descriptor Queue, this is a FIFO queue that
 229            indicates that frames are to be transmitted
 230         */
 231
 232         stgAddr = (unsigned long) icom_port->statStg;
 233         for (index = 0; index < NUM_XBUFFS; index++) {
 234                 trace(icom_port, "FOD_ADDR", stgAddr);
 235                 stgAddr = stgAddr + sizeof(icom_port->statStg->xmit[0]);
 236                 if (index < (NUM_XBUFFS - 1)) {
 237                         memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
 238                         icom_port->statStg->xmit[index].leLengthASD =
 239                             (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
 240                         trace(icom_port, "FOD_ADDR", stgAddr);
 241                         trace(icom_port, "FOD_XBUFF",
 242                               (unsigned long) icom_port->xmit_buf);
 243                         icom_port->statStg->xmit[index].leBuffer =
 244                             cpu_to_le32(icom_port->xmit_buf_pci);
 245                 } else if (index == (NUM_XBUFFS - 1)) {
 246                         memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
 247                         icom_port->statStg->xmit[index].leLengthASD =
 248                             (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
 249                         trace(icom_port, "FOD_XBUFF",
 250                               (unsigned long) icom_port->xmit_buf);
 251                         icom_port->statStg->xmit[index].leBuffer =
 252                             cpu_to_le32(icom_port->xmit_buf_pci);
 253                 } else {
 254                         memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
 255                 }
 256         }
 257         /* FIDs */
 258         startStgAddr = stgAddr;
 259
 260         /* fill in every entry, even if no buffer */
 261         for (index = 0; index <  NUM_RBUFFS; index++) {
 262                 trace(icom_port, "FID_ADDR", stgAddr);
 263                 stgAddr = stgAddr + sizeof(icom_port->statStg->rcv[0]);
 264                 icom_port->statStg->rcv[index].leLength = 0;
 265                 icom_port->statStg->rcv[index].WorkingLength =
 266                     (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
 267                 if (index < (NUM_RBUFFS - 1) ) {
 268                         offset = stgAddr - (unsigned long) icom_port->statStg;
 269                         icom_port->statStg->rcv[index].leNext =
 270                               cpu_to_le32(icom_port-> statStg_pci + offset);
 271                         trace(icom_port, "FID_RBUFF",
 272                               (unsigned long) icom_port->recv_buf);
 273                         icom_port->statStg->rcv[index].leBuffer =
 274                             cpu_to_le32(icom_port->recv_buf_pci);
 275                 } else if (index == (NUM_RBUFFS -1) ) {
 276                         offset = startStgAddr - (unsigned long) icom_port->statStg;
 277                         icom_port->statStg->rcv[index].leNext =
 278                             cpu_to_le32(icom_port-> statStg_pci + offset);
 279                         trace(icom_port, "FID_RBUFF",
 280                               (unsigned long) icom_port->recv_buf + 2048);
 281                         icom_port->statStg->rcv[index].leBuffer =
 282                             cpu_to_le32(icom_port->recv_buf_pci + 2048);
 283                 } else {
 284                         icom_port->statStg->rcv[index].leNext = 0;
 285                         icom_port->statStg->rcv[index].leBuffer = 0;
 286                 }
 287         }
 288
 289         return 0;
 290 }
 291
 292 static void stop_processor(struct icom_port *icom_port)
 293 {
 294         unsigned long temp;
 295         unsigned long flags;
 296         int port;
 297
 298         spin_lock_irqsave(&icom_lock, flags);
 299
 300         port = icom_port->port;
 301         if (port == 0 || port == 1)
 302                 stop_proc[port].global_control_reg = &icom_port->global_reg->control;
 303         else
 304                 stop_proc[port].global_control_reg = &icom_port->global_reg->control_2;
 305
 306
 307         if (port < 4) {
 308                 temp = readl(stop_proc[port].global_control_reg);
 309                 temp =
 310                         (temp & ~start_proc[port].processor_id) | stop_proc[port].processor_id;
 311                 writel(temp, stop_proc[port].global_control_reg);
 312
 313                 /* write flush */
 314                 readl(stop_proc[port].global_control_reg);
 315         } else {
 316                 dev_err(&icom_port->adapter->pci_dev->dev,
 317                         "Invalid port assignment\n");
 318         }
 319
 320         spin_unlock_irqrestore(&icom_lock, flags);
 321 }
 322
 323 static void start_processor(struct icom_port *icom_port)
 324 {
 325         unsigned long temp;
 326         unsigned long flags;
 327         int port;
 328
 329         spin_lock_irqsave(&icom_lock, flags);
 330
 331         port = icom_port->port;
 332         if (port == 0 || port == 1)
 333                 start_proc[port].global_control_reg = &icom_port->global_reg->control;
 334         else
 335                 start_proc[port].global_control_reg = &icom_port->global_reg->control_2;
 336         if (port < 4) {
 337                 temp = readl(start_proc[port].global_control_reg);
 338                 temp =
 339                         (temp & ~stop_proc[port].processor_id) | start_proc[port].processor_id;
 340                 writel(temp, start_proc[port].global_control_reg);
 341
 342                 /* write flush */
 343                 readl(start_proc[port].global_control_reg);
 344         } else {
 345                 dev_err(&icom_port->adapter->pci_dev->dev,
 346                         "Invalid port assignment\n");
 347         }
 348
 349         spin_unlock_irqrestore(&icom_lock, flags);
 350 }
 351
 352 static void load_code(struct icom_port *icom_port)
 353 {
 354         const struct firmware *fw;
 355         char __iomem *iram_ptr;
 356         int index;
 357         int status = 0;
 358         void __iomem *dram_ptr = icom_port->dram;
 359         dma_addr_t temp_pci;
 360         unsigned char *new_page = NULL;
 361         unsigned char cable_id = NO_CABLE;
 362         struct pci_dev *dev = icom_port->adapter->pci_dev;
 363
 364         /* Clear out any pending interrupts */
 365         writew(0x3FFF, icom_port->int_reg);
 366
 367         trace(icom_port, "CLEAR_INTERRUPTS", 0);
 368
 369         /* Stop processor */
 370         stop_processor(icom_port);
 371
 372         /* Zero out DRAM */
 373         memset_io(dram_ptr, 0, 512);
 374
 375         /* Load Call Setup into Adapter */
 376         if (request_firmware(&fw, "icom_call_setup.bin", &dev->dev) < 0) {
 377                 dev_err(&dev->dev,"Unable to load icom_call_setup.bin firmware image\n");
 378                 status = -1;
 379                 goto load_code_exit;
 380         }
 381
 382         if (fw->size > ICOM_DCE_IRAM_OFFSET) {
 383                 dev_err(&dev->dev, "Invalid firmware image for icom_call_setup.bin found.\n");
 384                 release_firmware(fw);
 385                 status = -1;
 386                 goto load_code_exit;
 387         }
 388
 389         iram_ptr = (char __iomem *)icom_port->dram + ICOM_IRAM_OFFSET;
 390         for (index = 0; index < fw->size; index++)
 391                 writeb(fw->data[index], &iram_ptr[index]);
 392
 393         release_firmware(fw);
 394
 395         /* Load Resident DCE portion of Adapter */
 396         if (request_firmware(&fw, "icom_res_dce.bin", &dev->dev) < 0) {
 397                 dev_err(&dev->dev,"Unable to load icom_res_dce.bin firmware image\n");
 398                 status = -1;
 399                 goto load_code_exit;
 400         }
 401
 402         if (fw->size > ICOM_IRAM_SIZE) {
 403                 dev_err(&dev->dev, "Invalid firmware image for icom_res_dce.bin found.\n");
 404                 release_firmware(fw);
 405                 status = -1;
 406                 goto load_code_exit;
 407         }
 408
 409         iram_ptr = (char __iomem *) icom_port->dram + ICOM_IRAM_OFFSET;
 410         for (index = ICOM_DCE_IRAM_OFFSET; index < fw->size; index++)
 411                 writeb(fw->data[index], &iram_ptr[index]);
 412
 413         release_firmware(fw);
 414
 415         /* Set Hardware level */
 416         if (icom_port->adapter->version == ADAPTER_V2)
 417                 writeb(V2_HARDWARE, &(icom_port->dram->misc_flags));
 418
 419         /* Start the processor in Adapter */
 420         start_processor(icom_port);
 421
 422         writeb((HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL),
 423                &(icom_port->dram->HDLCConfigReg));
 424         writeb(0x04, &(icom_port->dram->FlagFillIdleTimer));    /* 0.5 seconds */
 425         writeb(0x00, &(icom_port->dram->CmdReg));
 426         writeb(0x10, &(icom_port->dram->async_config3));
 427         writeb((ICOM_ACFG_DRIVE1 | ICOM_ACFG_NO_PARITY | ICOM_ACFG_8BPC |
 428                 ICOM_ACFG_1STOP_BIT), &(icom_port->dram->async_config2));
 429
 430         /*Set up data in icom DRAM to indicate where personality
 431          *code is located and its length.
 432          */
 433         new_page = pci_alloc_consistent(dev, 4096, &temp_pci);
 434
 435         if (!new_page) {
 436                 dev_err(&dev->dev, "Can not allocate DMA buffer\n");
 437                 status = -1;
 438                 goto load_code_exit;
 439         }
 440
 441         if (request_firmware(&fw, "icom_asc.bin", &dev->dev) < 0) {
 442                 dev_err(&dev->dev,"Unable to load icom_asc.bin firmware image\n");
 443                 status = -1;
 444                 goto load_code_exit;
 445         }
 446
 447         if (fw->size > ICOM_DCE_IRAM_OFFSET) {
 448                 dev_err(&dev->dev, "Invalid firmware image for icom_asc.bin found.\n");
 449                 release_firmware(fw);
 450                 status = -1;
 451                 goto load_code_exit;
 452         }
 453
 454         for (index = 0; index < fw->size; index++)
 455                 new_page[index] = fw->data[index];
 456
 457         release_firmware(fw);
 458
 459         writeb((char) ((fw->size + 16)/16), &icom_port->dram->mac_length);
 460         writel(temp_pci, &icom_port->dram->mac_load_addr);
 461
 462         /*Setting the syncReg to 0x80 causes adapter to start downloading
 463            the personality code into adapter instruction RAM.
 464            Once code is loaded, it will begin executing and, based on
 465            information provided above, will start DMAing data from
 466            shared memory to adapter DRAM.
 467          */
 468         /* the wait loop below verifies this write operation has been done
 469            and processed
 470         */
 471         writeb(START_DOWNLOAD, &icom_port->dram->sync);
 472
 473         /* Wait max 1 Sec for data download and processor to start */
 474         for (index = 0; index < 10; index++) {
 475                 msleep(100);
 476                 if (readb(&icom_port->dram->misc_flags) & ICOM_HDW_ACTIVE)
 477                         break;
 478         }
 479
 480         if (index == 10)
 481                 status = -1;
 482
 483         /*
 484          * check Cable ID
 485          */
 486         cable_id = readb(&icom_port->dram->cable_id);
 487
 488         if (cable_id & ICOM_CABLE_ID_VALID) {
 489                 /* Get cable ID into the lower 4 bits (standard form) */
 490                 cable_id = (cable_id & ICOM_CABLE_ID_MASK) >> 4;
 491                 icom_port->cable_id = cable_id;
 492         } else {
 493                 dev_err(&dev->dev,"Invalid or no cable attached\n");
 494                 icom_port->cable_id = NO_CABLE;
 495         }
 496
 497       load_code_exit:
 498
 499         if (status != 0) {
 500                 /* Clear out any pending interrupts */
 501                 writew(0x3FFF, icom_port->int_reg);
 502
 503                 /* Turn off port */
 504                 writeb(ICOM_DISABLE, &(icom_port->dram->disable));
 505
 506                 /* Stop processor */
 507                 stop_processor(icom_port);
 508
 509                 dev_err(&icom_port->adapter->pci_dev->dev,"Port not opertional\n");
 510         }
 511
 512         if (new_page != NULL)
 513                 pci_free_consistent(dev, 4096, new_page, temp_pci);
 514 }
 515
 516 static int startup(struct icom_port *icom_port)
 517 {
 518         unsigned long temp;
 519         unsigned char cable_id, raw_cable_id;
 520         unsigned long flags;
 521         int port;
 522
 523         trace(icom_port, "STARTUP", 0);
 524
 525         if (!icom_port->dram) {
 526                 /* should NEVER be NULL */
 527                 dev_err(&icom_port->adapter->pci_dev->dev,
 528                         "Unusable Port, port configuration missing\n");
 529                 return -ENODEV;
 530         }
 531
 532         /*
 533          * check Cable ID
 534          */
 535         raw_cable_id = readb(&icom_port->dram->cable_id);
 536         trace(icom_port, "CABLE_ID", raw_cable_id);
 537
 538         /* Get cable ID into the lower 4 bits (standard form) */
 539         cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
 540
 541         /* Check for valid Cable ID */
 542         if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
 543             (cable_id != icom_port->cable_id)) {
 544
 545                 /* reload adapter code, pick up any potential changes in cable id */
 546                 load_code(icom_port);
 547
 548                 /* still no sign of cable, error out */
 549                 raw_cable_id = readb(&icom_port->dram->cable_id);
 550                 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
 551                 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
 552                     (icom_port->cable_id == NO_CABLE))
 553                         return -EIO;
 554         }
 555
 556         /*
 557          * Finally, clear and  enable interrupts
 558          */
 559         spin_lock_irqsave(&icom_lock, flags);
 560         port = icom_port->port;
 561         if (port == 0 || port == 1)
 562                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
 563         else
 564                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
 565
 566         if (port == 0 || port == 2)
 567                 writew(0x00FF, icom_port->int_reg);
 568         else
 569                 writew(0x3F00, icom_port->int_reg);
 570         if (port < 4) {
 571                 temp = readl(int_mask_tbl[port].global_int_mask);
 572                 writel(temp & ~int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
 573
 574                 /* write flush */
 575                 readl(int_mask_tbl[port].global_int_mask);
 576         } else {
 577                 dev_err(&icom_port->adapter->pci_dev->dev,
 578                         "Invalid port assignment\n");
 579         }
 580
 581         spin_unlock_irqrestore(&icom_lock, flags);
 582         return 0;
 583 }
 584
 585 static void shutdown(struct icom_port *icom_port)
 586 {
 587         unsigned long temp;
 588         unsigned char cmdReg;
 589         unsigned long flags;
 590         int port;
 591
 592         spin_lock_irqsave(&icom_lock, flags);
 593         trace(icom_port, "SHUTDOWN", 0);
 594
 595         /*
 596          * disable all interrupts
 597          */
 598         port = icom_port->port;
 599         if (port == 0 || port == 1)
 600                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
 601         else
 602                 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
 603
 604         if (port < 4) {
 605                 temp = readl(int_mask_tbl[port].global_int_mask);
 606                 writel(temp | int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
 607
 608                 /* write flush */
 609                 readl(int_mask_tbl[port].global_int_mask);
 610         } else {
 611                 dev_err(&icom_port->adapter->pci_dev->dev,
 612                         "Invalid port assignment\n");
 613         }
 614         spin_unlock_irqrestore(&icom_lock, flags);
 615
 616         /*
 617          * disable break condition
 618          */
 619         cmdReg = readb(&icom_port->dram->CmdReg);
 620         if (cmdReg & CMD_SND_BREAK) {
 621                 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
 622         }
 623 }
 624
 625 static int icom_write(struct uart_port *port)
 626 {
 627         unsigned long data_count;
 628         unsigned char cmdReg;
 629         unsigned long offset;
 630         int temp_tail = port->state->xmit.tail;
 631
 632         trace(ICOM_PORT, "WRITE", 0);
 633
 634         if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
 635             SA_FLAGS_READY_TO_XMIT) {
 636                 trace(ICOM_PORT, "WRITE_FULL", 0);
 637                 return 0;
 638         }
 639
 640         data_count = 0;
 641         while ((port->state->xmit.head != temp_tail) &&
 642                (data_count <= XMIT_BUFF_SZ)) {
 643
 644                 ICOM_PORT->xmit_buf[data_count++] =
 645                     port->state->xmit.buf[temp_tail];
 646
 647                 temp_tail++;
 648                 temp_tail &= (UART_XMIT_SIZE - 1);
 649         }
 650
 651         if (data_count) {
 652                 ICOM_PORT->statStg->xmit[0].flags =
 653                     cpu_to_le16(SA_FLAGS_READY_TO_XMIT);
 654                 ICOM_PORT->statStg->xmit[0].leLength =
 655                     cpu_to_le16(data_count);
 656                 offset =
 657                     (unsigned long) &ICOM_PORT->statStg->xmit[0] -
 658                     (unsigned long) ICOM_PORT->statStg;
 659                 *ICOM_PORT->xmitRestart =
 660                     cpu_to_le32(ICOM_PORT->statStg_pci + offset);
 661                 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
 662                 writeb(cmdReg | CMD_XMIT_RCV_ENABLE,
 663                        &ICOM_PORT->dram->CmdReg);
 664                 writeb(START_XMIT, &ICOM_PORT->dram->StartXmitCmd);
 665                 trace(ICOM_PORT, "WRITE_START", data_count);
 666                 /* write flush */
 667                 readb(&ICOM_PORT->dram->StartXmitCmd);
 668         }
 669
 670         return data_count;
 671 }
 672
 673 static inline void check_modem_status(struct icom_port *icom_port)
 674 {
 675         static char old_status = 0;
 676         char delta_status;
 677         unsigned char status;
 678
 679         spin_lock(&icom_port->uart_port.lock);
 680
 681         /*modem input register */
 682         status = readb(&icom_port->dram->isr);
 683         trace(icom_port, "CHECK_MODEM", status);
 684         delta_status = status ^ old_status;
 685         if (delta_status) {
 686                 if (delta_status & ICOM_RI)
 687                         icom_port->uart_port.icount.rng++;
 688                 if (delta_status & ICOM_DSR)
 689                         icom_port->uart_port.icount.dsr++;
 690                 if (delta_status & ICOM_DCD)
 691                         uart_handle_dcd_change(&icom_port->uart_port,
 692                                                delta_status & ICOM_DCD);
 693                 if (delta_status & ICOM_CTS)
 694                         uart_handle_cts_change(&icom_port->uart_port,
 695                                                delta_status & ICOM_CTS);
 696
 697                 wake_up_interruptible(&icom_port->uart_port.state->
 698                                       port.delta_msr_wait);
 699                 old_status = status;
 700         }
 701         spin_unlock(&icom_port->uart_port.lock);
 702 }
 703
 704 static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 705 {
 706         unsigned short int count;
 707         int i;
 708
 709         if (port_int_reg & (INT_XMIT_COMPLETED)) {
 710                 trace(icom_port, "XMIT_COMPLETE", 0);
 711
 712                 /* clear buffer in use bit */
 713                 icom_port->statStg->xmit[0].flags &=
 714                         cpu_to_le16(~SA_FLAGS_READY_TO_XMIT);
 715
 716                 count = (unsigned short int)
 717                         cpu_to_le16(icom_port->statStg->xmit[0].leLength);
 718                 icom_port->uart_port.icount.tx += count;
 719
 720                 for (i=0; i<count &&
 721                         !uart_circ_empty(&icom_port->uart_port.state->xmit); i++) {
 722
 723                         icom_port->uart_port.state->xmit.tail++;
 724                         icom_port->uart_port.state->xmit.tail &=
 725                                 (UART_XMIT_SIZE - 1);
 726                 }
 727
 728                 if (!icom_write(&icom_port->uart_port))
 729                         /* activate write queue */
 730                         uart_write_wakeup(&icom_port->uart_port);
 731         } else
 732                 trace(icom_port, "XMIT_DISABLED", 0);
 733 }
 734
 735 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 736 {
 737         short int count, rcv_buff;
 738         struct tty_struct *tty = icom_port->uart_port.state->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(tty, *(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(tty, 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 Reciever */
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 __devinit 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 __devinit 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 __devinit 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 __devinit 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_DISABLED | 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 __devexit 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 = __devexit_p(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");