1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/module.h>
25#include <linux/types.h>
26#include <linux/mm.h>
27#include <linux/ioport.h>
28#include <linux/errno.h>
29#include <linux/firmware.h>
30#include <linux/signal.h>
31#include <linux/sched.h>
32#include <linux/timer.h>
33#include <linux/interrupt.h>
34#include <linux/tty.h>
35#include <linux/tty_flip.h>
36#include <linux/major.h>
37#include <linux/string.h>
38#include <linux/fcntl.h>
39#include <linux/ptrace.h>
40#include <linux/serial.h>
41#include <linux/tty_driver.h>
42#include <linux/delay.h>
43#include <linux/pci.h>
44#include <linux/init.h>
45#include <linux/bitops.h>
46#include <linux/slab.h>
47#include <linux/ratelimit.h>
48
49#include <asm/io.h>
50#include <asm/uaccess.h>
51
52#include "moxa.h"
53
54#define MOXA_VERSION "6.0k"
55
56#define MOXA_FW_HDRLEN 32
57
58#define MOXAMAJOR 172
59
60#define MAX_BOARDS 4
61#define MAX_PORTS_PER_BOARD 32
62#define MAX_PORTS (MAX_BOARDS * MAX_PORTS_PER_BOARD)
63
64#define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \
65 (brd)->boardType == MOXA_BOARD_C320_PCI)
66
67
68
69
70#define MOXA_BUS_TYPE_ISA 0
71#define MOXA_BUS_TYPE_PCI 1
72
73enum {
74 MOXA_BOARD_C218_PCI = 1,
75 MOXA_BOARD_C218_ISA,
76 MOXA_BOARD_C320_PCI,
77 MOXA_BOARD_C320_ISA,
78 MOXA_BOARD_CP204J,
79};
80
81static char *moxa_brdname[] =
82{
83 "C218 Turbo PCI series",
84 "C218 Turbo ISA series",
85 "C320 Turbo PCI series",
86 "C320 Turbo ISA series",
87 "CP-204J series",
88};
89
90#ifdef CONFIG_PCI
91static struct pci_device_id moxa_pcibrds[] = {
92 { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),
93 .driver_data = MOXA_BOARD_C218_PCI },
94 { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),
95 .driver_data = MOXA_BOARD_C320_PCI },
96 { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),
97 .driver_data = MOXA_BOARD_CP204J },
98 { 0 }
99};
100MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
101#endif
102
103struct moxa_port;
104
105static struct moxa_board_conf {
106 int boardType;
107 int numPorts;
108 int busType;
109
110 unsigned int ready;
111
112 struct moxa_port *ports;
113
114 void __iomem *basemem;
115 void __iomem *intNdx;
116 void __iomem *intPend;
117 void __iomem *intTable;
118} moxa_boards[MAX_BOARDS];
119
120struct mxser_mstatus {
121 tcflag_t cflag;
122 int cts;
123 int dsr;
124 int ri;
125 int dcd;
126};
127
128struct moxaq_str {
129 int inq;
130 int outq;
131};
132
133struct moxa_port {
134 struct tty_port port;
135 struct moxa_board_conf *board;
136 void __iomem *tableAddr;
137
138 int type;
139 int cflag;
140 unsigned long statusflags;
141
142 u8 DCDState;
143 u8 lineCtrl;
144 u8 lowChkFlag;
145};
146
147struct mon_str {
148 int tick;
149 int rxcnt[MAX_PORTS];
150 int txcnt[MAX_PORTS];
151};
152
153
154#define TXSTOPPED 1
155#define LOWWAIT 2
156#define EMPTYWAIT 3
157
158#define SERIAL_DO_RESTART
159
160#define WAKEUP_CHARS 256
161
162static int ttymajor = MOXAMAJOR;
163static struct mon_str moxaLog;
164static unsigned int moxaFuncTout = HZ / 2;
165static unsigned int moxaLowWaterChk;
166static DEFINE_MUTEX(moxa_openlock);
167static DEFINE_SPINLOCK(moxa_lock);
168
169static unsigned long baseaddr[MAX_BOARDS];
170static unsigned int type[MAX_BOARDS];
171static unsigned int numports[MAX_BOARDS];
172
173MODULE_AUTHOR("William Chen");
174MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
175MODULE_LICENSE("GPL");
176MODULE_FIRMWARE("c218tunx.cod");
177MODULE_FIRMWARE("cp204unx.cod");
178MODULE_FIRMWARE("c320tunx.cod");
179
180module_param_array(type, uint, NULL, 0);
181MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
182module_param_array(baseaddr, ulong, NULL, 0);
183MODULE_PARM_DESC(baseaddr, "base address");
184module_param_array(numports, uint, NULL, 0);
185MODULE_PARM_DESC(numports, "numports (ignored for C218)");
186
187module_param(ttymajor, int, 0);
188
189
190
191
192static int moxa_open(struct tty_struct *, struct file *);
193static void moxa_close(struct tty_struct *, struct file *);
194static int moxa_write(struct tty_struct *, const unsigned char *, int);
195static int moxa_write_room(struct tty_struct *);
196static void moxa_flush_buffer(struct tty_struct *);
197static int moxa_chars_in_buffer(struct tty_struct *);
198static void moxa_set_termios(struct tty_struct *, struct ktermios *);
199static void moxa_stop(struct tty_struct *);
200static void moxa_start(struct tty_struct *);
201static void moxa_hangup(struct tty_struct *);
202static int moxa_tiocmget(struct tty_struct *tty);
203static int moxa_tiocmset(struct tty_struct *tty,
204 unsigned int set, unsigned int clear);
205static void moxa_poll(unsigned long);
206static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
207static void moxa_shutdown(struct tty_port *);
208static int moxa_carrier_raised(struct tty_port *);
209static void moxa_dtr_rts(struct tty_port *, int);
210
211
212
213static void MoxaPortEnable(struct moxa_port *);
214static void MoxaPortDisable(struct moxa_port *);
215static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);
216static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);
217static void MoxaPortLineCtrl(struct moxa_port *, int, int);
218static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
219static int MoxaPortLineStatus(struct moxa_port *);
220static void MoxaPortFlushData(struct moxa_port *, int);
221static int MoxaPortWriteData(struct tty_struct *, const unsigned char *, int);
222static int MoxaPortReadData(struct moxa_port *);
223static int MoxaPortTxQueue(struct moxa_port *);
224static int MoxaPortRxQueue(struct moxa_port *);
225static int MoxaPortTxFree(struct moxa_port *);
226static void MoxaPortTxDisable(struct moxa_port *);
227static void MoxaPortTxEnable(struct moxa_port *);
228static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
229static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
230static void MoxaSetFifo(struct moxa_port *port, int enable);
231
232
233
234
235
236static DEFINE_SPINLOCK(moxafunc_lock);
237
238static void moxa_wait_finish(void __iomem *ofsAddr)
239{
240 unsigned long end = jiffies + moxaFuncTout;
241
242 while (readw(ofsAddr + FuncCode) != 0)
243 if (time_after(jiffies, end))
244 return;
245 if (readw(ofsAddr + FuncCode) != 0)
246 printk_ratelimited(KERN_WARNING "moxa function expired\n");
247}
248
249static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)
250{
251 unsigned long flags;
252 spin_lock_irqsave(&moxafunc_lock, flags);
253 writew(arg, ofsAddr + FuncArg);
254 writew(cmd, ofsAddr + FuncCode);
255 moxa_wait_finish(ofsAddr);
256 spin_unlock_irqrestore(&moxafunc_lock, flags);
257}
258
259static int moxafuncret(void __iomem *ofsAddr, u16 cmd, u16 arg)
260{
261 unsigned long flags;
262 u16 ret;
263 spin_lock_irqsave(&moxafunc_lock, flags);
264 writew(arg, ofsAddr + FuncArg);
265 writew(cmd, ofsAddr + FuncCode);
266 moxa_wait_finish(ofsAddr);
267 ret = readw(ofsAddr + FuncArg);
268 spin_unlock_irqrestore(&moxafunc_lock, flags);
269 return ret;
270}
271
272static void moxa_low_water_check(void __iomem *ofsAddr)
273{
274 u16 rptr, wptr, mask, len;
275
276 if (readb(ofsAddr + FlagStat) & Xoff_state) {
277 rptr = readw(ofsAddr + RXrptr);
278 wptr = readw(ofsAddr + RXwptr);
279 mask = readw(ofsAddr + RX_mask);
280 len = (wptr - rptr) & mask;
281 if (len <= Low_water)
282 moxafunc(ofsAddr, FC_SendXon, 0);
283 }
284}
285
286
287
288
289
290static int moxa_ioctl(struct tty_struct *tty,
291 unsigned int cmd, unsigned long arg)
292{
293 struct moxa_port *ch = tty->driver_data;
294 void __user *argp = (void __user *)arg;
295 int status, ret = 0;
296
297 if (tty->index == MAX_PORTS) {
298 if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
299 cmd != MOXA_GETMSTATUS)
300 return -EINVAL;
301 } else if (!ch)
302 return -ENODEV;
303
304 switch (cmd) {
305 case MOXA_GETDATACOUNT:
306 moxaLog.tick = jiffies;
307 if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))
308 ret = -EFAULT;
309 break;
310 case MOXA_FLUSH_QUEUE:
311 MoxaPortFlushData(ch, arg);
312 break;
313 case MOXA_GET_IOQUEUE: {
314 struct moxaq_str __user *argm = argp;
315 struct moxaq_str tmp;
316 struct moxa_port *p;
317 unsigned int i, j;
318
319 for (i = 0; i < MAX_BOARDS; i++) {
320 p = moxa_boards[i].ports;
321 for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
322 memset(&tmp, 0, sizeof(tmp));
323 spin_lock_bh(&moxa_lock);
324 if (moxa_boards[i].ready) {
325 tmp.inq = MoxaPortRxQueue(p);
326 tmp.outq = MoxaPortTxQueue(p);
327 }
328 spin_unlock_bh(&moxa_lock);
329 if (copy_to_user(argm, &tmp, sizeof(tmp)))
330 return -EFAULT;
331 }
332 }
333 break;
334 } case MOXA_GET_OQUEUE:
335 status = MoxaPortTxQueue(ch);
336 ret = put_user(status, (unsigned long __user *)argp);
337 break;
338 case MOXA_GET_IQUEUE:
339 status = MoxaPortRxQueue(ch);
340 ret = put_user(status, (unsigned long __user *)argp);
341 break;
342 case MOXA_GETMSTATUS: {
343 struct mxser_mstatus __user *argm = argp;
344 struct mxser_mstatus tmp;
345 struct moxa_port *p;
346 unsigned int i, j;
347
348 for (i = 0; i < MAX_BOARDS; i++) {
349 p = moxa_boards[i].ports;
350 for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
351 struct tty_struct *ttyp;
352 memset(&tmp, 0, sizeof(tmp));
353 spin_lock_bh(&moxa_lock);
354 if (!moxa_boards[i].ready) {
355 spin_unlock_bh(&moxa_lock);
356 goto copy;
357 }
358
359 status = MoxaPortLineStatus(p);
360 spin_unlock_bh(&moxa_lock);
361
362 if (status & 1)
363 tmp.cts = 1;
364 if (status & 2)
365 tmp.dsr = 1;
366 if (status & 4)
367 tmp.dcd = 1;
368
369 ttyp = tty_port_tty_get(&p->port);
370 if (!ttyp || !ttyp->termios)
371 tmp.cflag = p->cflag;
372 else
373 tmp.cflag = ttyp->termios->c_cflag;
374 tty_kref_put(ttyp);
375copy:
376 if (copy_to_user(argm, &tmp, sizeof(tmp)))
377 return -EFAULT;
378 }
379 }
380 break;
381 }
382 case TIOCGSERIAL:
383 mutex_lock(&ch->port.mutex);
384 ret = moxa_get_serial_info(ch, argp);
385 mutex_unlock(&ch->port.mutex);
386 break;
387 case TIOCSSERIAL:
388 mutex_lock(&ch->port.mutex);
389 ret = moxa_set_serial_info(ch, argp);
390 mutex_unlock(&ch->port.mutex);
391 break;
392 default:
393 ret = -ENOIOCTLCMD;
394 }
395 return ret;
396}
397
398static int moxa_break_ctl(struct tty_struct *tty, int state)
399{
400 struct moxa_port *port = tty->driver_data;
401
402 moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,
403 Magic_code);
404 return 0;
405}
406
407static const struct tty_operations moxa_ops = {
408 .open = moxa_open,
409 .close = moxa_close,
410 .write = moxa_write,
411 .write_room = moxa_write_room,
412 .flush_buffer = moxa_flush_buffer,
413 .chars_in_buffer = moxa_chars_in_buffer,
414 .ioctl = moxa_ioctl,
415 .set_termios = moxa_set_termios,
416 .stop = moxa_stop,
417 .start = moxa_start,
418 .hangup = moxa_hangup,
419 .break_ctl = moxa_break_ctl,
420 .tiocmget = moxa_tiocmget,
421 .tiocmset = moxa_tiocmset,
422};
423
424static const struct tty_port_operations moxa_port_ops = {
425 .carrier_raised = moxa_carrier_raised,
426 .dtr_rts = moxa_dtr_rts,
427 .shutdown = moxa_shutdown,
428};
429
430static struct tty_driver *moxaDriver;
431static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);
432
433
434
435
436
437static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)
438{
439 switch (brd->boardType) {
440 case MOXA_BOARD_C218_ISA:
441 case MOXA_BOARD_C218_PCI:
442 if (model != 1)
443 goto err;
444 break;
445 case MOXA_BOARD_CP204J:
446 if (model != 3)
447 goto err;
448 break;
449 default:
450 if (model != 2)
451 goto err;
452 break;
453 }
454 return 0;
455err:
456 return -EINVAL;
457}
458
459static int moxa_check_fw(const void *ptr)
460{
461 const __le16 *lptr = ptr;
462
463 if (*lptr != cpu_to_le16(0x7980))
464 return -EINVAL;
465
466 return 0;
467}
468
469static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
470 size_t len)
471{
472 void __iomem *baseAddr = brd->basemem;
473 u16 tmp;
474
475 writeb(HW_reset, baseAddr + Control_reg);
476 msleep(10);
477 memset_io(baseAddr, 0, 4096);
478 memcpy_toio(baseAddr, buf, len);
479 writeb(0, baseAddr + Control_reg);
480
481 msleep(2000);
482
483 switch (brd->boardType) {
484 case MOXA_BOARD_C218_ISA:
485 case MOXA_BOARD_C218_PCI:
486 tmp = readw(baseAddr + C218_key);
487 if (tmp != C218_KeyCode)
488 goto err;
489 break;
490 case MOXA_BOARD_CP204J:
491 tmp = readw(baseAddr + C218_key);
492 if (tmp != CP204J_KeyCode)
493 goto err;
494 break;
495 default:
496 tmp = readw(baseAddr + C320_key);
497 if (tmp != C320_KeyCode)
498 goto err;
499 tmp = readw(baseAddr + C320_status);
500 if (tmp != STS_init) {
501 printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "
502 "module not found\n");
503 return -EIO;
504 }
505 break;
506 }
507
508 return 0;
509err:
510 printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");
511 return -EIO;
512}
513
514static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
515 size_t len)
516{
517 void __iomem *baseAddr = brd->basemem;
518
519 if (len < 7168) {
520 printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");
521 return -EINVAL;
522 }
523
524 writew(len - 7168 - 2, baseAddr + C320bapi_len);
525 writeb(1, baseAddr + Control_reg);
526 memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);
527 writeb(2, baseAddr + Control_reg);
528 memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);
529
530 return 0;
531}
532
533static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,
534 size_t len)
535{
536 void __iomem *baseAddr = brd->basemem;
537 const __le16 *uptr = ptr;
538 size_t wlen, len2, j;
539 unsigned long key, loadbuf, loadlen, checksum, checksum_ok;
540 unsigned int i, retry;
541 u16 usum, keycode;
542
543 keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :
544 C218_KeyCode;
545
546 switch (brd->boardType) {
547 case MOXA_BOARD_CP204J:
548 case MOXA_BOARD_C218_ISA:
549 case MOXA_BOARD_C218_PCI:
550 key = C218_key;
551 loadbuf = C218_LoadBuf;
552 loadlen = C218DLoad_len;
553 checksum = C218check_sum;
554 checksum_ok = C218chksum_ok;
555 break;
556 default:
557 key = C320_key;
558 keycode = C320_KeyCode;
559 loadbuf = C320_LoadBuf;
560 loadlen = C320DLoad_len;
561 checksum = C320check_sum;
562 checksum_ok = C320chksum_ok;
563 break;
564 }
565
566 usum = 0;
567 wlen = len >> 1;
568 for (i = 0; i < wlen; i++)
569 usum += le16_to_cpu(uptr[i]);
570 retry = 0;
571 do {
572 wlen = len >> 1;
573 j = 0;
574 while (wlen) {
575 len2 = (wlen > 2048) ? 2048 : wlen;
576 wlen -= len2;
577 memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);
578 j += len2 << 1;
579
580 writew(len2, baseAddr + loadlen);
581 writew(0, baseAddr + key);
582 for (i = 0; i < 100; i++) {
583 if (readw(baseAddr + key) == keycode)
584 break;
585 msleep(10);
586 }
587 if (readw(baseAddr + key) != keycode)
588 return -EIO;
589 }
590 writew(0, baseAddr + loadlen);
591 writew(usum, baseAddr + checksum);
592 writew(0, baseAddr + key);
593 for (i = 0; i < 100; i++) {
594 if (readw(baseAddr + key) == keycode)
595 break;
596 msleep(10);
597 }
598 retry++;
599 } while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));
600 if (readb(baseAddr + checksum_ok) != 1)
601 return -EIO;
602
603 writew(0, baseAddr + key);
604 for (i = 0; i < 600; i++) {
605 if (readw(baseAddr + Magic_no) == Magic_code)
606 break;
607 msleep(10);
608 }
609 if (readw(baseAddr + Magic_no) != Magic_code)
610 return -EIO;
611
612 if (MOXA_IS_320(brd)) {
613 if (brd->busType == MOXA_BUS_TYPE_PCI) {
614 writew(0x3800, baseAddr + TMS320_PORT1);
615 writew(0x3900, baseAddr + TMS320_PORT2);
616 writew(28499, baseAddr + TMS320_CLOCK);
617 } else {
618 writew(0x3200, baseAddr + TMS320_PORT1);
619 writew(0x3400, baseAddr + TMS320_PORT2);
620 writew(19999, baseAddr + TMS320_CLOCK);
621 }
622 }
623 writew(1, baseAddr + Disable_IRQ);
624 writew(0, baseAddr + Magic_no);
625 for (i = 0; i < 500; i++) {
626 if (readw(baseAddr + Magic_no) == Magic_code)
627 break;
628 msleep(10);
629 }
630 if (readw(baseAddr + Magic_no) != Magic_code)
631 return -EIO;
632
633 if (MOXA_IS_320(brd)) {
634 j = readw(baseAddr + Module_cnt);
635 if (j <= 0)
636 return -EIO;
637 brd->numPorts = j * 8;
638 writew(j, baseAddr + Module_no);
639 writew(0, baseAddr + Magic_no);
640 for (i = 0; i < 600; i++) {
641 if (readw(baseAddr + Magic_no) == Magic_code)
642 break;
643 msleep(10);
644 }
645 if (readw(baseAddr + Magic_no) != Magic_code)
646 return -EIO;
647 }
648 brd->intNdx = baseAddr + IRQindex;
649 brd->intPend = baseAddr + IRQpending;
650 brd->intTable = baseAddr + IRQtable;
651
652 return 0;
653}
654
655static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
656 size_t len)
657{
658 void __iomem *ofsAddr, *baseAddr = brd->basemem;
659 struct moxa_port *port;
660 int retval, i;
661
662 if (len % 2) {
663 printk(KERN_ERR "MOXA: bios length is not even\n");
664 return -EINVAL;
665 }
666
667 retval = moxa_real_load_code(brd, ptr, len);
668 if (retval)
669 return retval;
670
671 switch (brd->boardType) {
672 case MOXA_BOARD_C218_ISA:
673 case MOXA_BOARD_C218_PCI:
674 case MOXA_BOARD_CP204J:
675 port = brd->ports;
676 for (i = 0; i < brd->numPorts; i++, port++) {
677 port->board = brd;
678 port->DCDState = 0;
679 port->tableAddr = baseAddr + Extern_table +
680 Extern_size * i;
681 ofsAddr = port->tableAddr;
682 writew(C218rx_mask, ofsAddr + RX_mask);
683 writew(C218tx_mask, ofsAddr + TX_mask);
684 writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
685 writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);
686
687 writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
688 writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);
689
690 }
691 break;
692 default:
693 port = brd->ports;
694 for (i = 0; i < brd->numPorts; i++, port++) {
695 port->board = brd;
696 port->DCDState = 0;
697 port->tableAddr = baseAddr + Extern_table +
698 Extern_size * i;
699 ofsAddr = port->tableAddr;
700 switch (brd->numPorts) {
701 case 8:
702 writew(C320p8rx_mask, ofsAddr + RX_mask);
703 writew(C320p8tx_mask, ofsAddr + TX_mask);
704 writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
705 writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
706 writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
707 writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);
708
709 break;
710 case 16:
711 writew(C320p16rx_mask, ofsAddr + RX_mask);
712 writew(C320p16tx_mask, ofsAddr + TX_mask);
713 writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
714 writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
715 writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
716 writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
717 break;
718
719 case 24:
720 writew(C320p24rx_mask, ofsAddr + RX_mask);
721 writew(C320p24tx_mask, ofsAddr + TX_mask);
722 writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
723 writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
724 writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
725 writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
726 break;
727 case 32:
728 writew(C320p32rx_mask, ofsAddr + RX_mask);
729 writew(C320p32tx_mask, ofsAddr + TX_mask);
730 writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
731 writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
732 writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
733 writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
734 writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
735 break;
736 }
737 }
738 break;
739 }
740 return 0;
741}
742
743static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
744{
745 const void *ptr = fw->data;
746 char rsn[64];
747 u16 lens[5];
748 size_t len;
749 unsigned int a, lenp, lencnt;
750 int ret = -EINVAL;
751 struct {
752 __le32 magic;
753 u8 reserved1[2];
754 u8 type;
755 u8 model;
756 u8 reserved2[8];
757 __le16 len[5];
758 } const *hdr = ptr;
759
760 BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));
761
762 if (fw->size < MOXA_FW_HDRLEN) {
763 strcpy(rsn, "too short (even header won't fit)");
764 goto err;
765 }
766 if (hdr->magic != cpu_to_le32(0x30343034)) {
767 sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));
768 goto err;
769 }
770 if (hdr->type != 3) {
771 sprintf(rsn, "not for linux, type is %u", hdr->type);
772 goto err;
773 }
774 if (moxa_check_fw_model(brd, hdr->model)) {
775 sprintf(rsn, "not for this card, model is %u", hdr->model);
776 goto err;
777 }
778
779 len = MOXA_FW_HDRLEN;
780 lencnt = hdr->model == 2 ? 5 : 3;
781 for (a = 0; a < ARRAY_SIZE(lens); a++) {
782 lens[a] = le16_to_cpu(hdr->len[a]);
783 if (lens[a] && len + lens[a] <= fw->size &&
784 moxa_check_fw(&fw->data[len]))
785 printk(KERN_WARNING "MOXA firmware: unexpected input "
786 "at offset %u, but going on\n", (u32)len);
787 if (!lens[a] && a < lencnt) {
788 sprintf(rsn, "too few entries in fw file");
789 goto err;
790 }
791 len += lens[a];
792 }
793
794 if (len != fw->size) {
795 sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,
796 (u32)len);
797 goto err;
798 }
799
800 ptr += MOXA_FW_HDRLEN;
801 lenp = 0;
802
803 strcpy(rsn, "read above");
804
805 ret = moxa_load_bios(brd, ptr, lens[lenp]);
806 if (ret)
807 goto err;
808
809
810 ptr += lens[lenp] + lens[lenp + 1];
811 lenp += 2;
812
813 if (hdr->model == 2) {
814 ret = moxa_load_320b(brd, ptr, lens[lenp]);
815 if (ret)
816 goto err;
817
818 ptr += lens[lenp] + lens[lenp + 1];
819 lenp += 2;
820 }
821
822 ret = moxa_load_code(brd, ptr, lens[lenp]);
823 if (ret)
824 goto err;
825
826 return 0;
827err:
828 printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);
829 return ret;
830}
831
832static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
833{
834 const struct firmware *fw;
835 const char *file;
836 struct moxa_port *p;
837 unsigned int i;
838 int ret;
839
840 brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),
841 GFP_KERNEL);
842 if (brd->ports == NULL) {
843 printk(KERN_ERR "cannot allocate memory for ports\n");
844 ret = -ENOMEM;
845 goto err;
846 }
847
848 for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {
849 tty_port_init(&p->port);
850 p->port.ops = &moxa_port_ops;
851 p->type = PORT_16550A;
852 p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
853 }
854
855 switch (brd->boardType) {
856 case MOXA_BOARD_C218_ISA:
857 case MOXA_BOARD_C218_PCI:
858 file = "c218tunx.cod";
859 break;
860 case MOXA_BOARD_CP204J:
861 file = "cp204unx.cod";
862 break;
863 default:
864 file = "c320tunx.cod";
865 break;
866 }
867
868 ret = request_firmware(&fw, file, dev);
869 if (ret) {
870 printk(KERN_ERR "MOXA: request_firmware failed. Make sure "
871 "you've placed '%s' file into your firmware "
872 "loader directory (e.g. /lib/firmware)\n",
873 file);
874 goto err_free;
875 }
876
877 ret = moxa_load_fw(brd, fw);
878
879 release_firmware(fw);
880
881 if (ret)
882 goto err_free;
883
884 spin_lock_bh(&moxa_lock);
885 brd->ready = 1;
886 if (!timer_pending(&moxaTimer))
887 mod_timer(&moxaTimer, jiffies + HZ / 50);
888 spin_unlock_bh(&moxa_lock);
889
890 return 0;
891err_free:
892 kfree(brd->ports);
893err:
894 return ret;
895}
896
897static void moxa_board_deinit(struct moxa_board_conf *brd)
898{
899 unsigned int a, opened;
900
901 mutex_lock(&moxa_openlock);
902 spin_lock_bh(&moxa_lock);
903 brd->ready = 0;
904 spin_unlock_bh(&moxa_lock);
905
906
907 for (a = 0; a < brd->numPorts; a++)
908 if (brd->ports[a].port.flags & ASYNC_INITIALIZED) {
909 struct tty_struct *tty = tty_port_tty_get(
910 &brd->ports[a].port);
911 if (tty) {
912 tty_hangup(tty);
913 tty_kref_put(tty);
914 }
915 }
916 while (1) {
917 opened = 0;
918 for (a = 0; a < brd->numPorts; a++)
919 if (brd->ports[a].port.flags & ASYNC_INITIALIZED)
920 opened++;
921 mutex_unlock(&moxa_openlock);
922 if (!opened)
923 break;
924 msleep(50);
925 mutex_lock(&moxa_openlock);
926 }
927
928 iounmap(brd->basemem);
929 brd->basemem = NULL;
930 kfree(brd->ports);
931}
932
933#ifdef CONFIG_PCI
934static int __devinit moxa_pci_probe(struct pci_dev *pdev,
935 const struct pci_device_id *ent)
936{
937 struct moxa_board_conf *board;
938 unsigned int i;
939 int board_type = ent->driver_data;
940 int retval;
941
942 retval = pci_enable_device(pdev);
943 if (retval) {
944 dev_err(&pdev->dev, "can't enable pci device\n");
945 goto err;
946 }
947
948 for (i = 0; i < MAX_BOARDS; i++)
949 if (moxa_boards[i].basemem == NULL)
950 break;
951
952 retval = -ENODEV;
953 if (i >= MAX_BOARDS) {
954 dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "
955 "found. Board is ignored.\n", MAX_BOARDS);
956 goto err;
957 }
958
959 board = &moxa_boards[i];
960
961 retval = pci_request_region(pdev, 2, "moxa-base");
962 if (retval) {
963 dev_err(&pdev->dev, "can't request pci region 2\n");
964 goto err;
965 }
966
967 board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);
968 if (board->basemem == NULL) {
969 dev_err(&pdev->dev, "can't remap io space 2\n");
970 goto err_reg;
971 }
972
973 board->boardType = board_type;
974 switch (board_type) {
975 case MOXA_BOARD_C218_ISA:
976 case MOXA_BOARD_C218_PCI:
977 board->numPorts = 8;
978 break;
979
980 case MOXA_BOARD_CP204J:
981 board->numPorts = 4;
982 break;
983 default:
984 board->numPorts = 0;
985 break;
986 }
987 board->busType = MOXA_BUS_TYPE_PCI;
988
989 retval = moxa_init_board(board, &pdev->dev);
990 if (retval)
991 goto err_base;
992
993 pci_set_drvdata(pdev, board);
994
995 dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",
996 moxa_brdname[board_type - 1], board->numPorts);
997
998 return 0;
999err_base:
1000 iounmap(board->basemem);
1001 board->basemem = NULL;
1002err_reg:
1003 pci_release_region(pdev, 2);
1004err:
1005 return retval;
1006}
1007
1008static void __devexit moxa_pci_remove(struct pci_dev *pdev)
1009{
1010 struct moxa_board_conf *brd = pci_get_drvdata(pdev);
1011
1012 moxa_board_deinit(brd);
1013
1014 pci_release_region(pdev, 2);
1015}
1016
1017static struct pci_driver moxa_pci_driver = {
1018 .name = "moxa",
1019 .id_table = moxa_pcibrds,
1020 .probe = moxa_pci_probe,
1021 .remove = __devexit_p(moxa_pci_remove)
1022};
1023#endif
1024
1025static int __init moxa_init(void)
1026{
1027 unsigned int isabrds = 0;
1028 int retval = 0;
1029 struct moxa_board_conf *brd = moxa_boards;
1030 unsigned int i;
1031
1032 printk(KERN_INFO "MOXA Intellio family driver version %s\n",
1033 MOXA_VERSION);
1034 moxaDriver = alloc_tty_driver(MAX_PORTS + 1);
1035 if (!moxaDriver)
1036 return -ENOMEM;
1037
1038 moxaDriver->name = "ttyMX";
1039 moxaDriver->major = ttymajor;
1040 moxaDriver->minor_start = 0;
1041 moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
1042 moxaDriver->subtype = SERIAL_TYPE_NORMAL;
1043 moxaDriver->init_termios = tty_std_termios;
1044 moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
1045 moxaDriver->init_termios.c_ispeed = 9600;
1046 moxaDriver->init_termios.c_ospeed = 9600;
1047 moxaDriver->flags = TTY_DRIVER_REAL_RAW;
1048 tty_set_operations(moxaDriver, &moxa_ops);
1049
1050 if (tty_register_driver(moxaDriver)) {
1051 printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
1052 put_tty_driver(moxaDriver);
1053 return -1;
1054 }
1055
1056
1057
1058 for (i = 0; i < MAX_BOARDS; i++) {
1059 if (!baseaddr[i])
1060 break;
1061 if (type[i] == MOXA_BOARD_C218_ISA ||
1062 type[i] == MOXA_BOARD_C320_ISA) {
1063 pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",
1064 isabrds + 1, moxa_brdname[type[i] - 1],
1065 baseaddr[i]);
1066 brd->boardType = type[i];
1067 brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :
1068 numports[i];
1069 brd->busType = MOXA_BUS_TYPE_ISA;
1070 brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);
1071 if (!brd->basemem) {
1072 printk(KERN_ERR "MOXA: can't remap %lx\n",
1073 baseaddr[i]);
1074 continue;
1075 }
1076 if (moxa_init_board(brd, NULL)) {
1077 iounmap(brd->basemem);
1078 brd->basemem = NULL;
1079 continue;
1080 }
1081
1082 printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "
1083 "ready (%u ports, firmware loaded)\n",
1084 baseaddr[i], brd->numPorts);
1085
1086 brd++;
1087 isabrds++;
1088 }
1089 }
1090
1091#ifdef CONFIG_PCI
1092 retval = pci_register_driver(&moxa_pci_driver);
1093 if (retval) {
1094 printk(KERN_ERR "Can't register MOXA pci driver!\n");
1095 if (isabrds)
1096 retval = 0;
1097 }
1098#endif
1099
1100 return retval;
1101}
1102
1103static void __exit moxa_exit(void)
1104{
1105 unsigned int i;
1106
1107#ifdef CONFIG_PCI
1108 pci_unregister_driver(&moxa_pci_driver);
1109#endif
1110
1111 for (i = 0; i < MAX_BOARDS; i++)
1112 if (moxa_boards[i].ready)
1113 moxa_board_deinit(&moxa_boards[i]);
1114
1115 del_timer_sync(&moxaTimer);
1116
1117 if (tty_unregister_driver(moxaDriver))
1118 printk(KERN_ERR "Couldn't unregister MOXA Intellio family "
1119 "serial driver\n");
1120 put_tty_driver(moxaDriver);
1121}
1122
1123module_init(moxa_init);
1124module_exit(moxa_exit);
1125
1126static void moxa_shutdown(struct tty_port *port)
1127{
1128 struct moxa_port *ch = container_of(port, struct moxa_port, port);
1129 MoxaPortDisable(ch);
1130 MoxaPortFlushData(ch, 2);
1131}
1132
1133static int moxa_carrier_raised(struct tty_port *port)
1134{
1135 struct moxa_port *ch = container_of(port, struct moxa_port, port);
1136 int dcd;
1137
1138 spin_lock_irq(&port->lock);
1139 dcd = ch->DCDState;
1140 spin_unlock_irq(&port->lock);
1141 return dcd;
1142}
1143
1144static void moxa_dtr_rts(struct tty_port *port, int onoff)
1145{
1146 struct moxa_port *ch = container_of(port, struct moxa_port, port);
1147 MoxaPortLineCtrl(ch, onoff, onoff);
1148}
1149
1150
1151static int moxa_open(struct tty_struct *tty, struct file *filp)
1152{
1153 struct moxa_board_conf *brd;
1154 struct moxa_port *ch;
1155 int port;
1156
1157 port = tty->index;
1158 if (port == MAX_PORTS) {
1159 return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
1160 }
1161 if (mutex_lock_interruptible(&moxa_openlock))
1162 return -ERESTARTSYS;
1163 brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
1164 if (!brd->ready) {
1165 mutex_unlock(&moxa_openlock);
1166 return -ENODEV;
1167 }
1168
1169 if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
1170 mutex_unlock(&moxa_openlock);
1171 return -ENODEV;
1172 }
1173
1174 ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
1175 ch->port.count++;
1176 tty->driver_data = ch;
1177 tty_port_tty_set(&ch->port, tty);
1178 mutex_lock(&ch->port.mutex);
1179 if (!(ch->port.flags & ASYNC_INITIALIZED)) {
1180 ch->statusflags = 0;
1181 moxa_set_tty_param(tty, tty->termios);
1182 MoxaPortLineCtrl(ch, 1, 1);
1183 MoxaPortEnable(ch);
1184 MoxaSetFifo(ch, ch->type == PORT_16550A);
1185 ch->port.flags |= ASYNC_INITIALIZED;
1186 }
1187 mutex_unlock(&ch->port.mutex);
1188 mutex_unlock(&moxa_openlock);
1189
1190 return tty_port_block_til_ready(&ch->port, tty, filp);
1191}
1192
1193static void moxa_close(struct tty_struct *tty, struct file *filp)
1194{
1195 struct moxa_port *ch = tty->driver_data;
1196 ch->cflag = tty->termios->c_cflag;
1197 tty_port_close(&ch->port, tty, filp);
1198}
1199
1200static int moxa_write(struct tty_struct *tty,
1201 const unsigned char *buf, int count)
1202{
1203 struct moxa_port *ch = tty->driver_data;
1204 unsigned long flags;
1205 int len;
1206
1207 if (ch == NULL)
1208 return 0;
1209
1210 spin_lock_irqsave(&moxa_lock, flags);
1211 len = MoxaPortWriteData(tty, buf, count);
1212 spin_unlock_irqrestore(&moxa_lock, flags);
1213
1214 set_bit(LOWWAIT, &ch->statusflags);
1215 return len;
1216}
1217
1218static int moxa_write_room(struct tty_struct *tty)
1219{
1220 struct moxa_port *ch;
1221
1222 if (tty->stopped)
1223 return 0;
1224 ch = tty->driver_data;
1225 if (ch == NULL)
1226 return 0;
1227 return MoxaPortTxFree(ch);
1228}
1229
1230static void moxa_flush_buffer(struct tty_struct *tty)
1231{
1232 struct moxa_port *ch = tty->driver_data;
1233
1234 if (ch == NULL)
1235 return;
1236 MoxaPortFlushData(ch, 1);
1237 tty_wakeup(tty);
1238}
1239
1240static int moxa_chars_in_buffer(struct tty_struct *tty)
1241{
1242 struct moxa_port *ch = tty->driver_data;
1243 int chars;
1244
1245 chars = MoxaPortTxQueue(ch);
1246 if (chars)
1247
1248
1249
1250
1251 set_bit(EMPTYWAIT, &ch->statusflags);
1252 return chars;
1253}
1254
1255static int moxa_tiocmget(struct tty_struct *tty)
1256{
1257 struct moxa_port *ch = tty->driver_data;
1258 int flag = 0, dtr, rts;
1259
1260 MoxaPortGetLineOut(ch, &dtr, &rts);
1261 if (dtr)
1262 flag |= TIOCM_DTR;
1263 if (rts)
1264 flag |= TIOCM_RTS;
1265 dtr = MoxaPortLineStatus(ch);
1266 if (dtr & 1)
1267 flag |= TIOCM_CTS;
1268 if (dtr & 2)
1269 flag |= TIOCM_DSR;
1270 if (dtr & 4)
1271 flag |= TIOCM_CD;
1272 return flag;
1273}
1274
1275static int moxa_tiocmset(struct tty_struct *tty,
1276 unsigned int set, unsigned int clear)
1277{
1278 struct moxa_port *ch;
1279 int dtr, rts;
1280
1281 mutex_lock(&moxa_openlock);
1282 ch = tty->driver_data;
1283 if (!ch) {
1284 mutex_unlock(&moxa_openlock);
1285 return -EINVAL;
1286 }
1287
1288 MoxaPortGetLineOut(ch, &dtr, &rts);
1289 if (set & TIOCM_RTS)
1290 rts = 1;
1291 if (set & TIOCM_DTR)
1292 dtr = 1;
1293 if (clear & TIOCM_RTS)
1294 rts = 0;
1295 if (clear & TIOCM_DTR)
1296 dtr = 0;
1297 MoxaPortLineCtrl(ch, dtr, rts);
1298 mutex_unlock(&moxa_openlock);
1299 return 0;
1300}
1301
1302static void moxa_set_termios(struct tty_struct *tty,
1303 struct ktermios *old_termios)
1304{
1305 struct moxa_port *ch = tty->driver_data;
1306
1307 if (ch == NULL)
1308 return;
1309 moxa_set_tty_param(tty, old_termios);
1310 if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
1311 wake_up_interruptible(&ch->port.open_wait);
1312}
1313
1314static void moxa_stop(struct tty_struct *tty)
1315{
1316 struct moxa_port *ch = tty->driver_data;
1317
1318 if (ch == NULL)
1319 return;
1320 MoxaPortTxDisable(ch);
1321 set_bit(TXSTOPPED, &ch->statusflags);
1322}
1323
1324
1325static void moxa_start(struct tty_struct *tty)
1326{
1327 struct moxa_port *ch = tty->driver_data;
1328
1329 if (ch == NULL)
1330 return;
1331
1332 if (!test_bit(TXSTOPPED, &ch->statusflags))
1333 return;
1334
1335 MoxaPortTxEnable(ch);
1336 clear_bit(TXSTOPPED, &ch->statusflags);
1337}
1338
1339static void moxa_hangup(struct tty_struct *tty)
1340{
1341 struct moxa_port *ch = tty->driver_data;
1342 tty_port_hangup(&ch->port);
1343}
1344
1345static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
1346{
1347 struct tty_struct *tty;
1348 unsigned long flags;
1349 dcd = !!dcd;
1350
1351 spin_lock_irqsave(&p->port.lock, flags);
1352 if (dcd != p->DCDState) {
1353 p->DCDState = dcd;
1354 spin_unlock_irqrestore(&p->port.lock, flags);
1355 tty = tty_port_tty_get(&p->port);
1356 if (tty && C_CLOCAL(tty) && !dcd)
1357 tty_hangup(tty);
1358 tty_kref_put(tty);
1359 }
1360 else
1361 spin_unlock_irqrestore(&p->port.lock, flags);
1362}
1363
1364static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
1365 u16 __iomem *ip)
1366{
1367 struct tty_struct *tty = tty_port_tty_get(&p->port);
1368 void __iomem *ofsAddr;
1369 unsigned int inited = p->port.flags & ASYNC_INITIALIZED;
1370 u16 intr;
1371
1372 if (tty) {
1373 if (test_bit(EMPTYWAIT, &p->statusflags) &&
1374 MoxaPortTxQueue(p) == 0) {
1375 clear_bit(EMPTYWAIT, &p->statusflags);
1376 tty_wakeup(tty);
1377 }
1378 if (test_bit(LOWWAIT, &p->statusflags) && !tty->stopped &&
1379 MoxaPortTxQueue(p) <= WAKEUP_CHARS) {
1380 clear_bit(LOWWAIT, &p->statusflags);
1381 tty_wakeup(tty);
1382 }
1383
1384 if (inited && !test_bit(TTY_THROTTLED, &tty->flags) &&
1385 MoxaPortRxQueue(p) > 0) {
1386 MoxaPortReadData(p);
1387 tty_schedule_flip(tty);
1388 }
1389 } else {
1390 clear_bit(EMPTYWAIT, &p->statusflags);
1391 MoxaPortFlushData(p, 0);
1392 }
1393
1394 if (!handle)
1395 goto put;
1396
1397 intr = readw(ip);
1398 if (intr == 0)
1399 goto put;
1400
1401 writew(0, ip);
1402 ofsAddr = p->tableAddr;
1403 if (intr & IntrTx)
1404 writew(readw(ofsAddr + HostStat) & ~WakeupTx,
1405 ofsAddr + HostStat);
1406
1407 if (!inited)
1408 goto put;
1409
1410 if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) {
1411 tty_insert_flip_char(tty, 0, TTY_BREAK);
1412 tty_schedule_flip(tty);
1413 }
1414
1415 if (intr & IntrLine)
1416 moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);
1417put:
1418 tty_kref_put(tty);
1419
1420 return 0;
1421}
1422
1423static void moxa_poll(unsigned long ignored)
1424{
1425 struct moxa_board_conf *brd;
1426 u16 __iomem *ip;
1427 unsigned int card, port, served = 0;
1428
1429 spin_lock(&moxa_lock);
1430 for (card = 0; card < MAX_BOARDS; card++) {
1431 brd = &moxa_boards[card];
1432 if (!brd->ready)
1433 continue;
1434
1435 served++;
1436
1437 ip = NULL;
1438 if (readb(brd->intPend) == 0xff)
1439 ip = brd->intTable + readb(brd->intNdx);
1440
1441 for (port = 0; port < brd->numPorts; port++)
1442 moxa_poll_port(&brd->ports[port], !!ip, ip + port);
1443
1444 if (ip)
1445 writeb(0, brd->intPend);
1446
1447 if (moxaLowWaterChk) {
1448 struct moxa_port *p = brd->ports;
1449 for (port = 0; port < brd->numPorts; port++, p++)
1450 if (p->lowChkFlag) {
1451 p->lowChkFlag = 0;
1452 moxa_low_water_check(p->tableAddr);
1453 }
1454 }
1455 }
1456 moxaLowWaterChk = 0;
1457
1458 if (served)
1459 mod_timer(&moxaTimer, jiffies + HZ / 50);
1460 spin_unlock(&moxa_lock);
1461}
1462
1463
1464
1465static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
1466{
1467 register struct ktermios *ts = tty->termios;
1468 struct moxa_port *ch = tty->driver_data;
1469 int rts, cts, txflow, rxflow, xany, baud;
1470
1471 rts = cts = txflow = rxflow = xany = 0;
1472 if (ts->c_cflag & CRTSCTS)
1473 rts = cts = 1;
1474 if (ts->c_iflag & IXON)
1475 txflow = 1;
1476 if (ts->c_iflag & IXOFF)
1477 rxflow = 1;
1478 if (ts->c_iflag & IXANY)
1479 xany = 1;
1480
1481
1482 ts->c_cflag &= ~CMSPAR;
1483 MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);
1484 baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));
1485 if (baud == -1)
1486 baud = tty_termios_baud_rate(old_termios);
1487
1488 tty_encode_baud_rate(tty, baud, baud);
1489}
1490
1491
1492
1493
1494
1495static void MoxaPortFlushData(struct moxa_port *port, int mode)
1496{
1497 void __iomem *ofsAddr;
1498 if (mode < 0 || mode > 2)
1499 return;
1500 ofsAddr = port->tableAddr;
1501 moxafunc(ofsAddr, FC_FlushQueue, mode);
1502 if (mode != 1) {
1503 port->lowChkFlag = 0;
1504 moxa_low_water_check(ofsAddr);
1505 }
1506}
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700static void MoxaPortEnable(struct moxa_port *port)
1701{
1702 void __iomem *ofsAddr;
1703 u16 lowwater = 512;
1704
1705 ofsAddr = port->tableAddr;
1706 writew(lowwater, ofsAddr + Low_water);
1707 if (MOXA_IS_320(port->board))
1708 moxafunc(ofsAddr, FC_SetBreakIrq, 0);
1709 else
1710 writew(readw(ofsAddr + HostStat) | WakeupBreak,
1711 ofsAddr + HostStat);
1712
1713 moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
1714 moxafunc(ofsAddr, FC_FlushQueue, 2);
1715
1716 moxafunc(ofsAddr, FC_EnableCH, Magic_code);
1717 MoxaPortLineStatus(port);
1718}
1719
1720static void MoxaPortDisable(struct moxa_port *port)
1721{
1722 void __iomem *ofsAddr = port->tableAddr;
1723
1724 moxafunc(ofsAddr, FC_SetFlowCtl, 0);
1725 moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
1726 writew(0, ofsAddr + HostStat);
1727 moxafunc(ofsAddr, FC_DisableCH, Magic_code);
1728}
1729
1730static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)
1731{
1732 void __iomem *ofsAddr = port->tableAddr;
1733 unsigned int clock, val;
1734 speed_t max;
1735
1736 max = MOXA_IS_320(port->board) ? 460800 : 921600;
1737 if (baud < 50)
1738 return 0;
1739 if (baud > max)
1740 baud = max;
1741 clock = 921600;
1742 val = clock / baud;
1743 moxafunc(ofsAddr, FC_SetBaud, val);
1744 baud = clock / val;
1745 return baud;
1746}
1747
1748static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
1749 speed_t baud)
1750{
1751 void __iomem *ofsAddr;
1752 tcflag_t mode = 0;
1753
1754 ofsAddr = port->tableAddr;
1755
1756 mode = termio->c_cflag & CSIZE;
1757 if (mode == CS5)
1758 mode = MX_CS5;
1759 else if (mode == CS6)
1760 mode = MX_CS6;
1761 else if (mode == CS7)
1762 mode = MX_CS7;
1763 else if (mode == CS8)
1764 mode = MX_CS8;
1765
1766 if (termio->c_cflag & CSTOPB) {
1767 if (mode == MX_CS5)
1768 mode |= MX_STOP15;
1769 else
1770 mode |= MX_STOP2;
1771 } else
1772 mode |= MX_STOP1;
1773
1774 if (termio->c_cflag & PARENB) {
1775 if (termio->c_cflag & PARODD)
1776 mode |= MX_PARODD;
1777 else
1778 mode |= MX_PAREVEN;
1779 } else
1780 mode |= MX_PARNONE;
1781
1782 moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);
1783
1784 if (MOXA_IS_320(port->board) && baud >= 921600)
1785 return -1;
1786
1787 baud = MoxaPortSetBaud(port, baud);
1788
1789 if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
1790 spin_lock_irq(&moxafunc_lock);
1791 writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
1792 writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
1793 writeb(FC_SetXonXoff, ofsAddr + FuncCode);
1794 moxa_wait_finish(ofsAddr);
1795 spin_unlock_irq(&moxafunc_lock);
1796
1797 }
1798 return baud;
1799}
1800
1801static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
1802 int *rtsState)
1803{
1804 if (dtrState)
1805 *dtrState = !!(port->lineCtrl & DTR_ON);
1806 if (rtsState)
1807 *rtsState = !!(port->lineCtrl & RTS_ON);
1808
1809 return 0;
1810}
1811
1812static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
1813{
1814 u8 mode = 0;
1815
1816 if (dtr)
1817 mode |= DTR_ON;
1818 if (rts)
1819 mode |= RTS_ON;
1820 port->lineCtrl = mode;
1821 moxafunc(port->tableAddr, FC_LineControl, mode);
1822}
1823
1824static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,
1825 int txflow, int rxflow, int txany)
1826{
1827 int mode = 0;
1828
1829 if (rts)
1830 mode |= RTS_FlowCtl;
1831 if (cts)
1832 mode |= CTS_FlowCtl;
1833 if (txflow)
1834 mode |= Tx_FlowCtl;
1835 if (rxflow)
1836 mode |= Rx_FlowCtl;
1837 if (txany)
1838 mode |= IXM_IXANY;
1839 moxafunc(port->tableAddr, FC_SetFlowCtl, mode);
1840}
1841
1842static int MoxaPortLineStatus(struct moxa_port *port)
1843{
1844 void __iomem *ofsAddr;
1845 int val;
1846
1847 ofsAddr = port->tableAddr;
1848 if (MOXA_IS_320(port->board))
1849 val = moxafuncret(ofsAddr, FC_LineStatus, 0);
1850 else
1851 val = readw(ofsAddr + FlagStat) >> 4;
1852 val &= 0x0B;
1853 if (val & 8)
1854 val |= 4;
1855 moxa_new_dcdstate(port, val & 8);
1856 val &= 7;
1857 return val;
1858}
1859
1860static int MoxaPortWriteData(struct tty_struct *tty,
1861 const unsigned char *buffer, int len)
1862{
1863 struct moxa_port *port = tty->driver_data;
1864 void __iomem *baseAddr, *ofsAddr, *ofs;
1865 unsigned int c, total;
1866 u16 head, tail, tx_mask, spage, epage;
1867 u16 pageno, pageofs, bufhead;
1868
1869 ofsAddr = port->tableAddr;
1870 baseAddr = port->board->basemem;
1871 tx_mask = readw(ofsAddr + TX_mask);
1872 spage = readw(ofsAddr + Page_txb);
1873 epage = readw(ofsAddr + EndPage_txb);
1874 tail = readw(ofsAddr + TXwptr);
1875 head = readw(ofsAddr + TXrptr);
1876 c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
1877 if (c > len)
1878 c = len;
1879 moxaLog.txcnt[port->port.tty->index] += c;
1880 total = c;
1881 if (spage == epage) {
1882 bufhead = readw(ofsAddr + Ofs_txb);
1883 writew(spage, baseAddr + Control_reg);
1884 while (c > 0) {
1885 if (head > tail)
1886 len = head - tail - 1;
1887 else
1888 len = tx_mask + 1 - tail;
1889 len = (c > len) ? len : c;
1890 ofs = baseAddr + DynPage_addr + bufhead + tail;
1891 memcpy_toio(ofs, buffer, len);
1892 buffer += len;
1893 tail = (tail + len) & tx_mask;
1894 c -= len;
1895 }
1896 } else {
1897 pageno = spage + (tail >> 13);
1898 pageofs = tail & Page_mask;
1899 while (c > 0) {
1900 len = Page_size - pageofs;
1901 if (len > c)
1902 len = c;
1903 writeb(pageno, baseAddr + Control_reg);
1904 ofs = baseAddr + DynPage_addr + pageofs;
1905 memcpy_toio(ofs, buffer, len);
1906 buffer += len;
1907 if (++pageno == epage)
1908 pageno = spage;
1909 pageofs = 0;
1910 c -= len;
1911 }
1912 tail = (tail + total) & tx_mask;
1913 }
1914 writew(tail, ofsAddr + TXwptr);
1915 writeb(1, ofsAddr + CD180TXirq);
1916 return total;
1917}
1918
1919static int MoxaPortReadData(struct moxa_port *port)
1920{
1921 struct tty_struct *tty = port->port.tty;
1922 unsigned char *dst;
1923 void __iomem *baseAddr, *ofsAddr, *ofs;
1924 unsigned int count, len, total;
1925 u16 tail, rx_mask, spage, epage;
1926 u16 pageno, pageofs, bufhead, head;
1927
1928 ofsAddr = port->tableAddr;
1929 baseAddr = port->board->basemem;
1930 head = readw(ofsAddr + RXrptr);
1931 tail = readw(ofsAddr + RXwptr);
1932 rx_mask = readw(ofsAddr + RX_mask);
1933 spage = readw(ofsAddr + Page_rxb);
1934 epage = readw(ofsAddr + EndPage_rxb);
1935 count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
1936 if (count == 0)
1937 return 0;
1938
1939 total = count;
1940 moxaLog.rxcnt[tty->index] += total;
1941 if (spage == epage) {
1942 bufhead = readw(ofsAddr + Ofs_rxb);
1943 writew(spage, baseAddr + Control_reg);
1944 while (count > 0) {
1945 ofs = baseAddr + DynPage_addr + bufhead + head;
1946 len = (tail >= head) ? (tail - head) :
1947 (rx_mask + 1 - head);
1948 len = tty_prepare_flip_string(tty, &dst,
1949 min(len, count));
1950 memcpy_fromio(dst, ofs, len);
1951 head = (head + len) & rx_mask;
1952 count -= len;
1953 }
1954 } else {
1955 pageno = spage + (head >> 13);
1956 pageofs = head & Page_mask;
1957 while (count > 0) {
1958 writew(pageno, baseAddr + Control_reg);
1959 ofs = baseAddr + DynPage_addr + pageofs;
1960 len = tty_prepare_flip_string(tty, &dst,
1961 min(Page_size - pageofs, count));
1962 memcpy_fromio(dst, ofs, len);
1963
1964 count -= len;
1965 pageofs = (pageofs + len) & Page_mask;
1966 if (pageofs == 0 && ++pageno == epage)
1967 pageno = spage;
1968 }
1969 head = (head + total) & rx_mask;
1970 }
1971 writew(head, ofsAddr + RXrptr);
1972 if (readb(ofsAddr + FlagStat) & Xoff_state) {
1973 moxaLowWaterChk = 1;
1974 port->lowChkFlag = 1;
1975 }
1976 return total;
1977}
1978
1979
1980static int MoxaPortTxQueue(struct moxa_port *port)
1981{
1982 void __iomem *ofsAddr = port->tableAddr;
1983 u16 rptr, wptr, mask;
1984
1985 rptr = readw(ofsAddr + TXrptr);
1986 wptr = readw(ofsAddr + TXwptr);
1987 mask = readw(ofsAddr + TX_mask);
1988 return (wptr - rptr) & mask;
1989}
1990
1991static int MoxaPortTxFree(struct moxa_port *port)
1992{
1993 void __iomem *ofsAddr = port->tableAddr;
1994 u16 rptr, wptr, mask;
1995
1996 rptr = readw(ofsAddr + TXrptr);
1997 wptr = readw(ofsAddr + TXwptr);
1998 mask = readw(ofsAddr + TX_mask);
1999 return mask - ((wptr - rptr) & mask);
2000}
2001
2002static int MoxaPortRxQueue(struct moxa_port *port)
2003{
2004 void __iomem *ofsAddr = port->tableAddr;
2005 u16 rptr, wptr, mask;
2006
2007 rptr = readw(ofsAddr + RXrptr);
2008 wptr = readw(ofsAddr + RXwptr);
2009 mask = readw(ofsAddr + RX_mask);
2010 return (wptr - rptr) & mask;
2011}
2012
2013static void MoxaPortTxDisable(struct moxa_port *port)
2014{
2015 moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
2016}
2017
2018static void MoxaPortTxEnable(struct moxa_port *port)
2019{
2020 moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
2021}
2022
2023static int moxa_get_serial_info(struct moxa_port *info,
2024 struct serial_struct __user *retinfo)
2025{
2026 struct serial_struct tmp = {
2027 .type = info->type,
2028 .line = info->port.tty->index,
2029 .flags = info->port.flags,
2030 .baud_base = 921600,
2031 .close_delay = info->port.close_delay
2032 };
2033 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2034}
2035
2036
2037static int moxa_set_serial_info(struct moxa_port *info,
2038 struct serial_struct __user *new_info)
2039{
2040 struct serial_struct new_serial;
2041
2042 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2043 return -EFAULT;
2044
2045 if (new_serial.irq != 0 || new_serial.port != 0 ||
2046 new_serial.custom_divisor != 0 ||
2047 new_serial.baud_base != 921600)
2048 return -EPERM;
2049
2050 if (!capable(CAP_SYS_ADMIN)) {
2051 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
2052 (info->port.flags & ~ASYNC_USR_MASK)))
2053 return -EPERM;
2054 } else
2055 info->port.close_delay = new_serial.close_delay * HZ / 100;
2056
2057 new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
2058 new_serial.flags |= (info->port.flags & ASYNC_FLAGS);
2059
2060 MoxaSetFifo(info, new_serial.type == PORT_16550A);
2061
2062 info->type = new_serial.type;
2063 return 0;
2064}
2065
2066
2067
2068
2069
2070
2071
2072static void MoxaSetFifo(struct moxa_port *port, int enable)
2073{
2074 void __iomem *ofsAddr = port->tableAddr;
2075
2076 if (!enable) {
2077 moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
2078 moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
2079 } else {
2080 moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
2081 moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
2082 }
2083}
2084
