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