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