diff options
author | Jiri Slaby <jirislaby@gmail.com> | 2007-02-10 04:45:33 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@woody.linux-foundation.org> | 2007-02-11 13:51:30 -0500 |
commit | 8f8ecbad09b48e5fe44a8d7f5344e802e9c231c8 (patch) | |
tree | 79dc563c17901db1c89eac45d97409038ef9e01e /drivers/char | |
parent | 889074ee0be9cc6c2a698d95db4d0927485ec139 (diff) |
[PATCH] Char: moxa, variables cleanup
- rename moxaChannels to moxa_port
- rename moxa_str to moxa_ports
- move board global variables into moxa_board
- move port global variables into moxa_port
Signed-off-by: Jiri Slaby <jirislaby@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Diffstat (limited to 'drivers/char')
-rw-r--r-- | drivers/char/moxa.c | 398 |
1 files changed, 210 insertions, 188 deletions
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c index 2899beafeb0f..0c34bc5b04e1 100644 --- a/drivers/char/moxa.c +++ b/drivers/char/moxa.c | |||
@@ -102,19 +102,35 @@ static struct moxa_isa_board_conf moxa_isa_boards[] = | |||
102 | /* {MOXA_BOARD_C218_ISA,8,0xDC000}, */ | 102 | /* {MOXA_BOARD_C218_ISA,8,0xDC000}, */ |
103 | }; | 103 | }; |
104 | 104 | ||
105 | struct moxa_board_conf { | 105 | static struct moxa_board_conf { |
106 | int boardType; | 106 | int boardType; |
107 | int numPorts; | 107 | int numPorts; |
108 | unsigned long baseAddr; | 108 | unsigned long baseAddr; |
109 | int busType; | 109 | int busType; |
110 | struct pci_dev *pdev; | 110 | struct pci_dev *pdev; |
111 | |||
112 | int loadstat; | ||
113 | |||
114 | void __iomem *basemem; | ||
115 | void __iomem *intNdx; | ||
116 | void __iomem *intPend; | ||
117 | void __iomem *intTable; | ||
118 | } moxa_boards[MAX_BOARDS]; | ||
119 | |||
120 | struct mxser_mstatus { | ||
121 | tcflag_t cflag; | ||
122 | int cts; | ||
123 | int dsr; | ||
124 | int ri; | ||
125 | int dcd; | ||
111 | }; | 126 | }; |
112 | 127 | ||
113 | static struct moxa_board_conf moxa_boards[MAX_BOARDS]; | 128 | struct moxaq_str { |
114 | static void __iomem *moxaBaseAddr[MAX_BOARDS]; | 129 | int inq; |
115 | static int loadstat[MAX_BOARDS]; | 130 | int outq; |
131 | }; | ||
116 | 132 | ||
117 | struct moxa_str { | 133 | struct moxa_port { |
118 | int type; | 134 | int type; |
119 | int port; | 135 | int port; |
120 | int close_delay; | 136 | int close_delay; |
@@ -128,17 +144,20 @@ struct moxa_str { | |||
128 | int cflag; | 144 | int cflag; |
129 | wait_queue_head_t open_wait; | 145 | wait_queue_head_t open_wait; |
130 | wait_queue_head_t close_wait; | 146 | wait_queue_head_t close_wait; |
131 | }; | ||
132 | 147 | ||
133 | struct mxser_mstatus { | 148 | struct timer_list emptyTimer; |
134 | tcflag_t cflag; | 149 | struct mxser_mstatus GMStatus; |
135 | int cts; | 150 | struct moxaq_str temp_queue; |
136 | int dsr; | ||
137 | int ri; | ||
138 | int dcd; | ||
139 | }; | ||
140 | 151 | ||
141 | static struct mxser_mstatus GMStatus[MAX_PORTS]; | 152 | char chkPort; |
153 | char lineCtrl; | ||
154 | void __iomem *tableAddr; | ||
155 | long curBaud; | ||
156 | char DCDState; | ||
157 | char lowChkFlag; | ||
158 | |||
159 | ushort breakCnt; | ||
160 | }; | ||
142 | 161 | ||
143 | /* statusflags */ | 162 | /* statusflags */ |
144 | #define TXSTOPPED 0x1 | 163 | #define TXSTOPPED 0x1 |
@@ -194,11 +213,11 @@ static int moxa_tiocmset(struct tty_struct *tty, struct file *file, | |||
194 | static void moxa_poll(unsigned long); | 213 | static void moxa_poll(unsigned long); |
195 | static void set_tty_param(struct tty_struct *); | 214 | static void set_tty_param(struct tty_struct *); |
196 | static int block_till_ready(struct tty_struct *, struct file *, | 215 | static int block_till_ready(struct tty_struct *, struct file *, |
197 | struct moxa_str *); | 216 | struct moxa_port *); |
198 | static void setup_empty_event(struct tty_struct *); | 217 | static void setup_empty_event(struct tty_struct *); |
199 | static void check_xmit_empty(unsigned long); | 218 | static void check_xmit_empty(unsigned long); |
200 | static void shut_down(struct moxa_str *); | 219 | static void shut_down(struct moxa_port *); |
201 | static void receive_data(struct moxa_str *); | 220 | static void receive_data(struct moxa_port *); |
202 | /* | 221 | /* |
203 | * moxa board interface functions: | 222 | * moxa board interface functions: |
204 | */ | 223 | */ |
@@ -228,8 +247,8 @@ static void MoxaPortTxDisable(int); | |||
228 | static void MoxaPortTxEnable(int); | 247 | static void MoxaPortTxEnable(int); |
229 | static int MoxaPortResetBrkCnt(int); | 248 | static int MoxaPortResetBrkCnt(int); |
230 | static void MoxaPortSendBreak(int, int); | 249 | static void MoxaPortSendBreak(int, int); |
231 | static int moxa_get_serial_info(struct moxa_str *, struct serial_struct __user *); | 250 | static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *); |
232 | static int moxa_set_serial_info(struct moxa_str *, struct serial_struct __user *); | 251 | static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *); |
233 | static void MoxaSetFifo(int port, int enable); | 252 | static void MoxaSetFifo(int port, int enable); |
234 | 253 | ||
235 | static const struct tty_operations moxa_ops = { | 254 | static const struct tty_operations moxa_ops = { |
@@ -253,9 +272,8 @@ static const struct tty_operations moxa_ops = { | |||
253 | }; | 272 | }; |
254 | 273 | ||
255 | static struct tty_driver *moxaDriver; | 274 | static struct tty_driver *moxaDriver; |
256 | static struct moxa_str moxaChannels[MAX_PORTS]; | 275 | static struct moxa_port moxa_ports[MAX_PORTS]; |
257 | static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0); | 276 | static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0); |
258 | static struct timer_list moxaEmptyTimer[MAX_PORTS]; | ||
259 | static DEFINE_SPINLOCK(moxa_lock); | 277 | static DEFINE_SPINLOCK(moxa_lock); |
260 | 278 | ||
261 | #ifdef CONFIG_PCI | 279 | #ifdef CONFIG_PCI |
@@ -288,7 +306,7 @@ static int moxa_get_PCI_conf(struct pci_dev *p, int board_type, | |||
288 | static int __init moxa_init(void) | 306 | static int __init moxa_init(void) |
289 | { | 307 | { |
290 | int i, numBoards; | 308 | int i, numBoards; |
291 | struct moxa_str *ch; | 309 | struct moxa_port *ch; |
292 | 310 | ||
293 | printk(KERN_INFO "MOXA Intellio family driver version %s\n", MOXA_VERSION); | 311 | printk(KERN_INFO "MOXA Intellio family driver version %s\n", MOXA_VERSION); |
294 | moxaDriver = alloc_tty_driver(MAX_PORTS + 1); | 312 | moxaDriver = alloc_tty_driver(MAX_PORTS + 1); |
@@ -308,7 +326,7 @@ static int __init moxa_init(void) | |||
308 | moxaDriver->flags = TTY_DRIVER_REAL_RAW; | 326 | moxaDriver->flags = TTY_DRIVER_REAL_RAW; |
309 | tty_set_operations(moxaDriver, &moxa_ops); | 327 | tty_set_operations(moxaDriver, &moxa_ops); |
310 | 328 | ||
311 | for (i = 0, ch = moxaChannels; i < MAX_PORTS; i++, ch++) { | 329 | for (i = 0, ch = moxa_ports; i < MAX_PORTS; i++, ch++) { |
312 | ch->type = PORT_16550A; | 330 | ch->type = PORT_16550A; |
313 | ch->port = i; | 331 | ch->port = i; |
314 | ch->close_delay = 5 * HZ / 10; | 332 | ch->close_delay = 5 * HZ / 10; |
@@ -316,6 +334,9 @@ static int __init moxa_init(void) | |||
316 | ch->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL; | 334 | ch->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL; |
317 | init_waitqueue_head(&ch->open_wait); | 335 | init_waitqueue_head(&ch->open_wait); |
318 | init_waitqueue_head(&ch->close_wait); | 336 | init_waitqueue_head(&ch->close_wait); |
337 | |||
338 | setup_timer(&ch->emptyTimer, check_xmit_empty, | ||
339 | (unsigned long)ch); | ||
319 | } | 340 | } |
320 | 341 | ||
321 | printk("Tty devices major number = %d\n", ttymajor); | 342 | printk("Tty devices major number = %d\n", ttymajor); |
@@ -325,9 +346,6 @@ static int __init moxa_init(void) | |||
325 | put_tty_driver(moxaDriver); | 346 | put_tty_driver(moxaDriver); |
326 | return -1; | 347 | return -1; |
327 | } | 348 | } |
328 | for (i = 0; i < MAX_PORTS; i++) | ||
329 | setup_timer(&moxaEmptyTimer[i], check_xmit_empty, | ||
330 | (unsigned long)&moxaChannels[i]); | ||
331 | 349 | ||
332 | mod_timer(&moxaTimer, jiffies + HZ / 50); | 350 | mod_timer(&moxaTimer, jiffies + HZ / 50); |
333 | 351 | ||
@@ -402,7 +420,8 @@ static int __init moxa_init(void) | |||
402 | } | 420 | } |
403 | #endif | 421 | #endif |
404 | for (i = 0; i < numBoards; i++) { | 422 | for (i = 0; i < numBoards; i++) { |
405 | moxaBaseAddr[i] = ioremap((unsigned long) moxa_boards[i].baseAddr, 0x4000); | 423 | moxa_boards[i].basemem = ioremap(moxa_boards[i].baseAddr, |
424 | 0x4000); | ||
406 | } | 425 | } |
407 | 426 | ||
408 | return (0); | 427 | return (0); |
@@ -418,15 +437,15 @@ static void __exit moxa_exit(void) | |||
418 | del_timer_sync(&moxaTimer); | 437 | del_timer_sync(&moxaTimer); |
419 | 438 | ||
420 | for (i = 0; i < MAX_PORTS; i++) | 439 | for (i = 0; i < MAX_PORTS; i++) |
421 | del_timer_sync(&moxaEmptyTimer[i]); | 440 | del_timer_sync(&moxa_ports[i].emptyTimer); |
422 | 441 | ||
423 | if (tty_unregister_driver(moxaDriver)) | 442 | if (tty_unregister_driver(moxaDriver)) |
424 | printk("Couldn't unregister MOXA Intellio family serial driver\n"); | 443 | printk("Couldn't unregister MOXA Intellio family serial driver\n"); |
425 | put_tty_driver(moxaDriver); | 444 | put_tty_driver(moxaDriver); |
426 | 445 | ||
427 | for (i = 0; i < MAX_BOARDS; i++) { | 446 | for (i = 0; i < MAX_BOARDS; i++) { |
428 | if (moxaBaseAddr[i]) | 447 | if (moxa_boards[i].basemem) |
429 | iounmap(moxaBaseAddr[i]); | 448 | iounmap(moxa_boards[i].basemem); |
430 | if (moxa_boards[i].busType == MOXA_BUS_TYPE_PCI) | 449 | if (moxa_boards[i].busType == MOXA_BUS_TYPE_PCI) |
431 | pci_dev_put(moxa_boards[i].pdev); | 450 | pci_dev_put(moxa_boards[i].pdev); |
432 | } | 451 | } |
@@ -440,7 +459,7 @@ module_exit(moxa_exit); | |||
440 | 459 | ||
441 | static int moxa_open(struct tty_struct *tty, struct file *filp) | 460 | static int moxa_open(struct tty_struct *tty, struct file *filp) |
442 | { | 461 | { |
443 | struct moxa_str *ch; | 462 | struct moxa_port *ch; |
444 | int port; | 463 | int port; |
445 | int retval; | 464 | int retval; |
446 | 465 | ||
@@ -453,7 +472,7 @@ static int moxa_open(struct tty_struct *tty, struct file *filp) | |||
453 | return (-ENODEV); | 472 | return (-ENODEV); |
454 | } | 473 | } |
455 | 474 | ||
456 | ch = &moxaChannels[port]; | 475 | ch = &moxa_ports[port]; |
457 | ch->count++; | 476 | ch->count++; |
458 | tty->driver_data = ch; | 477 | tty->driver_data = ch; |
459 | ch->tty = tty; | 478 | ch->tty = tty; |
@@ -479,7 +498,7 @@ static int moxa_open(struct tty_struct *tty, struct file *filp) | |||
479 | 498 | ||
480 | static void moxa_close(struct tty_struct *tty, struct file *filp) | 499 | static void moxa_close(struct tty_struct *tty, struct file *filp) |
481 | { | 500 | { |
482 | struct moxa_str *ch; | 501 | struct moxa_port *ch; |
483 | int port; | 502 | int port; |
484 | 503 | ||
485 | port = tty->index; | 504 | port = tty->index; |
@@ -499,7 +518,7 @@ static void moxa_close(struct tty_struct *tty, struct file *filp) | |||
499 | if (tty_hung_up_p(filp)) { | 518 | if (tty_hung_up_p(filp)) { |
500 | return; | 519 | return; |
501 | } | 520 | } |
502 | ch = (struct moxa_str *) tty->driver_data; | 521 | ch = (struct moxa_port *) tty->driver_data; |
503 | 522 | ||
504 | if ((tty->count == 1) && (ch->count != 1)) { | 523 | if ((tty->count == 1) && (ch->count != 1)) { |
505 | printk("moxa_close: bad serial port count; tty->count is 1, " | 524 | printk("moxa_close: bad serial port count; tty->count is 1, " |
@@ -520,7 +539,7 @@ static void moxa_close(struct tty_struct *tty, struct file *filp) | |||
520 | if (ch->asyncflags & ASYNC_INITIALIZED) { | 539 | if (ch->asyncflags & ASYNC_INITIALIZED) { |
521 | setup_empty_event(tty); | 540 | setup_empty_event(tty); |
522 | tty_wait_until_sent(tty, 30 * HZ); /* 30 seconds timeout */ | 541 | tty_wait_until_sent(tty, 30 * HZ); /* 30 seconds timeout */ |
523 | del_timer_sync(&moxaEmptyTimer[ch->port]); | 542 | del_timer_sync(&moxa_ports[ch->port].emptyTimer); |
524 | } | 543 | } |
525 | shut_down(ch); | 544 | shut_down(ch); |
526 | MoxaPortFlushData(port, 2); | 545 | MoxaPortFlushData(port, 2); |
@@ -545,11 +564,11 @@ static void moxa_close(struct tty_struct *tty, struct file *filp) | |||
545 | static int moxa_write(struct tty_struct *tty, | 564 | static int moxa_write(struct tty_struct *tty, |
546 | const unsigned char *buf, int count) | 565 | const unsigned char *buf, int count) |
547 | { | 566 | { |
548 | struct moxa_str *ch; | 567 | struct moxa_port *ch; |
549 | int len, port; | 568 | int len, port; |
550 | unsigned long flags; | 569 | unsigned long flags; |
551 | 570 | ||
552 | ch = (struct moxa_str *) tty->driver_data; | 571 | ch = (struct moxa_port *) tty->driver_data; |
553 | if (ch == NULL) | 572 | if (ch == NULL) |
554 | return (0); | 573 | return (0); |
555 | port = ch->port; | 574 | port = ch->port; |
@@ -568,11 +587,11 @@ static int moxa_write(struct tty_struct *tty, | |||
568 | 587 | ||
569 | static int moxa_write_room(struct tty_struct *tty) | 588 | static int moxa_write_room(struct tty_struct *tty) |
570 | { | 589 | { |
571 | struct moxa_str *ch; | 590 | struct moxa_port *ch; |
572 | 591 | ||
573 | if (tty->stopped) | 592 | if (tty->stopped) |
574 | return (0); | 593 | return (0); |
575 | ch = (struct moxa_str *) tty->driver_data; | 594 | ch = (struct moxa_port *) tty->driver_data; |
576 | if (ch == NULL) | 595 | if (ch == NULL) |
577 | return (0); | 596 | return (0); |
578 | return (MoxaPortTxFree(ch->port)); | 597 | return (MoxaPortTxFree(ch->port)); |
@@ -580,7 +599,7 @@ static int moxa_write_room(struct tty_struct *tty) | |||
580 | 599 | ||
581 | static void moxa_flush_buffer(struct tty_struct *tty) | 600 | static void moxa_flush_buffer(struct tty_struct *tty) |
582 | { | 601 | { |
583 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 602 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
584 | 603 | ||
585 | if (ch == NULL) | 604 | if (ch == NULL) |
586 | return; | 605 | return; |
@@ -591,7 +610,7 @@ static void moxa_flush_buffer(struct tty_struct *tty) | |||
591 | static int moxa_chars_in_buffer(struct tty_struct *tty) | 610 | static int moxa_chars_in_buffer(struct tty_struct *tty) |
592 | { | 611 | { |
593 | int chars; | 612 | int chars; |
594 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 613 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
595 | 614 | ||
596 | /* | 615 | /* |
597 | * Sigh...I have to check if driver_data is NULL here, because | 616 | * Sigh...I have to check if driver_data is NULL here, because |
@@ -623,11 +642,11 @@ static void moxa_flush_chars(struct tty_struct *tty) | |||
623 | 642 | ||
624 | static void moxa_put_char(struct tty_struct *tty, unsigned char c) | 643 | static void moxa_put_char(struct tty_struct *tty, unsigned char c) |
625 | { | 644 | { |
626 | struct moxa_str *ch; | 645 | struct moxa_port *ch; |
627 | int port; | 646 | int port; |
628 | unsigned long flags; | 647 | unsigned long flags; |
629 | 648 | ||
630 | ch = (struct moxa_str *) tty->driver_data; | 649 | ch = (struct moxa_port *) tty->driver_data; |
631 | if (ch == NULL) | 650 | if (ch == NULL) |
632 | return; | 651 | return; |
633 | port = ch->port; | 652 | port = ch->port; |
@@ -642,7 +661,7 @@ static void moxa_put_char(struct tty_struct *tty, unsigned char c) | |||
642 | 661 | ||
643 | static int moxa_tiocmget(struct tty_struct *tty, struct file *file) | 662 | static int moxa_tiocmget(struct tty_struct *tty, struct file *file) |
644 | { | 663 | { |
645 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 664 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
646 | int port; | 665 | int port; |
647 | int flag = 0, dtr, rts; | 666 | int flag = 0, dtr, rts; |
648 | 667 | ||
@@ -668,7 +687,7 @@ static int moxa_tiocmget(struct tty_struct *tty, struct file *file) | |||
668 | static int moxa_tiocmset(struct tty_struct *tty, struct file *file, | 687 | static int moxa_tiocmset(struct tty_struct *tty, struct file *file, |
669 | unsigned int set, unsigned int clear) | 688 | unsigned int set, unsigned int clear) |
670 | { | 689 | { |
671 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 690 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
672 | int port; | 691 | int port; |
673 | int dtr, rts; | 692 | int dtr, rts; |
674 | 693 | ||
@@ -692,7 +711,7 @@ static int moxa_tiocmset(struct tty_struct *tty, struct file *file, | |||
692 | static int moxa_ioctl(struct tty_struct *tty, struct file *file, | 711 | static int moxa_ioctl(struct tty_struct *tty, struct file *file, |
693 | unsigned int cmd, unsigned long arg) | 712 | unsigned int cmd, unsigned long arg) |
694 | { | 713 | { |
695 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 714 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
696 | register int port; | 715 | register int port; |
697 | void __user *argp = (void __user *)arg; | 716 | void __user *argp = (void __user *)arg; |
698 | int retval; | 717 | int retval; |
@@ -745,14 +764,14 @@ static int moxa_ioctl(struct tty_struct *tty, struct file *file, | |||
745 | 764 | ||
746 | static void moxa_throttle(struct tty_struct *tty) | 765 | static void moxa_throttle(struct tty_struct *tty) |
747 | { | 766 | { |
748 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 767 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
749 | 768 | ||
750 | ch->statusflags |= THROTTLE; | 769 | ch->statusflags |= THROTTLE; |
751 | } | 770 | } |
752 | 771 | ||
753 | static void moxa_unthrottle(struct tty_struct *tty) | 772 | static void moxa_unthrottle(struct tty_struct *tty) |
754 | { | 773 | { |
755 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 774 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
756 | 775 | ||
757 | ch->statusflags &= ~THROTTLE; | 776 | ch->statusflags &= ~THROTTLE; |
758 | } | 777 | } |
@@ -760,7 +779,7 @@ static void moxa_unthrottle(struct tty_struct *tty) | |||
760 | static void moxa_set_termios(struct tty_struct *tty, | 779 | static void moxa_set_termios(struct tty_struct *tty, |
761 | struct ktermios *old_termios) | 780 | struct ktermios *old_termios) |
762 | { | 781 | { |
763 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 782 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
764 | 783 | ||
765 | if (ch == NULL) | 784 | if (ch == NULL) |
766 | return; | 785 | return; |
@@ -772,7 +791,7 @@ static void moxa_set_termios(struct tty_struct *tty, | |||
772 | 791 | ||
773 | static void moxa_stop(struct tty_struct *tty) | 792 | static void moxa_stop(struct tty_struct *tty) |
774 | { | 793 | { |
775 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 794 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
776 | 795 | ||
777 | if (ch == NULL) | 796 | if (ch == NULL) |
778 | return; | 797 | return; |
@@ -783,7 +802,7 @@ static void moxa_stop(struct tty_struct *tty) | |||
783 | 802 | ||
784 | static void moxa_start(struct tty_struct *tty) | 803 | static void moxa_start(struct tty_struct *tty) |
785 | { | 804 | { |
786 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 805 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
787 | 806 | ||
788 | if (ch == NULL) | 807 | if (ch == NULL) |
789 | return; | 808 | return; |
@@ -797,7 +816,7 @@ static void moxa_start(struct tty_struct *tty) | |||
797 | 816 | ||
798 | static void moxa_hangup(struct tty_struct *tty) | 817 | static void moxa_hangup(struct tty_struct *tty) |
799 | { | 818 | { |
800 | struct moxa_str *ch = (struct moxa_str *) tty->driver_data; | 819 | struct moxa_port *ch = (struct moxa_port *) tty->driver_data; |
801 | 820 | ||
802 | moxa_flush_buffer(tty); | 821 | moxa_flush_buffer(tty); |
803 | shut_down(ch); | 822 | shut_down(ch); |
@@ -811,7 +830,7 @@ static void moxa_hangup(struct tty_struct *tty) | |||
811 | static void moxa_poll(unsigned long ignored) | 830 | static void moxa_poll(unsigned long ignored) |
812 | { | 831 | { |
813 | register int card; | 832 | register int card; |
814 | struct moxa_str *ch; | 833 | struct moxa_port *ch; |
815 | struct tty_struct *tp; | 834 | struct tty_struct *tp; |
816 | int i, ports; | 835 | int i, ports; |
817 | 836 | ||
@@ -824,7 +843,7 @@ static void moxa_poll(unsigned long ignored) | |||
824 | for (card = 0; card < MAX_BOARDS; card++) { | 843 | for (card = 0; card < MAX_BOARDS; card++) { |
825 | if ((ports = MoxaPortsOfCard(card)) <= 0) | 844 | if ((ports = MoxaPortsOfCard(card)) <= 0) |
826 | continue; | 845 | continue; |
827 | ch = &moxaChannels[card * MAX_PORTS_PER_BOARD]; | 846 | ch = &moxa_ports[card * MAX_PORTS_PER_BOARD]; |
828 | for (i = 0; i < ports; i++, ch++) { | 847 | for (i = 0; i < ports; i++, ch++) { |
829 | if ((ch->asyncflags & ASYNC_INITIALIZED) == 0) | 848 | if ((ch->asyncflags & ASYNC_INITIALIZED) == 0) |
830 | continue; | 849 | continue; |
@@ -867,10 +886,10 @@ static void moxa_poll(unsigned long ignored) | |||
867 | static void set_tty_param(struct tty_struct *tty) | 886 | static void set_tty_param(struct tty_struct *tty) |
868 | { | 887 | { |
869 | register struct ktermios *ts; | 888 | register struct ktermios *ts; |
870 | struct moxa_str *ch; | 889 | struct moxa_port *ch; |
871 | int rts, cts, txflow, rxflow, xany; | 890 | int rts, cts, txflow, rxflow, xany; |
872 | 891 | ||
873 | ch = (struct moxa_str *) tty->driver_data; | 892 | ch = (struct moxa_port *) tty->driver_data; |
874 | ts = tty->termios; | 893 | ts = tty->termios; |
875 | if (ts->c_cflag & CLOCAL) | 894 | if (ts->c_cflag & CLOCAL) |
876 | ch->asyncflags &= ~ASYNC_CHECK_CD; | 895 | ch->asyncflags &= ~ASYNC_CHECK_CD; |
@@ -890,7 +909,7 @@ static void set_tty_param(struct tty_struct *tty) | |||
890 | } | 909 | } |
891 | 910 | ||
892 | static int block_till_ready(struct tty_struct *tty, struct file *filp, | 911 | static int block_till_ready(struct tty_struct *tty, struct file *filp, |
893 | struct moxa_str *ch) | 912 | struct moxa_port *ch) |
894 | { | 913 | { |
895 | DECLARE_WAITQUEUE(wait,current); | 914 | DECLARE_WAITQUEUE(wait,current); |
896 | unsigned long flags; | 915 | unsigned long flags; |
@@ -981,33 +1000,33 @@ static int block_till_ready(struct tty_struct *tty, struct file *filp, | |||
981 | 1000 | ||
982 | static void setup_empty_event(struct tty_struct *tty) | 1001 | static void setup_empty_event(struct tty_struct *tty) |
983 | { | 1002 | { |
984 | struct moxa_str *ch = tty->driver_data; | 1003 | struct moxa_port *ch = tty->driver_data; |
985 | unsigned long flags; | 1004 | unsigned long flags; |
986 | 1005 | ||
987 | spin_lock_irqsave(&moxa_lock, flags); | 1006 | spin_lock_irqsave(&moxa_lock, flags); |
988 | ch->statusflags |= EMPTYWAIT; | 1007 | ch->statusflags |= EMPTYWAIT; |
989 | mod_timer(&moxaEmptyTimer[ch->port], jiffies + HZ); | 1008 | mod_timer(&moxa_ports[ch->port].emptyTimer, jiffies + HZ); |
990 | spin_unlock_irqrestore(&moxa_lock, flags); | 1009 | spin_unlock_irqrestore(&moxa_lock, flags); |
991 | } | 1010 | } |
992 | 1011 | ||
993 | static void check_xmit_empty(unsigned long data) | 1012 | static void check_xmit_empty(unsigned long data) |
994 | { | 1013 | { |
995 | struct moxa_str *ch; | 1014 | struct moxa_port *ch; |
996 | 1015 | ||
997 | ch = (struct moxa_str *) data; | 1016 | ch = (struct moxa_port *) data; |
998 | del_timer_sync(&moxaEmptyTimer[ch->port]); | 1017 | del_timer_sync(&moxa_ports[ch->port].emptyTimer); |
999 | if (ch->tty && (ch->statusflags & EMPTYWAIT)) { | 1018 | if (ch->tty && (ch->statusflags & EMPTYWAIT)) { |
1000 | if (MoxaPortTxQueue(ch->port) == 0) { | 1019 | if (MoxaPortTxQueue(ch->port) == 0) { |
1001 | ch->statusflags &= ~EMPTYWAIT; | 1020 | ch->statusflags &= ~EMPTYWAIT; |
1002 | tty_wakeup(ch->tty); | 1021 | tty_wakeup(ch->tty); |
1003 | return; | 1022 | return; |
1004 | } | 1023 | } |
1005 | mod_timer(&moxaEmptyTimer[ch->port], jiffies + HZ); | 1024 | mod_timer(&moxa_ports[ch->port].emptyTimer, jiffies + HZ); |
1006 | } else | 1025 | } else |
1007 | ch->statusflags &= ~EMPTYWAIT; | 1026 | ch->statusflags &= ~EMPTYWAIT; |
1008 | } | 1027 | } |
1009 | 1028 | ||
1010 | static void shut_down(struct moxa_str *ch) | 1029 | static void shut_down(struct moxa_port *ch) |
1011 | { | 1030 | { |
1012 | struct tty_struct *tp; | 1031 | struct tty_struct *tp; |
1013 | 1032 | ||
@@ -1027,7 +1046,7 @@ static void shut_down(struct moxa_str *ch) | |||
1027 | ch->asyncflags &= ~ASYNC_INITIALIZED; | 1046 | ch->asyncflags &= ~ASYNC_INITIALIZED; |
1028 | } | 1047 | } |
1029 | 1048 | ||
1030 | static void receive_data(struct moxa_str *ch) | 1049 | static void receive_data(struct moxa_port *ch) |
1031 | { | 1050 | { |
1032 | struct tty_struct *tp; | 1051 | struct tty_struct *tp; |
1033 | struct ktermios *ts; | 1052 | struct ktermios *ts; |
@@ -1355,20 +1374,10 @@ struct mon_str { | |||
1355 | #define DCD_oldstate 0x80 | 1374 | #define DCD_oldstate 0x80 |
1356 | 1375 | ||
1357 | static unsigned char moxaBuff[10240]; | 1376 | static unsigned char moxaBuff[10240]; |
1358 | static void __iomem *moxaIntNdx[MAX_BOARDS]; | ||
1359 | static void __iomem *moxaIntPend[MAX_BOARDS]; | ||
1360 | static void __iomem *moxaIntTable[MAX_BOARDS]; | ||
1361 | static char moxaChkPort[MAX_PORTS]; | ||
1362 | static char moxaLineCtrl[MAX_PORTS]; | ||
1363 | static void __iomem *moxaTableAddr[MAX_PORTS]; | ||
1364 | static long moxaCurBaud[MAX_PORTS]; | ||
1365 | static char moxaDCDState[MAX_PORTS]; | ||
1366 | static char moxaLowChkFlag[MAX_PORTS]; | ||
1367 | static int moxaLowWaterChk; | 1377 | static int moxaLowWaterChk; |
1368 | static int moxaCard; | 1378 | static int moxaCard; |
1369 | static struct mon_str moxaLog; | 1379 | static struct mon_str moxaLog; |
1370 | static int moxaFuncTout = HZ / 2; | 1380 | static int moxaFuncTout = HZ / 2; |
1371 | static ushort moxaBreakCnt[MAX_PORTS]; | ||
1372 | 1381 | ||
1373 | static void moxadelay(int); | 1382 | static void moxadelay(int); |
1374 | static void moxafunc(void __iomem *, int, ushort); | 1383 | static void moxafunc(void __iomem *, int, ushort); |
@@ -1389,16 +1398,18 @@ static int moxaloadc320(int, void __iomem *, int, int *); | |||
1389 | *****************************************************************************/ | 1398 | *****************************************************************************/ |
1390 | void MoxaDriverInit(void) | 1399 | void MoxaDriverInit(void) |
1391 | { | 1400 | { |
1392 | int i; | 1401 | struct moxa_port *p; |
1402 | unsigned int i; | ||
1393 | 1403 | ||
1394 | moxaFuncTout = HZ / 2; /* 500 mini-seconds */ | 1404 | moxaFuncTout = HZ / 2; /* 500 mini-seconds */ |
1395 | moxaCard = 0; | 1405 | moxaCard = 0; |
1396 | moxaLog.tick = 0; | 1406 | moxaLog.tick = 0; |
1397 | moxaLowWaterChk = 0; | 1407 | moxaLowWaterChk = 0; |
1398 | for (i = 0; i < MAX_PORTS; i++) { | 1408 | for (i = 0; i < MAX_PORTS; i++) { |
1399 | moxaChkPort[i] = 0; | 1409 | p = &moxa_ports[i]; |
1400 | moxaLowChkFlag[i] = 0; | 1410 | p->chkPort = 0; |
1401 | moxaLineCtrl[i] = 0; | 1411 | p->lowChkFlag = 0; |
1412 | p->lineCtrl = 0; | ||
1402 | moxaLog.rxcnt[i] = 0; | 1413 | moxaLog.rxcnt[i] = 0; |
1403 | moxaLog.txcnt[i] = 0; | 1414 | moxaLog.txcnt[i] = 0; |
1404 | } | 1415 | } |
@@ -1420,19 +1431,12 @@ void MoxaDriverInit(void) | |||
1420 | #define MOXA_GET_CUMAJOR (MOXA + 64) | 1431 | #define MOXA_GET_CUMAJOR (MOXA + 64) |
1421 | #define MOXA_GETMSTATUS (MOXA + 65) | 1432 | #define MOXA_GETMSTATUS (MOXA + 65) |
1422 | 1433 | ||
1423 | |||
1424 | struct moxaq_str { | ||
1425 | int inq; | ||
1426 | int outq; | ||
1427 | }; | ||
1428 | |||
1429 | struct dl_str { | 1434 | struct dl_str { |
1430 | char __user *buf; | 1435 | char __user *buf; |
1431 | int len; | 1436 | int len; |
1432 | int cardno; | 1437 | int cardno; |
1433 | }; | 1438 | }; |
1434 | 1439 | ||
1435 | static struct moxaq_str temp_queue[MAX_PORTS]; | ||
1436 | static struct dl_str dltmp; | 1440 | static struct dl_str dltmp; |
1437 | 1441 | ||
1438 | void MoxaPortFlushData(int port, int mode) | 1442 | void MoxaPortFlushData(int port, int mode) |
@@ -1440,10 +1444,10 @@ void MoxaPortFlushData(int port, int mode) | |||
1440 | void __iomem *ofsAddr; | 1444 | void __iomem *ofsAddr; |
1441 | if ((mode < 0) || (mode > 2)) | 1445 | if ((mode < 0) || (mode > 2)) |
1442 | return; | 1446 | return; |
1443 | ofsAddr = moxaTableAddr[port]; | 1447 | ofsAddr = moxa_ports[port].tableAddr; |
1444 | moxafunc(ofsAddr, FC_FlushQueue, mode); | 1448 | moxafunc(ofsAddr, FC_FlushQueue, mode); |
1445 | if (mode != 1) { | 1449 | if (mode != 1) { |
1446 | moxaLowChkFlag[port] = 0; | 1450 | moxa_ports[port].lowChkFlag = 0; |
1447 | low_water_check(ofsAddr); | 1451 | low_water_check(ofsAddr); |
1448 | } | 1452 | } |
1449 | } | 1453 | } |
@@ -1481,17 +1485,23 @@ int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port) | |||
1481 | case MOXA_FLUSH_QUEUE: | 1485 | case MOXA_FLUSH_QUEUE: |
1482 | MoxaPortFlushData(port, arg); | 1486 | MoxaPortFlushData(port, arg); |
1483 | return (0); | 1487 | return (0); |
1484 | case MOXA_GET_IOQUEUE: | 1488 | case MOXA_GET_IOQUEUE: { |
1485 | for (i = 0; i < MAX_PORTS; i++) { | 1489 | struct moxaq_str __user *argm = argp; |
1486 | if (moxaChkPort[i]) { | 1490 | struct moxa_port *p; |
1487 | temp_queue[i].inq = MoxaPortRxQueue(i); | 1491 | |
1488 | temp_queue[i].outq = MoxaPortTxQueue(i); | 1492 | for (i = 0; i < MAX_PORTS; i++, argm++) { |
1493 | p = &moxa_ports[i]; | ||
1494 | memset(&p->temp_queue, 0, sizeof(p->temp_queue)); | ||
1495 | if (p->chkPort) { | ||
1496 | p->temp_queue.inq = MoxaPortRxQueue(i); | ||
1497 | p->temp_queue.outq = MoxaPortTxQueue(i); | ||
1489 | } | 1498 | } |
1499 | if (copy_to_user(argm, &p->temp_queue, | ||
1500 | sizeof(p->temp_queue))) | ||
1501 | return -EFAULT; | ||
1490 | } | 1502 | } |
1491 | if(copy_to_user(argp, temp_queue, sizeof(struct moxaq_str) * MAX_PORTS)) | ||
1492 | return -EFAULT; | ||
1493 | return (0); | 1503 | return (0); |
1494 | case MOXA_GET_OQUEUE: | 1504 | } case MOXA_GET_OQUEUE: |
1495 | i = MoxaPortTxQueue(port); | 1505 | i = MoxaPortTxQueue(port); |
1496 | return put_user(i, (unsigned long __user *)argp); | 1506 | return put_user(i, (unsigned long __user *)argp); |
1497 | case MOXA_GET_IQUEUE: | 1507 | case MOXA_GET_IQUEUE: |
@@ -1506,33 +1516,39 @@ int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port) | |||
1506 | if(copy_to_user(argp, &i, sizeof(int))) | 1516 | if(copy_to_user(argp, &i, sizeof(int))) |
1507 | return -EFAULT; | 1517 | return -EFAULT; |
1508 | return 0; | 1518 | return 0; |
1509 | case MOXA_GETMSTATUS: | 1519 | case MOXA_GETMSTATUS: { |
1510 | for (i = 0; i < MAX_PORTS; i++) { | 1520 | struct mxser_mstatus __user *argm = argp; |
1511 | GMStatus[i].ri = 0; | 1521 | struct moxa_port *p; |
1512 | GMStatus[i].dcd = 0; | 1522 | |
1513 | GMStatus[i].dsr = 0; | 1523 | for (i = 0; i < MAX_PORTS; i++, argm++) { |
1514 | GMStatus[i].cts = 0; | 1524 | p = &moxa_ports[i]; |
1515 | if (!moxaChkPort[i]) { | 1525 | p->GMStatus.ri = 0; |
1516 | continue; | 1526 | p->GMStatus.dcd = 0; |
1527 | p->GMStatus.dsr = 0; | ||
1528 | p->GMStatus.cts = 0; | ||
1529 | if (!p->chkPort) { | ||
1530 | goto copy; | ||
1517 | } else { | 1531 | } else { |
1518 | status = MoxaPortLineStatus(moxaChannels[i].port); | 1532 | status = MoxaPortLineStatus(p->port); |
1519 | if (status & 1) | 1533 | if (status & 1) |
1520 | GMStatus[i].cts = 1; | 1534 | p->GMStatus.cts = 1; |
1521 | if (status & 2) | 1535 | if (status & 2) |
1522 | GMStatus[i].dsr = 1; | 1536 | p->GMStatus.dsr = 1; |
1523 | if (status & 4) | 1537 | if (status & 4) |
1524 | GMStatus[i].dcd = 1; | 1538 | p->GMStatus.dcd = 1; |
1525 | } | 1539 | } |
1526 | 1540 | ||
1527 | if (!moxaChannels[i].tty || !moxaChannels[i].tty->termios) | 1541 | if (!p->tty || !p->tty->termios) |
1528 | GMStatus[i].cflag = moxaChannels[i].cflag; | 1542 | p->GMStatus.cflag = p->cflag; |
1529 | else | 1543 | else |
1530 | GMStatus[i].cflag = moxaChannels[i].tty->termios->c_cflag; | 1544 | p->GMStatus.cflag = p->tty->termios->c_cflag; |
1545 | copy: | ||
1546 | if (copy_to_user(argm, &p->GMStatus, | ||
1547 | sizeof(p->GMStatus))) | ||
1548 | return -EFAULT; | ||
1531 | } | 1549 | } |
1532 | if(copy_to_user(argp, GMStatus, sizeof(struct mxser_mstatus) * MAX_PORTS)) | ||
1533 | return -EFAULT; | ||
1534 | return 0; | 1550 | return 0; |
1535 | default: | 1551 | } default: |
1536 | return (-ENOIOCTLCMD); | 1552 | return (-ENOIOCTLCMD); |
1537 | case MOXA_LOAD_BIOS: | 1553 | case MOXA_LOAD_BIOS: |
1538 | case MOXA_FIND_BOARD: | 1554 | case MOXA_FIND_BOARD: |
@@ -1570,6 +1586,7 @@ int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port) | |||
1570 | 1586 | ||
1571 | int MoxaDriverPoll(void) | 1587 | int MoxaDriverPoll(void) |
1572 | { | 1588 | { |
1589 | struct moxa_board_conf *brd; | ||
1573 | register ushort temp; | 1590 | register ushort temp; |
1574 | register int card; | 1591 | register int card; |
1575 | void __iomem *ofsAddr; | 1592 | void __iomem *ofsAddr; |
@@ -1579,43 +1596,44 @@ int MoxaDriverPoll(void) | |||
1579 | if (moxaCard == 0) | 1596 | if (moxaCard == 0) |
1580 | return (-1); | 1597 | return (-1); |
1581 | for (card = 0; card < MAX_BOARDS; card++) { | 1598 | for (card = 0; card < MAX_BOARDS; card++) { |
1582 | if (loadstat[card] == 0) | 1599 | brd = &moxa_boards[card]; |
1600 | if (brd->loadstat == 0) | ||
1583 | continue; | 1601 | continue; |
1584 | if ((ports = moxa_boards[card].numPorts) == 0) | 1602 | if ((ports = brd->numPorts) == 0) |
1585 | continue; | 1603 | continue; |
1586 | if (readb(moxaIntPend[card]) == 0xff) { | 1604 | if (readb(brd->intPend) == 0xff) { |
1587 | ip = moxaIntTable[card] + readb(moxaIntNdx[card]); | 1605 | ip = brd->intTable + readb(brd->intNdx); |
1588 | p = card * MAX_PORTS_PER_BOARD; | 1606 | p = card * MAX_PORTS_PER_BOARD; |
1589 | ports <<= 1; | 1607 | ports <<= 1; |
1590 | for (port = 0; port < ports; port += 2, p++) { | 1608 | for (port = 0; port < ports; port += 2, p++) { |
1591 | if ((temp = readw(ip + port)) != 0) { | 1609 | if ((temp = readw(ip + port)) != 0) { |
1592 | writew(0, ip + port); | 1610 | writew(0, ip + port); |
1593 | ofsAddr = moxaTableAddr[p]; | 1611 | ofsAddr = moxa_ports[p].tableAddr; |
1594 | if (temp & IntrTx) | 1612 | if (temp & IntrTx) |
1595 | writew(readw(ofsAddr + HostStat) & ~WakeupTx, ofsAddr + HostStat); | 1613 | writew(readw(ofsAddr + HostStat) & ~WakeupTx, ofsAddr + HostStat); |
1596 | if (temp & IntrBreak) { | 1614 | if (temp & IntrBreak) { |
1597 | moxaBreakCnt[p]++; | 1615 | moxa_ports[p].breakCnt++; |
1598 | } | 1616 | } |
1599 | if (temp & IntrLine) { | 1617 | if (temp & IntrLine) { |
1600 | if (readb(ofsAddr + FlagStat) & DCD_state) { | 1618 | if (readb(ofsAddr + FlagStat) & DCD_state) { |
1601 | if ((moxaDCDState[p] & DCD_oldstate) == 0) | 1619 | if ((moxa_ports[p].DCDState & DCD_oldstate) == 0) |
1602 | moxaDCDState[p] = (DCD_oldstate | | 1620 | moxa_ports[p].DCDState = (DCD_oldstate | |
1603 | DCD_changed); | 1621 | DCD_changed); |
1604 | } else { | 1622 | } else { |
1605 | if (moxaDCDState[p] & DCD_oldstate) | 1623 | if (moxa_ports[p].DCDState & DCD_oldstate) |
1606 | moxaDCDState[p] = DCD_changed; | 1624 | moxa_ports[p].DCDState = DCD_changed; |
1607 | } | 1625 | } |
1608 | } | 1626 | } |
1609 | } | 1627 | } |
1610 | } | 1628 | } |
1611 | writeb(0, moxaIntPend[card]); | 1629 | writeb(0, brd->intPend); |
1612 | } | 1630 | } |
1613 | if (moxaLowWaterChk) { | 1631 | if (moxaLowWaterChk) { |
1614 | p = card * MAX_PORTS_PER_BOARD; | 1632 | p = card * MAX_PORTS_PER_BOARD; |
1615 | for (port = 0; port < ports; port++, p++) { | 1633 | for (port = 0; port < ports; port++, p++) { |
1616 | if (moxaLowChkFlag[p]) { | 1634 | if (moxa_ports[p].lowChkFlag) { |
1617 | moxaLowChkFlag[p] = 0; | 1635 | moxa_ports[p].lowChkFlag = 0; |
1618 | ofsAddr = moxaTableAddr[p]; | 1636 | ofsAddr = moxa_ports[p].tableAddr; |
1619 | low_water_check(ofsAddr); | 1637 | low_water_check(ofsAddr); |
1620 | } | 1638 | } |
1621 | } | 1639 | } |
@@ -1921,7 +1939,7 @@ int MoxaPortIsValid(int port) | |||
1921 | 1939 | ||
1922 | if (moxaCard == 0) | 1940 | if (moxaCard == 0) |
1923 | return (0); | 1941 | return (0); |
1924 | if (moxaChkPort[port] == 0) | 1942 | if (moxa_ports[port].chkPort == 0) |
1925 | return (0); | 1943 | return (0); |
1926 | return (1); | 1944 | return (1); |
1927 | } | 1945 | } |
@@ -1932,9 +1950,9 @@ void MoxaPortEnable(int port) | |||
1932 | int MoxaPortLineStatus(int); | 1950 | int MoxaPortLineStatus(int); |
1933 | short lowwater = 512; | 1951 | short lowwater = 512; |
1934 | 1952 | ||
1935 | ofsAddr = moxaTableAddr[port]; | 1953 | ofsAddr = moxa_ports[port].tableAddr; |
1936 | writew(lowwater, ofsAddr + Low_water); | 1954 | writew(lowwater, ofsAddr + Low_water); |
1937 | moxaBreakCnt[port] = 0; | 1955 | moxa_ports[port].breakCnt = 0; |
1938 | if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) || | 1956 | if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) || |
1939 | (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) { | 1957 | (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) { |
1940 | moxafunc(ofsAddr, FC_SetBreakIrq, 0); | 1958 | moxafunc(ofsAddr, FC_SetBreakIrq, 0); |
@@ -1951,7 +1969,7 @@ void MoxaPortEnable(int port) | |||
1951 | 1969 | ||
1952 | void MoxaPortDisable(int port) | 1970 | void MoxaPortDisable(int port) |
1953 | { | 1971 | { |
1954 | void __iomem *ofsAddr = moxaTableAddr[port]; | 1972 | void __iomem *ofsAddr = moxa_ports[port].tableAddr; |
1955 | 1973 | ||
1956 | moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */ | 1974 | moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */ |
1957 | moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code); | 1975 | moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code); |
@@ -1977,7 +1995,7 @@ long MoxaPortSetBaud(int port, long baud) | |||
1977 | 1995 | ||
1978 | if ((baud < 50L) || ((max = MoxaPortGetMaxBaud(port)) == 0)) | 1996 | if ((baud < 50L) || ((max = MoxaPortGetMaxBaud(port)) == 0)) |
1979 | return (0); | 1997 | return (0); |
1980 | ofsAddr = moxaTableAddr[port]; | 1998 | ofsAddr = moxa_ports[port].tableAddr; |
1981 | if (baud > max) | 1999 | if (baud > max) |
1982 | baud = max; | 2000 | baud = max; |
1983 | if (max == 38400L) | 2001 | if (max == 38400L) |
@@ -1989,7 +2007,7 @@ long MoxaPortSetBaud(int port, long baud) | |||
1989 | val = clock / baud; | 2007 | val = clock / baud; |
1990 | moxafunc(ofsAddr, FC_SetBaud, val); | 2008 | moxafunc(ofsAddr, FC_SetBaud, val); |
1991 | baud = clock / val; | 2009 | baud = clock / val; |
1992 | moxaCurBaud[port] = baud; | 2010 | moxa_ports[port].curBaud = baud; |
1993 | return (baud); | 2011 | return (baud); |
1994 | } | 2012 | } |
1995 | 2013 | ||
@@ -1999,9 +2017,9 @@ int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud) | |||
1999 | tcflag_t cflag; | 2017 | tcflag_t cflag; |
2000 | tcflag_t mode = 0; | 2018 | tcflag_t mode = 0; |
2001 | 2019 | ||
2002 | if (moxaChkPort[port] == 0 || termio == 0) | 2020 | if (moxa_ports[port].chkPort == 0 || termio == 0) |
2003 | return (-1); | 2021 | return (-1); |
2004 | ofsAddr = moxaTableAddr[port]; | 2022 | ofsAddr = moxa_ports[port].tableAddr; |
2005 | cflag = termio->c_cflag; /* termio->c_cflag */ | 2023 | cflag = termio->c_cflag; /* termio->c_cflag */ |
2006 | 2024 | ||
2007 | mode = termio->c_cflag & CSIZE; | 2025 | mode = termio->c_cflag & CSIZE; |
@@ -2055,13 +2073,13 @@ int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState) | |||
2055 | if (!MoxaPortIsValid(port)) | 2073 | if (!MoxaPortIsValid(port)) |
2056 | return (-1); | 2074 | return (-1); |
2057 | if (dtrState) { | 2075 | if (dtrState) { |
2058 | if (moxaLineCtrl[port] & DTR_ON) | 2076 | if (moxa_ports[port].lineCtrl & DTR_ON) |
2059 | *dtrState = 1; | 2077 | *dtrState = 1; |
2060 | else | 2078 | else |
2061 | *dtrState = 0; | 2079 | *dtrState = 0; |
2062 | } | 2080 | } |
2063 | if (rtsState) { | 2081 | if (rtsState) { |
2064 | if (moxaLineCtrl[port] & RTS_ON) | 2082 | if (moxa_ports[port].lineCtrl & RTS_ON) |
2065 | *rtsState = 1; | 2083 | *rtsState = 1; |
2066 | else | 2084 | else |
2067 | *rtsState = 0; | 2085 | *rtsState = 0; |
@@ -2074,13 +2092,13 @@ void MoxaPortLineCtrl(int port, int dtr, int rts) | |||
2074 | void __iomem *ofsAddr; | 2092 | void __iomem *ofsAddr; |
2075 | int mode; | 2093 | int mode; |
2076 | 2094 | ||
2077 | ofsAddr = moxaTableAddr[port]; | 2095 | ofsAddr = moxa_ports[port].tableAddr; |
2078 | mode = 0; | 2096 | mode = 0; |
2079 | if (dtr) | 2097 | if (dtr) |
2080 | mode |= DTR_ON; | 2098 | mode |= DTR_ON; |
2081 | if (rts) | 2099 | if (rts) |
2082 | mode |= RTS_ON; | 2100 | mode |= RTS_ON; |
2083 | moxaLineCtrl[port] = mode; | 2101 | moxa_ports[port].lineCtrl = mode; |
2084 | moxafunc(ofsAddr, FC_LineControl, mode); | 2102 | moxafunc(ofsAddr, FC_LineControl, mode); |
2085 | } | 2103 | } |
2086 | 2104 | ||
@@ -2089,7 +2107,7 @@ void MoxaPortFlowCtrl(int port, int rts, int cts, int txflow, int rxflow, int tx | |||
2089 | void __iomem *ofsAddr; | 2107 | void __iomem *ofsAddr; |
2090 | int mode; | 2108 | int mode; |
2091 | 2109 | ||
2092 | ofsAddr = moxaTableAddr[port]; | 2110 | ofsAddr = moxa_ports[port].tableAddr; |
2093 | mode = 0; | 2111 | mode = 0; |
2094 | if (rts) | 2112 | if (rts) |
2095 | mode |= RTS_FlowCtl; | 2113 | mode |= RTS_FlowCtl; |
@@ -2109,7 +2127,7 @@ int MoxaPortLineStatus(int port) | |||
2109 | void __iomem *ofsAddr; | 2127 | void __iomem *ofsAddr; |
2110 | int val; | 2128 | int val; |
2111 | 2129 | ||
2112 | ofsAddr = moxaTableAddr[port]; | 2130 | ofsAddr = moxa_ports[port].tableAddr; |
2113 | if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) || | 2131 | if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) || |
2114 | (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) { | 2132 | (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) { |
2115 | moxafunc(ofsAddr, FC_LineStatus, 0); | 2133 | moxafunc(ofsAddr, FC_LineStatus, 0); |
@@ -2120,11 +2138,11 @@ int MoxaPortLineStatus(int port) | |||
2120 | val &= 0x0B; | 2138 | val &= 0x0B; |
2121 | if (val & 8) { | 2139 | if (val & 8) { |
2122 | val |= 4; | 2140 | val |= 4; |
2123 | if ((moxaDCDState[port] & DCD_oldstate) == 0) | 2141 | if ((moxa_ports[port].DCDState & DCD_oldstate) == 0) |
2124 | moxaDCDState[port] = (DCD_oldstate | DCD_changed); | 2142 | moxa_ports[port].DCDState = (DCD_oldstate | DCD_changed); |
2125 | } else { | 2143 | } else { |
2126 | if (moxaDCDState[port] & DCD_oldstate) | 2144 | if (moxa_ports[port].DCDState & DCD_oldstate) |
2127 | moxaDCDState[port] = DCD_changed; | 2145 | moxa_ports[port].DCDState = DCD_changed; |
2128 | } | 2146 | } |
2129 | val &= 7; | 2147 | val &= 7; |
2130 | return (val); | 2148 | return (val); |
@@ -2134,10 +2152,10 @@ int MoxaPortDCDChange(int port) | |||
2134 | { | 2152 | { |
2135 | int n; | 2153 | int n; |
2136 | 2154 | ||
2137 | if (moxaChkPort[port] == 0) | 2155 | if (moxa_ports[port].chkPort == 0) |
2138 | return (0); | 2156 | return (0); |
2139 | n = moxaDCDState[port]; | 2157 | n = moxa_ports[port].DCDState; |
2140 | moxaDCDState[port] &= ~DCD_changed; | 2158 | moxa_ports[port].DCDState &= ~DCD_changed; |
2141 | n &= DCD_changed; | 2159 | n &= DCD_changed; |
2142 | return (n); | 2160 | return (n); |
2143 | } | 2161 | } |
@@ -2146,9 +2164,9 @@ int MoxaPortDCDON(int port) | |||
2146 | { | 2164 | { |
2147 | int n; | 2165 | int n; |
2148 | 2166 | ||
2149 | if (moxaChkPort[port] == 0) | 2167 | if (moxa_ports[port].chkPort == 0) |
2150 | return (0); | 2168 | return (0); |
2151 | if (moxaDCDState[port] & DCD_oldstate) | 2169 | if (moxa_ports[port].DCDState & DCD_oldstate) |
2152 | n = 1; | 2170 | n = 1; |
2153 | else | 2171 | else |
2154 | n = 0; | 2172 | n = 0; |
@@ -2164,8 +2182,8 @@ int MoxaPortWriteData(int port, unsigned char * buffer, int len) | |||
2164 | ushort pageno, pageofs, bufhead; | 2182 | ushort pageno, pageofs, bufhead; |
2165 | void __iomem *baseAddr, *ofsAddr, *ofs; | 2183 | void __iomem *baseAddr, *ofsAddr, *ofs; |
2166 | 2184 | ||
2167 | ofsAddr = moxaTableAddr[port]; | 2185 | ofsAddr = moxa_ports[port].tableAddr; |
2168 | baseAddr = moxaBaseAddr[port / MAX_PORTS_PER_BOARD]; | 2186 | baseAddr = moxa_boards[port / MAX_PORTS_PER_BOARD].basemem; |
2169 | tx_mask = readw(ofsAddr + TX_mask); | 2187 | tx_mask = readw(ofsAddr + TX_mask); |
2170 | spage = readw(ofsAddr + Page_txb); | 2188 | spage = readw(ofsAddr + Page_txb); |
2171 | epage = readw(ofsAddr + EndPage_txb); | 2189 | epage = readw(ofsAddr + EndPage_txb); |
@@ -2227,8 +2245,8 @@ int MoxaPortReadData(int port, struct tty_struct *tty) | |||
2227 | ushort pageno, bufhead; | 2245 | ushort pageno, bufhead; |
2228 | void __iomem *baseAddr, *ofsAddr, *ofs; | 2246 | void __iomem *baseAddr, *ofsAddr, *ofs; |
2229 | 2247 | ||
2230 | ofsAddr = moxaTableAddr[port]; | 2248 | ofsAddr = moxa_ports[port].tableAddr; |
2231 | baseAddr = moxaBaseAddr[port / MAX_PORTS_PER_BOARD]; | 2249 | baseAddr = moxa_boards[port / MAX_PORTS_PER_BOARD].basemem; |
2232 | head = readw(ofsAddr + RXrptr); | 2250 | head = readw(ofsAddr + RXrptr); |
2233 | tail = readw(ofsAddr + RXwptr); | 2251 | tail = readw(ofsAddr + RXwptr); |
2234 | rx_mask = readw(ofsAddr + RX_mask); | 2252 | rx_mask = readw(ofsAddr + RX_mask); |
@@ -2283,7 +2301,7 @@ int MoxaPortReadData(int port, struct tty_struct *tty) | |||
2283 | } | 2301 | } |
2284 | if ((readb(ofsAddr + FlagStat) & Xoff_state) && (remain < LowWater)) { | 2302 | if ((readb(ofsAddr + FlagStat) & Xoff_state) && (remain < LowWater)) { |
2285 | moxaLowWaterChk = 1; | 2303 | moxaLowWaterChk = 1; |
2286 | moxaLowChkFlag[port] = 1; | 2304 | moxa_ports[port].lowChkFlag = 1; |
2287 | } | 2305 | } |
2288 | return (total); | 2306 | return (total); |
2289 | } | 2307 | } |
@@ -2295,7 +2313,7 @@ int MoxaPortTxQueue(int port) | |||
2295 | ushort rptr, wptr, mask; | 2313 | ushort rptr, wptr, mask; |
2296 | int len; | 2314 | int len; |
2297 | 2315 | ||
2298 | ofsAddr = moxaTableAddr[port]; | 2316 | ofsAddr = moxa_ports[port].tableAddr; |
2299 | rptr = readw(ofsAddr + TXrptr); | 2317 | rptr = readw(ofsAddr + TXrptr); |
2300 | wptr = readw(ofsAddr + TXwptr); | 2318 | wptr = readw(ofsAddr + TXwptr); |
2301 | mask = readw(ofsAddr + TX_mask); | 2319 | mask = readw(ofsAddr + TX_mask); |
@@ -2309,7 +2327,7 @@ int MoxaPortTxFree(int port) | |||
2309 | ushort rptr, wptr, mask; | 2327 | ushort rptr, wptr, mask; |
2310 | int len; | 2328 | int len; |
2311 | 2329 | ||
2312 | ofsAddr = moxaTableAddr[port]; | 2330 | ofsAddr = moxa_ports[port].tableAddr; |
2313 | rptr = readw(ofsAddr + TXrptr); | 2331 | rptr = readw(ofsAddr + TXrptr); |
2314 | wptr = readw(ofsAddr + TXwptr); | 2332 | wptr = readw(ofsAddr + TXwptr); |
2315 | mask = readw(ofsAddr + TX_mask); | 2333 | mask = readw(ofsAddr + TX_mask); |
@@ -2323,7 +2341,7 @@ int MoxaPortRxQueue(int port) | |||
2323 | ushort rptr, wptr, mask; | 2341 | ushort rptr, wptr, mask; |
2324 | int len; | 2342 | int len; |
2325 | 2343 | ||
2326 | ofsAddr = moxaTableAddr[port]; | 2344 | ofsAddr = moxa_ports[port].tableAddr; |
2327 | rptr = readw(ofsAddr + RXrptr); | 2345 | rptr = readw(ofsAddr + RXrptr); |
2328 | wptr = readw(ofsAddr + RXwptr); | 2346 | wptr = readw(ofsAddr + RXwptr); |
2329 | mask = readw(ofsAddr + RX_mask); | 2347 | mask = readw(ofsAddr + RX_mask); |
@@ -2336,7 +2354,7 @@ void MoxaPortTxDisable(int port) | |||
2336 | { | 2354 | { |
2337 | void __iomem *ofsAddr; | 2355 | void __iomem *ofsAddr; |
2338 | 2356 | ||
2339 | ofsAddr = moxaTableAddr[port]; | 2357 | ofsAddr = moxa_ports[port].tableAddr; |
2340 | moxafunc(ofsAddr, FC_SetXoffState, Magic_code); | 2358 | moxafunc(ofsAddr, FC_SetXoffState, Magic_code); |
2341 | } | 2359 | } |
2342 | 2360 | ||
@@ -2344,7 +2362,7 @@ void MoxaPortTxEnable(int port) | |||
2344 | { | 2362 | { |
2345 | void __iomem *ofsAddr; | 2363 | void __iomem *ofsAddr; |
2346 | 2364 | ||
2347 | ofsAddr = moxaTableAddr[port]; | 2365 | ofsAddr = moxa_ports[port].tableAddr; |
2348 | moxafunc(ofsAddr, FC_SetXonState, Magic_code); | 2366 | moxafunc(ofsAddr, FC_SetXonState, Magic_code); |
2349 | } | 2367 | } |
2350 | 2368 | ||
@@ -2352,8 +2370,8 @@ void MoxaPortTxEnable(int port) | |||
2352 | int MoxaPortResetBrkCnt(int port) | 2370 | int MoxaPortResetBrkCnt(int port) |
2353 | { | 2371 | { |
2354 | ushort cnt; | 2372 | ushort cnt; |
2355 | cnt = moxaBreakCnt[port]; | 2373 | cnt = moxa_ports[port].breakCnt; |
2356 | moxaBreakCnt[port] = 0; | 2374 | moxa_ports[port].breakCnt = 0; |
2357 | return (cnt); | 2375 | return (cnt); |
2358 | } | 2376 | } |
2359 | 2377 | ||
@@ -2362,7 +2380,7 @@ void MoxaPortSendBreak(int port, int ms100) | |||
2362 | { | 2380 | { |
2363 | void __iomem *ofsAddr; | 2381 | void __iomem *ofsAddr; |
2364 | 2382 | ||
2365 | ofsAddr = moxaTableAddr[port]; | 2383 | ofsAddr = moxa_ports[port].tableAddr; |
2366 | if (ms100) { | 2384 | if (ms100) { |
2367 | moxafunc(ofsAddr, FC_SendBreak, Magic_code); | 2385 | moxafunc(ofsAddr, FC_SendBreak, Magic_code); |
2368 | moxadelay(ms100 * (HZ / 10)); | 2386 | moxadelay(ms100 * (HZ / 10)); |
@@ -2373,7 +2391,7 @@ void MoxaPortSendBreak(int port, int ms100) | |||
2373 | moxafunc(ofsAddr, FC_StopBreak, Magic_code); | 2391 | moxafunc(ofsAddr, FC_StopBreak, Magic_code); |
2374 | } | 2392 | } |
2375 | 2393 | ||
2376 | static int moxa_get_serial_info(struct moxa_str *info, | 2394 | static int moxa_get_serial_info(struct moxa_port *info, |
2377 | struct serial_struct __user *retinfo) | 2395 | struct serial_struct __user *retinfo) |
2378 | { | 2396 | { |
2379 | struct serial_struct tmp; | 2397 | struct serial_struct tmp; |
@@ -2395,7 +2413,7 @@ static int moxa_get_serial_info(struct moxa_str *info, | |||
2395 | } | 2413 | } |
2396 | 2414 | ||
2397 | 2415 | ||
2398 | static int moxa_set_serial_info(struct moxa_str *info, | 2416 | static int moxa_set_serial_info(struct moxa_port *info, |
2399 | struct serial_struct __user *new_info) | 2417 | struct serial_struct __user *new_info) |
2400 | { | 2418 | { |
2401 | struct serial_struct new_serial; | 2419 | struct serial_struct new_serial; |
@@ -2492,7 +2510,7 @@ static int moxaloadbios(int cardno, unsigned char __user *tmp, int len) | |||
2492 | 2510 | ||
2493 | if(copy_from_user(moxaBuff, tmp, len)) | 2511 | if(copy_from_user(moxaBuff, tmp, len)) |
2494 | return -EFAULT; | 2512 | return -EFAULT; |
2495 | baseAddr = moxaBaseAddr[cardno]; | 2513 | baseAddr = moxa_boards[cardno].basemem; |
2496 | writeb(HW_reset, baseAddr + Control_reg); /* reset */ | 2514 | writeb(HW_reset, baseAddr + Control_reg); /* reset */ |
2497 | moxadelay(1); /* delay 10 ms */ | 2515 | moxadelay(1); /* delay 10 ms */ |
2498 | for (i = 0; i < 4096; i++) | 2516 | for (i = 0; i < 4096; i++) |
@@ -2508,7 +2526,7 @@ static int moxafindcard(int cardno) | |||
2508 | void __iomem *baseAddr; | 2526 | void __iomem *baseAddr; |
2509 | ushort tmp; | 2527 | ushort tmp; |
2510 | 2528 | ||
2511 | baseAddr = moxaBaseAddr[cardno]; | 2529 | baseAddr = moxa_boards[cardno].basemem; |
2512 | switch (moxa_boards[cardno].boardType) { | 2530 | switch (moxa_boards[cardno].boardType) { |
2513 | case MOXA_BOARD_C218_ISA: | 2531 | case MOXA_BOARD_C218_ISA: |
2514 | case MOXA_BOARD_C218_PCI: | 2532 | case MOXA_BOARD_C218_PCI: |
@@ -2541,7 +2559,7 @@ static int moxaload320b(int cardno, unsigned char __user *tmp, int len) | |||
2541 | return -EINVAL; | 2559 | return -EINVAL; |
2542 | if(copy_from_user(moxaBuff, tmp, len)) | 2560 | if(copy_from_user(moxaBuff, tmp, len)) |
2543 | return -EFAULT; | 2561 | return -EFAULT; |
2544 | baseAddr = moxaBaseAddr[cardno]; | 2562 | baseAddr = moxa_boards[cardno].basemem; |
2545 | writew(len - 7168 - 2, baseAddr + C320bapi_len); | 2563 | writew(len - 7168 - 2, baseAddr + C320bapi_len); |
2546 | writeb(1, baseAddr + Control_reg); /* Select Page 1 */ | 2564 | writeb(1, baseAddr + Control_reg); /* Select Page 1 */ |
2547 | for (i = 0; i < 7168; i++) | 2565 | for (i = 0; i < 7168; i++) |
@@ -2559,7 +2577,7 @@ static int moxaloadcode(int cardno, unsigned char __user *tmp, int len) | |||
2559 | 2577 | ||
2560 | if(copy_from_user(moxaBuff, tmp, len)) | 2578 | if(copy_from_user(moxaBuff, tmp, len)) |
2561 | return -EFAULT; | 2579 | return -EFAULT; |
2562 | baseAddr = moxaBaseAddr[cardno]; | 2580 | baseAddr = moxa_boards[cardno].basemem; |
2563 | switch (moxa_boards[cardno].boardType) { | 2581 | switch (moxa_boards[cardno].boardType) { |
2564 | case MOXA_BOARD_C218_ISA: | 2582 | case MOXA_BOARD_C218_ISA: |
2565 | case MOXA_BOARD_C218_PCI: | 2583 | case MOXA_BOARD_C218_PCI: |
@@ -2569,11 +2587,13 @@ static int moxaloadcode(int cardno, unsigned char __user *tmp, int len) | |||
2569 | return (retval); | 2587 | return (retval); |
2570 | port = cardno * MAX_PORTS_PER_BOARD; | 2588 | port = cardno * MAX_PORTS_PER_BOARD; |
2571 | for (i = 0; i < moxa_boards[cardno].numPorts; i++, port++) { | 2589 | for (i = 0; i < moxa_boards[cardno].numPorts; i++, port++) { |
2572 | moxaChkPort[port] = 1; | 2590 | struct moxa_port *p = &moxa_ports[port]; |
2573 | moxaCurBaud[port] = 9600L; | 2591 | |
2574 | moxaDCDState[port] = 0; | 2592 | p->chkPort = 1; |
2575 | moxaTableAddr[port] = baseAddr + Extern_table + Extern_size * i; | 2593 | p->curBaud = 9600L; |
2576 | ofsAddr = moxaTableAddr[port]; | 2594 | p->DCDState = 0; |
2595 | p->tableAddr = baseAddr + Extern_table + Extern_size * i; | ||
2596 | ofsAddr = p->tableAddr; | ||
2577 | writew(C218rx_mask, ofsAddr + RX_mask); | 2597 | writew(C218rx_mask, ofsAddr + RX_mask); |
2578 | writew(C218tx_mask, ofsAddr + TX_mask); | 2598 | writew(C218tx_mask, ofsAddr + TX_mask); |
2579 | writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb); | 2599 | writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb); |
@@ -2591,11 +2611,13 @@ static int moxaloadcode(int cardno, unsigned char __user *tmp, int len) | |||
2591 | return (retval); | 2611 | return (retval); |
2592 | port = cardno * MAX_PORTS_PER_BOARD; | 2612 | port = cardno * MAX_PORTS_PER_BOARD; |
2593 | for (i = 0; i < moxa_boards[cardno].numPorts; i++, port++) { | 2613 | for (i = 0; i < moxa_boards[cardno].numPorts; i++, port++) { |
2594 | moxaChkPort[port] = 1; | 2614 | struct moxa_port *p = &moxa_ports[port]; |
2595 | moxaCurBaud[port] = 9600L; | 2615 | |
2596 | moxaDCDState[port] = 0; | 2616 | p->chkPort = 1; |
2597 | moxaTableAddr[port] = baseAddr + Extern_table + Extern_size * i; | 2617 | p->curBaud = 9600L; |
2598 | ofsAddr = moxaTableAddr[port]; | 2618 | p->DCDState = 0; |
2619 | p->tableAddr = baseAddr + Extern_table + Extern_size * i; | ||
2620 | ofsAddr = p->tableAddr; | ||
2599 | if (moxa_boards[cardno].numPorts == 8) { | 2621 | if (moxa_boards[cardno].numPorts == 8) { |
2600 | writew(C320p8rx_mask, ofsAddr + RX_mask); | 2622 | writew(C320p8rx_mask, ofsAddr + RX_mask); |
2601 | writew(C320p8tx_mask, ofsAddr + TX_mask); | 2623 | writew(C320p8tx_mask, ofsAddr + TX_mask); |
@@ -2631,7 +2653,7 @@ static int moxaloadcode(int cardno, unsigned char __user *tmp, int len) | |||
2631 | } | 2653 | } |
2632 | break; | 2654 | break; |
2633 | } | 2655 | } |
2634 | loadstat[cardno] = 1; | 2656 | moxa_boards[cardno].loadstat = 1; |
2635 | return (0); | 2657 | return (0); |
2636 | } | 2658 | } |
2637 | 2659 | ||
@@ -2705,9 +2727,9 @@ static int moxaloadc218(int cardno, void __iomem *baseAddr, int len) | |||
2705 | return (-1); | 2727 | return (-1); |
2706 | } | 2728 | } |
2707 | moxaCard = 1; | 2729 | moxaCard = 1; |
2708 | moxaIntNdx[cardno] = baseAddr + IRQindex; | 2730 | moxa_boards[cardno].intNdx = baseAddr + IRQindex; |
2709 | moxaIntPend[cardno] = baseAddr + IRQpending; | 2731 | moxa_boards[cardno].intPend = baseAddr + IRQpending; |
2710 | moxaIntTable[cardno] = baseAddr + IRQtable; | 2732 | moxa_boards[cardno].intTable = baseAddr + IRQtable; |
2711 | return (0); | 2733 | return (0); |
2712 | } | 2734 | } |
2713 | 2735 | ||
@@ -2800,15 +2822,15 @@ static int moxaloadc320(int cardno, void __iomem *baseAddr, int len, int *numPor | |||
2800 | if (readw(baseAddr + Magic_no) != Magic_code) | 2822 | if (readw(baseAddr + Magic_no) != Magic_code) |
2801 | return (-102); | 2823 | return (-102); |
2802 | moxaCard = 1; | 2824 | moxaCard = 1; |
2803 | moxaIntNdx[cardno] = baseAddr + IRQindex; | 2825 | moxa_boards[cardno].intNdx = baseAddr + IRQindex; |
2804 | moxaIntPend[cardno] = baseAddr + IRQpending; | 2826 | moxa_boards[cardno].intPend = baseAddr + IRQpending; |
2805 | moxaIntTable[cardno] = baseAddr + IRQtable; | 2827 | moxa_boards[cardno].intTable = baseAddr + IRQtable; |
2806 | return (0); | 2828 | return (0); |
2807 | } | 2829 | } |
2808 | 2830 | ||
2809 | static void MoxaSetFifo(int port, int enable) | 2831 | static void MoxaSetFifo(int port, int enable) |
2810 | { | 2832 | { |
2811 | void __iomem *ofsAddr = moxaTableAddr[port]; | 2833 | void __iomem *ofsAddr = moxa_ports[port].tableAddr; |
2812 | 2834 | ||
2813 | if (!enable) { | 2835 | if (!enable) { |
2814 | moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0); | 2836 | moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0); |