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