File: /usr/src/linux/drivers/char/moxa.c
1 /*****************************************************************************/
2 /*
3 * moxa.c -- MOXA Intellio family multiport serial driver.
4 *
5 * Copyright (C) 1999-2000 Moxa Technologies (support@moxa.com.tw).
6 *
7 * This code is loosely based on the Linux serial driver, written by
8 * Linus Torvalds, Theodore T'so and others.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 /*
26 * MOXA Intellio Series Driver
27 * for : LINUX
28 * date : 1999/1/7
29 * version : 5.1
30 */
31
32 #include <linux/config.h>
33 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/version.h>
36 #include <linux/mm.h>
37 #include <linux/ioport.h>
38 #include <linux/errno.h>
39 #include <linux/signal.h>
40 #include <linux/sched.h>
41 #include <linux/timer.h>
42 #include <linux/interrupt.h>
43 #include <linux/tty.h>
44 #include <linux/tty_flip.h>
45 #include <linux/major.h>
46 #include <linux/string.h>
47 #include <linux/fcntl.h>
48 #include <linux/ptrace.h>
49 #include <linux/serial.h>
50 #include <linux/tty_driver.h>
51 #include <linux/delay.h>
52 #include <linux/pci.h>
53
54 #include <asm/system.h>
55 #include <asm/io.h>
56 #include <asm/segment.h>
57 #include <asm/bitops.h>
58 #include <asm/uaccess.h>
59
60 #define MOXA_VERSION "5.1k"
61
62 #define MOXAMAJOR 172
63 #define MOXACUMAJOR 173
64
65 #define put_to_user(arg1, arg2) put_user(arg1, (unsigned long *)arg2)
66 #define get_from_user(arg1, arg2) get_user(arg1, (unsigned int *)arg2)
67
68 #define MAX_BOARDS 4 /* Don't change this value */
69 #define MAX_PORTS_PER_BOARD 32 /* Don't change this value */
70 #define MAX_PORTS 128 /* Don't change this value */
71
72 /*
73 * Define the Moxa PCI vendor and device IDs.
74 */
75 #define MOXA_BUS_TYPE_ISA 0
76 #define MOXA_BUS_TYPE_PCI 1
77
78 #ifndef PCI_VENDOR_ID_MOXA
79 #define PCI_VENDOR_ID_MOXA 0x1393
80 #endif
81 #ifndef PCI_DEVICE_ID_CP204J
82 #define PCI_DEVICE_ID_CP204J 0x2040
83 #endif
84 #ifndef PCI_DEVICE_ID_C218
85 #define PCI_DEVICE_ID_C218 0x2180
86 #endif
87 #ifndef PCI_DEVICE_ID_C320
88 #define PCI_DEVICE_ID_C320 0x3200
89 #endif
90
91 enum {
92 MOXA_BOARD_C218_PCI = 1,
93 MOXA_BOARD_C218_ISA,
94 MOXA_BOARD_C320_PCI,
95 MOXA_BOARD_C320_ISA,
96 MOXA_BOARD_CP204J,
97 };
98
99 static char *moxa_brdname[] =
100 {
101 "C218 Turbo PCI series",
102 "C218 Turbo ISA series",
103 "C320 Turbo PCI series",
104 "C320 Turbo ISA series",
105 "CP-204J series",
106 };
107
108 typedef struct {
109 unsigned short vendor_id;
110 unsigned short device_id;
111 unsigned short board_type;
112 } moxa_pciinfo;
113
114 static moxa_pciinfo moxa_pcibrds[] =
115 {
116 {PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_C218, MOXA_BOARD_C218_PCI},
117 {PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_C320, MOXA_BOARD_C320_PCI},
118 {PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_CP204J, MOXA_BOARD_CP204J},
119 };
120
121 typedef struct _moxa_isa_board_conf {
122 int boardType;
123 int numPorts;
124 unsigned long baseAddr;
125 } moxa_isa_board_conf;
126
127 static moxa_isa_board_conf moxa_isa_boards[] =
128 {
129 /* {MOXA_BOARD_C218_ISA,8,0xDC000}, */
130 };
131
132 typedef struct _moxa_pci_devinfo {
133 ushort busNum;
134 ushort devNum;
135 } moxa_pci_devinfo;
136
137 typedef struct _moxa_board_conf {
138 int boardType;
139 int numPorts;
140 unsigned long baseAddr;
141 int busType;
142 moxa_pci_devinfo pciInfo;
143 } moxa_board_conf;
144
145 static moxa_board_conf moxa_boards[MAX_BOARDS];
146 static unsigned long moxaBaseAddr[MAX_BOARDS];
147
148 struct moxa_str {
149 int type;
150 int port;
151 int close_delay;
152 unsigned short closing_wait;
153 int count;
154 int blocked_open;
155 long event; /* long req'd for set_bit --RR */
156 int asyncflags;
157 long session;
158 long pgrp;
159 unsigned long statusflags;
160 struct tty_struct *tty;
161 struct termios normal_termios;
162 struct termios callout_termios;
163 wait_queue_head_t open_wait;
164 wait_queue_head_t close_wait;
165 struct tq_struct tqueue;
166 };
167
168 struct mxser_mstatus {
169 tcflag_t cflag;
170 int cts;
171 int dsr;
172 int ri;
173 int dcd;
174 };
175
176 static struct mxser_mstatus GMStatus[MAX_PORTS];
177
178 /* statusflags */
179 #define TXSTOPPED 0x1
180 #define LOWWAIT 0x2
181 #define EMPTYWAIT 0x4
182 #define THROTTLE 0x8
183
184 /* event */
185 #define MOXA_EVENT_HANGUP 1
186
187 #define SERIAL_DO_RESTART
188
189
190 #define SERIAL_TYPE_NORMAL 1
191 #define SERIAL_TYPE_CALLOUT 2
192
193 #define WAKEUP_CHARS 256
194
195 #define PORTNO(x) (MINOR((x)->device) - (x)->driver.minor_start)
196
197 static int verbose = 0;
198 static int ttymajor = MOXAMAJOR;
199 static int calloutmajor = MOXACUMAJOR;
200 #ifdef MODULE
201 /* Variables for insmod */
202 static int baseaddr[] = {0, 0, 0, 0};
203 static int type[] = {0, 0, 0, 0};
204 static int numports[] = {0, 0, 0, 0};
205
206 MODULE_AUTHOR("William Chen");
207 MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
208 MODULE_LICENSE("GPL");
209 MODULE_PARM(type, "1-4i");
210 MODULE_PARM(baseaddr, "1-4i");
211 MODULE_PARM(numports, "1-4i");
212 MODULE_PARM(ttymajor, "i");
213 MODULE_PARM(calloutmajor, "i");
214 MODULE_PARM(verbose, "i");
215
216 EXPORT_NO_SYMBOLS;
217
218 #endif //MODULE
219
220 static struct tty_driver moxaDriver;
221 static struct tty_driver moxaCallout;
222 static struct tty_struct *moxaTable[MAX_PORTS + 1];
223 static struct termios *moxaTermios[MAX_PORTS + 1];
224 static struct termios *moxaTermiosLocked[MAX_PORTS + 1];
225 static struct moxa_str moxaChannels[MAX_PORTS];
226 static int moxaRefcount;
227 static unsigned char *moxaXmitBuff;
228 static int moxaTimer_on;
229 static struct timer_list moxaTimer;
230 static int moxaEmptyTimer_on[MAX_PORTS];
231 static struct timer_list moxaEmptyTimer[MAX_PORTS];
232 static struct semaphore moxaBuffSem;
233
234 int moxa_init(void);
235 #ifdef MODULE
236 int init_module(void);
237 void cleanup_module(void);
238 #endif
239 /*
240 * static functions:
241 */
242 static int moxa_get_PCI_conf(struct pci_dev *, int, moxa_board_conf *);
243 static void do_moxa_softint(void *);
244 static int moxa_open(struct tty_struct *, struct file *);
245 static void moxa_close(struct tty_struct *, struct file *);
246 static int moxa_write(struct tty_struct *, int, const unsigned char *, int);
247 static int moxa_write_room(struct tty_struct *);
248 static void moxa_flush_buffer(struct tty_struct *);
249 static int moxa_chars_in_buffer(struct tty_struct *);
250 static void moxa_flush_chars(struct tty_struct *);
251 static void moxa_put_char(struct tty_struct *, unsigned char);
252 static int moxa_ioctl(struct tty_struct *, struct file *, unsigned int, unsigned long);
253 static void moxa_throttle(struct tty_struct *);
254 static void moxa_unthrottle(struct tty_struct *);
255 static void moxa_set_termios(struct tty_struct *, struct termios *);
256 static void moxa_stop(struct tty_struct *);
257 static void moxa_start(struct tty_struct *);
258 static void moxa_hangup(struct tty_struct *);
259 static void moxa_poll(unsigned long);
260 static void set_tty_param(struct tty_struct *);
261 static int block_till_ready(struct tty_struct *, struct file *,
262 struct moxa_str *);
263 static void setup_empty_event(struct tty_struct *);
264 static void check_xmit_empty(unsigned long);
265 static void shut_down(struct moxa_str *);
266 static void receive_data(struct moxa_str *);
267 /*
268 * moxa board interface functions:
269 */
270 static void MoxaDriverInit(void);
271 static int MoxaDriverIoctl(unsigned int, unsigned long, int);
272 static int MoxaDriverPoll(void);
273 static int MoxaPortsOfCard(int);
274 static int MoxaPortIsValid(int);
275 static void MoxaPortEnable(int);
276 static void MoxaPortDisable(int);
277 static long MoxaPortGetMaxBaud(int);
278 static long MoxaPortSetBaud(int, long);
279 static int MoxaPortSetTermio(int, struct termios *);
280 static int MoxaPortGetLineOut(int, int *, int *);
281 static void MoxaPortLineCtrl(int, int, int);
282 static void MoxaPortFlowCtrl(int, int, int, int, int, int);
283 static int MoxaPortLineStatus(int);
284 static int MoxaPortDCDChange(int);
285 static int MoxaPortDCDON(int);
286 static void MoxaPortFlushData(int, int);
287 static int MoxaPortWriteData(int, unsigned char *, int);
288 static int MoxaPortReadData(int, unsigned char *, int);
289 static int MoxaPortTxQueue(int);
290 static int MoxaPortRxQueue(int);
291 static int MoxaPortTxFree(int);
292 static void MoxaPortTxDisable(int);
293 static void MoxaPortTxEnable(int);
294 static int MoxaPortResetBrkCnt(int);
295 static void MoxaPortSendBreak(int, int);
296 static int moxa_get_serial_info(struct moxa_str *, struct serial_struct *);
297 static int moxa_set_serial_info(struct moxa_str *, struct serial_struct *);
298 static void MoxaSetFifo(int port, int enable);
299
300 #ifdef MODULE
301 int init_module(void)
302 {
303 int ret;
304
305 if (verbose)
306 printk("Loading module moxa ...\n");
307 ret = moxa_init();
308 if (verbose)
309 printk("Done\n");
310 return (ret);
311 }
312
313 void cleanup_module(void)
314 {
315 int i;
316
317 if (verbose)
318 printk("Unloading module moxa ...\n");
319
320 if (moxaTimer_on)
321 del_timer(&moxaTimer);
322
323 for (i = 0; i < MAX_PORTS; i++)
324 if (moxaEmptyTimer_on[i])
325 del_timer(&moxaEmptyTimer[i]);
326
327 if (tty_unregister_driver(&moxaCallout))
328 printk("Couldn't unregister MOXA Intellio family callout driver\n");
329 if (tty_unregister_driver(&moxaDriver))
330 printk("Couldn't unregister MOXA Intellio family serial driver\n");
331 if (verbose)
332 printk("Done\n");
333
334 }
335 #endif
336
337 int moxa_init(void)
338 {
339 int i, n, numBoards;
340 struct moxa_str *ch;
341 int ret1, ret2;
342
343 printk(KERN_INFO "MOXA Intellio family driver version %s\n", MOXA_VERSION);
344
345 init_MUTEX(&moxaBuffSem);
346 memset(&moxaDriver, 0, sizeof(struct tty_driver));
347 memset(&moxaCallout, 0, sizeof(struct tty_driver));
348 moxaDriver.magic = TTY_DRIVER_MAGIC;
349 moxaDriver.name = "ttya";
350 moxaDriver.major = ttymajor;
351 moxaDriver.minor_start = 0;
352 moxaDriver.num = MAX_PORTS + 1;
353 moxaDriver.type = TTY_DRIVER_TYPE_SERIAL;
354 moxaDriver.subtype = SERIAL_TYPE_NORMAL;
355 moxaDriver.init_termios = tty_std_termios;
356 moxaDriver.init_termios.c_iflag = 0;
357 moxaDriver.init_termios.c_oflag = 0;
358 moxaDriver.init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
359 moxaDriver.init_termios.c_lflag = 0;
360 moxaDriver.flags = TTY_DRIVER_REAL_RAW;
361 moxaDriver.refcount = &moxaRefcount;
362 moxaDriver.table = moxaTable;
363 moxaDriver.termios = moxaTermios;
364 moxaDriver.termios_locked = moxaTermiosLocked;
365
366 moxaDriver.open = moxa_open;
367 moxaDriver.close = moxa_close;
368 moxaDriver.write = moxa_write;
369 moxaDriver.write_room = moxa_write_room;
370 moxaDriver.flush_buffer = moxa_flush_buffer;
371 moxaDriver.chars_in_buffer = moxa_chars_in_buffer;
372 moxaDriver.flush_chars = moxa_flush_chars;
373 moxaDriver.put_char = moxa_put_char;
374 moxaDriver.ioctl = moxa_ioctl;
375 moxaDriver.throttle = moxa_throttle;
376 moxaDriver.unthrottle = moxa_unthrottle;
377 moxaDriver.set_termios = moxa_set_termios;
378 moxaDriver.stop = moxa_stop;
379 moxaDriver.start = moxa_start;
380 moxaDriver.hangup = moxa_hangup;
381
382 moxaCallout = moxaDriver;
383 moxaCallout.name = "ttyA";
384 moxaCallout.major = calloutmajor;
385 moxaCallout.subtype = SERIAL_TYPE_CALLOUT;
386
387 moxaXmitBuff = 0;
388
389 for (i = 0, ch = moxaChannels; i < MAX_PORTS; i++, ch++) {
390 ch->type = PORT_16550A;
391 ch->port = i;
392 ch->tqueue.routine = do_moxa_softint;
393 ch->tqueue.data = ch;
394 ch->tty = 0;
395 ch->close_delay = 5 * HZ / 10;
396 ch->closing_wait = 30 * HZ;
397 ch->count = 0;
398 ch->blocked_open = 0;
399 ch->callout_termios = moxaCallout.init_termios;
400 ch->normal_termios = moxaDriver.init_termios;
401 init_waitqueue_head(&ch->open_wait);
402 init_waitqueue_head(&ch->close_wait);
403 }
404
405 for (i = 0; i < MAX_BOARDS; i++) {
406 moxa_boards[i].boardType = 0;
407 moxa_boards[i].numPorts = 0;
408 moxa_boards[i].baseAddr = 0;
409 moxa_boards[i].busType = 0;
410 moxa_boards[i].pciInfo.busNum = 0;
411 moxa_boards[i].pciInfo.devNum = 0;
412 }
413 MoxaDriverInit();
414 printk("Tty devices major number = %d, callout devices major number = %d\n", ttymajor, calloutmajor);
415
416 ret1 = 0;
417 ret2 = 0;
418 if ((ret1 = tty_register_driver(&moxaDriver))) {
419 printk(KERN_ERR "Couldn't install MOXA Smartio family driver !\n");
420 } else if ((ret2 = tty_register_driver(&moxaCallout))) {
421 tty_unregister_driver(&moxaDriver);
422 printk(KERN_ERR "Couldn't install MOXA Smartio family callout driver !\n");
423 }
424 if (ret1 || ret2) {
425 return -1;
426 }
427 for (i = 0; i < MAX_PORTS; i++) {
428 init_timer(&moxaEmptyTimer[i]);
429 moxaEmptyTimer[i].function = check_xmit_empty;
430 moxaEmptyTimer[i].data = (unsigned long) & moxaChannels[i];
431 moxaEmptyTimer_on[i] = 0;
432 }
433
434 init_timer(&moxaTimer);
435 moxaTimer.function = moxa_poll;
436 moxaTimer.expires = jiffies + (HZ / 50);
437 moxaTimer_on = 1;
438 add_timer(&moxaTimer);
439
440 /* Find the boards defined in source code */
441 numBoards = 0;
442 for (i = 0; i < MAX_BOARDS; i++) {
443 if ((moxa_isa_boards[i].boardType == MOXA_BOARD_C218_ISA) ||
444 (moxa_isa_boards[i].boardType == MOXA_BOARD_C320_ISA)) {
445 moxa_boards[numBoards].boardType = moxa_isa_boards[i].boardType;
446 if (moxa_isa_boards[i].boardType == MOXA_BOARD_C218_ISA)
447 moxa_boards[numBoards].numPorts = 8;
448 else
449 moxa_boards[numBoards].numPorts = moxa_isa_boards[i].numPorts;
450 moxa_boards[numBoards].busType = MOXA_BUS_TYPE_ISA;
451 moxa_boards[numBoards].baseAddr = moxa_isa_boards[i].baseAddr;
452 if (verbose)
453 printk("Board %2d: %s board(baseAddr=%lx)\n",
454 numBoards + 1,
455 moxa_brdname[moxa_boards[numBoards].boardType - 1],
456 moxa_boards[numBoards].baseAddr);
457 numBoards++;
458 }
459 }
460 /* Find the boards defined form module args. */
461 #ifdef MODULE
462 for (i = 0; i < MAX_BOARDS; i++) {
463 if ((type[i] == MOXA_BOARD_C218_ISA) ||
464 (type[i] == MOXA_BOARD_C320_ISA)) {
465 if (verbose)
466 printk("Board %2d: %s board(baseAddr=%lx)\n",
467 numBoards + 1,
468 moxa_brdname[type[i] - 1],
469 (unsigned long) baseaddr[i]);
470 if (numBoards >= MAX_BOARDS) {
471 if (verbose)
472 printk("More than %d MOXA Intellio family boards found. Board is ignored.", MAX_BOARDS);
473 continue;
474 }
475 moxa_boards[numBoards].boardType = type[i];
476 if (moxa_isa_boards[i].boardType == MOXA_BOARD_C218_ISA)
477 moxa_boards[numBoards].numPorts = 8;
478 else
479 moxa_boards[numBoards].numPorts = numports[i];
480 moxa_boards[numBoards].busType = MOXA_BUS_TYPE_ISA;
481 moxa_boards[numBoards].baseAddr = baseaddr[i];
482 numBoards++;
483 }
484 }
485 #endif
486 /* Find PCI boards here */
487 #ifdef CONFIG_PCI
488 {
489 struct pci_dev *p = NULL;
490 n = sizeof(moxa_pcibrds) / sizeof(moxa_pciinfo);
491 i = 0;
492 while (i < n) {
493 while((p = pci_find_device(moxa_pcibrds[i].vendor_id, moxa_pcibrds[i].device_id, p))!=NULL)
494 {
495 if (pci_enable_device(p))
496 continue;
497 if (numBoards >= MAX_BOARDS) {
498 if (verbose)
499 printk("More than %d MOXA Intellio family boards found. Board is ignored.", MAX_BOARDS);
500 } else {
501 moxa_get_PCI_conf(p, moxa_pcibrds[i].board_type,
502 &moxa_boards[numBoards]);
503 numBoards++;
504 }
505 }
506 i++;
507 }
508 }
509 #endif
510 for (i = 0; i < numBoards; i++) {
511 moxaBaseAddr[i] = (unsigned long) ioremap((unsigned long) moxa_boards[i].baseAddr, 0x4000);
512 }
513
514 return (0);
515 }
516
517 static int moxa_get_PCI_conf(struct pci_dev *p, int board_type, moxa_board_conf * board)
518 {
519 board->baseAddr = pci_resource_start (p, 2);
520 board->boardType = board_type;
521 switch (board_type) {
522 case MOXA_BOARD_C218_ISA:
523 case MOXA_BOARD_C218_PCI:
524 board->numPorts = 8;
525 break;
526
527 case MOXA_BOARD_CP204J:
528 board->numPorts = 4;
529 break;
530 default:
531 board->numPorts = 0;
532 break;
533 }
534 board->busType = MOXA_BUS_TYPE_PCI;
535 board->pciInfo.busNum = p->bus->number;
536 board->pciInfo.devNum = p->devfn >> 3;
537
538 return (0);
539 }
540
541 static void do_moxa_softint(void *private_)
542 {
543 struct moxa_str *ch = (struct moxa_str *) private_;
544 struct tty_struct *tty;
545
546 if (ch && (tty = ch->tty)) {
547 if (test_and_clear_bit(MOXA_EVENT_HANGUP, &ch->event)) {
548 tty_hangup(tty); /* FIXME: module removal race here - AKPM */
549 wake_up_interruptible(&ch->open_wait);
550 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE);
551 }
552 }
553 MOD_DEC_USE_COUNT;
554 }
555
556 static int moxa_open(struct tty_struct *tty, struct file *filp)
557 {
558 struct moxa_str *ch;
559 int port;
560 int retval;
561 unsigned long page;
562
563 port = PORTNO(tty);
564 if (port == MAX_PORTS) {
565 MOD_INC_USE_COUNT;
566 return (0);
567 }
568 if (!MoxaPortIsValid(port)) {
569 tty->driver_data = NULL;
570 return (-ENODEV);
571 }
572 down(&moxaBuffSem);
573 if (!moxaXmitBuff) {
574 page = get_free_page(GFP_KERNEL);
575 if (!page) {
576 up(&moxaBuffSem);
577 return (-ENOMEM);
578 }
579 /* This test is guarded by the BuffSem so no longer needed
580 delete me in 2.5 */
581 if (moxaXmitBuff)
582 free_page(page);
583 else
584 moxaXmitBuff = (unsigned char *) page;
585 }
586 up(&moxaBuffSem);
587
588 MOD_INC_USE_COUNT;
589 ch = &moxaChannels[port];
590 ch->count++;
591 tty->driver_data = ch;
592 ch->tty = tty;
593 if (ch->count == 1 && (ch->asyncflags & ASYNC_SPLIT_TERMIOS)) {
594 if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
595 *tty->termios = ch->normal_termios;
596 else
597 *tty->termios = ch->callout_termios;
598 }
599 ch->session = current->session;
600 ch->pgrp = current->pgrp;
601 if (!(ch->asyncflags & ASYNC_INITIALIZED)) {
602 ch->statusflags = 0;
603 set_tty_param(tty);
604 MoxaPortLineCtrl(ch->port, 1, 1);
605 MoxaPortEnable(ch->port);
606 ch->asyncflags |= ASYNC_INITIALIZED;
607 }
608 retval = block_till_ready(tty, filp, ch);
609
610 moxa_unthrottle(tty);
611
612 if (ch->type == PORT_16550A) {
613 MoxaSetFifo(ch->port, 1);
614 } else {
615 MoxaSetFifo(ch->port, 0);
616 }
617
618 return (retval);
619 }
620
621 static void moxa_close(struct tty_struct *tty, struct file *filp)
622 {
623 struct moxa_str *ch;
624 int port;
625
626 port = PORTNO(tty);
627 if (port == MAX_PORTS) {
628 MOD_DEC_USE_COUNT;
629 return;
630 }
631 if (!MoxaPortIsValid(port)) {
632 #ifdef SERIAL_DEBUG_CLOSE
633 printk("Invalid portno in moxa_close\n");
634 #endif
635 tty->driver_data = NULL;
636 return;
637 }
638 if (tty->driver_data == NULL) {
639 return;
640 }
641 if (tty_hung_up_p(filp)) {
642 MOD_DEC_USE_COUNT;
643 return;
644 }
645 ch = (struct moxa_str *) tty->driver_data;
646
647 if ((tty->count == 1) && (ch->count != 1)) {
648 printk("moxa_close: bad serial port count; tty->count is 1, "
649 "ch->count is %d\n", ch->count);
650 ch->count = 1;
651 }
652 if (--ch->count < 0) {
653 printk("moxa_close: bad serial port count, minor=%d\n",
654 MINOR(tty->device));
655 ch->count = 0;
656 }
657 if (ch->count) {
658 MOD_DEC_USE_COUNT;
659 return;
660 }
661 ch->asyncflags |= ASYNC_CLOSING;
662
663 /*
664 * Save the termios structure, since this port may have
665 * separate termios for callout and dialin.
666 */
667 if (ch->asyncflags & ASYNC_NORMAL_ACTIVE)
668 ch->normal_termios = *tty->termios;
669 if (ch->asyncflags & ASYNC_CALLOUT_ACTIVE)
670 ch->callout_termios = *tty->termios;
671 if (ch->asyncflags & ASYNC_INITIALIZED) {
672 setup_empty_event(tty);
673 tty_wait_until_sent(tty, 30 * HZ); /* 30 seconds timeout */
674 moxaEmptyTimer_on[ch->port] = 0;
675 del_timer(&moxaEmptyTimer[ch->port]);
676 }
677 shut_down(ch);
678 MoxaPortFlushData(port, 2);
679
680 if (tty->driver.flush_buffer)
681 tty->driver.flush_buffer(tty);
682 if (tty->ldisc.flush_buffer)
683 tty->ldisc.flush_buffer(tty);
684 tty->closing = 0;
685 ch->event = 0;
686 ch->tty = 0;
687 if (ch->blocked_open) {
688 if (ch->close_delay) {
689 current->state = TASK_INTERRUPTIBLE;
690 schedule_timeout(ch->close_delay);
691 }
692 wake_up_interruptible(&ch->open_wait);
693 }
694 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE |
695 ASYNC_CLOSING);
696 wake_up_interruptible(&ch->close_wait);
697 MOD_DEC_USE_COUNT;
698 }
699
700 static int moxa_write(struct tty_struct *tty, int from_user,
701 const unsigned char *buf, int count)
702 {
703 struct moxa_str *ch;
704 int len, port;
705 unsigned long flags;
706
707 ch = (struct moxa_str *) tty->driver_data;
708 if (ch == NULL)
709 return (0);
710 port = ch->port;
711 save_flags(flags);
712 if (from_user) {
713 if (count > PAGE_SIZE)
714 count = PAGE_SIZE;
715 down(&moxaBuffSem);
716 if (copy_from_user(moxaXmitBuff, buf, count)) {
717 len = -EFAULT;
718 } else {
719 cli();
720 len = MoxaPortWriteData(port, moxaXmitBuff, count);
721 restore_flags(flags);
722 }
723 up(&moxaBuffSem);
724 if (len < 0)
725 return len;
726 } else {
727 cli();
728 len = MoxaPortWriteData(port, (unsigned char *) buf, count);
729 restore_flags(flags);
730 }
731
732 /*********************************************
733 if ( !(ch->statusflags & LOWWAIT) &&
734 ((len != count) || (MoxaPortTxFree(port) <= 100)) )
735 ************************************************/
736 ch->statusflags |= LOWWAIT;
737 return (len);
738 }
739
740 static int moxa_write_room(struct tty_struct *tty)
741 {
742 struct moxa_str *ch;
743
744 if (tty->stopped)
745 return (0);
746 ch = (struct moxa_str *) tty->driver_data;
747 if (ch == NULL)
748 return (0);
749 return (MoxaPortTxFree(ch->port));
750 }
751
752 static void moxa_flush_buffer(struct tty_struct *tty)
753 {
754 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
755
756 if (ch == NULL)
757 return;
758 MoxaPortFlushData(ch->port, 1);
759 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
760 tty->ldisc.write_wakeup)
761 (tty->ldisc.write_wakeup) (tty);
762 wake_up_interruptible(&tty->write_wait);
763 }
764
765 static int moxa_chars_in_buffer(struct tty_struct *tty)
766 {
767 int chars;
768 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
769
770 /*
771 * Sigh...I have to check if driver_data is NULL here, because
772 * if an open() fails, the TTY subsystem eventually calls
773 * tty_wait_until_sent(), which calls the driver's chars_in_buffer()
774 * routine. And since the open() failed, we return 0 here. TDJ
775 */
776 if (ch == NULL)
777 return (0);
778 chars = MoxaPortTxQueue(ch->port);
779 if (chars) {
780 /*
781 * Make it possible to wakeup anything waiting for output
782 * in tty_ioctl.c, etc.
783 */
784 if (!(ch->statusflags & EMPTYWAIT))
785 setup_empty_event(tty);
786 }
787 return (chars);
788 }
789
790 static void moxa_flush_chars(struct tty_struct *tty)
791 {
792 /*
793 * Don't think I need this, because this is called to empty the TX
794 * buffer for the 16450, 16550, etc.
795 */
796 }
797
798 static void moxa_put_char(struct tty_struct *tty, unsigned char c)
799 {
800 struct moxa_str *ch;
801 int port;
802 unsigned long flags;
803
804 ch = (struct moxa_str *) tty->driver_data;
805 if (ch == NULL)
806 return;
807 port = ch->port;
808 save_flags(flags);
809 cli();
810 moxaXmitBuff[0] = c;
811 MoxaPortWriteData(port, moxaXmitBuff, 1);
812 restore_flags(flags);
813 /************************************************
814 if ( !(ch->statusflags & LOWWAIT) && (MoxaPortTxFree(port) <= 100) )
815 *************************************************/
816 ch->statusflags |= LOWWAIT;
817 }
818
819 static int moxa_ioctl(struct tty_struct *tty, struct file *file,
820 unsigned int cmd, unsigned long arg)
821 {
822 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
823 register int port;
824 int retval, dtr, rts;
825 unsigned long flag;
826
827 port = PORTNO(tty);
828 if ((port != MAX_PORTS) && (!ch))
829 return (-EINVAL);
830
831 switch (cmd) {
832 case TCSBRK: /* SVID version: non-zero arg --> no break */
833 retval = tty_check_change(tty);
834 if (retval)
835 return (retval);
836 setup_empty_event(tty);
837 tty_wait_until_sent(tty, 0);
838 if (!arg)
839 MoxaPortSendBreak(ch->port, 0);
840 return (0);
841 case TCSBRKP: /* support for POSIX tcsendbreak() */
842 retval = tty_check_change(tty);
843 if (retval)
844 return (retval);
845 setup_empty_event(tty);
846 tty_wait_until_sent(tty, 0);
847 MoxaPortSendBreak(ch->port, arg);
848 return (0);
849 case TIOCGSOFTCAR:
850 return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long *) arg);
851 case TIOCSSOFTCAR:
852 if(get_user(retval, (unsigned long *) arg))
853 return -EFAULT;
854 arg = retval;
855 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) |
856 (arg ? CLOCAL : 0));
857 if (C_CLOCAL(tty))
858 ch->asyncflags &= ~ASYNC_CHECK_CD;
859 else
860 ch->asyncflags |= ASYNC_CHECK_CD;
861 return (0);
862 case TIOCMGET:
863 flag = 0;
864 MoxaPortGetLineOut(ch->port, &dtr, &rts);
865 if (dtr)
866 flag |= TIOCM_DTR;
867 if (rts)
868 flag |= TIOCM_RTS;
869 dtr = MoxaPortLineStatus(ch->port);
870 if (dtr & 1)
871 flag |= TIOCM_CTS;
872 if (dtr & 2)
873 flag |= TIOCM_DSR;
874 if (dtr & 4)
875 flag |= TIOCM_CD;
876 return put_user(flag, (unsigned int *) arg);
877 case TIOCMBIS:
878 if(get_user(retval, (unsigned int *) arg))
879 return -EFAULT;
880 MoxaPortGetLineOut(ch->port, &dtr, &rts);
881 if (retval & TIOCM_RTS)
882 rts = 1;
883 if (retval & TIOCM_DTR)
884 dtr = 1;
885 MoxaPortLineCtrl(ch->port, dtr, rts);
886 return (0);
887 case TIOCMBIC:
888 if(get_user(retval, (unsigned int *) arg))
889 return -EFAULT;
890 MoxaPortGetLineOut(ch->port, &dtr, &rts);
891 if (retval & TIOCM_RTS)
892 rts = 0;
893 if (retval & TIOCM_DTR)
894 dtr = 0;
895 MoxaPortLineCtrl(ch->port, dtr, rts);
896 return (0);
897 case TIOCMSET:
898 if(get_user(retval, (unsigned long *) arg))
899 return -EFAULT;
900 dtr = rts = 0;
901 if (retval & TIOCM_RTS)
902 rts = 1;
903 if (retval & TIOCM_DTR)
904 dtr = 1;
905 MoxaPortLineCtrl(ch->port, dtr, rts);
906 return (0);
907 case TIOCGSERIAL:
908 return (moxa_get_serial_info(ch, (struct serial_struct *) arg));
909
910 case TIOCSSERIAL:
911 return (moxa_set_serial_info(ch, (struct serial_struct *) arg));
912 default:
913 retval = MoxaDriverIoctl(cmd, arg, port);
914 }
915 return (retval);
916 }
917
918 static void moxa_throttle(struct tty_struct *tty)
919 {
920 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
921
922 ch->statusflags |= THROTTLE;
923 }
924
925 static void moxa_unthrottle(struct tty_struct *tty)
926 {
927 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
928
929 ch->statusflags &= ~THROTTLE;
930 }
931
932 static void moxa_set_termios(struct tty_struct *tty,
933 struct termios *old_termios)
934 {
935 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
936
937 if (ch == NULL)
938 return;
939 set_tty_param(tty);
940 if (!(old_termios->c_cflag & CLOCAL) &&
941 (tty->termios->c_cflag & CLOCAL))
942 wake_up_interruptible(&ch->open_wait);
943 }
944
945 static void moxa_stop(struct tty_struct *tty)
946 {
947 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
948
949 if (ch == NULL)
950 return;
951 MoxaPortTxDisable(ch->port);
952 ch->statusflags |= TXSTOPPED;
953 }
954
955
956 static void moxa_start(struct tty_struct *tty)
957 {
958 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
959
960 if (ch == NULL)
961 return;
962
963 if (!(ch->statusflags & TXSTOPPED))
964 return;
965
966 MoxaPortTxEnable(ch->port);
967 ch->statusflags &= ~TXSTOPPED;
968 }
969
970 static void moxa_hangup(struct tty_struct *tty)
971 {
972 struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
973
974 moxa_flush_buffer(tty);
975 shut_down(ch);
976 ch->event = 0;
977 ch->count = 0;
978 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE);
979 ch->tty = 0;
980 wake_up_interruptible(&ch->open_wait);
981 }
982
983 static void moxa_poll(unsigned long ignored)
984 {
985 register int card;
986 struct moxa_str *ch;
987 struct tty_struct *tp;
988 int i, ports;
989
990 moxaTimer_on = 0;
991 del_timer(&moxaTimer);
992
993 if (MoxaDriverPoll() < 0) {
994 moxaTimer.function = moxa_poll;
995 moxaTimer.expires = jiffies + (HZ / 50);
996 moxaTimer_on = 1;
997 add_timer(&moxaTimer);
998 return;
999 }
1000 for (card = 0; card < MAX_BOARDS; card++) {
1001 if ((ports = MoxaPortsOfCard(card)) <= 0)
1002 continue;
1003 ch = &moxaChannels[card * MAX_PORTS_PER_BOARD];
1004 for (i = 0; i < ports; i++, ch++) {
1005 if ((ch->asyncflags & ASYNC_INITIALIZED) == 0)
1006 continue;
1007 if (!(ch->statusflags & THROTTLE) &&
1008 (MoxaPortRxQueue(ch->port) > 0))
1009 receive_data(ch);
1010 if ((tp = ch->tty) == 0)
1011 continue;
1012 if (ch->statusflags & LOWWAIT) {
1013 if (MoxaPortTxQueue(ch->port) <= WAKEUP_CHARS) {
1014 if (!tp->stopped) {
1015 ch->statusflags &= ~LOWWAIT;
1016 if ((tp->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
1017 tp->ldisc.write_wakeup)
1018 (tp->ldisc.write_wakeup) (tp);
1019 wake_up_interruptible(&tp->write_wait);
1020 }
1021 }
1022 }
1023 if (!I_IGNBRK(tp) && (MoxaPortResetBrkCnt(ch->port) > 0)) {
1024 tty_insert_flip_char(tp, 0, TTY_BREAK);
1025 tty_schedule_flip(tp);
1026 }
1027 if (MoxaPortDCDChange(ch->port)) {
1028 if (ch->asyncflags & ASYNC_CHECK_CD) {
1029 if (MoxaPortDCDON(ch->port))
1030 wake_up_interruptible(&ch->open_wait);
1031 else {
1032 set_bit(MOXA_EVENT_HANGUP, &ch->event);
1033 MOD_DEC_USE_COUNT;
1034 if (schedule_task(&ch->tqueue) == 0)
1035 MOD_INC_USE_COUNT;
1036 }
1037 }
1038 }
1039 }
1040 }
1041
1042 moxaTimer.function = moxa_poll;
1043 moxaTimer.expires = jiffies + (HZ / 50);
1044 moxaTimer_on = 1;
1045 add_timer(&moxaTimer);
1046 }
1047
1048 /******************************************************************************/
1049
1050 static void set_tty_param(struct tty_struct *tty)
1051 {
1052 register struct termios *ts;
1053 struct moxa_str *ch;
1054 int rts, cts, txflow, rxflow, xany;
1055
1056 ch = (struct moxa_str *) tty->driver_data;
1057 ts = tty->termios;
1058 if (ts->c_cflag & CLOCAL)
1059 ch->asyncflags &= ~ASYNC_CHECK_CD;
1060 else
1061 ch->asyncflags |= ASYNC_CHECK_CD;
1062 rts = cts = txflow = rxflow = xany = 0;
1063 if (ts->c_cflag & CRTSCTS)
1064 rts = cts = 1;
1065 if (ts->c_iflag & IXON)
1066 txflow = 1;
1067 if (ts->c_iflag & IXOFF)
1068 rxflow = 1;
1069 if (ts->c_iflag & IXANY)
1070 xany = 1;
1071 MoxaPortFlowCtrl(ch->port, rts, cts, txflow, rxflow, xany);
1072 MoxaPortSetTermio(ch->port, ts);
1073 }
1074
1075 static int block_till_ready(struct tty_struct *tty, struct file *filp,
1076 struct moxa_str *ch)
1077 {
1078 DECLARE_WAITQUEUE(wait,current);
1079 unsigned long flags;
1080 int retval;
1081 int do_clocal = C_CLOCAL(tty);
1082
1083 /*
1084 * If the device is in the middle of being closed, then block
1085 * until it's done, and then try again.
1086 */
1087 if (tty_hung_up_p(filp) || (ch->asyncflags & ASYNC_CLOSING)) {
1088 if (ch->asyncflags & ASYNC_CLOSING)
1089 interruptible_sleep_on(&ch->close_wait);
1090 #ifdef SERIAL_DO_RESTART
1091 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1092 return (-EAGAIN);
1093 else
1094 return (-ERESTARTSYS);
1095 #else
1096 return (-EAGAIN);
1097 #endif
1098 }
1099 /*
1100 * If this is a callout device, then just make sure the normal
1101 * device isn't being used.
1102 */
1103 if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
1104 if (ch->asyncflags & ASYNC_NORMAL_ACTIVE)
1105 return (-EBUSY);
1106 if ((ch->asyncflags & ASYNC_CALLOUT_ACTIVE) &&
1107 (ch->asyncflags & ASYNC_SESSION_LOCKOUT) &&
1108 (ch->session != current->session))
1109 return (-EBUSY);
1110 if ((ch->asyncflags & ASYNC_CALLOUT_ACTIVE) &&
1111 (ch->asyncflags & ASYNC_PGRP_LOCKOUT) &&
1112 (ch->pgrp != current->pgrp))
1113 return (-EBUSY);
1114 ch->asyncflags |= ASYNC_CALLOUT_ACTIVE;
1115 return (0);
1116 }
1117 /*
1118 * If non-blocking mode is set, then make the check up front
1119 * and then exit.
1120 */
1121 if (filp->f_flags & O_NONBLOCK) {
1122 if (ch->asyncflags & ASYNC_CALLOUT_ACTIVE)
1123 return (-EBUSY);
1124 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
1125 return (0);
1126 }
1127 /*
1128 * Block waiting for the carrier detect and the line to become free
1129 */
1130 retval = 0;
1131 add_wait_queue(&ch->open_wait, &wait);
1132 #ifdef SERIAL_DEBUG_OPEN
1133 printk("block_til_ready before block: ttys%d, count = %d\n",
1134 ch->line, ch->count);
1135 #endif
1136 save_flags(flags);
1137 cli();
1138 if (!tty_hung_up_p(filp))
1139 ch->count--;
1140 restore_flags(flags);
1141 ch->blocked_open++;
1142 while (1) {
1143 current->state = TASK_INTERRUPTIBLE;
1144 if (tty_hung_up_p(filp) ||
1145 !(ch->asyncflags & ASYNC_INITIALIZED)) {
1146 #ifdef SERIAL_DO_RESTART
1147 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1148 retval = -EAGAIN;
1149 else
1150 retval = -ERESTARTSYS;
1151 #else
1152 retval = -EAGAIN;
1153 #endif
1154 break;
1155 }
1156 if (!(ch->asyncflags & ASYNC_CALLOUT_ACTIVE) &&
1157 !(ch->asyncflags & ASYNC_CLOSING) && (do_clocal ||
1158 MoxaPortDCDON(ch->port)))
1159 break;
1160
1161 if (signal_pending(current)) {
1162 retval = -ERESTARTSYS;
1163 break;
1164 }
1165 schedule();
1166 }
1167 current->state = TASK_RUNNING;
1168 remove_wait_queue(&ch->open_wait, &wait);
1169 if (!tty_hung_up_p(filp))
1170 ch->count++;
1171 ch->blocked_open--;
1172 #ifdef SERIAL_DEBUG_OPEN
1173 printk("block_til_ready after blocking: ttys%d, count = %d\n",
1174 ch->line, ch->count);
1175 #endif
1176 if (retval)
1177 return (retval);
1178 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
1179 return (0);
1180 }
1181
1182 static void setup_empty_event(struct tty_struct *tty)
1183 {
1184 struct moxa_str *ch = tty->driver_data;
1185 unsigned long flags;
1186
1187 save_flags(flags);
1188 cli();
1189 ch->statusflags |= EMPTYWAIT;
1190 moxaEmptyTimer_on[ch->port] = 0;
1191 del_timer(&moxaEmptyTimer[ch->port]);
1192 moxaEmptyTimer[ch->port].expires = jiffies + HZ;
1193 moxaEmptyTimer_on[ch->port] = 1;
1194 add_timer(&moxaEmptyTimer[ch->port]);
1195 restore_flags(flags);
1196 }
1197
1198 static void check_xmit_empty(unsigned long data)
1199 {
1200 struct moxa_str *ch;
1201
1202 ch = (struct moxa_str *) data;
1203 moxaEmptyTimer_on[ch->port] = 0;
1204 del_timer(&moxaEmptyTimer[ch->port]);
1205 if (ch->tty && (ch->statusflags & EMPTYWAIT)) {
1206 if (MoxaPortTxQueue(ch->port) == 0) {
1207 ch->statusflags &= ~EMPTYWAIT;
1208 if ((ch->tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
1209 ch->tty->ldisc.write_wakeup)
1210 (ch->tty->ldisc.write_wakeup) (ch->tty);
1211 wake_up_interruptible(&ch->tty->write_wait);
1212 return;
1213 }
1214 moxaEmptyTimer[ch->port].expires = jiffies + HZ;
1215 moxaEmptyTimer_on[ch->port] = 1;
1216 add_timer(&moxaEmptyTimer[ch->port]);
1217 } else
1218 ch->statusflags &= ~EMPTYWAIT;
1219 }
1220
1221 static void shut_down(struct moxa_str *ch)
1222 {
1223 struct tty_struct *tp;
1224
1225 if (!(ch->asyncflags & ASYNC_INITIALIZED))
1226 return;
1227
1228 tp = ch->tty;
1229
1230 MoxaPortDisable(ch->port);
1231
1232 /*
1233 * If we're a modem control device and HUPCL is on, drop RTS & DTR.
1234 */
1235 if (tp->termios->c_cflag & HUPCL)
1236 MoxaPortLineCtrl(ch->port, 0, 0);
1237
1238 ch->asyncflags &= ~ASYNC_INITIALIZED;
1239 }
1240
1241 static void receive_data(struct moxa_str *ch)
1242 {
1243 struct tty_struct *tp;
1244 struct termios *ts;
1245 int i, count, rc, space;
1246 unsigned char *charptr, *flagptr;
1247 unsigned long flags;
1248
1249 ts = 0;
1250 tp = ch->tty;
1251 if (tp)
1252 ts = tp->termios;
1253 /**************************************************
1254 if ( !tp || !ts || !(ts->c_cflag & CREAD) ) {
1255 *****************************************************/
1256 if (!tp || !ts) {
1257 MoxaPortFlushData(ch->port, 0);
1258 return;
1259 }
1260 space = TTY_FLIPBUF_SIZE - tp->flip.count;
1261 if (space <= 0)
1262 return;
1263 charptr = tp->flip.char_buf_ptr;
1264 flagptr = tp->flip.flag_buf_ptr;
1265 rc = tp->flip.count;
1266 save_flags(flags);
1267 cli();
1268 count = MoxaPortReadData(ch->port, charptr, space);
1269 restore_flags(flags);
1270 for (i = 0; i < count; i++)
1271 *flagptr++ = 0;
1272 charptr += count;
1273 rc += count;
1274 tp->flip.count = rc;
1275 tp->flip.char_buf_ptr = charptr;
1276 tp->flip.flag_buf_ptr = flagptr;
1277 tty_schedule_flip(ch->tty);
1278 }
1279
1280 #define Magic_code 0x404
1281
1282 /*
1283 * System Configuration
1284 */
1285 /*
1286 * for C218 BIOS initialization
1287 */
1288 #define C218_ConfBase 0x800
1289 #define C218_status (C218_ConfBase + 0) /* BIOS running status */
1290 #define C218_diag (C218_ConfBase + 2) /* diagnostic status */
1291 #define C218_key (C218_ConfBase + 4) /* WORD (0x218 for C218) */
1292 #define C218DLoad_len (C218_ConfBase + 6) /* WORD */
1293 #define C218check_sum (C218_ConfBase + 8) /* BYTE */
1294 #define C218chksum_ok (C218_ConfBase + 0x0a) /* BYTE (1:ok) */
1295 #define C218_TestRx (C218_ConfBase + 0x10) /* 8 bytes for 8 ports */
1296 #define C218_TestTx (C218_ConfBase + 0x18) /* 8 bytes for 8 ports */
1297 #define C218_RXerr (C218_ConfBase + 0x20) /* 8 bytes for 8 ports */
1298 #define C218_ErrFlag (C218_ConfBase + 0x28) /* 8 bytes for 8 ports */
1299
1300 #define C218_LoadBuf 0x0F00
1301 #define C218_KeyCode 0x218
1302 #define CP204J_KeyCode 0x204
1303
1304 /*
1305 * for C320 BIOS initialization
1306 */
1307 #define C320_ConfBase 0x800
1308 #define C320_LoadBuf 0x0f00
1309 #define STS_init 0x05 /* for C320_status */
1310
1311 #define C320_status C320_ConfBase + 0 /* BIOS running status */
1312 #define C320_diag C320_ConfBase + 2 /* diagnostic status */
1313 #define C320_key C320_ConfBase + 4 /* WORD (0320H for C320) */
1314 #define C320DLoad_len C320_ConfBase + 6 /* WORD */
1315 #define C320check_sum C320_ConfBase + 8 /* WORD */
1316 #define C320chksum_ok C320_ConfBase + 0x0a /* WORD (1:ok) */
1317 #define C320bapi_len C320_ConfBase + 0x0c /* WORD */
1318 #define C320UART_no C320_ConfBase + 0x0e /* WORD */
1319
1320 #define C320_KeyCode 0x320
1321
1322 #define FixPage_addr 0x0000 /* starting addr of static page */
1323 #define DynPage_addr 0x2000 /* starting addr of dynamic page */
1324 #define C218_start 0x3000 /* starting addr of C218 BIOS prg */
1325 #define Control_reg 0x1ff0 /* select page and reset control */
1326 #define HW_reset 0x80
1327
1328 /*
1329 * Function Codes
1330 */
1331 #define FC_CardReset 0x80
1332 #define FC_ChannelReset 1 /* C320 firmware not supported */
1333 #define FC_EnableCH 2
1334 #define FC_DisableCH 3
1335 #define FC_SetParam 4
1336 #define FC_SetMode 5
1337 #define FC_SetRate 6
1338 #define FC_LineControl 7
1339 #define FC_LineStatus 8
1340 #define FC_XmitControl 9
1341 #define FC_FlushQueue 10
1342 #define FC_SendBreak 11
1343 #define FC_StopBreak 12
1344 #define FC_LoopbackON 13
1345 #define FC_LoopbackOFF 14
1346 #define FC_ClrIrqTable 15
1347 #define FC_SendXon 16
1348 #define FC_SetTermIrq 17 /* C320 firmware not supported */
1349 #define FC_SetCntIrq 18 /* C320 firmware not supported */
1350 #define FC_SetBreakIrq 19
1351 #define FC_SetLineIrq 20
1352 #define FC_SetFlowCtl 21
1353 #define FC_GenIrq 22
1354 #define FC_InCD180 23
1355 #define FC_OutCD180 24
1356 #define FC_InUARTreg 23
1357 #define FC_OutUARTreg 24
1358 #define FC_SetXonXoff 25
1359 #define FC_OutCD180CCR 26
1360 #define FC_ExtIQueue 27
1361 #define FC_ExtOQueue 28
1362 #define FC_ClrLineIrq 29
1363 #define FC_HWFlowCtl 30
1364 #define FC_GetClockRate 35
1365 #define FC_SetBaud 36
1366 #define FC_SetDataMode 41
1367 #define FC_GetCCSR 43
1368 #define FC_GetDataError 45
1369 #define FC_RxControl 50
1370 #define FC_ImmSend 51
1371 #define FC_SetXonState 52
1372 #define FC_SetXoffState 53
1373 #define FC_SetRxFIFOTrig 54
1374 #define FC_SetTxFIFOCnt 55
1375 #define FC_UnixRate 56
1376 #define FC_UnixResetTimer 57
1377
1378 #define RxFIFOTrig1 0
1379 #define RxFIFOTrig4 1
1380 #define RxFIFOTrig8 2
1381 #define RxFIFOTrig14 3
1382
1383 /*
1384 * Dual-Ported RAM
1385 */
1386 #define DRAM_global 0
1387 #define INT_data (DRAM_global + 0)
1388 #define Config_base (DRAM_global + 0x108)
1389
1390 #define IRQindex (INT_data + 0)
1391 #define IRQpending (INT_data + 4)
1392 #define IRQtable (INT_data + 8)
1393
1394 /*
1395 * Interrupt Status
1396 */
1397 #define IntrRx 0x01 /* receiver data O.K. */
1398 #define IntrTx 0x02 /* transmit buffer empty */
1399 #define IntrFunc 0x04 /* function complete */
1400 #define IntrBreak 0x08 /* received break */
1401 #define IntrLine 0x10 /* line status change
1402 for transmitter */
1403 #define IntrIntr 0x20 /* received INTR code */
1404 #define IntrQuit 0x40 /* received QUIT code */
1405 #define IntrEOF 0x80 /* received EOF code */
1406
1407 #define IntrRxTrigger 0x100 /* rx data count reach tigger value */
1408 #define IntrTxTrigger 0x200 /* tx data count below trigger value */
1409
1410 #define Magic_no (Config_base + 0)
1411 #define Card_model_no (Config_base + 2)
1412 #define Total_ports (Config_base + 4)
1413 #define Module_cnt (Config_base + 8)
1414 #define Module_no (Config_base + 10)
1415 #define Timer_10ms (Config_base + 14)
1416 #define Disable_IRQ (Config_base + 20)
1417 #define TMS320_PORT1 (Config_base + 22)
1418 #define TMS320_PORT2 (Config_base + 24)
1419 #define TMS320_CLOCK (Config_base + 26)
1420
1421 /*
1422 * DATA BUFFER in DRAM
1423 */
1424 #define Extern_table 0x400 /* Base address of the external table
1425 (24 words * 64) total 3K bytes
1426 (24 words * 128) total 6K bytes */
1427 #define Extern_size 0x60 /* 96 bytes */
1428 #define RXrptr 0x00 /* read pointer for RX buffer */
1429 #define RXwptr 0x02 /* write pointer for RX buffer */
1430 #define TXrptr 0x04 /* read pointer for TX buffer */
1431 #define TXwptr 0x06 /* write pointer for TX buffer */
1432 #define HostStat 0x08 /* IRQ flag and general flag */
1433 #define FlagStat 0x0A
1434 #define FlowControl 0x0C /* B7 B6 B5 B4 B3 B2 B1 B0 */
1435 /* x x x x | | | | */
1436 /* | | | + CTS flow */
1437 /* | | +--- RTS flow */
1438 /* | +------ TX Xon/Xoff */
1439 /* +--------- RX Xon/Xoff */
1440 #define Break_cnt 0x0E /* received break count */
1441 #define CD180TXirq 0x10 /* if non-0: enable TX irq */
1442 #define RX_mask 0x12
1443 #define TX_mask 0x14
1444 #define Ofs_rxb 0x16
1445 #define Ofs_txb 0x18
1446 #define Page_rxb 0x1A
1447 #define Page_txb 0x1C
1448 #define EndPage_rxb 0x1E
1449 #define EndPage_txb 0x20
1450 #define Data_error 0x22
1451 #define RxTrigger 0x28
1452 #define TxTrigger 0x2a
1453
1454 #define rRXwptr 0x34
1455 #define Low_water 0x36
1456
1457 #define FuncCode 0x40
1458 #define FuncArg 0x42
1459 #define FuncArg1 0x44
1460
1461 #define C218rx_size 0x2000 /* 8K bytes */
1462 #define C218tx_size 0x8000 /* 32K bytes */
1463
1464 #define C218rx_mask (C218rx_size - 1)
1465 #define C218tx_mask (C218tx_size - 1)
1466
1467 #define C320p8rx_size 0x2000
1468 #define C320p8tx_size 0x8000
1469 #define C320p8rx_mask (C320p8rx_size - 1)
1470 #define C320p8tx_mask (C320p8tx_size - 1)
1471
1472 #define C320p16rx_size 0x2000
1473 #define C320p16tx_size 0x4000
1474 #define C320p16rx_mask (C320p16rx_size - 1)
1475 #define C320p16tx_mask (C320p16tx_size - 1)
1476
1477 #define C320p24rx_size 0x2000
1478 #define C320p24tx_size 0x2000
1479 #define C320p24rx_mask (C320p24rx_size - 1)
1480 #define C320p24tx_mask (C320p24tx_size - 1)
1481
1482 #define C320p32rx_size 0x1000
1483 #define C320p32tx_size 0x1000
1484 #define C320p32rx_mask (C320p32rx_size - 1)
1485 #define C320p32tx_mask (C320p32tx_size - 1)
1486
1487 #define Page_size 0x2000
1488 #define Page_mask (Page_size - 1)
1489 #define C218rx_spage 3
1490 #define C218tx_spage 4
1491 #define C218rx_pageno 1
1492 #define C218tx_pageno 4
1493 #define C218buf_pageno 5
1494
1495 #define C320p8rx_spage 3
1496 #define C320p8tx_spage 4
1497 #define C320p8rx_pgno 1
1498 #define C320p8tx_pgno 4
1499 #define C320p8buf_pgno 5
1500
1501 #define C320p16rx_spage 3
1502 #define C320p16tx_spage 4
1503 #define C320p16rx_pgno 1
1504 #define C320p16tx_pgno 2
1505 #define C320p16buf_pgno 3
1506
1507 #define C320p24rx_spage 3
1508 #define C320p24tx_spage 4
1509 #define C320p24rx_pgno 1
1510 #define C320p24tx_pgno 1
1511 #define C320p24buf_pgno 2
1512
1513 #define C320p32rx_spage 3
1514 #define C320p32tx_ofs C320p32rx_size
1515 #define C320p32tx_spage 3
1516 #define C320p32buf_pgno 1
1517
1518 /*
1519 * Host Status
1520 */
1521 #define WakeupRx 0x01
1522 #define WakeupTx 0x02
1523 #define WakeupBreak 0x08
1524 #define WakeupLine 0x10
1525 #define WakeupIntr 0x20
1526 #define WakeupQuit 0x40
1527 #define WakeupEOF 0x80 /* used in VTIME control */
1528 #define WakeupRxTrigger 0x100
1529 #define WakeupTxTrigger 0x200
1530 /*
1531 * Flag status
1532 */
1533 #define Rx_over 0x01
1534 #define Xoff_state 0x02
1535 #define Tx_flowOff 0x04
1536 #define Tx_enable 0x08
1537 #define CTS_state 0x10
1538 #define DSR_state 0x20
1539 #define DCD_state 0x80
1540 /*
1541 * FlowControl
1542 */
1543 #define CTS_FlowCtl 1
1544 #define RTS_FlowCtl 2
1545 #define Tx_FlowCtl 4
1546 #define Rx_FlowCtl 8
1547 #define IXM_IXANY 0x10
1548
1549 #define LowWater 128
1550
1551 #define DTR_ON 1
1552 #define RTS_ON 2
1553 #define CTS_ON 1
1554 #define DSR_ON 2
1555 #define DCD_ON 8
1556
1557 /* mode definition */
1558 #define MX_CS8 0x03
1559 #define MX_CS7 0x02
1560 #define MX_CS6 0x01
1561 #define MX_CS5 0x00
1562
1563 #define MX_STOP1 0x00
1564 #define MX_STOP15 0x04
1565 #define MX_STOP2 0x08
1566
1567 #define MX_PARNONE 0x00
1568 #define MX_PAREVEN 0x40
1569 #define MX_PARODD 0xC0
1570
1571 /*
1572 * Query
1573 */
1574 #define QueryPort MAX_PORTS
1575
1576
1577
1578 struct mon_str {
1579 int tick;
1580 int rxcnt[MAX_PORTS];
1581 int txcnt[MAX_PORTS];
1582 };
1583 typedef struct mon_str mon_st;
1584
1585 #define DCD_changed 0x01
1586 #define DCD_oldstate 0x80
1587
1588 static unsigned char moxaBuff[10240];
1589 static unsigned long moxaIntNdx[MAX_BOARDS];
1590 static unsigned long moxaIntPend[MAX_BOARDS];
1591 static unsigned long moxaIntTable[MAX_BOARDS];
1592 static char moxaChkPort[MAX_PORTS];
1593 static char moxaLineCtrl[MAX_PORTS];
1594 static unsigned long moxaTableAddr[MAX_PORTS];
1595 static long moxaCurBaud[MAX_PORTS];
1596 static char moxaDCDState[MAX_PORTS];
1597 static char moxaLowChkFlag[MAX_PORTS];
1598 static int moxaLowWaterChk;
1599 static int moxaCard;
1600 static mon_st moxaLog;
1601 static int moxaFuncTout;
1602 static ushort moxaBreakCnt[MAX_PORTS];
1603
1604 static void moxadelay(int);
1605 static void moxafunc(unsigned long, int, ushort);
1606 static void wait_finish(unsigned long);
1607 static void low_water_check(unsigned long);
1608 static int moxaloadbios(int, unsigned char *, int);
1609 static int moxafindcard(int);
1610 static int moxaload320b(int, unsigned char *, int);
1611 static int moxaloadcode(int, unsigned char *, int);
1612 static int moxaloadc218(int, unsigned long, int);
1613 static int moxaloadc320(int, unsigned long, int, int *);
1614
1615 /*****************************************************************************
1616 * Driver level functions: *
1617 * 1. MoxaDriverInit(void); *
1618 * 2. MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port); *
1619 * 3. MoxaDriverPoll(void); *
1620 *****************************************************************************/
1621 void MoxaDriverInit(void)
1622 {
1623 int i;
1624
1625 moxaFuncTout = HZ / 2; /* 500 mini-seconds */
1626 moxaCard = 0;
1627 moxaLog.tick = 0;
1628 moxaLowWaterChk = 0;
1629 for (i = 0; i < MAX_PORTS; i++) {
1630 moxaChkPort[i] = 0;
1631 moxaLowChkFlag[i] = 0;
1632 moxaLineCtrl[i] = 0;
1633 moxaLog.rxcnt[i] = 0;
1634 moxaLog.txcnt[i] = 0;
1635 }
1636 }
1637
1638 #define MOXA 0x400
1639 #define MOXA_GET_IQUEUE (MOXA + 1) /* get input buffered count */
1640 #define MOXA_GET_OQUEUE (MOXA + 2) /* get output buffered count */
1641 #define MOXA_INIT_DRIVER (MOXA + 6) /* moxaCard=0 */
1642 #define MOXA_LOAD_BIOS (MOXA + 9) /* download BIOS */
1643 #define MOXA_FIND_BOARD (MOXA + 10) /* Check if MOXA card exist? */
1644 #define MOXA_LOAD_C320B (MOXA + 11) /* download 320B firmware */
1645 #define MOXA_LOAD_CODE (MOXA + 12) /* download firmware */
1646 #define MOXA_GETDATACOUNT (MOXA + 23)
1647 #define MOXA_GET_IOQUEUE (MOXA + 27)
1648 #define MOXA_FLUSH_QUEUE (MOXA + 28)
1649 #define MOXA_GET_CONF (MOXA + 35) /* configuration */
1650 #define MOXA_GET_MAJOR (MOXA + 63)
1651 #define MOXA_GET_CUMAJOR (MOXA + 64)
1652 #define MOXA_GETMSTATUS (MOXA + 65)
1653
1654
1655 struct moxaq_str {
1656 int inq;
1657 int outq;
1658 };
1659
1660 struct dl_str {
1661 char *buf;
1662 int len;
1663 int cardno;
1664 };
1665
1666 static struct moxaq_str temp_queue[MAX_PORTS];
1667 static struct dl_str dltmp;
1668
1669 void MoxaPortFlushData(int port, int mode)
1670 {
1671 unsigned long ofsAddr;
1672 if ((mode < 0) || (mode > 2))
1673 return;
1674 ofsAddr = moxaTableAddr[port];
1675 moxafunc(ofsAddr, FC_FlushQueue, mode);
1676 if (mode != 1) {
1677 moxaLowChkFlag[port] = 0;
1678 low_water_check(ofsAddr);
1679 }
1680 }
1681
1682 int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port)
1683 {
1684 int i;
1685 int status;
1686 int MoxaPortTxQueue(int), MoxaPortRxQueue(int);
1687
1688 if (port == QueryPort) {
1689 if ((cmd != MOXA_GET_CONF) && (cmd != MOXA_INIT_DRIVER) &&
1690 (cmd != MOXA_LOAD_BIOS) && (cmd != MOXA_FIND_BOARD) && (cmd != MOXA_LOAD_C320B) &&
1691 (cmd != MOXA_LOAD_CODE) && (cmd != MOXA_GETDATACOUNT) &&
1692 (cmd != MOXA_GET_IOQUEUE) && (cmd != MOXA_GET_MAJOR) &&
1693 (cmd != MOXA_GET_CUMAJOR) && (cmd != MOXA_GETMSTATUS))
1694 return (-EINVAL);
1695 }
1696 switch (cmd) {
1697 case MOXA_GET_CONF:
1698 if(copy_to_user((void *)arg, &moxa_boards, MAX_BOARDS * sizeof(moxa_board_conf)))
1699 return -EFAULT;
1700 return (0);
1701 case MOXA_INIT_DRIVER:
1702 if ((int) arg == 0x404)
1703 MoxaDriverInit();
1704 return (0);
1705 case MOXA_GETDATACOUNT:
1706 moxaLog.tick = jiffies;
1707 if(copy_to_user((void *)arg, &moxaLog, sizeof(mon_st)))
1708 return -EFAULT;
1709 return (0);
1710 case MOXA_FLUSH_QUEUE:
1711 MoxaPortFlushData(port, arg);
1712 return (0);
1713 case MOXA_GET_IOQUEUE:
1714 for (i = 0; i < MAX_PORTS; i++) {
1715 if (moxaChkPort[i]) {
1716 temp_queue[i].inq = MoxaPortRxQueue(i);
1717 temp_queue[i].outq = MoxaPortTxQueue(i);
1718 }
1719 }
1720 if(copy_to_user((void *)arg, temp_queue, sizeof(struct moxaq_str) * MAX_PORTS))
1721 return -EFAULT;
1722 return (0);
1723 case MOXA_GET_OQUEUE:
1724 i = MoxaPortTxQueue(port);
1725 return put_user(i, (unsigned long *) arg);
1726 case MOXA_GET_IQUEUE:
1727 i = MoxaPortRxQueue(port);
1728 return put_user(i, (unsigned long *) arg);
1729 case MOXA_GET_MAJOR:
1730 if(copy_to_user((void *)arg, &ttymajor, sizeof(int)))
1731 return -EFAULT;
1732 return 0;
1733 case MOXA_GET_CUMAJOR:
1734 if(copy_to_user((void *)arg, &calloutmajor, sizeof(int)))
1735 return -EFAULT;
1736 return 0;
1737 case MOXA_GETMSTATUS:
1738 for (i = 0; i < MAX_PORTS; i++) {
1739 GMStatus[i].ri = 0;
1740 GMStatus[i].dcd = 0;
1741 GMStatus[i].dsr = 0;
1742 GMStatus[i].cts = 0;
1743 if (!moxaChkPort[i]) {
1744 continue;
1745 } else {
1746 status = MoxaPortLineStatus(moxaChannels[i].port);
1747 if (status & 1)
1748 GMStatus[i].cts = 1;
1749 if (status & 2)
1750 GMStatus[i].dsr = 1;
1751 if (status & 4)
1752 GMStatus[i].dcd = 1;
1753 }
1754
1755 if (!moxaChannels[i].tty || !moxaChannels[i].tty->termios)
1756 GMStatus[i].cflag = moxaChannels[i].normal_termios.c_cflag;
1757 else
1758 GMStatus[i].cflag = moxaChannels[i].tty->termios->c_cflag;
1759 }
1760 if(copy_to_user((void *)arg, GMStatus, sizeof(struct mxser_mstatus) * MAX_PORTS))
1761 return -EFAULT;
1762 return 0;
1763 default:
1764 return (-ENOIOCTLCMD);
1765 case MOXA_LOAD_BIOS:
1766 case MOXA_FIND_BOARD:
1767 case MOXA_LOAD_C320B:
1768 case MOXA_LOAD_CODE:
1769 break;
1770 }
1771
1772 if(copy_from_user(&dltmp, (void *)arg, sizeof(struct dl_str)))
1773 return -EFAULT;
1774 if(dltmp.cardno < 0 || dltmp.cardno >= MAX_BOARDS)
1775 return -EINVAL;
1776
1777 switch(cmd)
1778 {
1779 case MOXA_LOAD_BIOS:
1780 i = moxaloadbios(dltmp.cardno, dltmp.buf, dltmp.len);
1781 return (i);
1782 case MOXA_FIND_BOARD:
1783 return moxafindcard(dltmp.cardno);
1784 case MOXA_LOAD_C320B:
1785 moxaload320b(dltmp.cardno, dltmp.buf, dltmp.len);
1786 default: /* to keep gcc happy */
1787 return (0);
1788 case MOXA_LOAD_CODE:
1789 i = moxaloadcode(dltmp.cardno, dltmp.buf, dltmp.len);
1790 if (i == -1)
1791 return (-EFAULT);
1792 return (i);
1793
1794 }
1795 }
1796
1797 int MoxaDriverPoll(void)
1798 {
1799 register ushort temp;
1800 register int card;
1801 unsigned long ip, ofsAddr;
1802 int port, p, ports;
1803
1804 if (moxaCard == 0)
1805 return (-1);
1806 for (card = 0; card < MAX_BOARDS; card++) {
1807 if ((ports = moxa_boards[card].numPorts) == 0)
1808 continue;
1809 if (readb(moxaIntPend[card]) == 0xff) {
1810 ip = moxaIntTable[card] + readb(moxaIntNdx[card]);
1811 p = card * MAX_PORTS_PER_BOARD;
1812 ports <<= 1;
1813 for (port = 0; port < ports; port += 2, p++) {
1814 if ((temp = readw(ip + port)) != 0) {
1815 writew(0, ip + port);
1816 ofsAddr = moxaTableAddr[p];
1817 if (temp & IntrTx)
1818 writew(readw(ofsAddr + HostStat) & ~WakeupTx, ofsAddr + HostStat);
1819 if (temp & IntrBreak) {
1820 moxaBreakCnt[p]++;
1821 }
1822 if (temp & IntrLine) {
1823 if (readb(ofsAddr + FlagStat) & DCD_state) {
1824 if ((moxaDCDState[p] & DCD_oldstate) == 0)
1825 moxaDCDState[p] = (DCD_oldstate |
1826 DCD_changed);
1827 } else {
1828 if (moxaDCDState[p] & DCD_oldstate)
1829 moxaDCDState[p] = DCD_changed;
1830 }
1831 }
1832 }
1833 }
1834 writeb(0, moxaIntPend[card]);
1835 }
1836 if (moxaLowWaterChk) {
1837 p = card * MAX_PORTS_PER_BOARD;
1838 for (port = 0; port < ports; port++, p++) {
1839 if (moxaLowChkFlag[p]) {
1840 moxaLowChkFlag[p] = 0;
1841 ofsAddr = moxaTableAddr[p];
1842 low_water_check(ofsAddr);
1843 }
1844 }
1845 }
1846 }
1847 moxaLowWaterChk = 0;
1848 return (0);
1849 }
1850
1851 /*****************************************************************************
1852 * Card level function: *
1853 * 1. MoxaPortsOfCard(int cardno); *
1854 *****************************************************************************/
1855 int MoxaPortsOfCard(int cardno)
1856 {
1857
1858 if (moxa_boards[cardno].boardType == 0)
1859 return (0);
1860 return (moxa_boards[cardno].numPorts);
1861 }
1862
1863 /*****************************************************************************
1864 * Port level functions: *
1865 * 1. MoxaPortIsValid(int port); *
1866 * 2. MoxaPortEnable(int port); *
1867 * 3. MoxaPortDisable(int port); *
1868 * 4. MoxaPortGetMaxBaud(int port); *
1869 * 5. MoxaPortGetCurBaud(int port); *
1870 * 6. MoxaPortSetBaud(int port, long baud); *
1871 * 7. MoxaPortSetMode(int port, int databit, int stopbit, int parity); *
1872 * 8. MoxaPortSetTermio(int port, unsigned char *termio); *
1873 * 9. MoxaPortGetLineOut(int port, int *dtrState, int *rtsState); *
1874 * 10. MoxaPortLineCtrl(int port, int dtrState, int rtsState); *
1875 * 11. MoxaPortFlowCtrl(int port, int rts, int cts, int rx, int tx,int xany); *
1876 * 12. MoxaPortLineStatus(int port); *
1877 * 13. MoxaPortDCDChange(int port); *
1878 * 14. MoxaPortDCDON(int port); *
1879 * 15. MoxaPortFlushData(int port, int mode); *
1880 * 16. MoxaPortWriteData(int port, unsigned char * buffer, int length); *
1881 * 17. MoxaPortReadData(int port, unsigned char * buffer, int length); *
1882 * 18. MoxaPortTxBufSize(int port); *
1883 * 19. MoxaPortRxBufSize(int port); *
1884 * 20. MoxaPortTxQueue(int port); *
1885 * 21. MoxaPortTxFree(int port); *
1886 * 22. MoxaPortRxQueue(int port); *
1887 * 23. MoxaPortRxFree(int port); *
1888 * 24. MoxaPortTxDisable(int port); *
1889 * 25. MoxaPortTxEnable(int port); *
1890 * 26. MoxaPortGetBrkCnt(int port); *
1891 * 27. MoxaPortResetBrkCnt(int port); *
1892 * 28. MoxaPortSetXonXoff(int port, int xonValue, int xoffValue); *
1893 * 29. MoxaPortIsTxHold(int port); *
1894 * 30. MoxaPortSendBreak(int port, int ticks); *
1895 *****************************************************************************/
1896 /*
1897 * Moxa Port Number Description:
1898 *
1899 * MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,
1900 * the port number using in MOXA driver functions will be 0 to 31 for
1901 * first MOXA board, 32 to 63 for second, 64 to 95 for third and 96
1902 * to 127 for fourth. For example, if you setup three MOXA boards,
1903 * first board is C218, second board is C320-16 and third board is
1904 * C320-32. The port number of first board (C218 - 8 ports) is from
1905 * 0 to 7. The port number of second board (C320 - 16 ports) is form
1906 * 32 to 47. The port number of third board (C320 - 32 ports) is from
1907 * 64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to
1908 * 127 will be invalid.
1909 *
1910 *
1911 * Moxa Functions Description:
1912 *
1913 * Function 1: Driver initialization routine, this routine must be
1914 * called when initialized driver.
1915 * Syntax:
1916 * void MoxaDriverInit();
1917 *
1918 *
1919 * Function 2: Moxa driver private IOCTL command processing.
1920 * Syntax:
1921 * int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);
1922 *
1923 * unsigned int cmd : IOCTL command
1924 * unsigned long arg : IOCTL argument
1925 * int port : port number (0 - 127)
1926 *
1927 * return: 0 (OK)
1928 * -EINVAL
1929 * -ENOIOCTLCMD
1930 *
1931 *
1932 * Function 3: Moxa driver polling process routine.
1933 * Syntax:
1934 * int MoxaDriverPoll(void);
1935 *
1936 * return: 0 ; polling O.K.
1937 * -1 : no any Moxa card.
1938 *
1939 *
1940 * Function 4: Get the ports of this card.
1941 * Syntax:
1942 * int MoxaPortsOfCard(int cardno);
1943 *
1944 * int cardno : card number (0 - 3)
1945 *
1946 * return: 0 : this card is invalid
1947 * 8/16/24/32
1948 *
1949 *
1950 * Function 5: Check this port is valid or invalid
1951 * Syntax:
1952 * int MoxaPortIsValid(int port);
1953 * int port : port number (0 - 127, ref port description)
1954 *
1955 * return: 0 : this port is invalid
1956 * 1 : this port is valid
1957 *
1958 *
1959 * Function 6: Enable this port to start Tx/Rx data.
1960 * Syntax:
1961 * void MoxaPortEnable(int port);
1962 * int port : port number (0 - 127)
1963 *
1964 *
1965 * Function 7: Disable this port
1966 * Syntax:
1967 * void MoxaPortDisable(int port);
1968 * int port : port number (0 - 127)
1969 *
1970 *
1971 * Function 8: Get the maximun available baud rate of this port.
1972 * Syntax:
1973 * long MoxaPortGetMaxBaud(int port);
1974 * int port : port number (0 - 127)
1975 *
1976 * return: 0 : this port is invalid
1977 * 38400/57600/115200 bps
1978 *
1979 *
1980 * Function 9: Get the current baud rate of this port.
1981 * Syntax:
1982 * long MoxaPortGetCurBaud(int port);
1983 * int port : port number (0 - 127)
1984 *
1985 * return: 0 : this port is invalid
1986 * 50 - 115200 bps
1987 *
1988 *
1989 * Function 10: Setting baud rate of this port.
1990 * Syntax:
1991 * long MoxaPortSetBaud(int port, long baud);
1992 * int port : port number (0 - 127)
1993 * long baud : baud rate (50 - 115200)
1994 *
1995 * return: 0 : this port is invalid or baud < 50
1996 * 50 - 115200 : the real baud rate set to the port, if
1997 * the argument baud is large than maximun
1998 * available baud rate, the real setting
1999 * baud rate will be the maximun baud rate.
2000 *
2001 *
2002 * Function 11: Setting the data-bits/stop-bits/parity of this port
2003 * Syntax:
2004 * int MoxaPortSetMode(int port, int databits, int stopbits, int parity);
2005 * int port : port number (0 - 127)
2006 * int databits : data bits (8/7/6/5)
2007 * int stopbits : stop bits (2/1/0, 0 show 1.5 stop bits)
2008 int parity : parity (0:None,1:Odd,2:Even,3:Mark,4:Space)
2009 *
2010 * return: -1 : invalid parameter
2011 * 0 : setting O.K.
2012 *
2013 *
2014 * Function 12: Configure the port.
2015 * Syntax:
2016 * int MoxaPortSetTermio(int port, struct termios *termio);
2017 * int port : port number (0 - 127)
2018 * struct termios * termio : termio structure pointer
2019 *
2020 * return: -1 : this port is invalid or termio == NULL
2021 * 0 : setting O.K.
2022 *
2023 *
2024 * Function 13: Get the DTR/RTS state of this port.
2025 * Syntax:
2026 * int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);
2027 * int port : port number (0 - 127)
2028 * int * dtrState : pointer to INT to receive the current DTR
2029 * state. (if NULL, this function will not
2030 * write to this address)
2031 * int * rtsState : pointer to INT to receive the current RTS
2032 * state. (if NULL, this function will not
2033 * write to this address)
2034 *
2035 * return: -1 : this port is invalid
2036 * 0 : O.K.
2037 *
2038 *
2039 * Function 14: Setting the DTR/RTS output state of this port.
2040 * Syntax:
2041 * void MoxaPortLineCtrl(int port, int dtrState, int rtsState);
2042 * int port : port number (0 - 127)
2043 * int dtrState : DTR output state (0: off, 1: on)
2044 * int rtsState : RTS output state (0: off, 1: on)
2045 *
2046 *
2047 * Function 15: Setting the flow control of this port.
2048 * Syntax:
2049 * void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,
2050 * int txFlow,int xany);
2051 * int port : port number (0 - 127)
2052 * int rtsFlow : H/W RTS flow control (0: no, 1: yes)
2053 * int ctsFlow : H/W CTS flow control (0: no, 1: yes)
2054 * int rxFlow : S/W Rx XON/XOFF flow control (0: no, 1: yes)
2055 * int txFlow : S/W Tx XON/XOFF flow control (0: no, 1: yes)
2056 * int xany : S/W XANY flow control (0: no, 1: yes)
2057 *
2058 *
2059 * Function 16: Get ths line status of this port
2060 * Syntax:
2061 * int MoxaPortLineStatus(int port);
2062 * int port : port number (0 - 127)
2063 *
2064 * return: Bit 0 - CTS state (0: off, 1: on)
2065 * Bit 1 - DSR state (0: off, 1: on)
2066 * Bit 2 - DCD state (0: off, 1: on)
2067 *
2068 *
2069 * Function 17: Check the DCD state has changed since the last read
2070 * of this function.
2071 * Syntax:
2072 * int MoxaPortDCDChange(int port);
2073 * int port : port number (0 - 127)
2074 *
2075 * return: 0 : no changed
2076 * 1 : DCD has changed
2077 *
2078 *
2079 * Function 18: Check ths current DCD state is ON or not.
2080 * Syntax:
2081 * int MoxaPortDCDON(int port);
2082 * int port : port number (0 - 127)
2083 *
2084 * return: 0 : DCD off
2085 * 1 : DCD on
2086 *
2087 *
2088 * Function 19: Flush the Rx/Tx buffer data of this port.
2089 * Syntax:
2090 * void MoxaPortFlushData(int port, int mode);
2091 * int port : port number (0 - 127)
2092 * int mode
2093 * 0 : flush the Rx buffer
2094 * 1 : flush the Tx buffer
2095 * 2 : flush the Rx and Tx buffer
2096 *
2097 *
2098 * Function 20: Write data.
2099 * Syntax:
2100 * int MoxaPortWriteData(int port, unsigned char * buffer, int length);
2101 * int port : port number (0 - 127)
2102 * unsigned char * buffer : pointer to write data buffer.
2103 * int length : write data length
2104 *
2105 * return: 0 - length : real write data length
2106 *
2107 *
2108 * Function 21: Read data.
2109 * Syntax:
2110 * int MoxaPortReadData(int port, unsigned char * buffer, int length);
2111 * int port : port number (0 - 127)
2112 * unsigned char * buffer : pointer to read data buffer.
2113 * int length : read data buffer length
2114 *
2115 * return: 0 - length : real read data length
2116 *
2117 *
2118 * Function 22: Get the Tx buffer size of this port
2119 * Syntax:
2120 * int MoxaPortTxBufSize(int port);
2121 * int port : port number (0 - 127)
2122 *
2123 * return: .. : Tx buffer size
2124 *
2125 *
2126 * Function 23: Get the Rx buffer size of this port
2127 * Syntax:
2128 * int MoxaPortRxBufSize(int port);
2129 * int port : port number (0 - 127)
2130 *
2131 * return: .. : Rx buffer size
2132 *
2133 *
2134 * Function 24: Get the Tx buffer current queued data bytes
2135 * Syntax:
2136 * int MoxaPortTxQueue(int port);
2137 * int port : port number (0 - 127)
2138 *
2139 * return: .. : Tx buffer current queued data bytes
2140 *
2141 *
2142 * Function 25: Get the Tx buffer current free space
2143 * Syntax:
2144 * int MoxaPortTxFree(int port);
2145 * int port : port number (0 - 127)
2146 *
2147 * return: .. : Tx buffer current free space
2148 *
2149 *
2150 * Function 26: Get the Rx buffer current queued data bytes
2151 * Syntax:
2152 * int MoxaPortRxQueue(int port);
2153 * int port : port number (0 - 127)
2154 *
2155 * return: .. : Rx buffer current queued data bytes
2156 *
2157 *
2158 * Function 27: Get the Rx buffer current free space
2159 * Syntax:
2160 * int MoxaPortRxFree(int port);
2161 * int port : port number (0 - 127)
2162 *
2163 * return: .. : Rx buffer current free space
2164 *
2165 *
2166 * Function 28: Disable port data transmission.
2167 * Syntax:
2168 * void MoxaPortTxDisable(int port);
2169 * int port : port number (0 - 127)
2170 *
2171 *
2172 * Function 29: Enable port data transmission.
2173 * Syntax:
2174 * void MoxaPortTxEnable(int port);
2175 * int port : port number (0 - 127)
2176 *
2177 *
2178 * Function 30: Get the received BREAK signal count.
2179 * Syntax:
2180 * int MoxaPortGetBrkCnt(int port);
2181 * int port : port number (0 - 127)
2182 *
2183 * return: 0 - .. : BREAK signal count
2184 *
2185 *
2186 * Function 31: Get the received BREAK signal count and reset it.
2187 * Syntax:
2188 * int MoxaPortResetBrkCnt(int port);
2189 * int port : port number (0 - 127)
2190 *
2191 * return: 0 - .. : BREAK signal count
2192 *
2193 *
2194 * Function 32: Set the S/W flow control new XON/XOFF value, default
2195 * XON is 0x11 & XOFF is 0x13.
2196 * Syntax:
2197 * void MoxaPortSetXonXoff(int port, int xonValue, int xoffValue);
2198 * int port : port number (0 - 127)
2199 * int xonValue : new XON value (0 - 255)
2200 * int xoffValue : new XOFF value (0 - 255)
2201 *
2202 *
2203 * Function 33: Check this port's transmission is hold by remote site
2204 * because the flow control.
2205 * Syntax:
2206 * int MoxaPortIsTxHold(int port);
2207 * int port : port number (0 - 127)
2208 *
2209 * return: 0 : normal
2210 * 1 : hold by remote site
2211 *
2212 *
2213 * Function 34: Send out a BREAK signal.
2214 * Syntax:
2215 * void MoxaPortSendBreak(int port, int ms100);
2216 * int port : port number (0 - 127)
2217 * int ms100 : break signal time interval.
2218 * unit: 100 mini-second. if ms100 == 0, it will
2219 * send out a about 250 ms BREAK signal.
2220 *
2221 */
2222 int MoxaPortIsValid(int port)
2223 {
2224
2225 if (moxaCard == 0)
2226 return (0);
2227 if (moxaChkPort[port] == 0)
2228 return (0);
2229 return (1);
2230 }
2231
2232 void MoxaPortEnable(int port)
2233 {
2234 unsigned long ofsAddr;
2235 int MoxaPortLineStatus(int);
2236 short lowwater = 512;
2237
2238 ofsAddr = moxaTableAddr[port];
2239 writew(lowwater, ofsAddr + Low_water);
2240 moxaBreakCnt[port] = 0;
2241 if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
2242 (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) {
2243 moxafunc(ofsAddr, FC_SetBreakIrq, 0);
2244 } else {
2245 writew(readw(ofsAddr + HostStat) | WakeupBreak, ofsAddr + HostStat);
2246 }
2247
2248 moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
2249 moxafunc(ofsAddr, FC_FlushQueue, 2);
2250
2251 moxafunc(ofsAddr, FC_EnableCH, Magic_code);
2252 MoxaPortLineStatus(port);
2253 }
2254
2255 void MoxaPortDisable(int port)
2256 {
2257 unsigned long ofsAddr;
2258
2259 ofsAddr = moxaTableAddr[port];
2260 moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */
2261 moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
2262 writew(0, ofsAddr + HostStat);
2263 moxafunc(ofsAddr, FC_DisableCH, Magic_code);
2264 }
2265
2266 long MoxaPortGetMaxBaud(int port)
2267 {
2268 if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
2269 (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI))
2270 return (460800L);
2271 else
2272 return (921600L);
2273 }
2274
2275
2276 long MoxaPortSetBaud(int port, long baud)
2277 {
2278 unsigned long ofsAddr;
2279 long max, clock;
2280 unsigned int val;
2281
2282 if ((baud < 50L) || ((max = MoxaPortGetMaxBaud(port)) == 0))
2283 return (0);
2284 ofsAddr = moxaTableAddr[port];
2285 if (baud > max)
2286 baud = max;
2287 if (max == 38400L)
2288 clock = 614400L; /* for 9.8304 Mhz : max. 38400 bps */
2289 else if (max == 57600L)
2290 clock = 691200L; /* for 11.0592 Mhz : max. 57600 bps */
2291 else
2292 clock = 921600L; /* for 14.7456 Mhz : max. 115200 bps */
2293 val = clock / baud;
2294 moxafunc(ofsAddr, FC_SetBaud, val);
2295 baud = clock / val;
2296 moxaCurBaud[port] = baud;
2297 return (baud);
2298 }
2299
2300 int MoxaPortSetTermio(int port, struct termios *termio)
2301 {
2302 unsigned long ofsAddr;
2303 tcflag_t cflag;
2304 long baud;
2305 tcflag_t mode = 0;
2306
2307 if (moxaChkPort[port] == 0 || termio == 0)
2308 return (-1);
2309 ofsAddr = moxaTableAddr[port];
2310 cflag = termio->c_cflag; /* termio->c_cflag */
2311
2312 mode = termio->c_cflag & CSIZE;
2313 if (mode == CS5)
2314 mode = MX_CS5;
2315 else if (mode == CS6)
2316 mode = MX_CS6;
2317 else if (mode == CS7)
2318 mode = MX_CS7;
2319 else if (mode == CS8)
2320 mode = MX_CS8;
2321
2322 if (termio->c_cflag & CSTOPB) {
2323 if (mode == MX_CS5)
2324 mode |= MX_STOP15;
2325 else
2326 mode |= MX_STOP2;
2327 } else
2328 mode |= MX_STOP1;
2329
2330 if (termio->c_cflag & PARENB) {
2331 if (termio->c_cflag & PARODD)
2332 mode |= MX_PARODD;
2333 else
2334 mode |= MX_PAREVEN;
2335 } else
2336 mode |= MX_PARNONE;
2337
2338 moxafunc(ofsAddr, FC_SetDataMode, (ushort) mode);
2339
2340 cflag &= (CBAUD | CBAUDEX);
2341 #ifndef B921600
2342 #define B921600 (B460800+1)
2343 #endif
2344 switch (cflag) {
2345 case B921600:
2346 baud = 921600L;
2347 break;
2348 case B460800:
2349 baud = 460800L;
2350 break;
2351 case B230400:
2352 baud = 230400L;
2353 break;
2354 case B115200:
2355 baud = 115200L;
2356 break;
2357 case B57600:
2358 baud = 57600L;
2359 break;
2360 case B38400:
2361 baud = 38400L;
2362 break;
2363 case B19200:
2364 baud = 19200L;
2365 break;
2366 case B9600:
2367 baud = 9600L;
2368 break;
2369 case B4800:
2370 baud = 4800L;
2371 break;
2372 case B2400:
2373 baud = 2400L;
2374 break;
2375 case B1800:
2376 baud = 1800L;
2377 break;
2378 case B1200:
2379 baud = 1200L;
2380 break;
2381 case B600:
2382 baud = 600L;
2383 break;
2384 case B300:
2385 baud = 300L;
2386 break;
2387 case B200:
2388 baud = 200L;
2389 break;
2390 case B150:
2391 baud = 150L;
2392 break;
2393 case B134:
2394 baud = 134L;
2395 break;
2396 case B110:
2397 baud = 110L;
2398 break;
2399 case B75:
2400 baud = 75L;
2401 break;
2402 case B50:
2403 baud = 50L;
2404 break;
2405 default:
2406 baud = 0;
2407 }
2408 if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
2409 (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) {
2410 if (baud == 921600L)
2411 return (-1);
2412 }
2413 MoxaPortSetBaud(port, baud);
2414
2415 if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
2416 writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
2417 writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
2418 writeb(FC_SetXonXoff, ofsAddr + FuncCode);
2419 wait_finish(ofsAddr);
2420
2421 }
2422 return (0);
2423 }
2424
2425 int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState)
2426 {
2427
2428 if (!MoxaPortIsValid(port))
2429 return (-1);
2430 if (dtrState) {
2431 if (moxaLineCtrl[port] & DTR_ON)
2432 *dtrState = 1;
2433 else
2434 *dtrState = 0;
2435 }
2436 if (rtsState) {
2437 if (moxaLineCtrl[port] & RTS_ON)
2438 *rtsState = 1;
2439 else
2440 *rtsState = 0;
2441 }
2442 return (0);
2443 }
2444
2445 void MoxaPortLineCtrl(int port, int dtr, int rts)
2446 {
2447 unsigned long ofsAddr;
2448 int mode;
2449
2450 ofsAddr = moxaTableAddr[port];
2451 mode = 0;
2452 if (dtr)
2453 mode |= DTR_ON;
2454 if (rts)
2455 mode |= RTS_ON;
2456 moxaLineCtrl[port] = mode;
2457 moxafunc(ofsAddr, FC_LineControl, mode);
2458 }
2459
2460 void MoxaPortFlowCtrl(int port, int rts, int cts, int txflow, int rxflow, int txany)
2461 {
2462 unsigned long ofsAddr;
2463 int mode;
2464
2465 ofsAddr = moxaTableAddr[port];
2466 mode = 0;
2467 if (rts)
2468 mode |= RTS_FlowCtl;
2469 if (cts)
2470 mode |= CTS_FlowCtl;
2471 if (txflow)
2472 mode |= Tx_FlowCtl;
2473 if (rxflow)
2474 mode |= Rx_FlowCtl;
2475 if (txany)
2476 mode |= IXM_IXANY;
2477 moxafunc(ofsAddr, FC_SetFlowCtl, mode);
2478 }
2479
2480 int MoxaPortLineStatus(int port)
2481 {
2482 unsigned long ofsAddr;
2483 int val;
2484
2485 ofsAddr = moxaTableAddr[port];
2486 if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
2487 (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) {
2488 moxafunc(ofsAddr, FC_LineStatus, 0);
2489 val = readw(ofsAddr + FuncArg);
2490 } else {
2491 val = readw(ofsAddr + FlagStat) >> 4;
2492 }
2493 val &= 0x0B;
2494 if (val & 8) {
2495 val |= 4;
2496 if ((moxaDCDState[port] & DCD_oldstate) == 0)
2497 moxaDCDState[port] = (DCD_oldstate | DCD_changed);
2498 } else {
2499 if (moxaDCDState[port] & DCD_oldstate)
2500 moxaDCDState[port] = DCD_changed;
2501 }
2502 val &= 7;
2503 return (val);
2504 }
2505
2506 int MoxaPortDCDChange(int port)
2507 {
2508 int n;
2509
2510 if (moxaChkPort[port] == 0)
2511 return (0);
2512 n = moxaDCDState[port];
2513 moxaDCDState[port] &= ~DCD_changed;
2514 n &= DCD_changed;
2515 return (n);
2516 }
2517
2518 int MoxaPortDCDON(int port)
2519 {
2520 int n;
2521
2522 if (moxaChkPort[port] == 0)
2523 return (0);
2524 if (moxaDCDState[port] & DCD_oldstate)
2525 n = 1;
2526 else
2527 n = 0;
2528 return (n);
2529 }
2530
2531
2532 /*
2533 int MoxaDumpMem(int port, unsigned char * buffer, int len)
2534 {
2535 int i;
2536 unsigned long baseAddr,ofsAddr,ofs;
2537
2538 baseAddr = moxaBaseAddr[port / MAX_PORTS_PER_BOARD];
2539 ofs = baseAddr + DynPage_addr + pageofs;
2540 if (len > 0x2000L)
2541 len = 0x2000L;
2542 for (i = 0; i < len; i++)
2543 buffer[i] = readb(ofs+i);
2544 }
2545 */
2546
2547
2548 int MoxaPortWriteData(int port, unsigned char * buffer, int len)
2549 {
2550 int c, total, i;
2551 ushort tail;
2552 int cnt;
2553 ushort head, tx_mask, spage, epage;
2554 ushort pageno, pageofs, bufhead;
2555 unsigned long baseAddr, ofsAddr, ofs;
2556
2557 ofsAddr = moxaTableAddr[port];
2558 baseAddr = moxaBaseAddr[port / MAX_PORTS_PER_BOARD];
2559 tx_mask = readw(ofsAddr + TX_mask);
2560 spage = readw(ofsAddr + Page_txb);
2561 epage = readw(ofsAddr + EndPage_txb);
2562 tail = readw(ofsAddr + TXwptr);
2563 head = readw(ofsAddr + TXrptr);
2564 c = (head > tail) ? (head - tail - 1)
2565 : (head - tail + tx_mask);
2566 if (c > len)
2567 c = len;
2568 moxaLog.txcnt[port] += c;
2569 total = c;
2570 if (spage == epage) {
2571 bufhead = readw(ofsAddr + Ofs_txb);
2572 writew(spage, baseAddr + Control_reg);
2573 while (c > 0) {
2574 if (head > tail)
2575 len = head - tail - 1;
2576 else
2577 len = tx_mask + 1 - tail;
2578 len = (c > len) ? len : c;
2579 ofs = baseAddr + DynPage_addr + bufhead + tail;
2580 for (i = 0; i < len; i++)
2581 writeb(*buffer++, ofs + i);
2582 tail = (tail + len) & tx_mask;
2583 c -= len;
2584 }
2585 writew(tail, ofsAddr + TXwptr);
2586 } else {
2587 len = c;
2588 pageno = spage + (tail >> 13);
2589 pageofs = tail & Page_mask;
2590 do {
2591 cnt = Page_size - pageofs;
2592 if (cnt > c)
2593 cnt = c;
2594 c -= cnt;
2595 writeb(pageno, baseAddr + Control_reg);
2596 ofs = baseAddr + DynPage_addr + pageofs;
2597 for (i = 0; i < cnt; i++)
2598 writeb(*buffer++, ofs + i);
2599 if (c == 0) {
2600 writew((tail + len) & tx_mask, ofsAddr + TXwptr);
2601 break;
2602 }
2603 if (++pageno == epage)
2604 pageno = spage;
2605 pageofs = 0;
2606 } while (1);
2607 }
2608 writeb(1, ofsAddr + CD180TXirq); /* start to send */
2609 return (total);
2610 }
2611
2612 int MoxaPortReadData(int port, unsigned char * buffer, int space)
2613 {
2614 register ushort head, pageofs;
2615 int i, count, cnt, len, total, remain;
2616 ushort tail, rx_mask, spage, epage;
2617 ushort pageno, bufhead;
2618 unsigned long baseAddr, ofsAddr, ofs;
2619
2620 ofsAddr = moxaTableAddr[port];
2621 baseAddr = moxaBaseAddr[port / MAX_PORTS_PER_BOARD];
2622 head = readw(ofsAddr + RXrptr);
2623 tail = readw(ofsAddr + RXwptr);
2624 rx_mask = readw(ofsAddr + RX_mask);
2625 spage = readw(ofsAddr + Page_rxb);
2626 epage = readw(ofsAddr + EndPage_rxb);
2627 count = (tail >= head) ? (tail - head)
2628 : (tail - head + rx_mask + 1);
2629 if (count == 0)
2630 return (0);
2631
2632 total = (space > count) ? count : space;
2633 remain = count - total;
2634 moxaLog.rxcnt[port] += total;
2635 count = total;
2636 if (spage == epage) {
2637 bufhead = readw(ofsAddr + Ofs_rxb);
2638 writew(spage, baseAddr + Control_reg);
2639 while (count > 0) {
2640 if (tail >= head)
2641 len = tail - head;
2642 else
2643 len = rx_mask + 1 - head;
2644 len = (count > len) ? len : count;
2645 ofs = baseAddr + DynPage_addr + bufhead + head;
2646 for (i = 0; i < len; i++)
2647 *buffer++ = readb(ofs + i);
2648 head = (head + len) & rx_mask;
2649 count -= len;
2650 }
2651 writew(head, ofsAddr + RXrptr);
2652 } else {
2653 len = count;
2654 pageno = spage + (head >> 13);
2655 pageofs = head & Page_mask;
2656 do {
2657 cnt = Page_size - pageofs;
2658 if (cnt > count)
2659 cnt = count;
2660 count -= cnt;
2661 writew(pageno, baseAddr + Control_reg);
2662 ofs = baseAddr + DynPage_addr + pageofs;
2663 for (i = 0; i < cnt; i++)
2664 *buffer++ = readb(ofs + i);
2665 if (count == 0) {
2666 writew((head + len) & rx_mask, ofsAddr + RXrptr);
2667 break;
2668 }
2669 if (++pageno == epage)
2670 pageno = spage;
2671 pageofs = 0;
2672 } while (1);
2673 }
2674 if ((readb(ofsAddr + FlagStat) & Xoff_state) && (remain < LowWater)) {
2675 moxaLowWaterChk = 1;
2676 moxaLowChkFlag[port] = 1;
2677 }
2678 return (total);
2679 }
2680
2681
2682 int MoxaPortTxQueue(int port)
2683 {
2684 unsigned long ofsAddr;
2685 ushort rptr, wptr, mask;
2686 int len;
2687
2688 ofsAddr = moxaTableAddr[port];
2689 rptr = readw(ofsAddr + TXrptr);
2690 wptr = readw(ofsAddr + TXwptr);
2691 mask = readw(ofsAddr + TX_mask);
2692 len = (wptr - rptr) & mask;
2693 return (len);
2694 }
2695
2696 int MoxaPortTxFree(int port)
2697 {
2698 unsigned long ofsAddr;
2699 ushort rptr, wptr, mask;
2700 int len;
2701
2702 ofsAddr = moxaTableAddr[port];
2703 rptr = readw(ofsAddr + TXrptr);
2704 wptr = readw(ofsAddr + TXwptr);
2705 mask = readw(ofsAddr + TX_mask);
2706 len = mask - ((wptr - rptr) & mask);
2707 return (len);
2708 }
2709
2710 int MoxaPortRxQueue(int port)
2711 {
2712 unsigned long ofsAddr;
2713 ushort rptr, wptr, mask;
2714 int len;
2715
2716 ofsAddr = moxaTableAddr[port];
2717 rptr = readw(ofsAddr + RXrptr);
2718 wptr = readw(ofsAddr + RXwptr);
2719 mask = readw(ofsAddr + RX_mask);
2720 len = (wptr - rptr) & mask;
2721 return (len);
2722 }
2723
2724
2725 void MoxaPortTxDisable(int port)
2726 {
2727 unsigned long ofsAddr;
2728
2729 ofsAddr = moxaTableAddr[port];
2730 moxafunc(ofsAddr, FC_SetXoffState, Magic_code);
2731 }
2732
2733 void MoxaPortTxEnable(int port)
2734 {
2735 unsigned long ofsAddr;
2736
2737 ofsAddr = moxaTableAddr[port];
2738 moxafunc(ofsAddr, FC_SetXonState, Magic_code);
2739 }
2740
2741
2742 int MoxaPortResetBrkCnt(int port)
2743 {
2744 ushort cnt;
2745 cnt = moxaBreakCnt[port];
2746 moxaBreakCnt[port] = 0;
2747 return (cnt);
2748 }
2749
2750
2751 void MoxaPortSendBreak(int port, int ms100)
2752 {
2753 unsigned long ofsAddr;
2754
2755 ofsAddr = moxaTableAddr[port];
2756 if (ms100) {
2757 moxafunc(ofsAddr, FC_SendBreak, Magic_code);
2758 moxadelay(ms100 * (HZ / 10));
2759 } else {
2760 moxafunc(ofsAddr, FC_SendBreak, Magic_code);
2761 moxadelay(HZ / 4); /* 250 ms */
2762 }
2763 moxafunc(ofsAddr, FC_StopBreak, Magic_code);
2764 }
2765
2766 static int moxa_get_serial_info(struct moxa_str *info,
2767 struct serial_struct *retinfo)
2768 {
2769 struct serial_struct tmp;
2770
2771 if (!retinfo)
2772 return (-EFAULT);
2773 memset(&tmp, 0, sizeof(tmp));
2774 tmp.type = info->type;
2775 tmp.line = info->port;
2776 tmp.port = 0;
2777 tmp.irq = 0;
2778 tmp.flags = info->asyncflags;
2779 tmp.baud_base = 921600;
2780 tmp.close_delay = info->close_delay;
2781 tmp.closing_wait = info->closing_wait;
2782 tmp.custom_divisor = 0;
2783 tmp.hub6 = 0;
2784 if(copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2785 return -EFAULT;
2786 return (0);
2787 }
2788
2789
2790 static int moxa_set_serial_info(struct moxa_str *info,
2791 struct serial_struct *new_info)
2792 {
2793 struct serial_struct new_serial;
2794
2795 if(copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2796 return -EFAULT;
2797
2798 if ((new_serial.irq != 0) ||
2799 (new_serial.port != 0) ||
2800 // (new_serial.type != info->type) ||
2801 (new_serial.custom_divisor != 0) ||
2802 (new_serial.baud_base != 921600))
2803 return (-EPERM);
2804
2805 if (!suser()) {
2806 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
2807 (info->asyncflags & ~ASYNC_USR_MASK)))
2808 return (-EPERM);
2809 } else {
2810 info->close_delay = new_serial.close_delay * HZ / 100;
2811 info->closing_wait = new_serial.closing_wait * HZ / 100;
2812 }
2813
2814 new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
2815 new_serial.flags |= (info->asyncflags & ASYNC_FLAGS);
2816
2817 if (new_serial.type == PORT_16550A) {
2818 MoxaSetFifo(info->port, 1);
2819 } else {
2820 MoxaSetFifo(info->port, 0);
2821 }
2822
2823 info->type = new_serial.type;
2824 return (0);
2825 }
2826
2827
2828
2829 /*****************************************************************************
2830 * Static local functions: *
2831 *****************************************************************************/
2832 /*
2833 * moxadelay - delays a specified number ticks
2834 */
2835 static void moxadelay(int tick)
2836 {
2837 unsigned long st, et;
2838
2839 st = jiffies;
2840 et = st + tick;
2841 while (jiffies < et);
2842 }
2843
2844 static void moxafunc(unsigned long ofsAddr, int cmd, ushort arg)
2845 {
2846
2847 writew(arg, ofsAddr + FuncArg);
2848 writew(cmd, ofsAddr + FuncCode);
2849 wait_finish(ofsAddr);
2850 }
2851
2852 static void wait_finish(unsigned long ofsAddr)
2853 {
2854 unsigned long i, j;
2855
2856 i = jiffies;
2857 while (readw(ofsAddr + FuncCode) != 0) {
2858 j = jiffies;
2859 if ((j - i) > moxaFuncTout) {
2860 return;
2861 }
2862 }
2863 }
2864
2865 static void low_water_check(unsigned long ofsAddr)
2866 {
2867 int len;
2868 ushort rptr, wptr, mask;
2869
2870 if (readb(ofsAddr + FlagStat) & Xoff_state) {
2871 rptr = readw(ofsAddr + RXrptr);
2872 wptr = readw(ofsAddr + RXwptr);
2873 mask = readw(ofsAddr + RX_mask);
2874 len = (wptr - rptr) & mask;
2875 if (len <= Low_water)
2876 moxafunc(ofsAddr, FC_SendXon, 0);
2877 }
2878 }
2879
2880 static int moxaloadbios(int cardno, unsigned char *tmp, int len)
2881 {
2882 unsigned long baseAddr;
2883 int i;
2884
2885 if(copy_from_user(moxaBuff, tmp, len))
2886 return -EFAULT;
2887 baseAddr = moxaBaseAddr[cardno];
2888 writeb(HW_reset, baseAddr + Control_reg); /* reset */
2889 moxadelay(1); /* delay 10 ms */
2890 for (i = 0; i < 4096; i++)
2891 writeb(0, baseAddr + i); /* clear fix page */
2892 for (i = 0; i < len; i++)
2893 writeb(moxaBuff[i], baseAddr + i); /* download BIOS */
2894 writeb(0, baseAddr + Control_reg); /* restart */
2895 return (0);
2896 }
2897
2898 static int moxafindcard(int cardno)
2899 {
2900 unsigned long baseAddr;
2901 ushort tmp;
2902
2903 baseAddr = moxaBaseAddr[cardno];
2904 switch (moxa_boards[cardno].boardType) {
2905 case MOXA_BOARD_C218_ISA:
2906 case MOXA_BOARD_C218_PCI:
2907 if ((tmp = readw(baseAddr + C218_key)) != C218_KeyCode) {
2908 return (-1);
2909 }
2910 break;
2911 case MOXA_BOARD_CP204J:
2912 if ((tmp = readw(baseAddr + C218_key)) != CP204J_KeyCode) {
2913 return (-1);
2914 }
2915 break;
2916 default:
2917 if ((tmp = readw(baseAddr + C320_key)) != C320_KeyCode) {
2918 return (-1);
2919 }
2920 if ((tmp = readw(baseAddr + C320_status)) != STS_init) {
2921 return (-2);
2922 }
2923 }
2924 return (0);
2925 }
2926
2927 static int moxaload320b(int cardno, unsigned char * tmp, int len)
2928 {
2929 unsigned long baseAddr;
2930 int i;
2931
2932 if(len > sizeof(moxaBuff))
2933 return -EINVAL;
2934 if(copy_from_user(moxaBuff, tmp, len))
2935 return -EFAULT;
2936 baseAddr = moxaBaseAddr[cardno];
2937 writew(len - 7168 - 2, baseAddr + C320bapi_len);
2938 writeb(1, baseAddr + Control_reg); /* Select Page 1 */
2939 for (i = 0; i < 7168; i++)
2940 writeb(moxaBuff[i], baseAddr + DynPage_addr + i);
2941 writeb(2, baseAddr + Control_reg); /* Select Page 2 */
2942 for (i = 0; i < (len - 7168); i++)
2943 writeb(moxaBuff[i + 7168], baseAddr + DynPage_addr + i);
2944 return (0);
2945 }
2946
2947 static int moxaloadcode(int cardno, unsigned char * tmp, int len)
2948 {
2949 unsigned long baseAddr, ofsAddr;
2950 int retval, port, i;
2951
2952 if(copy_from_user(moxaBuff, tmp, len))
2953 return -EFAULT;
2954 baseAddr = moxaBaseAddr[cardno];
2955 switch (moxa_boards[cardno].boardType) {
2956 case MOXA_BOARD_C218_ISA:
2957 case MOXA_BOARD_C218_PCI:
2958 case MOXA_BOARD_CP204J:
2959 retval = moxaloadc218(cardno, baseAddr, len);
2960 if (retval)
2961 return (retval);
2962 port = cardno * MAX_PORTS_PER_BOARD;
2963 for (i = 0; i < moxa_boards[cardno].numPorts; i++, port++) {
2964 moxaChkPort[port] = 1;
2965 moxaCurBaud[port] = 9600L;
2966 moxaDCDState[port] = 0;
2967 moxaTableAddr[port] = baseAddr + Extern_table + Extern_size * i;
2968 ofsAddr = moxaTableAddr[port];
2969 writew(C218rx_mask, ofsAddr + RX_mask);
2970 writew(C218tx_mask, ofsAddr + TX_mask);
2971 writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
2972 writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);
2973
2974 writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
2975 writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);
2976
2977 }
2978 break;
2979 default:
2980 retval = moxaloadc320(cardno, baseAddr, len,
2981 &moxa_boards[cardno].numPorts);
2982 if (retval)
2983 return (retval);
2984 port = cardno * MAX_PORTS_PER_BOARD;
2985 for (i = 0; i < moxa_boards[cardno].numPorts; i++, port++) {
2986 moxaChkPort[port] = 1;
2987 moxaCurBaud[port] = 9600L;
2988 moxaDCDState[port] = 0;
2989 moxaTableAddr[port] = baseAddr + Extern_table + Extern_size * i;
2990 ofsAddr = moxaTableAddr[port];
2991 if (moxa_boards[cardno].numPorts == 8) {
2992 writew(C320p8rx_mask, ofsAddr + RX_mask);
2993 writew(C320p8tx_mask, ofsAddr + TX_mask);
2994 writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
2995 writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
2996 writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
2997 writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);
2998
2999 } else if (moxa_boards[cardno].numPorts == 16) {
3000 writew(C320p16rx_mask, ofsAddr + RX_mask);
3001 writew(C320p16tx_mask, ofsAddr + TX_mask);
3002 writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
3003 writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
3004 writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
3005 writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
3006
3007 } else if (moxa_boards[cardno].numPorts == 24) {
3008 writew(C320p24rx_mask, ofsAddr + RX_mask);
3009 writew(C320p24tx_mask, ofsAddr + TX_mask);
3010 writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
3011 writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
3012 writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
3013 writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
3014 } else if (moxa_boards[cardno].numPorts == 32) {
3015 writew(C320p32rx_mask, ofsAddr + RX_mask);
3016 writew(C320p32tx_mask, ofsAddr + TX_mask);
3017 writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
3018 writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
3019 writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
3020 writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
3021 writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
3022 }
3023 }
3024 break;
3025 }
3026 return (0);
3027 }
3028
3029 static int moxaloadc218(int cardno, unsigned long baseAddr, int len)
3030 {
3031 char retry;
3032 int i, j, len1, len2;
3033 ushort usum, *ptr, keycode;
3034
3035 if (moxa_boards[cardno].boardType == MOXA_BOARD_CP204J)
3036 keycode = CP204J_KeyCode;
3037 else
3038 keycode = C218_KeyCode;
3039 usum = 0;
3040 len1 = len >> 1;
3041 ptr = (ushort *) moxaBuff;
3042 for (i = 0; i < len1; i++)
3043 usum += *(ptr + i);
3044 retry = 0;
3045 do {
3046 len1 = len >> 1;
3047 j = 0;
3048 while (len1) {
3049 len2 = (len1 > 2048) ? 2048 : len1;
3050 len1 -= len2;
3051 for (i = 0; i < len2 << 1; i++)
3052 writeb(moxaBuff[i + j], baseAddr + C218_LoadBuf + i);
3053 j += i;
3054
3055 writew(len2, baseAddr + C218DLoad_len);
3056 writew(0, baseAddr + C218_key);
3057 for (i = 0; i < 100; i++) {
3058 if (readw(baseAddr + C218_key) == keycode)
3059 break;
3060 moxadelay(1); /* delay 10 ms */
3061 }
3062 if (readw(baseAddr + C218_key) != keycode) {
3063 return (-1);
3064 }
3065 }
3066 writew(0, baseAddr + C218DLoad_len);
3067 writew(usum, baseAddr + C218check_sum);
3068 writew(0, baseAddr + C218_key);
3069 for (i = 0; i < 100; i++) {
3070 if (readw(baseAddr + C218_key) == keycode)
3071 break;
3072 moxadelay(1); /* delay 10 ms */
3073 }
3074 retry++;
3075 } while ((readb(baseAddr + C218chksum_ok) != 1) && (retry < 3));
3076 if (readb(baseAddr + C218chksum_ok) != 1) {
3077 return (-1);
3078 }
3079 writew(0, baseAddr + C218_key);
3080 for (i = 0; i < 100; i++) {
3081 if (readw(baseAddr + Magic_no) == Magic_code)
3082 break;
3083 moxadelay(1); /* delay 10 ms */
3084 }
3085 if (readw(baseAddr + Magic_no) != Magic_code) {
3086 return (-1);
3087 }
3088 writew(1, baseAddr + Disable_IRQ);
3089 writew(0, baseAddr + Magic_no);
3090 for (i = 0; i < 100; i++) {
3091 if (readw(baseAddr + Magic_no) == Magic_code)
3092 break;
3093 moxadelay(1); /* delay 10 ms */
3094 }
3095 if (readw(baseAddr + Magic_no) != Magic_code) {
3096 return (-1);
3097 }
3098 moxaCard = 1;
3099 moxaIntNdx[cardno] = baseAddr + IRQindex;
3100 moxaIntPend[cardno] = baseAddr + IRQpending;
3101 moxaIntTable[cardno] = baseAddr + IRQtable;
3102 return (0);
3103 }
3104
3105 static int moxaloadc320(int cardno, unsigned long baseAddr, int len, int *numPorts)
3106 {
3107 ushort usum;
3108 int i, j, wlen, len2, retry;
3109 ushort *uptr;
3110
3111 usum = 0;
3112 wlen = len >> 1;
3113 uptr = (ushort *) moxaBuff;
3114 for (i = 0; i < wlen; i++)
3115 usum += uptr[i];
3116 retry = 0;
3117 j = 0;
3118 do {
3119 while (wlen) {
3120 if (wlen > 2048)
3121 len2 = 2048;
3122 else
3123 len2 = wlen;
3124 wlen -= len2;
3125 len2 <<= 1;
3126 for (i = 0; i < len2; i++)
3127 writeb(moxaBuff[j + i], baseAddr + C320_LoadBuf + i);
3128 len2 >>= 1;
3129 j += i;
3130 writew(len2, baseAddr + C320DLoad_len);
3131 writew(0, baseAddr + C320_key);
3132 for (i = 0; i < 10; i++) {
3133 if (readw(baseAddr + C320_key) == C320_KeyCode)
3134 break;
3135 moxadelay(1);
3136 }
3137 if (readw(baseAddr + C320_key) != C320_KeyCode)
3138 return (-1);
3139 }
3140 writew(0, baseAddr + C320DLoad_len);
3141 writew(usum, baseAddr + C320check_sum);
3142 writew(0, baseAddr + C320_key);
3143 for (i = 0; i < 10; i++) {
3144 if (readw(baseAddr + C320_key) == C320_KeyCode)
3145 break;
3146 moxadelay(1);
3147 }
3148 retry++;
3149 } while ((readb(baseAddr + C320chksum_ok) != 1) && (retry < 3));
3150 if (readb(baseAddr + C320chksum_ok) != 1)
3151 return (-1);
3152 writew(0, baseAddr + C320_key);
3153 for (i = 0; i < 600; i++) {
3154 if (readw(baseAddr + Magic_no) == Magic_code)
3155 break;
3156 moxadelay(1);
3157 }
3158 if (readw(baseAddr + Magic_no) != Magic_code)
3159 return (-100);
3160
3161 if (moxa_boards[cardno].busType == MOXA_BUS_TYPE_PCI) { /* ASIC board */
3162 writew(0x3800, baseAddr + TMS320_PORT1);
3163 writew(0x3900, baseAddr + TMS320_PORT2);
3164 writew(28499, baseAddr + TMS320_CLOCK);
3165 } else {
3166 writew(0x3200, baseAddr + TMS320_PORT1);
3167 writew(0x3400, baseAddr + TMS320_PORT2);
3168 writew(19999, baseAddr + TMS320_CLOCK);
3169 }
3170 writew(1, baseAddr + Disable_IRQ);
3171 writew(0, baseAddr + Magic_no);
3172 for (i = 0; i < 500; i++) {
3173 if (readw(baseAddr + Magic_no) == Magic_code)
3174 break;
3175 moxadelay(1);
3176 }
3177 if (readw(baseAddr + Magic_no) != Magic_code)
3178 return (-102);
3179
3180 j = readw(baseAddr + Module_cnt);
3181 if (j <= 0)
3182 return (-101);
3183 *numPorts = j * 8;
3184 writew(j, baseAddr + Module_no);
3185 writew(0, baseAddr + Magic_no);
3186 for (i = 0; i < 600; i++) {
3187 if (readw(baseAddr + Magic_no) == Magic_code)
3188 break;
3189 moxadelay(1);
3190 }
3191 if (readw(baseAddr + Magic_no) != Magic_code)
3192 return (-102);
3193 moxaCard = 1;
3194 moxaIntNdx[cardno] = baseAddr + IRQindex;
3195 moxaIntPend[cardno] = baseAddr + IRQpending;
3196 moxaIntTable[cardno] = baseAddr + IRQtable;
3197 return (0);
3198 }
3199
3200 long MoxaPortGetCurBaud(int port)
3201 {
3202
3203 if (moxaChkPort[port] == 0)
3204 return (0);
3205 return (moxaCurBaud[port]);
3206 }
3207
3208 static void MoxaSetFifo(int port, int enable)
3209 {
3210 unsigned long ofsAddr = moxaTableAddr[port];
3211
3212 if (!enable) {
3213 moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
3214 moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
3215 } else {
3216 moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
3217 moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
3218 }
3219 }
3220
3221 #if 0
3222 int MoxaPortSetMode(int port, int databits, int stopbits, int parity)
3223 {
3224 unsigned long ofsAddr;
3225 int val;
3226
3227 val = 0;
3228 switch (databits) {
3229 case 5:
3230 val |= 0;
3231 break;
3232 case 6:
3233 val |= 1;
3234 break;
3235 case 7:
3236 val |= 2;
3237 break;
3238 case 8:
3239 val |= 3;
3240 break;
3241 default:
3242 return (-1);
3243 }
3244 switch (stopbits) {
3245 case 0:
3246 val |= 0;
3247 break; /* stop bits 1.5 */
3248 case 1:
3249 val |= 0;
3250 break;
3251 case 2:
3252 val |= 4;
3253 break;
3254 default:
3255 return (-1);
3256 }
3257 switch (parity) {
3258 case 0:
3259 val |= 0x00;
3260 break; /* None */
3261 case 1:
3262 val |= 0x08;
3263 break; /* Odd */
3264 case 2:
3265 val |= 0x18;
3266 break; /* Even */
3267 case 3:
3268 val |= 0x28;
3269 break; /* Mark */
3270 case 4:
3271 val |= 0x38;
3272 break; /* Space */
3273 default:
3274 return (-1);
3275 }
3276 ofsAddr = moxaTableAddr[port];
3277 moxafunc(ofsAddr, FC_SetMode, val);
3278 return (0);
3279 }
3280
3281 int MoxaPortTxBufSize(int port)
3282 {
3283 unsigned long ofsAddr;
3284 int size;
3285
3286 ofsAddr = moxaTableAddr[port];
3287 size = readw(ofsAddr + TX_mask);
3288 return (size);
3289 }
3290
3291 int MoxaPortRxBufSize(int port)
3292 {
3293 unsigned long ofsAddr;
3294 int size;
3295
3296 ofsAddr = moxaTableAddr[port];
3297 size = readw(ofsAddr + RX_mask);
3298 return (size);
3299 }
3300
3301 int MoxaPortRxFree(int port)
3302 {
3303 unsigned long ofsAddr;
3304 ushort rptr, wptr, mask;
3305 int len;
3306
3307 ofsAddr = moxaTableAddr[port];
3308 rptr = readw(ofsAddr + RXrptr);
3309 wptr = readw(ofsAddr + RXwptr);
3310 mask = readw(ofsAddr + RX_mask);
3311 len = mask - ((wptr - rptr) & mask);
3312 return (len);
3313 }
3314 int MoxaPortGetBrkCnt(int port)
3315 {
3316 return (moxaBreakCnt[port]);
3317 }
3318
3319 void MoxaPortSetXonXoff(int port, int xonValue, int xoffValue)
3320 {
3321 unsigned long ofsAddr;
3322
3323 ofsAddr = moxaTableAddr[port];
3324 writew(xonValue, ofsAddr + FuncArg);
3325 writew(xoffValue, ofsAddr + FuncArg1);
3326 writew(FC_SetXonXoff, ofsAddr + FuncCode);
3327 wait_finish(ofsAddr);
3328 }
3329
3330 int MoxaPortIsTxHold(int port)
3331 {
3332 unsigned long ofsAddr;
3333 int val;
3334
3335 ofsAddr = moxaTableAddr[port];
3336 if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
3337 (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) {
3338 moxafunc(ofsAddr, FC_GetCCSR, 0);
3339 val = readw(ofsAddr + FuncArg);
3340 if (val & 0x04)
3341 return (1);
3342 } else {
3343 if (readw(ofsAddr + FlagStat) & Tx_flowOff)
3344 return (1);
3345 }
3346 return (0);
3347 }
3348 #endif
3349