1 // SPDX-License-Identifier: GPL-2.0+
5 * Copyright (C) 2001 IBM Corporation. All rights reserved.
7 * Serial device driver.
9 * Based on code from serial.c
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>
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>
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>
42 #include <linux/uaccess.h>
46 /*#define ICOM_TRACE enable port trace capabilities */
48 #define ICOM_DRIVER_NAME "icom"
49 #define ICOM_VERSION_STR "1.3.1"
51 #define ICOM_PORT ((struct icom_port *)port)
52 #define to_icom_adapter(d) container_of(d, struct icom_adapter, kref)
54 static const struct pci_device_id icom_pci_table[] = {
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,
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,
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,
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,
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,
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}
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}
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},
116 MODULE_DEVICE_TABLE(pci, icom_pci_table);
118 static LIST_HEAD(icom_adapter_head);
120 /* spinlock for adapter initialization and changing adapter operations */
121 static DEFINE_SPINLOCK(icom_lock);
124 static inline void trace(struct icom_port *icom_port, char *trace_pt,
125 unsigned long trace_data)
127 dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
128 icom_port->port, trace_pt, trace_data);
131 static inline void trace(struct icom_port *icom_port, char *trace_pt, unsigned long trace_data) {};
133 static void icom_kref_release(struct kref *kref);
135 static void free_port_memory(struct icom_port *icom_port)
137 struct pci_dev *dev = icom_port->adapter->pci_dev;
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;
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;
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;
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;
163 static int get_port_memory(struct icom_port *icom_port)
166 unsigned long stgAddr;
167 unsigned long startStgAddr;
168 unsigned long offset;
169 struct pci_dev *dev = icom_port->adapter->pci_dev;
171 icom_port->xmit_buf =
172 dma_alloc_coherent(&dev->dev, 4096, &icom_port->xmit_buf_pci,
174 if (!icom_port->xmit_buf) {
175 dev_err(&dev->dev, "Can not allocate Transmit buffer\n");
179 trace(icom_port, "GET_PORT_MEM",
180 (unsigned long) icom_port->xmit_buf);
182 icom_port->recv_buf =
183 dma_alloc_coherent(&dev->dev, 4096, &icom_port->recv_buf_pci,
185 if (!icom_port->recv_buf) {
186 dev_err(&dev->dev, "Can not allocate Receive buffer\n");
187 free_port_memory(icom_port);
190 trace(icom_port, "GET_PORT_MEM",
191 (unsigned long) icom_port->recv_buf);
194 dma_alloc_coherent(&dev->dev, 4096, &icom_port->statStg_pci,
196 if (!icom_port->statStg) {
197 dev_err(&dev->dev, "Can not allocate Status buffer\n");
198 free_port_memory(icom_port);
201 trace(icom_port, "GET_PORT_MEM",
202 (unsigned long) icom_port->statStg);
204 icom_port->xmitRestart =
205 dma_alloc_coherent(&dev->dev, 4096, &icom_port->xmitRestart_pci,
207 if (!icom_port->xmitRestart) {
209 "Can not allocate xmit Restart buffer\n");
210 free_port_memory(icom_port);
214 /* FODs: Frame Out Descriptor Queue, this is a FIFO queue that
215 indicates that frames are to be transmitted
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);
240 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
244 startStgAddr = stgAddr;
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);
270 icom_port->statStg->rcv[index].leNext = 0;
271 icom_port->statStg->rcv[index].leBuffer = 0;
278 static void stop_processor(struct icom_port *icom_port)
284 spin_lock_irqsave(&icom_lock, flags);
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");
293 if (port == 0 || port == 1)
294 stop_proc[port].global_control_reg = &icom_port->global_reg->control;
296 stop_proc[port].global_control_reg = &icom_port->global_reg->control_2;
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);
303 readl(stop_proc[port].global_control_reg);
306 spin_unlock_irqrestore(&icom_lock, flags);
309 static void start_processor(struct icom_port *icom_port)
315 spin_lock_irqsave(&icom_lock, flags);
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");
324 if (port == 0 || port == 1)
325 start_proc[port].global_control_reg = &icom_port->global_reg->control;
327 start_proc[port].global_control_reg = &icom_port->global_reg->control_2;
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);
334 readl(start_proc[port].global_control_reg);
337 spin_unlock_irqrestore(&icom_lock, flags);
340 static void load_code(struct icom_port *icom_port)
342 const struct firmware *fw;
343 char __iomem *iram_ptr;
346 void __iomem *dram_ptr = icom_port->dram;
348 unsigned char *new_page = NULL;
349 unsigned char cable_id = NO_CABLE;
350 struct pci_dev *dev = icom_port->adapter->pci_dev;
352 /* Clear out any pending interrupts */
353 writew(0x3FFF, icom_port->int_reg);
355 trace(icom_port, "CLEAR_INTERRUPTS", 0);
358 stop_processor(icom_port);
361 memset_io(dram_ptr, 0, 512);
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");
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);
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]);
381 release_firmware(fw);
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");
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);
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]);
401 release_firmware(fw);
403 /* Set Hardware level */
404 if (icom_port->adapter->version == ADAPTER_V2)
405 writeb(V2_HARDWARE, &(icom_port->dram->misc_flags));
407 /* Start the processor in Adapter */
408 start_processor(icom_port);
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));
418 /*Set up data in icom DRAM to indicate where personality
419 *code is located and its length.
421 new_page = dma_alloc_coherent(&dev->dev, 4096, &temp_pci, GFP_KERNEL);
424 dev_err(&dev->dev, "Can not allocate DMA buffer\n");
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");
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);
442 for (index = 0; index < fw->size; index++)
443 new_page[index] = fw->data[index];
445 writeb((char) ((fw->size + 16)/16), &icom_port->dram->mac_length);
446 writel(temp_pci, &icom_port->dram->mac_load_addr);
448 release_firmware(fw);
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.
456 /* the wait loop below verifies this write operation has been done
459 writeb(START_DOWNLOAD, &icom_port->dram->sync);
461 /* Wait max 1 Sec for data download and processor to start */
462 for (index = 0; index < 10; index++) {
464 if (readb(&icom_port->dram->misc_flags) & ICOM_HDW_ACTIVE)
474 cable_id = readb(&icom_port->dram->cable_id);
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;
481 dev_err(&dev->dev,"Invalid or no cable attached\n");
482 icom_port->cable_id = NO_CABLE;
488 /* Clear out any pending interrupts */
489 writew(0x3FFF, icom_port->int_reg);
492 writeb(ICOM_DISABLE, &(icom_port->dram->disable));
495 stop_processor(icom_port);
497 dev_err(&icom_port->adapter->pci_dev->dev,"Port not operational\n");
500 if (new_page != NULL)
501 dma_free_coherent(&dev->dev, 4096, new_page, temp_pci);
504 static int startup(struct icom_port *icom_port)
507 unsigned char cable_id, raw_cable_id;
511 trace(icom_port, "STARTUP", 0);
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");
523 raw_cable_id = readb(&icom_port->dram->cable_id);
524 trace(icom_port, "CABLE_ID", raw_cable_id);
526 /* Get cable ID into the lower 4 bits (standard form) */
527 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
529 /* Check for valid Cable ID */
530 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
531 (cable_id != icom_port->cable_id)) {
533 /* reload adapter code, pick up any potential changes in cable id */
534 load_code(icom_port);
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))
545 * Finally, clear and enable interrupts
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");
555 if (port == 0 || port == 1)
556 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
558 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
560 if (port == 0 || port == 2)
561 writew(0x00FF, icom_port->int_reg);
563 writew(0x3F00, icom_port->int_reg);
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);
569 readl(int_mask_tbl[port].global_int_mask);
572 spin_unlock_irqrestore(&icom_lock, flags);
576 static void shutdown(struct icom_port *icom_port)
579 unsigned char cmdReg;
583 spin_lock_irqsave(&icom_lock, flags);
584 trace(icom_port, "SHUTDOWN", 0);
587 * disable all interrupts
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");
595 if (port == 0 || port == 1)
596 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
598 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
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);
604 readl(int_mask_tbl[port].global_int_mask);
607 spin_unlock_irqrestore(&icom_lock, flags);
610 * disable break condition
612 cmdReg = readb(&icom_port->dram->CmdReg);
613 if (cmdReg & CMD_SND_BREAK) {
614 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
618 static int icom_write(struct uart_port *port)
620 unsigned long data_count;
621 unsigned char cmdReg;
622 unsigned long offset;
623 int temp_tail = port->state->xmit.tail;
625 trace(ICOM_PORT, "WRITE", 0);
627 if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
628 SA_FLAGS_READY_TO_XMIT) {
629 trace(ICOM_PORT, "WRITE_FULL", 0);
634 while ((port->state->xmit.head != temp_tail) &&
635 (data_count <= XMIT_BUFF_SZ)) {
637 ICOM_PORT->xmit_buf[data_count++] =
638 port->state->xmit.buf[temp_tail];
641 temp_tail &= (UART_XMIT_SIZE - 1);
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);
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);
660 readb(&ICOM_PORT->dram->StartXmitCmd);
666 static inline void check_modem_status(struct icom_port *icom_port)
668 static char old_status = 0;
670 unsigned char status;
672 spin_lock(&icom_port->uart_port.lock);
674 /*modem input register */
675 status = readb(&icom_port->dram->isr);
676 trace(icom_port, "CHECK_MODEM", status);
677 delta_status = status ^ old_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);
690 wake_up_interruptible(&icom_port->uart_port.state->
691 port.delta_msr_wait);
694 spin_unlock(&icom_port->uart_port.lock);
697 static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
699 unsigned short int count;
702 if (port_int_reg & (INT_XMIT_COMPLETED)) {
703 trace(icom_port, "XMIT_COMPLETE", 0);
705 /* clear buffer in use bit */
706 icom_port->statStg->xmit[0].flags &=
707 cpu_to_le16(~SA_FLAGS_READY_TO_XMIT);
709 count = (unsigned short int)
710 cpu_to_le16(icom_port->statStg->xmit[0].leLength);
711 icom_port->uart_port.icount.tx += count;
714 !uart_circ_empty(&icom_port->uart_port.state->xmit); i++) {
716 icom_port->uart_port.state->xmit.tail++;
717 icom_port->uart_port.state->xmit.tail &=
718 (UART_XMIT_SIZE - 1);
721 if (!icom_write(&icom_port->uart_port))
722 /* activate write queue */
723 uart_write_wakeup(&icom_port->uart_port);
725 trace(icom_port, "XMIT_DISABLED", 0);
728 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
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;
737 trace(icom_port, "RCV_COMPLETE", 0);
738 rcv_buff = icom_port->next_rcv;
740 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
741 while (status & SA_FL_RCV_DONE) {
744 trace(icom_port, "FID_STATUS", status);
745 count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
747 trace(icom_port, "RCV_COUNT", count);
749 trace(icom_port, "REAL_COUNT", count);
752 cpu_to_le32(icom_port->statStg->rcv[rcv_buff].leBuffer) -
753 icom_port->recv_buf_pci;
755 /* Block copy all but the last byte as this may have status */
757 first = icom_port->recv_buf[offset];
758 tty_insert_flip_string(port, icom_port->recv_buf + offset, count - 1);
761 icount = &icom_port->uart_port.icount;
764 /* Break detect logic */
765 if ((status & SA_FLAGS_FRAME_ERROR)
767 status &= ~SA_FLAGS_FRAME_ERROR;
768 status |= SA_FLAGS_BREAK_DET;
769 trace(icom_port, "BREAK_DET", 0);
775 (SA_FLAGS_BREAK_DET | SA_FLAGS_PARITY_ERROR |
776 SA_FLAGS_FRAME_ERROR | SA_FLAGS_OVERRUN)) {
778 if (status & SA_FLAGS_BREAK_DET)
780 if (status & SA_FLAGS_PARITY_ERROR)
782 if (status & SA_FLAGS_FRAME_ERROR)
784 if (status & SA_FLAGS_OVERRUN)
788 * Now check to see if character should be
789 * ignored, and mask off conditions which
792 if (status & icom_port->ignore_status_mask) {
793 trace(icom_port, "IGNORE_CHAR", 0);
797 status &= icom_port->read_status_mask;
799 if (status & SA_FLAGS_BREAK_DET) {
801 } else if (status & SA_FLAGS_PARITY_ERROR) {
802 trace(icom_port, "PARITY_ERROR", 0);
804 } else if (status & SA_FLAGS_FRAME_ERROR)
809 tty_insert_flip_char(port, *(icom_port->recv_buf + offset + count - 1), flag);
811 if (status & SA_FLAGS_OVERRUN)
813 * Overrun is special, since it's
814 * reported immediately, and doesn't
815 * affect the current character
817 tty_insert_flip_char(port, 0, TTY_OVERRUN);
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);
825 if (rcv_buff == NUM_RBUFFS)
828 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
830 icom_port->next_rcv = rcv_buff;
832 spin_unlock(&icom_port->uart_port.lock);
833 tty_flip_buffer_push(port);
834 spin_lock(&icom_port->uart_port.lock);
837 static void process_interrupt(u16 port_int_reg,
838 struct icom_port *icom_port)
841 spin_lock(&icom_port->uart_port.lock);
842 trace(icom_port, "INTERRUPT", port_int_reg);
844 if (port_int_reg & (INT_XMIT_COMPLETED | INT_XMIT_DISABLED))
845 xmit_interrupt(port_int_reg, icom_port);
847 if (port_int_reg & INT_RCV_COMPLETED)
848 recv_interrupt(port_int_reg, icom_port);
850 spin_unlock(&icom_port->uart_port.lock);
853 static irqreturn_t icom_interrupt(int irq, void *dev_id)
855 void __iomem * int_reg;
856 u32 adapter_interrupts;
858 struct icom_adapter *icom_adapter;
859 struct icom_port *icom_port;
861 /* find icom_port for this interrupt */
862 icom_adapter = (struct icom_adapter *) dev_id;
864 if (icom_adapter->version == ADAPTER_V2) {
865 int_reg = icom_adapter->base_addr + 0x8024;
867 adapter_interrupts = readl(int_reg);
869 if (adapter_interrupts & 0x00003FFF) {
870 /* port 2 interrupt, NOTE: for all ADAPTER_V2, port 2 will be active */
871 icom_port = &icom_adapter->port_info[2];
872 port_int_reg = (u16) adapter_interrupts;
873 process_interrupt(port_int_reg, icom_port);
874 check_modem_status(icom_port);
876 if (adapter_interrupts & 0x3FFF0000) {
877 /* port 3 interrupt */
878 icom_port = &icom_adapter->port_info[3];
879 if (icom_port->status == ICOM_PORT_ACTIVE) {
881 (u16) (adapter_interrupts >> 16);
882 process_interrupt(port_int_reg, icom_port);
883 check_modem_status(icom_port);
887 /* Clear out any pending interrupts */
888 writel(adapter_interrupts, int_reg);
890 int_reg = icom_adapter->base_addr + 0x8004;
892 int_reg = icom_adapter->base_addr + 0x4004;
895 adapter_interrupts = readl(int_reg);
897 if (adapter_interrupts & 0x00003FFF) {
898 /* port 0 interrupt, NOTE: for all adapters, port 0 will be active */
899 icom_port = &icom_adapter->port_info[0];
900 port_int_reg = (u16) adapter_interrupts;
901 process_interrupt(port_int_reg, icom_port);
902 check_modem_status(icom_port);
904 if (adapter_interrupts & 0x3FFF0000) {
905 /* port 1 interrupt */
906 icom_port = &icom_adapter->port_info[1];
907 if (icom_port->status == ICOM_PORT_ACTIVE) {
908 port_int_reg = (u16) (adapter_interrupts >> 16);
909 process_interrupt(port_int_reg, icom_port);
910 check_modem_status(icom_port);
914 /* Clear out any pending interrupts */
915 writel(adapter_interrupts, int_reg);
917 /* flush the write */
918 adapter_interrupts = readl(int_reg);
924 * ------------------------------------------------------------------
925 * Begin serial-core API
926 * ------------------------------------------------------------------
928 static unsigned int icom_tx_empty(struct uart_port *port)
933 spin_lock_irqsave(&port->lock, flags);
934 if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
935 SA_FLAGS_READY_TO_XMIT)
940 spin_unlock_irqrestore(&port->lock, flags);
944 static void icom_set_mctrl(struct uart_port *port, unsigned int mctrl)
946 unsigned char local_osr;
948 trace(ICOM_PORT, "SET_MODEM", 0);
949 local_osr = readb(&ICOM_PORT->dram->osr);
951 if (mctrl & TIOCM_RTS) {
952 trace(ICOM_PORT, "RAISE_RTS", 0);
953 local_osr |= ICOM_RTS;
955 trace(ICOM_PORT, "LOWER_RTS", 0);
956 local_osr &= ~ICOM_RTS;
959 if (mctrl & TIOCM_DTR) {
960 trace(ICOM_PORT, "RAISE_DTR", 0);
961 local_osr |= ICOM_DTR;
963 trace(ICOM_PORT, "LOWER_DTR", 0);
964 local_osr &= ~ICOM_DTR;
967 writeb(local_osr, &ICOM_PORT->dram->osr);
970 static unsigned int icom_get_mctrl(struct uart_port *port)
972 unsigned char status;
975 trace(ICOM_PORT, "GET_MODEM", 0);
977 status = readb(&ICOM_PORT->dram->isr);
979 result = ((status & ICOM_DCD) ? TIOCM_CAR : 0)
980 | ((status & ICOM_RI) ? TIOCM_RNG : 0)
981 | ((status & ICOM_DSR) ? TIOCM_DSR : 0)
982 | ((status & ICOM_CTS) ? TIOCM_CTS : 0);
986 static void icom_stop_tx(struct uart_port *port)
988 unsigned char cmdReg;
990 trace(ICOM_PORT, "STOP", 0);
991 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
992 writeb(cmdReg | CMD_HOLD_XMIT, &ICOM_PORT->dram->CmdReg);
995 static void icom_start_tx(struct uart_port *port)
997 unsigned char cmdReg;
999 trace(ICOM_PORT, "START", 0);
1000 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1001 if ((cmdReg & CMD_HOLD_XMIT) == CMD_HOLD_XMIT)
1002 writeb(cmdReg & ~CMD_HOLD_XMIT,
1003 &ICOM_PORT->dram->CmdReg);
1008 static void icom_send_xchar(struct uart_port *port, char ch)
1010 unsigned char xdata;
1012 unsigned long flags;
1014 trace(ICOM_PORT, "SEND_XCHAR", ch);
1016 /* wait .1 sec to send char */
1017 for (index = 0; index < 10; index++) {
1018 spin_lock_irqsave(&port->lock, flags);
1019 xdata = readb(&ICOM_PORT->dram->xchar);
1020 if (xdata == 0x00) {
1021 trace(ICOM_PORT, "QUICK_WRITE", 0);
1022 writeb(ch, &ICOM_PORT->dram->xchar);
1024 /* flush write operation */
1025 xdata = readb(&ICOM_PORT->dram->xchar);
1026 spin_unlock_irqrestore(&port->lock, flags);
1029 spin_unlock_irqrestore(&port->lock, flags);
1034 static void icom_stop_rx(struct uart_port *port)
1036 unsigned char cmdReg;
1038 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1039 writeb(cmdReg & ~CMD_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1042 static void icom_break(struct uart_port *port, int break_state)
1044 unsigned char cmdReg;
1045 unsigned long flags;
1047 spin_lock_irqsave(&port->lock, flags);
1048 trace(ICOM_PORT, "BREAK", 0);
1049 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1050 if (break_state == -1) {
1051 writeb(cmdReg | CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1053 writeb(cmdReg & ~CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1055 spin_unlock_irqrestore(&port->lock, flags);
1058 static int icom_open(struct uart_port *port)
1062 kref_get(&ICOM_PORT->adapter->kref);
1063 retval = startup(ICOM_PORT);
1066 kref_put(&ICOM_PORT->adapter->kref, icom_kref_release);
1067 trace(ICOM_PORT, "STARTUP_ERROR", 0);
1074 static void icom_close(struct uart_port *port)
1076 unsigned char cmdReg;
1078 trace(ICOM_PORT, "CLOSE", 0);
1081 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1082 writeb(cmdReg & ~CMD_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1084 shutdown(ICOM_PORT);
1086 kref_put(&ICOM_PORT->adapter->kref, icom_kref_release);
1089 static void icom_set_termios(struct uart_port *port,
1090 struct ktermios *termios,
1091 struct ktermios *old_termios)
1094 unsigned cflag, iflag;
1096 char new_config3 = 0;
1099 int rcv_buff, xmit_buff;
1100 unsigned long offset;
1101 unsigned long flags;
1103 spin_lock_irqsave(&port->lock, flags);
1104 trace(ICOM_PORT, "CHANGE_SPEED", 0);
1106 cflag = termios->c_cflag;
1107 iflag = termios->c_iflag;
1109 new_config2 = ICOM_ACFG_DRIVE1;
1111 /* byte size and parity */
1112 switch (cflag & CSIZE) {
1113 case CS5: /* 5 bits/char */
1114 new_config2 |= ICOM_ACFG_5BPC;
1116 case CS6: /* 6 bits/char */
1117 new_config2 |= ICOM_ACFG_6BPC;
1119 case CS7: /* 7 bits/char */
1120 new_config2 |= ICOM_ACFG_7BPC;
1122 case CS8: /* 8 bits/char */
1123 new_config2 |= ICOM_ACFG_8BPC;
1128 if (cflag & CSTOPB) {
1130 new_config2 |= ICOM_ACFG_2STOP_BIT;
1132 if (cflag & PARENB) {
1133 /* parity bit enabled */
1134 new_config2 |= ICOM_ACFG_PARITY_ENAB;
1135 trace(ICOM_PORT, "PARENB", 0);
1137 if (cflag & PARODD) {
1139 new_config2 |= ICOM_ACFG_PARITY_ODD;
1140 trace(ICOM_PORT, "PARODD", 0);
1143 /* Determine divisor based on baud rate */
1144 baud = uart_get_baud_rate(port, termios, old_termios,
1146 icom_acfg_baud[BAUD_TABLE_LIMIT]);
1148 baud = 9600; /* B0 transition handled in rs_set_termios */
1150 for (index = 0; index < BAUD_TABLE_LIMIT; index++) {
1151 if (icom_acfg_baud[index] == baud) {
1152 new_config3 = index;
1157 uart_update_timeout(port, cflag, baud);
1159 /* CTS flow control flag and modem status interrupts */
1160 tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1161 if (cflag & CRTSCTS)
1162 tmp_byte |= HDLC_HDW_FLOW;
1164 tmp_byte &= ~HDLC_HDW_FLOW;
1165 writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1168 * Set up parity check flag
1170 ICOM_PORT->read_status_mask = SA_FLAGS_OVERRUN | SA_FL_RCV_DONE;
1172 ICOM_PORT->read_status_mask |=
1173 SA_FLAGS_FRAME_ERROR | SA_FLAGS_PARITY_ERROR;
1175 if ((iflag & BRKINT) || (iflag & PARMRK))
1176 ICOM_PORT->read_status_mask |= SA_FLAGS_BREAK_DET;
1179 * Characters to ignore
1181 ICOM_PORT->ignore_status_mask = 0;
1183 ICOM_PORT->ignore_status_mask |=
1184 SA_FLAGS_PARITY_ERROR | SA_FLAGS_FRAME_ERROR;
1185 if (iflag & IGNBRK) {
1186 ICOM_PORT->ignore_status_mask |= SA_FLAGS_BREAK_DET;
1188 * If we're ignore parity and break indicators, ignore
1189 * overruns too. (For real raw support).
1192 ICOM_PORT->ignore_status_mask |= SA_FLAGS_OVERRUN;
1196 * !!! ignore all characters if CREAD is not set
1198 if ((cflag & CREAD) == 0)
1199 ICOM_PORT->ignore_status_mask |= SA_FL_RCV_DONE;
1201 /* Turn off Receiver to prepare for reset */
1202 writeb(CMD_RCV_DISABLE, &ICOM_PORT->dram->CmdReg);
1204 for (index = 0; index < 10; index++) {
1205 if (readb(&ICOM_PORT->dram->PrevCmdReg) == 0x00) {
1210 /* clear all current buffers of data */
1211 for (rcv_buff = 0; rcv_buff < NUM_RBUFFS; rcv_buff++) {
1212 ICOM_PORT->statStg->rcv[rcv_buff].flags = 0;
1213 ICOM_PORT->statStg->rcv[rcv_buff].leLength = 0;
1214 ICOM_PORT->statStg->rcv[rcv_buff].WorkingLength =
1215 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
1218 for (xmit_buff = 0; xmit_buff < NUM_XBUFFS; xmit_buff++) {
1219 ICOM_PORT->statStg->xmit[xmit_buff].flags = 0;
1222 /* activate changes and start xmit and receiver here */
1223 /* Enable the receiver */
1224 writeb(new_config3, &(ICOM_PORT->dram->async_config3));
1225 writeb(new_config2, &(ICOM_PORT->dram->async_config2));
1226 tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1227 tmp_byte |= HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL;
1228 writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1229 writeb(0x04, &(ICOM_PORT->dram->FlagFillIdleTimer)); /* 0.5 seconds */
1230 writeb(0xFF, &(ICOM_PORT->dram->ier)); /* enable modem signal interrupts */
1232 /* reset processor */
1233 writeb(CMD_RESTART, &ICOM_PORT->dram->CmdReg);
1235 for (index = 0; index < 10; index++) {
1236 if (readb(&ICOM_PORT->dram->CmdReg) == 0x00) {
1241 /* Enable Transmitter and Receiver */
1243 (unsigned long) &ICOM_PORT->statStg->rcv[0] -
1244 (unsigned long) ICOM_PORT->statStg;
1245 writel(ICOM_PORT->statStg_pci + offset,
1246 &ICOM_PORT->dram->RcvStatusAddr);
1247 ICOM_PORT->next_rcv = 0;
1248 ICOM_PORT->put_length = 0;
1249 *ICOM_PORT->xmitRestart = 0;
1250 writel(ICOM_PORT->xmitRestart_pci,
1251 &ICOM_PORT->dram->XmitStatusAddr);
1252 trace(ICOM_PORT, "XR_ENAB", 0);
1253 writeb(CMD_XMIT_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1255 spin_unlock_irqrestore(&port->lock, flags);
1258 static const char *icom_type(struct uart_port *port)
1263 static void icom_release_port(struct uart_port *port)
1267 static int icom_request_port(struct uart_port *port)
1272 static void icom_config_port(struct uart_port *port, int flags)
1274 port->type = PORT_ICOM;
1277 static const struct uart_ops icom_ops = {
1278 .tx_empty = icom_tx_empty,
1279 .set_mctrl = icom_set_mctrl,
1280 .get_mctrl = icom_get_mctrl,
1281 .stop_tx = icom_stop_tx,
1282 .start_tx = icom_start_tx,
1283 .send_xchar = icom_send_xchar,
1284 .stop_rx = icom_stop_rx,
1285 .break_ctl = icom_break,
1286 .startup = icom_open,
1287 .shutdown = icom_close,
1288 .set_termios = icom_set_termios,
1290 .release_port = icom_release_port,
1291 .request_port = icom_request_port,
1292 .config_port = icom_config_port,
1295 #define ICOM_CONSOLE NULL
1297 static struct uart_driver icom_uart_driver = {
1298 .owner = THIS_MODULE,
1299 .driver_name = ICOM_DRIVER_NAME,
1301 .major = ICOM_MAJOR,
1302 .minor = ICOM_MINOR_START,
1304 .cons = ICOM_CONSOLE,
1307 static int icom_init_ports(struct icom_adapter *icom_adapter)
1309 u32 subsystem_id = icom_adapter->subsystem_id;
1311 struct icom_port *icom_port;
1313 if (icom_adapter->version == ADAPTER_V1) {
1314 icom_adapter->numb_ports = 2;
1316 for (i = 0; i < 2; i++) {
1317 icom_port = &icom_adapter->port_info[i];
1318 icom_port->port = i;
1319 icom_port->status = ICOM_PORT_ACTIVE;
1320 icom_port->imbed_modem = ICOM_UNKNOWN;
1323 if (subsystem_id == PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL) {
1324 icom_adapter->numb_ports = 4;
1326 for (i = 0; i < 4; i++) {
1327 icom_port = &icom_adapter->port_info[i];
1329 icom_port->port = i;
1330 icom_port->status = ICOM_PORT_ACTIVE;
1331 icom_port->imbed_modem = ICOM_IMBED_MODEM;
1334 icom_adapter->numb_ports = 4;
1336 icom_adapter->port_info[0].port = 0;
1337 icom_adapter->port_info[0].status = ICOM_PORT_ACTIVE;
1340 PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM) {
1341 icom_adapter->port_info[0].imbed_modem = ICOM_IMBED_MODEM;
1343 icom_adapter->port_info[0].imbed_modem = ICOM_RVX;
1346 icom_adapter->port_info[1].status = ICOM_PORT_OFF;
1348 icom_adapter->port_info[2].port = 2;
1349 icom_adapter->port_info[2].status = ICOM_PORT_ACTIVE;
1350 icom_adapter->port_info[2].imbed_modem = ICOM_RVX;
1351 icom_adapter->port_info[3].status = ICOM_PORT_OFF;
1358 static void icom_port_active(struct icom_port *icom_port, struct icom_adapter *icom_adapter, int port_num)
1360 if (icom_adapter->version == ADAPTER_V1) {
1361 icom_port->global_reg = icom_adapter->base_addr + 0x4000;
1362 icom_port->int_reg = icom_adapter->base_addr +
1363 0x4004 + 2 - 2 * port_num;
1365 icom_port->global_reg = icom_adapter->base_addr + 0x8000;
1366 if (icom_port->port < 2)
1367 icom_port->int_reg = icom_adapter->base_addr +
1368 0x8004 + 2 - 2 * icom_port->port;
1370 icom_port->int_reg = icom_adapter->base_addr +
1371 0x8024 + 2 - 2 * (icom_port->port - 2);
1374 static int icom_load_ports(struct icom_adapter *icom_adapter)
1376 struct icom_port *icom_port;
1379 for (port_num = 0; port_num < icom_adapter->numb_ports; port_num++) {
1381 icom_port = &icom_adapter->port_info[port_num];
1383 if (icom_port->status == ICOM_PORT_ACTIVE) {
1384 icom_port_active(icom_port, icom_adapter, port_num);
1385 icom_port->dram = icom_adapter->base_addr +
1386 0x2000 * icom_port->port;
1388 icom_port->adapter = icom_adapter;
1390 /* get port memory */
1391 if (get_port_memory(icom_port) != 0) {
1392 dev_err(&icom_port->adapter->pci_dev->dev,
1393 "Memory allocation for port FAILED\n");
1400 static int icom_alloc_adapter(struct icom_adapter
1403 int adapter_count = 0;
1404 struct icom_adapter *icom_adapter;
1405 struct icom_adapter *cur_adapter_entry;
1406 struct list_head *tmp;
1408 icom_adapter = kzalloc(sizeof(struct icom_adapter), GFP_KERNEL);
1410 if (!icom_adapter) {
1414 list_for_each(tmp, &icom_adapter_head) {
1416 list_entry(tmp, struct icom_adapter,
1417 icom_adapter_entry);
1418 if (cur_adapter_entry->index != adapter_count) {
1424 icom_adapter->index = adapter_count;
1425 list_add_tail(&icom_adapter->icom_adapter_entry, tmp);
1427 *icom_adapter_ref = icom_adapter;
1431 static void icom_free_adapter(struct icom_adapter *icom_adapter)
1433 list_del(&icom_adapter->icom_adapter_entry);
1434 kfree(icom_adapter);
1437 static void icom_remove_adapter(struct icom_adapter *icom_adapter)
1439 struct icom_port *icom_port;
1442 for (index = 0; index < icom_adapter->numb_ports; index++) {
1443 icom_port = &icom_adapter->port_info[index];
1445 if (icom_port->status == ICOM_PORT_ACTIVE) {
1446 dev_info(&icom_adapter->pci_dev->dev,
1447 "Device removed\n");
1449 uart_remove_one_port(&icom_uart_driver,
1450 &icom_port->uart_port);
1452 /* be sure that DTR and RTS are dropped */
1453 writeb(0x00, &icom_port->dram->osr);
1455 /* Wait 0.1 Sec for simple Init to complete */
1458 /* Stop proccessor */
1459 stop_processor(icom_port);
1461 free_port_memory(icom_port);
1465 free_irq(icom_adapter->pci_dev->irq, (void *) icom_adapter);
1466 iounmap(icom_adapter->base_addr);
1467 pci_release_regions(icom_adapter->pci_dev);
1468 icom_free_adapter(icom_adapter);
1471 static void icom_kref_release(struct kref *kref)
1473 struct icom_adapter *icom_adapter;
1475 icom_adapter = to_icom_adapter(kref);
1476 icom_remove_adapter(icom_adapter);
1479 static int icom_probe(struct pci_dev *dev,
1480 const struct pci_device_id *ent)
1483 unsigned int command_reg;
1485 struct icom_adapter *icom_adapter;
1486 struct icom_port *icom_port;
1488 retval = pci_enable_device(dev);
1490 dev_err(&dev->dev, "Device enable FAILED\n");
1494 retval = pci_request_regions(dev, "icom");
1496 dev_err(&dev->dev, "pci_request_regions FAILED\n");
1497 pci_disable_device(dev);
1501 pci_set_master(dev);
1503 retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg);
1505 dev_err(&dev->dev, "PCI Config read FAILED\n");
1509 pci_write_config_dword(dev, PCI_COMMAND,
1510 command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER
1511 | PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
1513 if (ent->driver_data == ADAPTER_V1) {
1514 pci_write_config_dword(dev, 0x44, 0x8300830A);
1516 pci_write_config_dword(dev, 0x44, 0x42004200);
1517 pci_write_config_dword(dev, 0x48, 0x42004200);
1521 retval = icom_alloc_adapter(&icom_adapter);
1523 dev_err(&dev->dev, "icom_alloc_adapter FAILED\n");
1528 icom_adapter->base_addr_pci = pci_resource_start(dev, 0);
1529 icom_adapter->pci_dev = dev;
1530 icom_adapter->version = ent->driver_data;
1531 icom_adapter->subsystem_id = ent->subdevice;
1534 retval = icom_init_ports(icom_adapter);
1536 dev_err(&dev->dev, "Port configuration failed\n");
1540 icom_adapter->base_addr = pci_ioremap_bar(dev, 0);
1542 if (!icom_adapter->base_addr) {
1547 /* save off irq and request irq line */
1548 retval = request_irq(dev->irq, icom_interrupt, IRQF_SHARED, ICOM_DRIVER_NAME, (void *)icom_adapter);
1553 retval = icom_load_ports(icom_adapter);
1555 for (index = 0; index < icom_adapter->numb_ports; index++) {
1556 icom_port = &icom_adapter->port_info[index];
1558 if (icom_port->status == ICOM_PORT_ACTIVE) {
1559 icom_port->uart_port.irq = icom_port->adapter->pci_dev->irq;
1560 icom_port->uart_port.type = PORT_ICOM;
1561 icom_port->uart_port.iotype = UPIO_MEM;
1562 icom_port->uart_port.membase =
1563 (unsigned char __iomem *)icom_adapter->base_addr_pci;
1564 icom_port->uart_port.fifosize = 16;
1565 icom_port->uart_port.ops = &icom_ops;
1566 icom_port->uart_port.line =
1567 icom_port->port + icom_adapter->index * 4;
1568 if (uart_add_one_port (&icom_uart_driver, &icom_port->uart_port)) {
1569 icom_port->status = ICOM_PORT_OFF;
1570 dev_err(&dev->dev, "Device add failed\n");
1572 dev_info(&dev->dev, "Device added\n");
1576 kref_init(&icom_adapter->kref);
1580 iounmap(icom_adapter->base_addr);
1582 icom_free_adapter(icom_adapter);
1585 pci_release_regions(dev);
1586 pci_disable_device(dev);
1591 static void icom_remove(struct pci_dev *dev)
1593 struct icom_adapter *icom_adapter;
1594 struct list_head *tmp;
1596 list_for_each(tmp, &icom_adapter_head) {
1597 icom_adapter = list_entry(tmp, struct icom_adapter,
1598 icom_adapter_entry);
1599 if (icom_adapter->pci_dev == dev) {
1600 kref_put(&icom_adapter->kref, icom_kref_release);
1605 dev_err(&dev->dev, "Unable to find device to remove\n");
1608 static struct pci_driver icom_pci_driver = {
1609 .name = ICOM_DRIVER_NAME,
1610 .id_table = icom_pci_table,
1611 .probe = icom_probe,
1612 .remove = icom_remove,
1615 static int __init icom_init(void)
1619 ret = uart_register_driver(&icom_uart_driver);
1623 ret = pci_register_driver(&icom_pci_driver);
1626 uart_unregister_driver(&icom_uart_driver);
1631 static void __exit icom_exit(void)
1633 pci_unregister_driver(&icom_pci_driver);
1634 uart_unregister_driver(&icom_uart_driver);
1637 module_init(icom_init);
1638 module_exit(icom_exit);
1640 MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1641 MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1642 MODULE_LICENSE("GPL");
1643 MODULE_FIRMWARE("icom_call_setup.bin");
1644 MODULE_FIRMWARE("icom_res_dce.bin");
1645 MODULE_FIRMWARE("icom_asc.bin");