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