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