drivers/tty/serial/icom.c

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