]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blame - drivers/char/moxa.c
projects / mirror_ubuntu-focal-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Char: moxa, ioctl cleanup
[mirror_ubuntu-focal-kernel.git] / drivers / char / moxa.c
CommitLineData
1da177e4
LT		 1/*****************************************************************************/
2/*
3 * moxa.c -- MOXA Intellio family multiport serial driver.
4 *
5 * Copyright (C) 1999-2000 Moxa Technologies (support@moxa.com.tw).
6 *
7 * This code is loosely based on the Linux serial driver, written by
8 * Linus Torvalds, Theodore T'so and others.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
1da177e4
LT		 14 */
15
16/*
17 * MOXA Intellio Series Driver
18 * for : LINUX
19 * date : 1999/1/7
20 * version : 5.1
21 */
22
1da177e4
LT		 23#include <linux/module.h>
24#include <linux/types.h>
25#include <linux/mm.h>
26#include <linux/ioport.h>
27#include <linux/errno.h>
03718234 28#include <linux/firmware.h>
1da177e4
LT		 29#include <linux/signal.h>
30#include <linux/sched.h>
31#include <linux/timer.h>
32#include <linux/interrupt.h>
33#include <linux/tty.h>
34#include <linux/tty_flip.h>
35#include <linux/major.h>
36#include <linux/string.h>
37#include <linux/fcntl.h>
38#include <linux/ptrace.h>
39#include <linux/serial.h>
40#include <linux/tty_driver.h>
41#include <linux/delay.h>
42#include <linux/pci.h>
43#include <linux/init.h>
44#include <linux/bitops.h>
95e07914 45#include <linux/completion.h>
1da177e4
LT		 46
47#include <asm/system.h>
48#include <asm/io.h>
49#include <asm/uaccess.h>
50
03718234
JS		 51#include "moxa.h"
52
11324edd 53#define MOXA_VERSION "5.1k"
1da177e4 54
03718234
JS		 55#define MOXA_FW_HDRLEN 32
56
11324edd
JS		 57#define MOXAMAJOR 172
58#define MOXACUMAJOR 173
1da177e4 59
11324edd 60#define MAX_BOARDS 4 /* Don't change this value */
1da177e4 61#define MAX_PORTS_PER_BOARD 32 /* Don't change this value */
11324edd 62#define MAX_PORTS (MAX_BOARDS * MAX_PORTS_PER_BOARD)
1da177e4
LT		 63
64/*
65 * Define the Moxa PCI vendor and device IDs.
66 */
11324edd
JS		 67#define MOXA_BUS_TYPE_ISA 0
68#define MOXA_BUS_TYPE_PCI 1
1da177e4 69
1da177e4
LT		 70enum {
71 MOXA_BOARD_C218_PCI = 1,
72 MOXA_BOARD_C218_ISA,
73 MOXA_BOARD_C320_PCI,
74 MOXA_BOARD_C320_ISA,
75 MOXA_BOARD_CP204J,
76};
77
78static char *moxa_brdname[] =
79{
80 "C218 Turbo PCI series",
81 "C218 Turbo ISA series",
82 "C320 Turbo PCI series",
83 "C320 Turbo ISA series",
84 "CP-204J series",
85};
86
87#ifdef CONFIG_PCI
88static struct pci_device_id moxa_pcibrds[] = {
5ebb4078
JS		 89 { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),
90 .driver_data = MOXA_BOARD_C218_PCI },
91 { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),
92 .driver_data = MOXA_BOARD_C320_PCI },
93 { PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),
94 .driver_data = MOXA_BOARD_CP204J },
1da177e4
LT		 95 { 0 }
96};
97MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
98#endif /* CONFIG_PCI */
99
03718234
JS		 100struct moxa_port;
101
8f8ecbad 102static struct moxa_board_conf {
1da177e4
LT		 103 int boardType;
104 int numPorts;
1da177e4 105 int busType;
8f8ecbad 106
810ab09b 107 unsigned int ready;
8f8ecbad 108
03718234
JS		 109 struct moxa_port *ports;
110
8f8ecbad
JS		 111 void __iomem *basemem;
112 void __iomem *intNdx;
113 void __iomem *intPend;
114 void __iomem *intTable;
115} moxa_boards[MAX_BOARDS];
116
117struct mxser_mstatus {
118 tcflag_t cflag;
119 int cts;
120 int dsr;
121 int ri;
122 int dcd;
9dff89cd 123};
1da177e4 124
8f8ecbad
JS		 125struct moxaq_str {
126 int inq;
127 int outq;
128};
1da177e4 129
8f8ecbad 130struct moxa_port {
b4173f45 131 struct moxa_board_conf *board;
1da177e4 132 int type;
1da177e4 133 int close_delay;
1da177e4
LT		 134 int count;
135 int blocked_open;
1da177e4
LT		 136 int asyncflags;
137 unsigned long statusflags;
138 struct tty_struct *tty;
139 int cflag;
140 wait_queue_head_t open_wait;
95e07914 141 struct completion close_wait;
1da177e4 142
8f8ecbad 143 struct timer_list emptyTimer;
1da177e4 144
8f8ecbad
JS		 145 char lineCtrl;
146 void __iomem *tableAddr;
8f8ecbad
JS		 147 char DCDState;
148 char lowChkFlag;
149
150 ushort breakCnt;
151};
1da177e4 152
74d7d97b
JS		 153struct mon_str {
154 int tick;
155 int rxcnt[MAX_PORTS];
156 int txcnt[MAX_PORTS];
157};
158
1da177e4
LT		 159/* statusflags */
160#define TXSTOPPED 0x1
161#define LOWWAIT 0x2
162#define EMPTYWAIT 0x4
163#define THROTTLE 0x8
164
1da177e4
LT		 165#define SERIAL_DO_RESTART
166
1da177e4
LT		 167#define WAKEUP_CHARS 256
168
1da177e4 169static int ttymajor = MOXAMAJOR;
74d7d97b
JS		 170static struct mon_str moxaLog;
171static unsigned int moxaFuncTout = HZ / 2;
1da177e4
LT		 172/* Variables for insmod */
173#ifdef MODULE
d353eca4
JS		 174static unsigned long baseaddr[MAX_BOARDS];
175static unsigned int type[MAX_BOARDS];
176static unsigned int numports[MAX_BOARDS];
1da177e4
LT		 177#endif
178
179MODULE_AUTHOR("William Chen");
180MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
181MODULE_LICENSE("GPL");
182#ifdef MODULE
d353eca4
JS		 183module_param_array(type, uint, NULL, 0);
184MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
185module_param_array(baseaddr, ulong, NULL, 0);
186MODULE_PARM_DESC(baseaddr, "base address");
187module_param_array(numports, uint, NULL, 0);
188MODULE_PARM_DESC(numports, "numports (ignored for C218)");
1da177e4
LT		 189#endif
190module_param(ttymajor, int, 0);
1da177e4 191
1da177e4
LT		 192/*
193 * static functions:
194 */
1da177e4
LT		 195static int moxa_open(struct tty_struct *, struct file *);
196static void moxa_close(struct tty_struct *, struct file *);
197static int moxa_write(struct tty_struct *, const unsigned char *, int);
198static int moxa_write_room(struct tty_struct *);
199static void moxa_flush_buffer(struct tty_struct *);
200static int moxa_chars_in_buffer(struct tty_struct *);
201static void moxa_flush_chars(struct tty_struct *);
202static void moxa_put_char(struct tty_struct *, unsigned char);
1da177e4
LT		 203static void moxa_throttle(struct tty_struct *);
204static void moxa_unthrottle(struct tty_struct *);
606d099c 205static void moxa_set_termios(struct tty_struct *, struct ktermios *);
1da177e4
LT		 206static void moxa_stop(struct tty_struct *);
207static void moxa_start(struct tty_struct *);
208static void moxa_hangup(struct tty_struct *);
209static int moxa_tiocmget(struct tty_struct *tty, struct file *file);
210static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
211 unsigned int set, unsigned int clear);
212static void moxa_poll(unsigned long);
db1acaa6 213static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
6f56b658 214static int moxa_block_till_ready(struct tty_struct *, struct file *,
8f8ecbad 215 struct moxa_port *);
6f56b658
JS		 216static void moxa_setup_empty_event(struct tty_struct *);
217static void moxa_check_xmit_empty(unsigned long);
218static void moxa_shut_down(struct moxa_port *);
219static void moxa_receive_data(struct moxa_port *);
1da177e4
LT		 220/*
221 * moxa board interface functions:
222 */
1da177e4 223static int MoxaDriverPoll(void);
b4173f45
JS		 224static void MoxaPortEnable(struct moxa_port *);
225static void MoxaPortDisable(struct moxa_port *);
226static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);
227static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);
228static void MoxaPortLineCtrl(struct moxa_port *, int, int);
229static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
230static int MoxaPortLineStatus(struct moxa_port *);
231static int MoxaPortDCDChange(struct moxa_port *);
232static int MoxaPortDCDON(struct moxa_port *);
233static void MoxaPortFlushData(struct moxa_port *, int);
234static int MoxaPortWriteData(struct moxa_port *, unsigned char *, int);
235static int MoxaPortReadData(struct moxa_port *, struct tty_struct *tty);
236static int MoxaPortTxQueue(struct moxa_port *);
237static int MoxaPortRxQueue(struct moxa_port *);
238static int MoxaPortTxFree(struct moxa_port *);
239static void MoxaPortTxDisable(struct moxa_port *);
240static void MoxaPortTxEnable(struct moxa_port *);
241static int MoxaPortResetBrkCnt(struct moxa_port *);
8f8ecbad
JS		 242static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
243static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
b4173f45 244static void MoxaSetFifo(struct moxa_port *port, int enable);
1da177e4 245
74d7d97b
JS		 246/*
247 * I/O functions
248 */
249
250static void moxa_wait_finish(void __iomem *ofsAddr)
251{
252 unsigned long end = jiffies + moxaFuncTout;
253
254 while (readw(ofsAddr + FuncCode) != 0)
255 if (time_after(jiffies, end))
256 return;
257 if (readw(ofsAddr + FuncCode) != 0 && printk_ratelimit())
258 printk(KERN_WARNING "moxa function expired\n");
259}
260
261static void moxafunc(void __iomem *ofsAddr, int cmd, ushort arg)
262{
263 writew(arg, ofsAddr + FuncArg);
264 writew(cmd, ofsAddr + FuncCode);
265 moxa_wait_finish(ofsAddr);
266}
267
268/*
269 * TTY operations
270 */
271
272static int moxa_ioctl(struct tty_struct *tty, struct file *file,
273 unsigned int cmd, unsigned long arg)
274{
275 struct moxa_port *ch = tty->driver_data;
276 void __user *argp = (void __user *)arg;
277 int status;
278
279 if (tty->index == MAX_PORTS) {
280 if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
281 cmd != MOXA_GETMSTATUS)
282 return -EINVAL;
283 } else if (!ch)
284 return -ENODEV;
285
286 switch (cmd) {
287 case MOXA_GETDATACOUNT:
288 moxaLog.tick = jiffies;
289 return copy_to_user(argp, &moxaLog, sizeof(moxaLog)) ?
290 -EFAULT : 0;
291 case MOXA_FLUSH_QUEUE:
292 MoxaPortFlushData(ch, arg);
293 return 0;
294 case MOXA_GET_IOQUEUE: {
295 struct moxaq_str __user *argm = argp;
296 struct moxaq_str tmp;
297 struct moxa_port *p;
298 unsigned int i, j;
299
300 for (i = 0; i < MAX_BOARDS; i++) {
301 p = moxa_boards[i].ports;
302 for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
303 memset(&tmp, 0, sizeof(tmp));
304 if (moxa_boards[i].ready) {
305 tmp.inq = MoxaPortRxQueue(p);
306 tmp.outq = MoxaPortTxQueue(p);
307 }
308 if (copy_to_user(argm, &tmp, sizeof(tmp)))
309 return -EFAULT;
310 }
311 }
312 return 0;
313 } case MOXA_GET_OQUEUE:
314 status = MoxaPortTxQueue(ch);
315 return put_user(status, (unsigned long __user *)argp);
316 case MOXA_GET_IQUEUE:
317 status = MoxaPortRxQueue(ch);
318 return put_user(status, (unsigned long __user *)argp);
319 case MOXA_GETMSTATUS: {
320 struct mxser_mstatus __user *argm = argp;
321 struct mxser_mstatus tmp;
322 struct moxa_port *p;
323 unsigned int i, j;
324
325 for (i = 0; i < MAX_BOARDS; i++) {
326 p = moxa_boards[i].ports;
327 for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
328 memset(&tmp, 0, sizeof(tmp));
329 if (!moxa_boards[i].ready)
330 goto copy;
331
332 status = MoxaPortLineStatus(p);
333 if (status & 1)
334 tmp.cts = 1;
335 if (status & 2)
336 tmp.dsr = 1;
337 if (status & 4)
338 tmp.dcd = 1;
339
340 if (!p->tty || !p->tty->termios)
341 tmp.cflag = p->cflag;
342 else
343 tmp.cflag = p->tty->termios->c_cflag;
344copy:
345 if (copy_to_user(argm, &tmp, sizeof(tmp)))
346 return -EFAULT;
347 }
348 }
349 return 0;
350 }
351 case TIOCGSERIAL:
352 return moxa_get_serial_info(ch, argp);
353 case TIOCSSERIAL:
354 return moxa_set_serial_info(ch, argp);
355 }
356 return -ENOIOCTLCMD;
357}
358
359static void moxa_break_ctl(struct tty_struct *tty, int state)
360{
361 struct moxa_port *port = tty->driver_data;
362
363 moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,
364 Magic_code);
365}
366
b68e31d0 367static const struct tty_operations moxa_ops = {
1da177e4
LT		 368 .open = moxa_open,
369 .close = moxa_close,
370 .write = moxa_write,
371 .write_room = moxa_write_room,
372 .flush_buffer = moxa_flush_buffer,
373 .chars_in_buffer = moxa_chars_in_buffer,
374 .flush_chars = moxa_flush_chars,
375 .put_char = moxa_put_char,
376 .ioctl = moxa_ioctl,
377 .throttle = moxa_throttle,
378 .unthrottle = moxa_unthrottle,
379 .set_termios = moxa_set_termios,
380 .stop = moxa_stop,
381 .start = moxa_start,
382 .hangup = moxa_hangup,
74d7d97b 383 .break_ctl = moxa_break_ctl,
1da177e4
LT		 384 .tiocmget = moxa_tiocmget,
385 .tiocmset = moxa_tiocmset,
386};
387
aa7e5221 388static struct tty_driver *moxaDriver;
aa7e5221 389static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);
34af946a 390static DEFINE_SPINLOCK(moxa_lock);
33f0f88f 391
74d7d97b
JS		 392/*
393 * HW init
394 */
395
03718234
JS		 396static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)
397{
398 switch (brd->boardType) {
399 case MOXA_BOARD_C218_ISA:
400 case MOXA_BOARD_C218_PCI:
401 if (model != 1)
402 goto err;
403 break;
404 case MOXA_BOARD_CP204J:
405 if (model != 3)
406 goto err;
407 break;
408 default:
409 if (model != 2)
410 goto err;
411 break;
412 }
413 return 0;
414err:
415 return -EINVAL;
416}
417
418static int moxa_check_fw(const void *ptr)
419{
420 const __le16 *lptr = ptr;
421
422 if (*lptr != cpu_to_le16(0x7980))
423 return -EINVAL;
424
425 return 0;
426}
427
428static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
429 size_t len)
430{
431 void __iomem *baseAddr = brd->basemem;
432 u16 tmp;
433
434 writeb(HW_reset, baseAddr + Control_reg); /* reset */
435 msleep(10);
436 memset_io(baseAddr, 0, 4096);
437 memcpy_toio(baseAddr, buf, len); /* download BIOS */
438 writeb(0, baseAddr + Control_reg); /* restart */
439
440 msleep(2000);
441
442 switch (brd->boardType) {
443 case MOXA_BOARD_C218_ISA:
444 case MOXA_BOARD_C218_PCI:
445 tmp = readw(baseAddr + C218_key);
446 if (tmp != C218_KeyCode)
447 goto err;
448 break;
449 case MOXA_BOARD_CP204J:
450 tmp = readw(baseAddr + C218_key);
451 if (tmp != CP204J_KeyCode)
452 goto err;
453 break;
454 default:
455 tmp = readw(baseAddr + C320_key);
456 if (tmp != C320_KeyCode)
457 goto err;
458 tmp = readw(baseAddr + C320_status);
459 if (tmp != STS_init) {
460 printk(KERN_ERR "moxa: bios upload failed -- CPU/Basic "
461 "module not found\n");
462 return -EIO;
463 }
464 break;
465 }
466
467 return 0;
468err:
469 printk(KERN_ERR "moxa: bios upload failed -- board not found\n");
470 return -EIO;
471}
472
473static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
474 size_t len)
475{
476 void __iomem *baseAddr = brd->basemem;
477
478 if (len < 7168) {
479 printk(KERN_ERR "moxa: invalid 320 bios -- too short\n");
480 return -EINVAL;
481 }
482
483 writew(len - 7168 - 2, baseAddr + C320bapi_len);
484 writeb(1, baseAddr + Control_reg); /* Select Page 1 */
485 memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);
486 writeb(2, baseAddr + Control_reg); /* Select Page 2 */
487 memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);
488
489 return 0;
490}
491
5292bcd3 492static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,
03718234
JS		 493 size_t len)
494{
495 void __iomem *baseAddr = brd->basemem;
496 const u16 *uptr = ptr;
497 size_t wlen, len2, j;
5292bcd3
JS		 498 unsigned long key, loadbuf, loadlen, checksum, checksum_ok;
499 unsigned int i, retry, c320;
03718234
JS		 500 u16 usum, keycode;
501
5292bcd3
JS		 502 c320 = brd->boardType == MOXA_BOARD_C320_PCI ||
503 brd->boardType == MOXA_BOARD_C320_ISA;
504 keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :
505 C218_KeyCode;
03718234 506
5292bcd3
JS		 507 switch (brd->boardType) {
508 case MOXA_BOARD_CP204J:
509 case MOXA_BOARD_C218_ISA:
510 case MOXA_BOARD_C218_PCI:
511 key = C218_key;
512 loadbuf = C218_LoadBuf;
513 loadlen = C218DLoad_len;
514 checksum = C218check_sum;
515 checksum_ok = C218chksum_ok;
516 break;
517 default:
518 key = C320_key;
519 keycode = C320_KeyCode;
520 loadbuf = C320_LoadBuf;
521 loadlen = C320DLoad_len;
522 checksum = C320check_sum;
523 checksum_ok = C320chksum_ok;
524 break;
03718234 525 }
03718234
JS		 526
527 usum = 0;
528 wlen = len >> 1;
529 for (i = 0; i < wlen; i++)
530 usum += le16_to_cpu(uptr[i]);
531 retry = 0;
532 do {
533 wlen = len >> 1;
534 j = 0;
535 while (wlen) {
536 len2 = (wlen > 2048) ? 2048 : wlen;
537 wlen -= len2;
5292bcd3 538 memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);
03718234 539 j += len2 << 1;
5292bcd3
JS		 540
541 writew(len2, baseAddr + loadlen);
542 writew(0, baseAddr + key);
543 for (i = 0; i < 100; i++) {
544 if (readw(baseAddr + key) == keycode)
03718234
JS		 545 break;
546 msleep(10);
547 }
5292bcd3 548 if (readw(baseAddr + key) != keycode)
03718234
JS		 549 return -EIO;
550 }
5292bcd3
JS		 551 writew(0, baseAddr + loadlen);
552 writew(usum, baseAddr + checksum);
553 writew(0, baseAddr + key);
554 for (i = 0; i < 100; i++) {
555 if (readw(baseAddr + key) == keycode)
03718234
JS		 556 break;
557 msleep(10);
558 }
559 retry++;
5292bcd3
JS		 560 } while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));
561 if (readb(baseAddr + checksum_ok) != 1)
03718234
JS		 562 return -EIO;
563
5292bcd3 564 writew(0, baseAddr + key);
03718234
JS		 565 for (i = 0; i < 600; i++) {
566 if (readw(baseAddr + Magic_no) == Magic_code)
567 break;
568 msleep(10);
569 }
570 if (readw(baseAddr + Magic_no) != Magic_code)
571 return -EIO;
572
5292bcd3
JS		 573 if (c320) {
574 if (brd->busType == MOXA_BUS_TYPE_PCI) { /* ASIC board */
575 writew(0x3800, baseAddr + TMS320_PORT1);
576 writew(0x3900, baseAddr + TMS320_PORT2);
577 writew(28499, baseAddr + TMS320_CLOCK);
578 } else {
579 writew(0x3200, baseAddr + TMS320_PORT1);
580 writew(0x3400, baseAddr + TMS320_PORT2);
581 writew(19999, baseAddr + TMS320_CLOCK);
582 }
03718234
JS		 583 }
584 writew(1, baseAddr + Disable_IRQ);
585 writew(0, baseAddr + Magic_no);
586 for (i = 0; i < 500; i++) {
587 if (readw(baseAddr + Magic_no) == Magic_code)
588 break;
589 msleep(10);
590 }
591 if (readw(baseAddr + Magic_no) != Magic_code)
592 return -EIO;
593
5292bcd3
JS		 594 if (c320) {
595 j = readw(baseAddr + Module_cnt);
596 if (j <= 0)
597 return -EIO;
598 brd->numPorts = j * 8;
599 writew(j, baseAddr + Module_no);
600 writew(0, baseAddr + Magic_no);
601 for (i = 0; i < 600; i++) {
602 if (readw(baseAddr + Magic_no) == Magic_code)
603 break;
604 msleep(10);
605 }
606 if (readw(baseAddr + Magic_no) != Magic_code)
607 return -EIO;
03718234 608 }
03718234
JS		 609 brd->intNdx = baseAddr + IRQindex;
610 brd->intPend = baseAddr + IRQpending;
611 brd->intTable = baseAddr + IRQtable;
612
613 return 0;
614}
615
616static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
617 size_t len)
618{
619 void __iomem *ofsAddr, *baseAddr = brd->basemem;
620 struct moxa_port *port;
621 int retval, i;
622
623 if (len % 2) {
5292bcd3 624 printk(KERN_ERR "moxa: bios length is not even\n");
03718234
JS		 625 return -EINVAL;
626 }
627
5292bcd3
JS		 628 retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */
629 if (retval)
630 return retval;
631
03718234
JS		 632 switch (brd->boardType) {
633 case MOXA_BOARD_C218_ISA:
634 case MOXA_BOARD_C218_PCI:
635 case MOXA_BOARD_CP204J:
03718234
JS		 636 port = brd->ports;
637 for (i = 0; i < brd->numPorts; i++, port++) {
b4173f45 638 port->board = brd;
03718234
JS		 639 port->DCDState = 0;
640 port->tableAddr = baseAddr + Extern_table +
641 Extern_size * i;
642 ofsAddr = port->tableAddr;
643 writew(C218rx_mask, ofsAddr + RX_mask);
644 writew(C218tx_mask, ofsAddr + TX_mask);
645 writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
646 writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);
647
648 writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
649 writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);
650
651 }
652 break;
653 default:
03718234
JS		 654 port = brd->ports;
655 for (i = 0; i < brd->numPorts; i++, port++) {
b4173f45 656 port->board = brd;
03718234
JS		 657 port->DCDState = 0;
658 port->tableAddr = baseAddr + Extern_table +
659 Extern_size * i;
660 ofsAddr = port->tableAddr;
661 switch (brd->numPorts) {
662 case 8:
663 writew(C320p8rx_mask, ofsAddr + RX_mask);
664 writew(C320p8tx_mask, ofsAddr + TX_mask);
665 writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
666 writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
667 writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
668 writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);
669
670 break;
671 case 16:
672 writew(C320p16rx_mask, ofsAddr + RX_mask);
673 writew(C320p16tx_mask, ofsAddr + TX_mask);
674 writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
675 writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
676 writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
677 writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
678 break;
679
680 case 24:
681 writew(C320p24rx_mask, ofsAddr + RX_mask);
682 writew(C320p24tx_mask, ofsAddr + TX_mask);
683 writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
684 writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
685 writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
686 writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
687 break;
688 case 32:
689 writew(C320p32rx_mask, ofsAddr + RX_mask);
690 writew(C320p32tx_mask, ofsAddr + TX_mask);
691 writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
692 writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
693 writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
694 writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
695 writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
696 break;
697 }
698 }
699 break;
700 }
03718234
JS		 701 return 0;
702}
703
704static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
705{
706 void *ptr = fw->data;
707 char rsn[64];
708 u16 lens[5];
709 size_t len;
710 unsigned int a, lenp, lencnt;
711 int ret = -EINVAL;
712 struct {
713 __le32 magic; /* 0x34303430 */
714 u8 reserved1[2];
715 u8 type; /* UNIX = 3 */
716 u8 model; /* C218T=1, C320T=2, CP204=3 */
717 u8 reserved2[8];
718 __le16 len[5];
719 } *hdr = ptr;
720
721 BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));
722
723 if (fw->size < MOXA_FW_HDRLEN) {
724 strcpy(rsn, "too short (even header won't fit)");
725 goto err;
726 }
727 if (hdr->magic != cpu_to_le32(0x30343034)) {
728 sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));
729 goto err;
730 }
731 if (hdr->type != 3) {
732 sprintf(rsn, "not for linux, type is %u", hdr->type);
733 goto err;
734 }
735 if (moxa_check_fw_model(brd, hdr->model)) {
736 sprintf(rsn, "not for this card, model is %u", hdr->model);
737 goto err;
738 }
739
740 len = MOXA_FW_HDRLEN;
741 lencnt = hdr->model == 2 ? 5 : 3;
742 for (a = 0; a < ARRAY_SIZE(lens); a++) {
743 lens[a] = le16_to_cpu(hdr->len[a]);
744 if (lens[a] && len + lens[a] <= fw->size &&
745 moxa_check_fw(&fw->data[len]))
746 printk(KERN_WARNING "moxa firmware: unexpected input "
747 "at offset %u, but going on\n", (u32)len);
748 if (!lens[a] && a < lencnt) {
749 sprintf(rsn, "too few entries in fw file");
750 goto err;
751 }
752 len += lens[a];
753 }
754
755 if (len != fw->size) {
756 sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,
757 (u32)len);
758 goto err;
759 }
760
761 ptr += MOXA_FW_HDRLEN;
762 lenp = 0; /* bios */
763
764 strcpy(rsn, "read above");
765
766 ret = moxa_load_bios(brd, ptr, lens[lenp]);
767 if (ret)
768 goto err;
769
770 /* we skip the tty section (lens[1]), since we don't need it */
771 ptr += lens[lenp] + lens[lenp + 1];
772 lenp += 2; /* comm */
773
774 if (hdr->model == 2) {
775 ret = moxa_load_320b(brd, ptr, lens[lenp]);
776 if (ret)
777 goto err;
778 /* skip another tty */
779 ptr += lens[lenp] + lens[lenp + 1];
780 lenp += 2;
781 }
782
783 ret = moxa_load_code(brd, ptr, lens[lenp]);
784 if (ret)
785 goto err;
786
787 return 0;
788err:
789 printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);
790 return ret;
791}
792
793static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
794{
795 const struct firmware *fw;
796 const char *file;
810ab09b
JS		 797 struct moxa_port *p;
798 unsigned int i;
03718234
JS		 799 int ret;
800
810ab09b
JS		 801 brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),
802 GFP_KERNEL);
803 if (brd->ports == NULL) {
804 printk(KERN_ERR "cannot allocate memory for ports\n");
805 ret = -ENOMEM;
806 goto err;
807 }
808
809 for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {
810 p->type = PORT_16550A;
811 p->close_delay = 5 * HZ / 10;
812 p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
813 init_waitqueue_head(&p->open_wait);
814 init_completion(&p->close_wait);
815
816 setup_timer(&p->emptyTimer, moxa_check_xmit_empty,
817 (unsigned long)p);
818 }
819
03718234
JS		 820 switch (brd->boardType) {
821 case MOXA_BOARD_C218_ISA:
822 case MOXA_BOARD_C218_PCI:
823 file = "c218tunx.cod";
824 break;
825 case MOXA_BOARD_CP204J:
826 file = "cp204unx.cod";
827 break;
828 default:
829 file = "c320tunx.cod";
830 break;
831 }
832
833 ret = request_firmware(&fw, file, dev);
834 if (ret) {
835 printk(KERN_ERR "request_firmware failed\n");
810ab09b 836 goto err_free;
03718234
JS		 837 }
838
839 ret = moxa_load_fw(brd, fw);
840
841 release_firmware(fw);
810ab09b
JS		 842
843 if (ret)
844 goto err_free;
845
846 brd->ready = 1;
847
0bcc4caa
JS		 848 if (!timer_pending(&moxaTimer))
849 mod_timer(&moxaTimer, jiffies + HZ / 50);
850
810ab09b
JS		 851 return 0;
852err_free:
853 kfree(brd->ports);
854err:
03718234
JS		 855 return ret;
856}
857
810ab09b
JS		 858static void moxa_board_deinit(struct moxa_board_conf *brd)
859{
860 unsigned int i;
861
862 brd->ready = 0;
863 for (i = 0; i < MAX_PORTS_PER_BOARD; i++)
864 del_timer_sync(&brd->ports[i].emptyTimer);
865
866 iounmap(brd->basemem);
867 brd->basemem = NULL;
868 kfree(brd->ports);
869}
870
1da177e4 871#ifdef CONFIG_PCI
9cde5bf0
JS		 872static int __devinit moxa_pci_probe(struct pci_dev *pdev,
873 const struct pci_device_id *ent)
1da177e4 874{
9cde5bf0
JS		 875 struct moxa_board_conf *board;
876 unsigned int i;
877 int board_type = ent->driver_data;
878 int retval;
879
880 retval = pci_enable_device(pdev);
7aeb95da
JS		 881 if (retval) {
882 dev_err(&pdev->dev, "can't enable pci device\n");
9cde5bf0 883 goto err;
7aeb95da 884 }
9cde5bf0
JS		 885
886 for (i = 0; i < MAX_BOARDS; i++)
887 if (moxa_boards[i].basemem == NULL)
888 break;
889
890 retval = -ENODEV;
891 if (i >= MAX_BOARDS) {
7aeb95da 892 dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "
9cde5bf0
JS		 893 "found. Board is ignored.\n", MAX_BOARDS);
894 goto err;
895 }
896
897 board = &moxa_boards[i];
e46a5e3f
JS		 898
899 retval = pci_request_region(pdev, 2, "moxa-base");
900 if (retval) {
901 dev_err(&pdev->dev, "can't request pci region 2\n");
902 goto err;
903 }
904
905 board->basemem = ioremap(pci_resource_start(pdev, 2), 0x4000);
7aeb95da
JS		 906 if (board->basemem == NULL) {
907 dev_err(&pdev->dev, "can't remap io space 2\n");
e46a5e3f 908 goto err_reg;
7aeb95da 909 }
9cde5bf0 910
1da177e4
LT		 911 board->boardType = board_type;
912 switch (board_type) {
913 case MOXA_BOARD_C218_ISA:
914 case MOXA_BOARD_C218_PCI:
915 board->numPorts = 8;
916 break;
917
918 case MOXA_BOARD_CP204J:
919 board->numPorts = 4;
920 break;
921 default:
922 board->numPorts = 0;
923 break;
924 }
925 board->busType = MOXA_BUS_TYPE_PCI;
a784bf7c 926
03718234
JS		 927 retval = moxa_init_board(board, &pdev->dev);
928 if (retval)
929 goto err_base;
930
9cde5bf0 931 pci_set_drvdata(pdev, board);
1da177e4
LT		 932
933 return (0);
03718234
JS		 934err_base:
935 iounmap(board->basemem);
936 board->basemem = NULL;
e46a5e3f
JS		 937err_reg:
938 pci_release_region(pdev, 2);
9cde5bf0
JS		 939err:
940 return retval;
941}
942
943static void __devexit moxa_pci_remove(struct pci_dev *pdev)
944{
945 struct moxa_board_conf *brd = pci_get_drvdata(pdev);
946
810ab09b
JS		 947 moxa_board_deinit(brd);
948
e46a5e3f 949 pci_release_region(pdev, 2);
1da177e4 950}
a784bf7c
JS		 951
952static struct pci_driver moxa_pci_driver = {
953 .name = "moxa",
954 .id_table = moxa_pcibrds,
955 .probe = moxa_pci_probe,
956 .remove = __devexit_p(moxa_pci_remove)
957};
1da177e4
LT		 958#endif /* CONFIG_PCI */
959
960static int __init moxa_init(void)
961{
810ab09b 962 unsigned int isabrds = 0;
d353eca4 963 int retval = 0;
1da177e4 964
7aeb95da
JS		 965 printk(KERN_INFO "MOXA Intellio family driver version %s\n",
966 MOXA_VERSION);
1da177e4
LT		 967 moxaDriver = alloc_tty_driver(MAX_PORTS + 1);
968 if (!moxaDriver)
969 return -ENOMEM;
970
1da177e4 971 moxaDriver->owner = THIS_MODULE;
9b4e3b13 972 moxaDriver->name = "ttyMX";
1da177e4
LT		 973 moxaDriver->major = ttymajor;
974 moxaDriver->minor_start = 0;
975 moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
976 moxaDriver->subtype = SERIAL_TYPE_NORMAL;
977 moxaDriver->init_termios = tty_std_termios;
1da177e4 978 moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
606d099c
AC		 979 moxaDriver->init_termios.c_ispeed = 9600;
980 moxaDriver->init_termios.c_ospeed = 9600;
1da177e4
LT		 981 moxaDriver->flags = TTY_DRIVER_REAL_RAW;
982 tty_set_operations(moxaDriver, &moxa_ops);
983
7aeb95da 984 pr_debug("Moxa tty devices major number = %d\n", ttymajor);
1da177e4
LT		 985
986 if (tty_register_driver(moxaDriver)) {
987 printk(KERN_ERR "Couldn't install MOXA Smartio family driver !\n");
988 put_tty_driver(moxaDriver);
989 return -1;
990 }
1da177e4 991
d353eca4 992 /* Find the boards defined from module args. */
1da177e4 993#ifdef MODULE
d353eca4
JS		 994 {
995 struct moxa_board_conf *brd = moxa_boards;
810ab09b 996 unsigned int i;
1da177e4 997 for (i = 0; i < MAX_BOARDS; i++) {
d353eca4
JS		 998 if (!baseaddr[i])
999 break;
1000 if (type[i] == MOXA_BOARD_C218_ISA ||
1001 type[i] == MOXA_BOARD_C320_ISA) {
7aeb95da 1002 pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",
d353eca4
JS		 1003 isabrds + 1, moxa_brdname[type[i] - 1],
1004 baseaddr[i]);
1005 brd->boardType = type[i];
1006 brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :
1007 numports[i];
1008 brd->busType = MOXA_BUS_TYPE_ISA;
1009 brd->basemem = ioremap(baseaddr[i], 0x4000);
1010 if (!brd->basemem) {
1011 printk(KERN_ERR "moxa: can't remap %lx\n",
1012 baseaddr[i]);
1da177e4
LT		 1013 continue;
1014 }
03718234
JS		 1015 if (moxa_init_board(brd, NULL)) {
1016 iounmap(brd->basemem);
1017 brd->basemem = NULL;
1018 continue;
1019 }
d353eca4
JS		 1020
1021 brd++;
1022 isabrds++;
1da177e4
LT		 1023 }
1024 }
d353eca4 1025 }
1da177e4 1026#endif
a784bf7c 1027
1da177e4 1028#ifdef CONFIG_PCI
a784bf7c
JS		 1029 retval = pci_register_driver(&moxa_pci_driver);
1030 if (retval) {
1031 printk(KERN_ERR "Can't register moxa pci driver!\n");
d353eca4 1032 if (isabrds)
a784bf7c 1033 retval = 0;
1da177e4
LT		 1034 }
1035#endif
a784bf7c 1036
a784bf7c 1037 return retval;
1da177e4
LT		 1038}
1039
1040static void __exit moxa_exit(void)
1041{
1042 int i;
1043
c251ae0d 1044 del_timer_sync(&moxaTimer);
1da177e4 1045
1da177e4 1046 if (tty_unregister_driver(moxaDriver))
7aeb95da
JS		 1047 printk(KERN_ERR "Couldn't unregister MOXA Intellio family "
1048 "serial driver\n");
1da177e4 1049 put_tty_driver(moxaDriver);
86fbf148 1050
9cde5bf0 1051#ifdef CONFIG_PCI
a784bf7c 1052 pci_unregister_driver(&moxa_pci_driver);
9cde5bf0 1053#endif
a784bf7c 1054
810ab09b
JS		 1055 for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */
1056 if (moxa_boards[i].ready)
1057 moxa_board_deinit(&moxa_boards[i]);
1da177e4
LT		 1058}
1059
1060module_init(moxa_init);
1061module_exit(moxa_exit);
1062
1da177e4
LT		 1063static int moxa_open(struct tty_struct *tty, struct file *filp)
1064{
810ab09b 1065 struct moxa_board_conf *brd;
8f8ecbad 1066 struct moxa_port *ch;
1da177e4
LT		 1067 int port;
1068 int retval;
1da177e4 1069
11324edd 1070 port = tty->index;
1da177e4 1071 if (port == MAX_PORTS) {
74d7d97b 1072 return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
1da177e4 1073 }
810ab09b
JS		 1074 brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
1075 if (!brd->ready)
1076 return -ENODEV;
1da177e4 1077
810ab09b 1078 ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
1da177e4
LT		 1079 ch->count++;
1080 tty->driver_data = ch;
1081 ch->tty = tty;
1082 if (!(ch->asyncflags & ASYNC_INITIALIZED)) {
1083 ch->statusflags = 0;
db1acaa6 1084 moxa_set_tty_param(tty, tty->termios);
b4173f45
JS		 1085 MoxaPortLineCtrl(ch, 1, 1);
1086 MoxaPortEnable(ch);
1da177e4
LT		 1087 ch->asyncflags |= ASYNC_INITIALIZED;
1088 }
6f56b658 1089 retval = moxa_block_till_ready(tty, filp, ch);
1da177e4
LT		 1090
1091 moxa_unthrottle(tty);
1092
1093 if (ch->type == PORT_16550A) {
b4173f45 1094 MoxaSetFifo(ch, 1);
1da177e4 1095 } else {
b4173f45 1096 MoxaSetFifo(ch, 0);
1da177e4
LT		 1097 }
1098
1099 return (retval);
1100}
1101
1102static void moxa_close(struct tty_struct *tty, struct file *filp)
1103{
8f8ecbad 1104 struct moxa_port *ch;
1da177e4
LT		 1105 int port;
1106
11324edd 1107 port = tty->index;
1da177e4
LT		 1108 if (port == MAX_PORTS) {
1109 return;
1110 }
1da177e4
LT		 1111 if (tty->driver_data == NULL) {
1112 return;
1113 }
1114 if (tty_hung_up_p(filp)) {
1115 return;
1116 }
8f8ecbad 1117 ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1118
1119 if ((tty->count == 1) && (ch->count != 1)) {
7aeb95da
JS		 1120 printk(KERN_WARNING "moxa_close: bad serial port count; "
1121 "tty->count is 1, ch->count is %d\n", ch->count);
1da177e4
LT		 1122 ch->count = 1;
1123 }
1124 if (--ch->count < 0) {
7aeb95da
JS		 1125 printk(KERN_WARNING "moxa_close: bad serial port count, "
1126 "device=%s\n", tty->name);
1da177e4
LT		 1127 ch->count = 0;
1128 }
1129 if (ch->count) {
1130 return;
1131 }
1132 ch->asyncflags |= ASYNC_CLOSING;
1133
1134 ch->cflag = tty->termios->c_cflag;
1135 if (ch->asyncflags & ASYNC_INITIALIZED) {
6f56b658 1136 moxa_setup_empty_event(tty);
1da177e4 1137 tty_wait_until_sent(tty, 30 * HZ); /* 30 seconds timeout */
b4173f45 1138 del_timer_sync(&ch->emptyTimer);
1da177e4 1139 }
6f56b658 1140 moxa_shut_down(ch);
b4173f45 1141 MoxaPortFlushData(ch, 2);
1da177e4
LT		 1142
1143 if (tty->driver->flush_buffer)
1144 tty->driver->flush_buffer(tty);
1145 tty_ldisc_flush(tty);
1146
1147 tty->closing = 0;
1da177e4
LT		 1148 ch->tty = NULL;
1149 if (ch->blocked_open) {
1150 if (ch->close_delay) {
1151 msleep_interruptible(jiffies_to_msecs(ch->close_delay));
1152 }
1153 wake_up_interruptible(&ch->open_wait);
1154 }
1155 ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
95e07914 1156 complete_all(&ch->close_wait);
1da177e4
LT		 1157}
1158
1159static int moxa_write(struct tty_struct *tty,
1160 const unsigned char *buf, int count)
1161{
b4173f45 1162 struct moxa_port *ch = tty->driver_data;
1da177e4 1163 unsigned long flags;
b4173f45 1164 int len;
1da177e4 1165
1da177e4 1166 if (ch == NULL)
b4173f45 1167 return 0;
33f0f88f
AC		 1168
1169 spin_lock_irqsave(&moxa_lock, flags);
b4173f45 1170 len = MoxaPortWriteData(ch, (unsigned char *) buf, count);
33f0f88f 1171 spin_unlock_irqrestore(&moxa_lock, flags);
1da177e4
LT		 1172
1173 /*********************************************
1174 if ( !(ch->statusflags & LOWWAIT) &&
1175 ((len != count) || (MoxaPortTxFree(port) <= 100)) )
1176 ************************************************/
1177 ch->statusflags |= LOWWAIT;
1178 return (len);
1179}
1180
1181static int moxa_write_room(struct tty_struct *tty)
1182{
8f8ecbad 1183 struct moxa_port *ch;
1da177e4
LT		 1184
1185 if (tty->stopped)
1186 return (0);
b4173f45 1187 ch = tty->driver_data;
1da177e4
LT		 1188 if (ch == NULL)
1189 return (0);
b4173f45 1190 return MoxaPortTxFree(ch);
1da177e4
LT		 1191}
1192
1193static void moxa_flush_buffer(struct tty_struct *tty)
1194{
b4173f45 1195 struct moxa_port *ch = tty->driver_data;
1da177e4
LT		 1196
1197 if (ch == NULL)
1198 return;
b4173f45 1199 MoxaPortFlushData(ch, 1);
1da177e4
LT		 1200 tty_wakeup(tty);
1201}
1202
1203static int moxa_chars_in_buffer(struct tty_struct *tty)
1204{
b4173f45 1205 struct moxa_port *ch = tty->driver_data;
1da177e4 1206 int chars;
1da177e4
LT		 1207
1208 /*
1209 * Sigh...I have to check if driver_data is NULL here, because
1210 * if an open() fails, the TTY subsystem eventually calls
1211 * tty_wait_until_sent(), which calls the driver's chars_in_buffer()
1212 * routine. And since the open() failed, we return 0 here. TDJ
1213 */
1214 if (ch == NULL)
1215 return (0);
b4173f45 1216 chars = MoxaPortTxQueue(ch);
1da177e4
LT		 1217 if (chars) {
1218 /*
1219 * Make it possible to wakeup anything waiting for output
1220 * in tty_ioctl.c, etc.
1221 */
1222 if (!(ch->statusflags & EMPTYWAIT))
6f56b658 1223 moxa_setup_empty_event(tty);
1da177e4
LT		 1224 }
1225 return (chars);
1226}
1227
1228static void moxa_flush_chars(struct tty_struct *tty)
1229{
1230 /*
1231 * Don't think I need this, because this is called to empty the TX
1232 * buffer for the 16450, 16550, etc.
1233 */
1234}
1235
1236static void moxa_put_char(struct tty_struct *tty, unsigned char c)
1237{
b4173f45 1238 struct moxa_port *ch = tty->driver_data;
1da177e4
LT		 1239 unsigned long flags;
1240
1da177e4
LT		 1241 if (ch == NULL)
1242 return;
33f0f88f 1243 spin_lock_irqsave(&moxa_lock, flags);
b4173f45 1244 MoxaPortWriteData(ch, &c, 1);
33f0f88f 1245 spin_unlock_irqrestore(&moxa_lock, flags);
1da177e4
LT		 1246 /************************************************
1247 if ( !(ch->statusflags & LOWWAIT) && (MoxaPortTxFree(port) <= 100) )
1248 *************************************************/
1249 ch->statusflags |= LOWWAIT;
1250}
1251
1252static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
1253{
b4173f45 1254 struct moxa_port *ch = tty->driver_data;
1da177e4
LT		 1255 int flag = 0, dtr, rts;
1256
74d7d97b
JS		 1257 if (!ch)
1258 return -EINVAL;
1da177e4 1259
b4173f45 1260 MoxaPortGetLineOut(ch, &dtr, &rts);
1da177e4
LT		 1261 if (dtr)
1262 flag |= TIOCM_DTR;
1263 if (rts)
1264 flag |= TIOCM_RTS;
b4173f45 1265 dtr = MoxaPortLineStatus(ch);
1da177e4
LT		 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, struct file *file,
1276 unsigned int set, unsigned int clear)
1277{
b4173f45 1278 struct moxa_port *ch = tty->driver_data;
1da177e4
LT		 1279 int port;
1280 int dtr, rts;
1281
11324edd 1282 port = tty->index;
74d7d97b
JS		 1283 if (!ch)
1284 return -EINVAL;
1da177e4 1285
b4173f45 1286 MoxaPortGetLineOut(ch, &dtr, &rts);
1da177e4
LT		 1287 if (set & TIOCM_RTS)
1288 rts = 1;
1289 if (set & TIOCM_DTR)
1290 dtr = 1;
1291 if (clear & TIOCM_RTS)
1292 rts = 0;
1293 if (clear & TIOCM_DTR)
1294 dtr = 0;
b4173f45 1295 MoxaPortLineCtrl(ch, dtr, rts);
1da177e4
LT		 1296 return 0;
1297}
1298
1da177e4
LT		 1299static void moxa_throttle(struct tty_struct *tty)
1300{
8f8ecbad 1301 struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1302
1303 ch->statusflags |= THROTTLE;
1304}
1305
1306static void moxa_unthrottle(struct tty_struct *tty)
1307{
8f8ecbad 1308 struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1309
1310 ch->statusflags &= ~THROTTLE;
1311}
1312
1313static void moxa_set_termios(struct tty_struct *tty,
606d099c 1314 struct ktermios *old_termios)
1da177e4 1315{
8f8ecbad 1316 struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1317
1318 if (ch == NULL)
1319 return;
db1acaa6 1320 moxa_set_tty_param(tty, old_termios);
1da177e4
LT		 1321 if (!(old_termios->c_cflag & CLOCAL) &&
1322 (tty->termios->c_cflag & CLOCAL))
1323 wake_up_interruptible(&ch->open_wait);
1324}
1325
1326static void moxa_stop(struct tty_struct *tty)
1327{
8f8ecbad 1328 struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1329
1330 if (ch == NULL)
1331 return;
b4173f45 1332 MoxaPortTxDisable(ch);
1da177e4
LT		 1333 ch->statusflags |= TXSTOPPED;
1334}
1335
1336
1337static void moxa_start(struct tty_struct *tty)
1338{
8f8ecbad 1339 struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1340
1341 if (ch == NULL)
1342 return;
1343
1344 if (!(ch->statusflags & TXSTOPPED))
1345 return;
1346
b4173f45 1347 MoxaPortTxEnable(ch);
1da177e4
LT		 1348 ch->statusflags &= ~TXSTOPPED;
1349}
1350
1351static void moxa_hangup(struct tty_struct *tty)
1352{
8f8ecbad 1353 struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1354
1355 moxa_flush_buffer(tty);
6f56b658 1356 moxa_shut_down(ch);
1da177e4
LT		 1357 ch->count = 0;
1358 ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
1359 ch->tty = NULL;
1360 wake_up_interruptible(&ch->open_wait);
1361}
1362
1363static void moxa_poll(unsigned long ignored)
1364{
8f8ecbad 1365 struct moxa_port *ch;
0bcc4caa
JS		 1366 struct tty_struct *tty;
1367 unsigned int card;
1368 int i;
1da177e4 1369
1da177e4
LT		 1370 del_timer(&moxaTimer);
1371
1372 if (MoxaDriverPoll() < 0) {
aa7e5221 1373 mod_timer(&moxaTimer, jiffies + HZ / 50);
1da177e4
LT		 1374 return;
1375 }
0bcc4caa 1376
1da177e4 1377 for (card = 0; card < MAX_BOARDS; card++) {
0bcc4caa 1378 if (!moxa_boards[card].ready)
1da177e4 1379 continue;
810ab09b 1380 ch = moxa_boards[card].ports;
0bcc4caa 1381 for (i = 0; i < moxa_boards[card].numPorts; i++, ch++) {
1da177e4
LT		 1382 if ((ch->asyncflags & ASYNC_INITIALIZED) == 0)
1383 continue;
1384 if (!(ch->statusflags & THROTTLE) &&
b4173f45 1385 (MoxaPortRxQueue(ch) > 0))
6f56b658 1386 moxa_receive_data(ch);
0bcc4caa
JS		 1387 tty = ch->tty;
1388 if (tty == NULL)
1da177e4
LT		 1389 continue;
1390 if (ch->statusflags & LOWWAIT) {
b4173f45 1391 if (MoxaPortTxQueue(ch) <= WAKEUP_CHARS) {
0bcc4caa 1392 if (!tty->stopped) {
1da177e4 1393 ch->statusflags &= ~LOWWAIT;
0bcc4caa 1394 tty_wakeup(tty);
1da177e4
LT		 1395 }
1396 }
1397 }
0bcc4caa
JS		 1398 if (!I_IGNBRK(tty) && (MoxaPortResetBrkCnt(ch) > 0)) {
1399 tty_insert_flip_char(tty, 0, TTY_BREAK);
1400 tty_schedule_flip(tty);
1da177e4 1401 }
b4173f45 1402 if (MoxaPortDCDChange(ch)) {
1da177e4 1403 if (ch->asyncflags & ASYNC_CHECK_CD) {
b4173f45 1404 if (MoxaPortDCDON(ch))
1da177e4
LT		 1405 wake_up_interruptible(&ch->open_wait);
1406 else {
0bcc4caa 1407 tty_hangup(tty);
ba196df3
JS		 1408 wake_up_interruptible(&ch->open_wait);
1409 ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
1da177e4
LT		 1410 }
1411 }
1412 }
1413 }
1414 }
1415
aa7e5221 1416 mod_timer(&moxaTimer, jiffies + HZ / 50);
1da177e4
LT		 1417}
1418
1419/******************************************************************************/
1420
db1acaa6 1421static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
1da177e4 1422{
606d099c 1423 register struct ktermios *ts;
8f8ecbad 1424 struct moxa_port *ch;
db1acaa6 1425 int rts, cts, txflow, rxflow, xany, baud;
1da177e4 1426
8f8ecbad 1427 ch = (struct moxa_port *) tty->driver_data;
1da177e4
LT		 1428 ts = tty->termios;
1429 if (ts->c_cflag & CLOCAL)
1430 ch->asyncflags &= ~ASYNC_CHECK_CD;
1431 else
1432 ch->asyncflags |= ASYNC_CHECK_CD;
1433 rts = cts = txflow = rxflow = xany = 0;
1434 if (ts->c_cflag & CRTSCTS)
1435 rts = cts = 1;
1436 if (ts->c_iflag & IXON)
1437 txflow = 1;
1438 if (ts->c_iflag & IXOFF)
1439 rxflow = 1;
1440 if (ts->c_iflag & IXANY)
1441 xany = 1;
db1acaa6
AC		 1442
1443 /* Clear the features we don't support */
1444 ts->c_cflag &= ~CMSPAR;
b4173f45
JS		 1445 MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);
1446 baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));
db1acaa6
AC		 1447 if (baud == -1)
1448 baud = tty_termios_baud_rate(old_termios);
1449 /* Not put the baud rate into the termios data */
1450 tty_encode_baud_rate(tty, baud, baud);
1da177e4
LT		 1451}
1452
6f56b658 1453static int moxa_block_till_ready(struct tty_struct *tty, struct file *filp,
8f8ecbad 1454 struct moxa_port *ch)
1da177e4
LT		 1455{
1456 DECLARE_WAITQUEUE(wait,current);
1457 unsigned long flags;
1458 int retval;
1459 int do_clocal = C_CLOCAL(tty);
1460
1461 /*
1462 * If the device is in the middle of being closed, then block
1463 * until it's done, and then try again.
1464 */
1465 if (tty_hung_up_p(filp) || (ch->asyncflags & ASYNC_CLOSING)) {
1466 if (ch->asyncflags & ASYNC_CLOSING)
95e07914 1467 wait_for_completion_interruptible(&ch->close_wait);
1da177e4
LT		 1468#ifdef SERIAL_DO_RESTART
1469 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1470 return (-EAGAIN);
1471 else
1472 return (-ERESTARTSYS);
1473#else
1474 return (-EAGAIN);
1475#endif
1476 }
1477 /*
1478 * If non-blocking mode is set, then make the check up front
1479 * and then exit.
1480 */
1481 if (filp->f_flags & O_NONBLOCK) {
1482 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
1483 return (0);
1484 }
1485 /*
1486 * Block waiting for the carrier detect and the line to become free
1487 */
1488 retval = 0;
1489 add_wait_queue(&ch->open_wait, &wait);
7aeb95da 1490 pr_debug("block_til_ready before block: ttys%d, count = %d\n",
b4173f45 1491 tty->index, ch->count);
33f0f88f 1492 spin_lock_irqsave(&moxa_lock, flags);
1da177e4
LT		 1493 if (!tty_hung_up_p(filp))
1494 ch->count--;
1da177e4 1495 ch->blocked_open++;
33f0f88f
AC		 1496 spin_unlock_irqrestore(&moxa_lock, flags);
1497
1da177e4
LT		 1498 while (1) {
1499 set_current_state(TASK_INTERRUPTIBLE);
1500 if (tty_hung_up_p(filp) ||
1501 !(ch->asyncflags & ASYNC_INITIALIZED)) {
1502#ifdef SERIAL_DO_RESTART
1503 if (ch->asyncflags & ASYNC_HUP_NOTIFY)
1504 retval = -EAGAIN;
1505 else
1506 retval = -ERESTARTSYS;
1507#else
1508 retval = -EAGAIN;
1509#endif
1510 break;
1511 }
1512 if (!(ch->asyncflags & ASYNC_CLOSING) && (do_clocal ||
b4173f45 1513 MoxaPortDCDON(ch)))
1da177e4
LT		 1514 break;
1515
1516 if (signal_pending(current)) {
1517 retval = -ERESTARTSYS;
1518 break;
1519 }
1520 schedule();
1521 }
1522 set_current_state(TASK_RUNNING);
1523 remove_wait_queue(&ch->open_wait, &wait);
33f0f88f
AC		 1524
1525 spin_lock_irqsave(&moxa_lock, flags);
1da177e4
LT		 1526 if (!tty_hung_up_p(filp))
1527 ch->count++;
1528 ch->blocked_open--;
33f0f88f 1529 spin_unlock_irqrestore(&moxa_lock, flags);
7aeb95da 1530 pr_debug("block_til_ready after blocking: ttys%d, count = %d\n",
b4173f45 1531 tty->index, ch->count);
1da177e4
LT		 1532 if (retval)
1533 return (retval);
33f0f88f 1534 /* FIXME: review to see if we need to use set_bit on these */
1da177e4 1535 ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
33f0f88f 1536 return 0;
1da177e4
LT		 1537}
1538
6f56b658 1539static void moxa_setup_empty_event(struct tty_struct *tty)
1da177e4 1540{
8f8ecbad 1541 struct moxa_port *ch = tty->driver_data;
1da177e4
LT		 1542 unsigned long flags;
1543
33f0f88f 1544 spin_lock_irqsave(&moxa_lock, flags);
1da177e4 1545 ch->statusflags |= EMPTYWAIT;
b4173f45 1546 mod_timer(&ch->emptyTimer, jiffies + HZ);
33f0f88f 1547 spin_unlock_irqrestore(&moxa_lock, flags);
1da177e4
LT		 1548}
1549
6f56b658 1550static void moxa_check_xmit_empty(unsigned long data)
1da177e4 1551{
8f8ecbad 1552 struct moxa_port *ch;
1da177e4 1553
8f8ecbad 1554 ch = (struct moxa_port *) data;
1da177e4 1555 if (ch->tty && (ch->statusflags & EMPTYWAIT)) {
b4173f45 1556 if (MoxaPortTxQueue(ch) == 0) {
1da177e4
LT		 1557 ch->statusflags &= ~EMPTYWAIT;
1558 tty_wakeup(ch->tty);
1559 return;
1560 }
b4173f45 1561 mod_timer(&ch->emptyTimer, round_jiffies(jiffies + HZ));
1da177e4
LT		 1562 } else
1563 ch->statusflags &= ~EMPTYWAIT;
1564}
1565
6f56b658 1566static void moxa_shut_down(struct moxa_port *ch)
1da177e4
LT		 1567{
1568 struct tty_struct *tp;
1569
1570 if (!(ch->asyncflags & ASYNC_INITIALIZED))
1571 return;
1572
1573 tp = ch->tty;
1574
b4173f45 1575 MoxaPortDisable(ch);
1da177e4
LT		 1576
1577 /*
1578 * If we're a modem control device and HUPCL is on, drop RTS & DTR.
1579 */
1580 if (tp->termios->c_cflag & HUPCL)
b4173f45 1581 MoxaPortLineCtrl(ch, 0, 0);
1da177e4
LT		 1582
1583 ch->asyncflags &= ~ASYNC_INITIALIZED;
1584}
1585
6f56b658 1586static void moxa_receive_data(struct moxa_port *ch)
1da177e4
LT		 1587{
1588 struct tty_struct *tp;
606d099c 1589 struct ktermios *ts;
1da177e4
LT		 1590 unsigned long flags;
1591
1592 ts = NULL;
1593 tp = ch->tty;
1594 if (tp)
1595 ts = tp->termios;
1596 /**************************************************
03718234
JS		 1597 if ( !tp || !ts || !(ts->c_cflag & CREAD) ) {
1598 *****************************************************/
1599 if (!tp || !ts) {
b4173f45 1600 MoxaPortFlushData(ch, 0);
03718234
JS		 1601 return;
1602 }
1603 spin_lock_irqsave(&moxa_lock, flags);
b4173f45 1604 MoxaPortReadData(ch, tp);
03718234
JS		 1605 spin_unlock_irqrestore(&moxa_lock, flags);
1606 tty_schedule_flip(tp);
1607}
1da177e4
LT		 1608
1609/*
1610 * Query
1611 */
1da177e4 1612
1da177e4
LT		 1613#define DCD_changed 0x01
1614#define DCD_oldstate 0x80
1615
1da177e4 1616static int moxaLowWaterChk;
1da177e4 1617
6f56b658 1618static void moxa_low_water_check(void __iomem *);
1da177e4
LT		 1619
1620/*****************************************************************************
1621 * Driver level functions: *
1da177e4
LT		 1622 * 3. MoxaDriverPoll(void); *
1623 *****************************************************************************/
1da177e4 1624
b4173f45 1625static void MoxaPortFlushData(struct moxa_port *port, int mode)
1da177e4
LT		 1626{
1627 void __iomem *ofsAddr;
1628 if ((mode < 0) || (mode > 2))
1629 return;
b4173f45 1630 ofsAddr = port->tableAddr;
1da177e4
LT		 1631 moxafunc(ofsAddr, FC_FlushQueue, mode);
1632 if (mode != 1) {
b4173f45 1633 port->lowChkFlag = 0;
6f56b658 1634 moxa_low_water_check(ofsAddr);
1da177e4
LT		 1635 }
1636}
1637
0bcc4caa 1638static int MoxaDriverPoll(void)
1da177e4 1639{
8f8ecbad 1640 struct moxa_board_conf *brd;
810ab09b 1641 struct moxa_port *p;
1da177e4
LT		 1642 void __iomem *ofsAddr;
1643 void __iomem *ip;
0bcc4caa
JS		 1644 unsigned int port, ports, card;
1645 ushort temp;
1da177e4 1646
1da177e4 1647 for (card = 0; card < MAX_BOARDS; card++) {
8f8ecbad 1648 brd = &moxa_boards[card];
810ab09b 1649 if (brd->ready == 0)
01cfaf0d 1650 continue;
8f8ecbad 1651 if ((ports = brd->numPorts) == 0)
1da177e4 1652 continue;
8f8ecbad
JS		 1653 if (readb(brd->intPend) == 0xff) {
1654 ip = brd->intTable + readb(brd->intNdx);
810ab09b 1655 p = brd->ports;
1da177e4
LT		 1656 ports <<= 1;
1657 for (port = 0; port < ports; port += 2, p++) {
810ab09b
JS		 1658 temp = readw(ip + port);
1659 if (temp == 0)
1660 continue;
1661
1662 writew(0, ip + port);
1663 ofsAddr = p->tableAddr;
1664 if (temp & IntrTx)
1665 writew(readw(ofsAddr + HostStat) &
1666 ~WakeupTx, ofsAddr + HostStat);
1667 if (temp & IntrBreak)
1668 p->breakCnt++;
1669
1670 if (temp & IntrLine) {
1671 if (readb(ofsAddr + FlagStat) & DCD_state) {
1672 if ((p->DCDState & DCD_oldstate) == 0)
1673 p->DCDState = (DCD_oldstate |
1674 DCD_changed);
1675 } else {
1676 if (p->DCDState & DCD_oldstate)
1677 p->DCDState = DCD_changed;
1da177e4
LT		 1678 }
1679 }
1680 }
8f8ecbad 1681 writeb(0, brd->intPend);
1da177e4
LT		 1682 }
1683 if (moxaLowWaterChk) {
810ab09b 1684 p = brd->ports;
1da177e4 1685 for (port = 0; port < ports; port++, p++) {
810ab09b
JS		 1686 if (p->lowChkFlag) {
1687 p->lowChkFlag = 0;
1688 ofsAddr = p->tableAddr;
6f56b658 1689 moxa_low_water_check(ofsAddr);
1da177e4
LT		 1690 }
1691 }
1692 }
1693 }
1694 moxaLowWaterChk = 0;
1da177e4 1695
0bcc4caa 1696 return 0;
1da177e4
LT		 1697}
1698
1699/*****************************************************************************
1700 * Port level functions: *
1da177e4
LT		 1701 * 2. MoxaPortEnable(int port); *
1702 * 3. MoxaPortDisable(int port); *
1703 * 4. MoxaPortGetMaxBaud(int port); *
1da177e4 1704 * 6. MoxaPortSetBaud(int port, long baud); *
1da177e4
LT		 1705 * 8. MoxaPortSetTermio(int port, unsigned char *termio); *
1706 * 9. MoxaPortGetLineOut(int port, int *dtrState, int *rtsState); *
1707 * 10. MoxaPortLineCtrl(int port, int dtrState, int rtsState); *
1708 * 11. MoxaPortFlowCtrl(int port, int rts, int cts, int rx, int tx,int xany); *
1709 * 12. MoxaPortLineStatus(int port); *
1710 * 13. MoxaPortDCDChange(int port); *
1711 * 14. MoxaPortDCDON(int port); *
1712 * 15. MoxaPortFlushData(int port, int mode); *
1713 * 16. MoxaPortWriteData(int port, unsigned char * buffer, int length); *
33f0f88f 1714 * 17. MoxaPortReadData(int port, struct tty_struct *tty); *
1da177e4
LT		 1715 * 20. MoxaPortTxQueue(int port); *
1716 * 21. MoxaPortTxFree(int port); *
1717 * 22. MoxaPortRxQueue(int port); *
1da177e4
LT		 1718 * 24. MoxaPortTxDisable(int port); *
1719 * 25. MoxaPortTxEnable(int port); *
1da177e4 1720 * 27. MoxaPortResetBrkCnt(int port); *
1da177e4
LT		 1721 *****************************************************************************/
1722/*
1723 * Moxa Port Number Description:
1724 *
1725 * MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,
1726 * the port number using in MOXA driver functions will be 0 to 31 for
1727 * first MOXA board, 32 to 63 for second, 64 to 95 for third and 96
1728 * to 127 for fourth. For example, if you setup three MOXA boards,
1729 * first board is C218, second board is C320-16 and third board is
1730 * C320-32. The port number of first board (C218 - 8 ports) is from
1731 * 0 to 7. The port number of second board (C320 - 16 ports) is form
1732 * 32 to 47. The port number of third board (C320 - 32 ports) is from
1733 * 64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to
1734 * 127 will be invalid.
1735 *
1736 *
1737 * Moxa Functions Description:
1738 *
1739 * Function 1: Driver initialization routine, this routine must be
1740 * called when initialized driver.
1741 * Syntax:
1742 * void MoxaDriverInit();
1743 *
1744 *
1745 * Function 2: Moxa driver private IOCTL command processing.
1746 * Syntax:
1747 * int MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);
1748 *
1749 * unsigned int cmd : IOCTL command
1750 * unsigned long arg : IOCTL argument
1751 * int port : port number (0 - 127)
1752 *
1753 * return: 0 (OK)
1754 * -EINVAL
1755 * -ENOIOCTLCMD
1756 *
1757 *
1758 * Function 3: Moxa driver polling process routine.
1759 * Syntax:
1760 * int MoxaDriverPoll(void);
1761 *
1762 * return: 0 ; polling O.K.
1763 * -1 : no any Moxa card.
1764 *
1765 *
1da177e4
LT		 1766 * Function 6: Enable this port to start Tx/Rx data.
1767 * Syntax:
1768 * void MoxaPortEnable(int port);
1769 * int port : port number (0 - 127)
1770 *
1771 *
1772 * Function 7: Disable this port
1773 * Syntax:
1774 * void MoxaPortDisable(int port);
1775 * int port : port number (0 - 127)
1776 *
1777 *
1778 * Function 8: Get the maximun available baud rate of this port.
1779 * Syntax:
1780 * long MoxaPortGetMaxBaud(int port);
1781 * int port : port number (0 - 127)
1782 *
1783 * return: 0 : this port is invalid
1784 * 38400/57600/115200 bps
1785 *
1786 *
1da177e4
LT		 1787 * Function 10: Setting baud rate of this port.
1788 * Syntax:
1789 * long MoxaPortSetBaud(int port, long baud);
1790 * int port : port number (0 - 127)
1791 * long baud : baud rate (50 - 115200)
1792 *
1793 * return: 0 : this port is invalid or baud < 50
1794 * 50 - 115200 : the real baud rate set to the port, if
1795 * the argument baud is large than maximun
1796 * available baud rate, the real setting
1797 * baud rate will be the maximun baud rate.
1798 *
1799 *
1da177e4
LT		 1800 * Function 12: Configure the port.
1801 * Syntax:
606d099c 1802 * int MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);
1da177e4 1803 * int port : port number (0 - 127)
606d099c 1804 * struct ktermios * termio : termio structure pointer
c7bce309 1805 * speed_t baud : baud rate
1da177e4
LT		 1806 *
1807 * return: -1 : this port is invalid or termio == NULL
1808 * 0 : setting O.K.
1809 *
1810 *
1811 * Function 13: Get the DTR/RTS state of this port.
1812 * Syntax:
1813 * int MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);
1814 * int port : port number (0 - 127)
1815 * int * dtrState : pointer to INT to receive the current DTR
1816 * state. (if NULL, this function will not
1817 * write to this address)
1818 * int * rtsState : pointer to INT to receive the current RTS
1819 * state. (if NULL, this function will not
1820 * write to this address)
1821 *
1822 * return: -1 : this port is invalid
1823 * 0 : O.K.
1824 *
1825 *
1826 * Function 14: Setting the DTR/RTS output state of this port.
1827 * Syntax:
1828 * void MoxaPortLineCtrl(int port, int dtrState, int rtsState);
1829 * int port : port number (0 - 127)
1830 * int dtrState : DTR output state (0: off, 1: on)
1831 * int rtsState : RTS output state (0: off, 1: on)
1832 *
1833 *
1834 * Function 15: Setting the flow control of this port.
1835 * Syntax:
1836 * void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,
1837 * int txFlow,int xany);
1838 * int port : port number (0 - 127)
1839 * int rtsFlow : H/W RTS flow control (0: no, 1: yes)
1840 * int ctsFlow : H/W CTS flow control (0: no, 1: yes)
1841 * int rxFlow : S/W Rx XON/XOFF flow control (0: no, 1: yes)
1842 * int txFlow : S/W Tx XON/XOFF flow control (0: no, 1: yes)
1843 * int xany : S/W XANY flow control (0: no, 1: yes)
1844 *
1845 *
1846 * Function 16: Get ths line status of this port
1847 * Syntax:
1848 * int MoxaPortLineStatus(int port);
1849 * int port : port number (0 - 127)
1850 *
1851 * return: Bit 0 - CTS state (0: off, 1: on)
1852 * Bit 1 - DSR state (0: off, 1: on)
1853 * Bit 2 - DCD state (0: off, 1: on)
1854 *
1855 *
1856 * Function 17: Check the DCD state has changed since the last read
1857 * of this function.
1858 * Syntax:
1859 * int MoxaPortDCDChange(int port);
1860 * int port : port number (0 - 127)
1861 *
1862 * return: 0 : no changed
1863 * 1 : DCD has changed
1864 *
1865 *
1866 * Function 18: Check ths current DCD state is ON or not.
1867 * Syntax:
1868 * int MoxaPortDCDON(int port);
1869 * int port : port number (0 - 127)
1870 *
1871 * return: 0 : DCD off
1872 * 1 : DCD on
1873 *
1874 *
1875 * Function 19: Flush the Rx/Tx buffer data of this port.
1876 * Syntax:
1877 * void MoxaPortFlushData(int port, int mode);
1878 * int port : port number (0 - 127)
1879 * int mode
1880 * 0 : flush the Rx buffer
1881 * 1 : flush the Tx buffer
1882 * 2 : flush the Rx and Tx buffer
1883 *
1884 *
1885 * Function 20: Write data.
1886 * Syntax:
1887 * int MoxaPortWriteData(int port, unsigned char * buffer, int length);
1888 * int port : port number (0 - 127)
1889 * unsigned char * buffer : pointer to write data buffer.
1890 * int length : write data length
1891 *
1892 * return: 0 - length : real write data length
1893 *
1894 *
1895 * Function 21: Read data.
1896 * Syntax:
33f0f88f 1897 * int MoxaPortReadData(int port, struct tty_struct *tty);
1da177e4 1898 * int port : port number (0 - 127)
33f0f88f 1899 * struct tty_struct *tty : tty for data
1da177e4
LT		 1900 *
1901 * return: 0 - length : real read data length
1902 *
1903 *
1da177e4
LT		 1904 * Function 24: Get the Tx buffer current queued data bytes
1905 * Syntax:
1906 * int MoxaPortTxQueue(int port);
1907 * int port : port number (0 - 127)
1908 *
1909 * return: .. : Tx buffer current queued data bytes
1910 *
1911 *
1912 * Function 25: Get the Tx buffer current free space
1913 * Syntax:
1914 * int MoxaPortTxFree(int port);
1915 * int port : port number (0 - 127)
1916 *
1917 * return: .. : Tx buffer current free space
1918 *
1919 *
1920 * Function 26: Get the Rx buffer current queued data bytes
1921 * Syntax:
1922 * int MoxaPortRxQueue(int port);
1923 * int port : port number (0 - 127)
1924 *
1925 * return: .. : Rx buffer current queued data bytes
1926 *
1927 *
1da177e4
LT		 1928 * Function 28: Disable port data transmission.
1929 * Syntax:
1930 * void MoxaPortTxDisable(int port);
1931 * int port : port number (0 - 127)
1932 *
1933 *
1934 * Function 29: Enable port data transmission.
1935 * Syntax:
1936 * void MoxaPortTxEnable(int port);
1937 * int port : port number (0 - 127)
1938 *
1939 *
1da177e4
LT		 1940 * Function 31: Get the received BREAK signal count and reset it.
1941 * Syntax:
1942 * int MoxaPortResetBrkCnt(int port);
1943 * int port : port number (0 - 127)
1944 *
1945 * return: 0 - .. : BREAK signal count
1946 *
1947 *
1da177e4 1948 */
1da177e4 1949
b4173f45 1950static void MoxaPortEnable(struct moxa_port *port)
1da177e4
LT		 1951{
1952 void __iomem *ofsAddr;
1da177e4
LT		 1953 short lowwater = 512;
1954
b4173f45 1955 ofsAddr = port->tableAddr;
1da177e4 1956 writew(lowwater, ofsAddr + Low_water);
b4173f45
JS		 1957 port->breakCnt = 0;
1958 if (port->board->boardType == MOXA_BOARD_C320_ISA ||
1959 port->board->boardType == MOXA_BOARD_C320_PCI) {
1da177e4
LT		 1960 moxafunc(ofsAddr, FC_SetBreakIrq, 0);
1961 } else {
1962 writew(readw(ofsAddr + HostStat) | WakeupBreak, ofsAddr + HostStat);
1963 }
1964
1965 moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
1966 moxafunc(ofsAddr, FC_FlushQueue, 2);
1967
1968 moxafunc(ofsAddr, FC_EnableCH, Magic_code);
1969 MoxaPortLineStatus(port);
1970}
1971
b4173f45 1972static void MoxaPortDisable(struct moxa_port *port)
1da177e4 1973{
b4173f45 1974 void __iomem *ofsAddr = port->tableAddr;
1da177e4
LT		 1975
1976 moxafunc(ofsAddr, FC_SetFlowCtl, 0); /* disable flow control */
1977 moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
1978 writew(0, ofsAddr + HostStat);
1979 moxafunc(ofsAddr, FC_DisableCH, Magic_code);
1980}
1981
b4173f45 1982static long MoxaPortGetMaxBaud(struct moxa_port *port)
1da177e4 1983{
b4173f45
JS		 1984 if (port->board->boardType == MOXA_BOARD_C320_ISA ||
1985 port->board->boardType == MOXA_BOARD_C320_PCI)
1da177e4
LT		 1986 return (460800L);
1987 else
1988 return (921600L);
1989}
1990
1991
b4173f45 1992static long MoxaPortSetBaud(struct moxa_port *port, long baud)
1da177e4
LT		 1993{
1994 void __iomem *ofsAddr;
1995 long max, clock;
1996 unsigned int val;
1997
1998 if ((baud < 50L) || ((max = MoxaPortGetMaxBaud(port)) == 0))
1999 return (0);
b4173f45 2000 ofsAddr = port->tableAddr;
1da177e4
LT		 2001 if (baud > max)
2002 baud = max;
2003 if (max == 38400L)
2004 clock = 614400L; /* for 9.8304 Mhz : max. 38400 bps */
2005 else if (max == 57600L)
2006 clock = 691200L; /* for 11.0592 Mhz : max. 57600 bps */
2007 else
2008 clock = 921600L; /* for 14.7456 Mhz : max. 115200 bps */
2009 val = clock / baud;
2010 moxafunc(ofsAddr, FC_SetBaud, val);
2011 baud = clock / val;
1da177e4
LT		 2012 return (baud);
2013}
2014
b4173f45
JS		 2015static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
2016 speed_t baud)
1da177e4
LT		 2017{
2018 void __iomem *ofsAddr;
2019 tcflag_t cflag;
1da177e4
LT		 2020 tcflag_t mode = 0;
2021
b4173f45 2022 ofsAddr = port->tableAddr;
1da177e4
LT		 2023 cflag = termio->c_cflag; /* termio->c_cflag */
2024
2025 mode = termio->c_cflag & CSIZE;
2026 if (mode == CS5)
2027 mode = MX_CS5;
2028 else if (mode == CS6)
2029 mode = MX_CS6;
2030 else if (mode == CS7)
2031 mode = MX_CS7;
2032 else if (mode == CS8)
2033 mode = MX_CS8;
2034
2035 if (termio->c_cflag & CSTOPB) {
2036 if (mode == MX_CS5)
2037 mode |= MX_STOP15;
2038 else
2039 mode |= MX_STOP2;
2040 } else
2041 mode |= MX_STOP1;
2042
2043 if (termio->c_cflag & PARENB) {
2044 if (termio->c_cflag & PARODD)
2045 mode |= MX_PARODD;
2046 else
2047 mode |= MX_PAREVEN;
2048 } else
2049 mode |= MX_PARNONE;
2050
2051 moxafunc(ofsAddr, FC_SetDataMode, (ushort) mode);
2052
b4173f45
JS		 2053 if (port->board->boardType == MOXA_BOARD_C320_ISA ||
2054 port->board->boardType == MOXA_BOARD_C320_PCI) {
c7bce309 2055 if (baud >= 921600L)
1da177e4
LT		 2056 return (-1);
2057 }
db1acaa6 2058 baud = MoxaPortSetBaud(port, baud);
1da177e4
LT		 2059
2060 if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
2061 writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
2062 writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
2063 writeb(FC_SetXonXoff, ofsAddr + FuncCode);
6f56b658 2064 moxa_wait_finish(ofsAddr);
1da177e4
LT		 2065
2066 }
db1acaa6 2067 return (baud);
1da177e4
LT		 2068}
2069
b4173f45
JS		 2070static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
2071 int *rtsState)
1da177e4
LT		 2072{
2073
b4173f45
JS		 2074 if (dtrState)
2075 *dtrState = !!(port->lineCtrl & DTR_ON);
2076 if (rtsState)
2077 *rtsState = !!(port->lineCtrl & RTS_ON);
2078
1da177e4
LT		 2079 return (0);
2080}
2081
b4173f45 2082static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
1da177e4 2083{
b4173f45 2084 int mode = 0;
1da177e4 2085
1da177e4
LT		 2086 if (dtr)
2087 mode |= DTR_ON;
2088 if (rts)
2089 mode |= RTS_ON;
b4173f45
JS		 2090 port->lineCtrl = mode;
2091 moxafunc(port->tableAddr, FC_LineControl, mode);
1da177e4
LT		 2092}
2093
b4173f45
JS		 2094static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,
2095 int txflow, int rxflow, int txany)
1da177e4 2096{
b4173f45 2097 int mode = 0;
1da177e4 2098
1da177e4
LT		 2099 if (rts)
2100 mode |= RTS_FlowCtl;
2101 if (cts)
2102 mode |= CTS_FlowCtl;
2103 if (txflow)
2104 mode |= Tx_FlowCtl;
2105 if (rxflow)
2106 mode |= Rx_FlowCtl;
2107 if (txany)
2108 mode |= IXM_IXANY;
b4173f45 2109 moxafunc(port->tableAddr, FC_SetFlowCtl, mode);
1da177e4
LT		 2110}
2111
b4173f45 2112static int MoxaPortLineStatus(struct moxa_port *port)
1da177e4
LT		 2113{
2114 void __iomem *ofsAddr;
2115 int val;
2116
b4173f45
JS		 2117 ofsAddr = port->tableAddr;
2118 if (port->board->boardType == MOXA_BOARD_C320_ISA ||
2119 port->board->boardType == MOXA_BOARD_C320_PCI) {
1da177e4
LT		 2120 moxafunc(ofsAddr, FC_LineStatus, 0);
2121 val = readw(ofsAddr + FuncArg);
2122 } else {
2123 val = readw(ofsAddr + FlagStat) >> 4;
2124 }
2125 val &= 0x0B;
2126 if (val & 8) {
2127 val |= 4;
b4173f45
JS		 2128 if ((port->DCDState & DCD_oldstate) == 0)
2129 port->DCDState = (DCD_oldstate | DCD_changed);
1da177e4 2130 } else {
b4173f45
JS		 2131 if (port->DCDState & DCD_oldstate)
2132 port->DCDState = DCD_changed;
1da177e4
LT		 2133 }
2134 val &= 7;
2135 return (val);
2136}
2137
b4173f45 2138static int MoxaPortDCDChange(struct moxa_port *port)
1da177e4
LT		 2139{
2140 int n;
2141
b4173f45
JS		 2142 n = port->DCDState;
2143 port->DCDState &= ~DCD_changed;
1da177e4
LT		 2144 n &= DCD_changed;
2145 return (n);
2146}
2147
b4173f45 2148static int MoxaPortDCDON(struct moxa_port *port)
1da177e4
LT		 2149{
2150 int n;
2151
b4173f45 2152 if (port->DCDState & DCD_oldstate)
1da177e4
LT		 2153 n = 1;
2154 else
2155 n = 0;
2156 return (n);
2157}
2158
b4173f45
JS		 2159static int MoxaPortWriteData(struct moxa_port *port, unsigned char *buffer,
2160 int len)
1da177e4
LT		 2161{
2162 int c, total, i;
2163 ushort tail;
2164 int cnt;
2165 ushort head, tx_mask, spage, epage;
2166 ushort pageno, pageofs, bufhead;
2167 void __iomem *baseAddr, *ofsAddr, *ofs;
2168
b4173f45
JS		 2169 ofsAddr = port->tableAddr;
2170 baseAddr = port->board->basemem;
1da177e4
LT		 2171 tx_mask = readw(ofsAddr + TX_mask);
2172 spage = readw(ofsAddr + Page_txb);
2173 epage = readw(ofsAddr + EndPage_txb);
2174 tail = readw(ofsAddr + TXwptr);
2175 head = readw(ofsAddr + TXrptr);
2176 c = (head > tail) ? (head - tail - 1)
2177 : (head - tail + tx_mask);
2178 if (c > len)
2179 c = len;
b4173f45 2180 moxaLog.txcnt[port->tty->index] += c;
1da177e4
LT		 2181 total = c;
2182 if (spage == epage) {
2183 bufhead = readw(ofsAddr + Ofs_txb);
2184 writew(spage, baseAddr + Control_reg);
2185 while (c > 0) {
2186 if (head > tail)
2187 len = head - tail - 1;
2188 else
2189 len = tx_mask + 1 - tail;
2190 len = (c > len) ? len : c;
2191 ofs = baseAddr + DynPage_addr + bufhead + tail;
2192 for (i = 0; i < len; i++)
2193 writeb(*buffer++, ofs + i);
2194 tail = (tail + len) & tx_mask;
2195 c -= len;
2196 }
2197 writew(tail, ofsAddr + TXwptr);
2198 } else {
2199 len = c;
2200 pageno = spage + (tail >> 13);
2201 pageofs = tail & Page_mask;
2202 do {
2203 cnt = Page_size - pageofs;
2204 if (cnt > c)
2205 cnt = c;
2206 c -= cnt;
2207 writeb(pageno, baseAddr + Control_reg);
2208 ofs = baseAddr + DynPage_addr + pageofs;
2209 for (i = 0; i < cnt; i++)
2210 writeb(*buffer++, ofs + i);
2211 if (c == 0) {
2212 writew((tail + len) & tx_mask, ofsAddr + TXwptr);
2213 break;
2214 }
2215 if (++pageno == epage)
2216 pageno = spage;
2217 pageofs = 0;
2218 } while (1);
2219 }
2220 writeb(1, ofsAddr + CD180TXirq); /* start to send */
2221 return (total);
2222}
2223
b4173f45 2224static int MoxaPortReadData(struct moxa_port *port, struct tty_struct *tty)
1da177e4
LT		 2225{
2226 register ushort head, pageofs;
2227 int i, count, cnt, len, total, remain;
2228 ushort tail, rx_mask, spage, epage;
2229 ushort pageno, bufhead;
2230 void __iomem *baseAddr, *ofsAddr, *ofs;
2231
b4173f45
JS		 2232 ofsAddr = port->tableAddr;
2233 baseAddr = port->board->basemem;
1da177e4
LT		 2234 head = readw(ofsAddr + RXrptr);
2235 tail = readw(ofsAddr + RXwptr);
2236 rx_mask = readw(ofsAddr + RX_mask);
2237 spage = readw(ofsAddr + Page_rxb);
2238 epage = readw(ofsAddr + EndPage_rxb);
2239 count = (tail >= head) ? (tail - head)
2240 : (tail - head + rx_mask + 1);
2241 if (count == 0)
33f0f88f 2242 return 0;
1da177e4 2243
33f0f88f 2244 total = count;
1da177e4 2245 remain = count - total;
b4173f45 2246 moxaLog.rxcnt[port->tty->index] += total;
1da177e4
LT		 2247 count = total;
2248 if (spage == epage) {
2249 bufhead = readw(ofsAddr + Ofs_rxb);
2250 writew(spage, baseAddr + Control_reg);
2251 while (count > 0) {
2252 if (tail >= head)
2253 len = tail - head;
2254 else
2255 len = rx_mask + 1 - head;
2256 len = (count > len) ? len : count;
2257 ofs = baseAddr + DynPage_addr + bufhead + head;
2258 for (i = 0; i < len; i++)
33f0f88f 2259 tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
1da177e4
LT		 2260 head = (head + len) & rx_mask;
2261 count -= len;
2262 }
2263 writew(head, ofsAddr + RXrptr);
2264 } else {
2265 len = count;
2266 pageno = spage + (head >> 13);
2267 pageofs = head & Page_mask;
2268 do {
2269 cnt = Page_size - pageofs;
2270 if (cnt > count)
2271 cnt = count;
2272 count -= cnt;
2273 writew(pageno, baseAddr + Control_reg);
2274 ofs = baseAddr + DynPage_addr + pageofs;
2275 for (i = 0; i < cnt; i++)
33f0f88f 2276 tty_insert_flip_char(tty, readb(ofs + i), TTY_NORMAL);
1da177e4
LT		 2277 if (count == 0) {
2278 writew((head + len) & rx_mask, ofsAddr + RXrptr);
2279 break;
2280 }
2281 if (++pageno == epage)
2282 pageno = spage;
2283 pageofs = 0;
2284 } while (1);
2285 }
2286 if ((readb(ofsAddr + FlagStat) & Xoff_state) && (remain < LowWater)) {
2287 moxaLowWaterChk = 1;
b4173f45 2288 port->lowChkFlag = 1;
1da177e4
LT		 2289 }
2290 return (total);
2291}
2292
2293
b4173f45 2294static int MoxaPortTxQueue(struct moxa_port *port)
1da177e4 2295{
b4173f45 2296 void __iomem *ofsAddr = port->tableAddr;
1da177e4
LT		 2297 ushort rptr, wptr, mask;
2298 int len;
2299
1da177e4
LT		 2300 rptr = readw(ofsAddr + TXrptr);
2301 wptr = readw(ofsAddr + TXwptr);
2302 mask = readw(ofsAddr + TX_mask);
2303 len = (wptr - rptr) & mask;
2304 return (len);
2305}
2306
b4173f45 2307static int MoxaPortTxFree(struct moxa_port *port)
1da177e4 2308{
b4173f45 2309 void __iomem *ofsAddr = port->tableAddr;
1da177e4
LT		 2310 ushort rptr, wptr, mask;
2311 int len;
2312
1da177e4
LT		 2313 rptr = readw(ofsAddr + TXrptr);
2314 wptr = readw(ofsAddr + TXwptr);
2315 mask = readw(ofsAddr + TX_mask);
2316 len = mask - ((wptr - rptr) & mask);
2317 return (len);
2318}
2319
b4173f45 2320static int MoxaPortRxQueue(struct moxa_port *port)
1da177e4 2321{
b4173f45 2322 void __iomem *ofsAddr = port->tableAddr;
1da177e4
LT		 2323 ushort rptr, wptr, mask;
2324 int len;
2325
1da177e4
LT		 2326 rptr = readw(ofsAddr + RXrptr);
2327 wptr = readw(ofsAddr + RXwptr);
2328 mask = readw(ofsAddr + RX_mask);
2329 len = (wptr - rptr) & mask;
2330 return (len);
2331}
2332
2333
b4173f45 2334static void MoxaPortTxDisable(struct moxa_port *port)
1da177e4 2335{
b4173f45 2336 moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
1da177e4
LT		 2337}
2338
b4173f45 2339static void MoxaPortTxEnable(struct moxa_port *port)
1da177e4 2340{
b4173f45 2341 moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
1da177e4
LT		 2342}
2343
2344
b4173f45 2345static int MoxaPortResetBrkCnt(struct moxa_port *port)
1da177e4
LT		 2346{
2347 ushort cnt;
b4173f45
JS		 2348 cnt = port->breakCnt;
2349 port->breakCnt = 0;
1da177e4
LT		 2350 return (cnt);
2351}
2352
8f8ecbad 2353static int moxa_get_serial_info(struct moxa_port *info,
1da177e4
LT		 2354 struct serial_struct __user *retinfo)
2355{
2356 struct serial_struct tmp;
2357
2358 memset(&tmp, 0, sizeof(tmp));
2359 tmp.type = info->type;
b4173f45 2360 tmp.line = info->tty->index;
1da177e4
LT		 2361 tmp.port = 0;
2362 tmp.irq = 0;
2363 tmp.flags = info->asyncflags;
2364 tmp.baud_base = 921600;
2365 tmp.close_delay = info->close_delay;
1da177e4
LT		 2366 tmp.custom_divisor = 0;
2367 tmp.hub6 = 0;
2368 if(copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2369 return -EFAULT;
2370 return (0);
2371}
2372
2373
8f8ecbad 2374static int moxa_set_serial_info(struct moxa_port *info,
1da177e4
LT		 2375 struct serial_struct __user *new_info)
2376{
2377 struct serial_struct new_serial;
2378
2379 if(copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2380 return -EFAULT;
2381
2382 if ((new_serial.irq != 0) ||
2383 (new_serial.port != 0) ||
2384// (new_serial.type != info->type) ||
2385 (new_serial.custom_divisor != 0) ||
2386 (new_serial.baud_base != 921600))
2387 return (-EPERM);
2388
2389 if (!capable(CAP_SYS_ADMIN)) {
2390 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
2391 (info->asyncflags & ~ASYNC_USR_MASK)))
2392 return (-EPERM);
2393 } else {
2394 info->close_delay = new_serial.close_delay * HZ / 100;
1da177e4
LT		 2395 }
2396
2397 new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
2398 new_serial.flags |= (info->asyncflags & ASYNC_FLAGS);
2399
2400 if (new_serial.type == PORT_16550A) {
b4173f45 2401 MoxaSetFifo(info, 1);
1da177e4 2402 } else {
b4173f45 2403 MoxaSetFifo(info, 0);
1da177e4
LT		 2404 }
2405
2406 info->type = new_serial.type;
2407 return (0);
2408}
2409
2410
2411
2412/*****************************************************************************
2413 * Static local functions: *
2414 *****************************************************************************/
1da177e4 2415
6f56b658 2416static void moxa_low_water_check(void __iomem *ofsAddr)
1da177e4
LT		 2417{
2418 int len;
2419 ushort rptr, wptr, mask;
2420
2421 if (readb(ofsAddr + FlagStat) & Xoff_state) {
2422 rptr = readw(ofsAddr + RXrptr);
2423 wptr = readw(ofsAddr + RXwptr);
2424 mask = readw(ofsAddr + RX_mask);
2425 len = (wptr - rptr) & mask;
2426 if (len <= Low_water)
2427 moxafunc(ofsAddr, FC_SendXon, 0);
2428 }
2429}
2430
b4173f45 2431static void MoxaSetFifo(struct moxa_port *port, int enable)
1da177e4 2432{
b4173f45 2433 void __iomem *ofsAddr = port->tableAddr;
1da177e4
LT		 2434
2435 if (!enable) {
2436 moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
2437 moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
2438 } else {
2439 moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
2440 moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
2441 }
2442}
Ubuntu Focal Linux kernel mirror