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