moxa.c 53.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
/*****************************************************************************/
/*
 *           moxa.c  -- MOXA Intellio family multiport serial driver.
 *
J
Jiri Slaby 已提交
5 6
 *      Copyright (C) 1999-2000  Moxa Technologies (support@moxa.com).
 *      Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *
 *      This code is loosely based on the Linux serial driver, written by
 *      Linus Torvalds, Theodore T'so and others.
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 */

/*
 *    MOXA Intellio Series Driver
 *      for             : LINUX
 *      date            : 1999/1/7
 *      version         : 5.1
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/errno.h>
J
Jiri Slaby 已提交
29
#include <linux/firmware.h>
L
Linus Torvalds 已提交
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/fcntl.h>
#include <linux/ptrace.h>
#include <linux/serial.h>
#include <linux/tty_driver.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/bitops.h>

#include <asm/system.h>
#include <asm/io.h>
#include <asm/uaccess.h>

J
Jiri Slaby 已提交
51 52
#include "moxa.h"

J
Jiri Slaby 已提交
53
#define MOXA_VERSION		"6.0k"
L
Linus Torvalds 已提交
54

J
Jiri Slaby 已提交
55 56
#define MOXA_FW_HDRLEN		32

J
Jiri Slaby 已提交
57
#define MOXAMAJOR		172
L
Linus Torvalds 已提交
58

J
Jiri Slaby 已提交
59
#define MAX_BOARDS		4	/* Don't change this value */
L
Linus Torvalds 已提交
60
#define MAX_PORTS_PER_BOARD	32	/* Don't change this value */
J
Jiri Slaby 已提交
61
#define MAX_PORTS		(MAX_BOARDS * MAX_PORTS_PER_BOARD)
L
Linus Torvalds 已提交
62

63 64 65
#define MOXA_IS_320(brd) ((brd)->boardType == MOXA_BOARD_C320_ISA || \
		(brd)->boardType == MOXA_BOARD_C320_PCI)

L
Linus Torvalds 已提交
66 67 68
/*
 *    Define the Moxa PCI vendor and device IDs.
 */
J
Jiri Slaby 已提交
69 70
#define MOXA_BUS_TYPE_ISA	0
#define MOXA_BUS_TYPE_PCI	1
L
Linus Torvalds 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

enum {
	MOXA_BOARD_C218_PCI = 1,
	MOXA_BOARD_C218_ISA,
	MOXA_BOARD_C320_PCI,
	MOXA_BOARD_C320_ISA,
	MOXA_BOARD_CP204J,
};

static char *moxa_brdname[] =
{
	"C218 Turbo PCI series",
	"C218 Turbo ISA series",
	"C320 Turbo PCI series",
	"C320 Turbo ISA series",
	"CP-204J series",
};

#ifdef CONFIG_PCI
static struct pci_device_id moxa_pcibrds[] = {
J
Jiri Slaby 已提交
91 92 93 94 95 96
	{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C218),
		.driver_data = MOXA_BOARD_C218_PCI },
	{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_C320),
		.driver_data = MOXA_BOARD_C320_PCI },
	{ PCI_DEVICE(PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_MOXA_CP204J),
		.driver_data = MOXA_BOARD_CP204J },
L
Linus Torvalds 已提交
97 98 99 100 101
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
#endif /* CONFIG_PCI */

J
Jiri Slaby 已提交
102 103
struct moxa_port;

104
static struct moxa_board_conf {
L
Linus Torvalds 已提交
105 106 107
	int boardType;
	int numPorts;
	int busType;
108

109
	unsigned int ready;
110

J
Jiri Slaby 已提交
111 112
	struct moxa_port *ports;

113 114 115 116 117 118 119 120 121 122 123 124
	void __iomem *basemem;
	void __iomem *intNdx;
	void __iomem *intPend;
	void __iomem *intTable;
} moxa_boards[MAX_BOARDS];

struct mxser_mstatus {
	tcflag_t cflag;
	int cts;
	int dsr;
	int ri;
	int dcd;
125
};
L
Linus Torvalds 已提交
126

127 128 129 130
struct moxaq_str {
	int inq;
	int outq;
};
L
Linus Torvalds 已提交
131

132
struct moxa_port {
J
Jiri Slaby 已提交
133
	struct moxa_board_conf *board;
J
Jiri Slaby 已提交
134 135 136
	struct tty_struct *tty;
	void __iomem *tableAddr;

L
Linus Torvalds 已提交
137 138
	int type;
	int close_delay;
J
Jiri Slaby 已提交
139
	unsigned int count;
L
Linus Torvalds 已提交
140 141
	int asyncflags;
	int cflag;
J
Jiri Slaby 已提交
142
	unsigned long statusflags;
L
Linus Torvalds 已提交
143 144
	wait_queue_head_t open_wait;

J
Jiri Slaby 已提交
145 146 147
	u8 DCDState;
	u8 lineCtrl;
	u8 lowChkFlag;
148
};
L
Linus Torvalds 已提交
149

J
Jiri Slaby 已提交
150 151 152 153 154 155
struct mon_str {
	int tick;
	int rxcnt[MAX_PORTS];
	int txcnt[MAX_PORTS];
};

L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163 164 165 166
/* statusflags */
#define TXSTOPPED	0x1
#define LOWWAIT 	0x2
#define EMPTYWAIT	0x4
#define THROTTLE	0x8

#define SERIAL_DO_RESTART

#define WAKEUP_CHARS		256

static int ttymajor = MOXAMAJOR;
J
Jiri Slaby 已提交
167 168
static struct mon_str moxaLog;
static unsigned int moxaFuncTout = HZ / 2;
J
Jiri Slaby 已提交
169
static unsigned int moxaLowWaterChk;
J
Jiri Slaby 已提交
170
static DEFINE_MUTEX(moxa_openlock);
L
Linus Torvalds 已提交
171 172
/* Variables for insmod */
#ifdef MODULE
173 174 175
static unsigned long baseaddr[MAX_BOARDS];
static unsigned int type[MAX_BOARDS];
static unsigned int numports[MAX_BOARDS];
L
Linus Torvalds 已提交
176 177 178 179 180 181
#endif

MODULE_AUTHOR("William Chen");
MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
MODULE_LICENSE("GPL");
#ifdef MODULE
182 183 184 185 186 187
module_param_array(type, uint, NULL, 0);
MODULE_PARM_DESC(type, "card type: C218=2, C320=4");
module_param_array(baseaddr, ulong, NULL, 0);
MODULE_PARM_DESC(baseaddr, "base address");
module_param_array(numports, uint, NULL, 0);
MODULE_PARM_DESC(numports, "numports (ignored for C218)");
L
Linus Torvalds 已提交
188 189 190 191 192 193 194 195 196 197 198 199 200 201
#endif
module_param(ttymajor, int, 0);

/*
 * static functions:
 */
static int moxa_open(struct tty_struct *, struct file *);
static void moxa_close(struct tty_struct *, struct file *);
static int moxa_write(struct tty_struct *, const unsigned char *, int);
static int moxa_write_room(struct tty_struct *);
static void moxa_flush_buffer(struct tty_struct *);
static int moxa_chars_in_buffer(struct tty_struct *);
static void moxa_throttle(struct tty_struct *);
static void moxa_unthrottle(struct tty_struct *);
A
Alan Cox 已提交
202
static void moxa_set_termios(struct tty_struct *, struct ktermios *);
L
Linus Torvalds 已提交
203 204 205 206 207 208 209
static void moxa_stop(struct tty_struct *);
static void moxa_start(struct tty_struct *);
static void moxa_hangup(struct tty_struct *);
static int moxa_tiocmget(struct tty_struct *tty, struct file *file);
static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
			 unsigned int set, unsigned int clear);
static void moxa_poll(unsigned long);
A
Alan Cox 已提交
210
static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
J
Jiri Slaby 已提交
211 212
static void moxa_setup_empty_event(struct tty_struct *);
static void moxa_shut_down(struct moxa_port *);
L
Linus Torvalds 已提交
213 214 215
/*
 * moxa board interface functions:
 */
J
Jiri Slaby 已提交
216 217 218 219 220 221 222 223
static void MoxaPortEnable(struct moxa_port *);
static void MoxaPortDisable(struct moxa_port *);
static int MoxaPortSetTermio(struct moxa_port *, struct ktermios *, speed_t);
static int MoxaPortGetLineOut(struct moxa_port *, int *, int *);
static void MoxaPortLineCtrl(struct moxa_port *, int, int);
static void MoxaPortFlowCtrl(struct moxa_port *, int, int, int, int, int);
static int MoxaPortLineStatus(struct moxa_port *);
static void MoxaPortFlushData(struct moxa_port *, int);
J
Jiri Slaby 已提交
224
static int MoxaPortWriteData(struct moxa_port *, const unsigned char *, int);
J
Jiri Slaby 已提交
225
static int MoxaPortReadData(struct moxa_port *);
J
Jiri Slaby 已提交
226 227 228 229 230
static int MoxaPortTxQueue(struct moxa_port *);
static int MoxaPortRxQueue(struct moxa_port *);
static int MoxaPortTxFree(struct moxa_port *);
static void MoxaPortTxDisable(struct moxa_port *);
static void MoxaPortTxEnable(struct moxa_port *);
231 232
static int moxa_get_serial_info(struct moxa_port *, struct serial_struct __user *);
static int moxa_set_serial_info(struct moxa_port *, struct serial_struct __user *);
J
Jiri Slaby 已提交
233
static void MoxaSetFifo(struct moxa_port *port, int enable);
L
Linus Torvalds 已提交
234

J
Jiri Slaby 已提交
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
/*
 * I/O functions
 */

static void moxa_wait_finish(void __iomem *ofsAddr)
{
	unsigned long end = jiffies + moxaFuncTout;

	while (readw(ofsAddr + FuncCode) != 0)
		if (time_after(jiffies, end))
			return;
	if (readw(ofsAddr + FuncCode) != 0 && printk_ratelimit())
		printk(KERN_WARNING "moxa function expired\n");
}

J
Jiri Slaby 已提交
250
static void moxafunc(void __iomem *ofsAddr, u16 cmd, u16 arg)
J
Jiri Slaby 已提交
251 252 253 254 255 256
{
	writew(arg, ofsAddr + FuncArg);
	writew(cmd, ofsAddr + FuncCode);
	moxa_wait_finish(ofsAddr);
}

J
Jiri Slaby 已提交
257 258 259 260 261 262 263 264 265 266 267 268 269 270
static void moxa_low_water_check(void __iomem *ofsAddr)
{
	u16 rptr, wptr, mask, len;

	if (readb(ofsAddr + FlagStat) & Xoff_state) {
		rptr = readw(ofsAddr + RXrptr);
		wptr = readw(ofsAddr + RXwptr);
		mask = readw(ofsAddr + RX_mask);
		len = (wptr - rptr) & mask;
		if (len <= Low_water)
			moxafunc(ofsAddr, FC_SendXon, 0);
	}
}

J
Jiri Slaby 已提交
271 272 273 274 275 276 277 278 279
/*
 * TTY operations
 */

static int moxa_ioctl(struct tty_struct *tty, struct file *file,
		      unsigned int cmd, unsigned long arg)
{
	struct moxa_port *ch = tty->driver_data;
	void __user *argp = (void __user *)arg;
J
Jiri Slaby 已提交
280
	int status, ret = 0;
J
Jiri Slaby 已提交
281 282 283 284 285 286 287 288 289 290 291

	if (tty->index == MAX_PORTS) {
		if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
				cmd != MOXA_GETMSTATUS)
			return -EINVAL;
	} else if (!ch)
		return -ENODEV;

	switch (cmd) {
	case MOXA_GETDATACOUNT:
		moxaLog.tick = jiffies;
J
Jiri Slaby 已提交
292 293 294
		if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))
			ret = -EFAULT;
		break;
J
Jiri Slaby 已提交
295 296
	case MOXA_FLUSH_QUEUE:
		MoxaPortFlushData(ch, arg);
J
Jiri Slaby 已提交
297
		break;
J
Jiri Slaby 已提交
298 299 300 301 302 303
	case MOXA_GET_IOQUEUE: {
		struct moxaq_str __user *argm = argp;
		struct moxaq_str tmp;
		struct moxa_port *p;
		unsigned int i, j;

J
Jiri Slaby 已提交
304
		mutex_lock(&moxa_openlock);
J
Jiri Slaby 已提交
305 306 307 308 309 310 311 312
		for (i = 0; i < MAX_BOARDS; i++) {
			p = moxa_boards[i].ports;
			for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
				memset(&tmp, 0, sizeof(tmp));
				if (moxa_boards[i].ready) {
					tmp.inq = MoxaPortRxQueue(p);
					tmp.outq = MoxaPortTxQueue(p);
				}
J
Jiri Slaby 已提交
313 314
				if (copy_to_user(argm, &tmp, sizeof(tmp))) {
					mutex_unlock(&moxa_openlock);
J
Jiri Slaby 已提交
315
					return -EFAULT;
J
Jiri Slaby 已提交
316
				}
J
Jiri Slaby 已提交
317 318
			}
		}
J
Jiri Slaby 已提交
319 320
		mutex_unlock(&moxa_openlock);
		break;
J
Jiri Slaby 已提交
321 322
	} case MOXA_GET_OQUEUE:
		status = MoxaPortTxQueue(ch);
J
Jiri Slaby 已提交
323 324
		ret = put_user(status, (unsigned long __user *)argp);
		break;
J
Jiri Slaby 已提交
325 326
	case MOXA_GET_IQUEUE:
		status = MoxaPortRxQueue(ch);
J
Jiri Slaby 已提交
327 328
		ret = put_user(status, (unsigned long __user *)argp);
		break;
J
Jiri Slaby 已提交
329 330 331 332 333 334
	case MOXA_GETMSTATUS: {
		struct mxser_mstatus __user *argm = argp;
		struct mxser_mstatus tmp;
		struct moxa_port *p;
		unsigned int i, j;

J
Jiri Slaby 已提交
335
		mutex_lock(&moxa_openlock);
J
Jiri Slaby 已提交
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
		for (i = 0; i < MAX_BOARDS; i++) {
			p = moxa_boards[i].ports;
			for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
				memset(&tmp, 0, sizeof(tmp));
				if (!moxa_boards[i].ready)
					goto copy;

				status = MoxaPortLineStatus(p);
				if (status & 1)
					tmp.cts = 1;
				if (status & 2)
					tmp.dsr = 1;
				if (status & 4)
					tmp.dcd = 1;

				if (!p->tty || !p->tty->termios)
					tmp.cflag = p->cflag;
				else
					tmp.cflag = p->tty->termios->c_cflag;
copy:
J
Jiri Slaby 已提交
356 357
				if (copy_to_user(argm, &tmp, sizeof(tmp))) {
					mutex_unlock(&moxa_openlock);
J
Jiri Slaby 已提交
358
					return -EFAULT;
J
Jiri Slaby 已提交
359
				}
J
Jiri Slaby 已提交
360 361
			}
		}
J
Jiri Slaby 已提交
362 363
		mutex_unlock(&moxa_openlock);
		break;
J
Jiri Slaby 已提交
364 365
	}
	case TIOCGSERIAL:
J
Jiri Slaby 已提交
366 367 368 369
		mutex_lock(&moxa_openlock);
		ret = moxa_get_serial_info(ch, argp);
		mutex_unlock(&moxa_openlock);
		break;
J
Jiri Slaby 已提交
370
	case TIOCSSERIAL:
J
Jiri Slaby 已提交
371 372 373 374 375 376
		mutex_lock(&moxa_openlock);
		ret = moxa_set_serial_info(ch, argp);
		mutex_unlock(&moxa_openlock);
		break;
	default:
		ret = -ENOIOCTLCMD;
J
Jiri Slaby 已提交
377
	}
J
Jiri Slaby 已提交
378
	return ret;
J
Jiri Slaby 已提交
379 380 381 382 383 384 385 386 387 388
}

static void moxa_break_ctl(struct tty_struct *tty, int state)
{
	struct moxa_port *port = tty->driver_data;

	moxafunc(port->tableAddr, state ? FC_SendBreak : FC_StopBreak,
			Magic_code);
}

J
Jeff Dike 已提交
389
static const struct tty_operations moxa_ops = {
L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397 398 399 400 401 402
	.open = moxa_open,
	.close = moxa_close,
	.write = moxa_write,
	.write_room = moxa_write_room,
	.flush_buffer = moxa_flush_buffer,
	.chars_in_buffer = moxa_chars_in_buffer,
	.ioctl = moxa_ioctl,
	.throttle = moxa_throttle,
	.unthrottle = moxa_unthrottle,
	.set_termios = moxa_set_termios,
	.stop = moxa_stop,
	.start = moxa_start,
	.hangup = moxa_hangup,
J
Jiri Slaby 已提交
403
	.break_ctl = moxa_break_ctl,
L
Linus Torvalds 已提交
404 405 406 407
	.tiocmget = moxa_tiocmget,
	.tiocmset = moxa_tiocmset,
};

J
Jiri Slaby 已提交
408 409
static struct tty_driver *moxaDriver;
static DEFINE_TIMER(moxaTimer, moxa_poll, 0, 0);
I
Ingo Molnar 已提交
410
static DEFINE_SPINLOCK(moxa_lock);
A
Alan Cox 已提交
411

J
Jiri Slaby 已提交
412 413 414 415
/*
 * HW init
 */

J
Jiri Slaby 已提交
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
static int moxa_check_fw_model(struct moxa_board_conf *brd, u8 model)
{
	switch (brd->boardType) {
	case MOXA_BOARD_C218_ISA:
	case MOXA_BOARD_C218_PCI:
		if (model != 1)
			goto err;
		break;
	case MOXA_BOARD_CP204J:
		if (model != 3)
			goto err;
		break;
	default:
		if (model != 2)
			goto err;
		break;
	}
	return 0;
err:
	return -EINVAL;
}

static int moxa_check_fw(const void *ptr)
{
	const __le16 *lptr = ptr;

	if (*lptr != cpu_to_le16(0x7980))
		return -EINVAL;

	return 0;
}

static int moxa_load_bios(struct moxa_board_conf *brd, const u8 *buf,
		size_t len)
{
	void __iomem *baseAddr = brd->basemem;
	u16 tmp;

	writeb(HW_reset, baseAddr + Control_reg);	/* reset */
	msleep(10);
	memset_io(baseAddr, 0, 4096);
	memcpy_toio(baseAddr, buf, len);	/* download BIOS */
	writeb(0, baseAddr + Control_reg);	/* restart */

	msleep(2000);

	switch (brd->boardType) {
	case MOXA_BOARD_C218_ISA:
	case MOXA_BOARD_C218_PCI:
		tmp = readw(baseAddr + C218_key);
		if (tmp != C218_KeyCode)
			goto err;
		break;
	case MOXA_BOARD_CP204J:
		tmp = readw(baseAddr + C218_key);
		if (tmp != CP204J_KeyCode)
			goto err;
		break;
	default:
		tmp = readw(baseAddr + C320_key);
		if (tmp != C320_KeyCode)
			goto err;
		tmp = readw(baseAddr + C320_status);
		if (tmp != STS_init) {
J
Jiri Slaby 已提交
480
			printk(KERN_ERR "MOXA: bios upload failed -- CPU/Basic "
J
Jiri Slaby 已提交
481 482 483 484 485 486 487 488
					"module not found\n");
			return -EIO;
		}
		break;
	}

	return 0;
err:
J
Jiri Slaby 已提交
489
	printk(KERN_ERR "MOXA: bios upload failed -- board not found\n");
J
Jiri Slaby 已提交
490 491 492 493 494 495 496 497 498
	return -EIO;
}

static int moxa_load_320b(struct moxa_board_conf *brd, const u8 *ptr,
		size_t len)
{
	void __iomem *baseAddr = brd->basemem;

	if (len < 7168) {
J
Jiri Slaby 已提交
499
		printk(KERN_ERR "MOXA: invalid 320 bios -- too short\n");
J
Jiri Slaby 已提交
500 501 502 503 504 505 506 507 508 509 510 511
		return -EINVAL;
	}

	writew(len - 7168 - 2, baseAddr + C320bapi_len);
	writeb(1, baseAddr + Control_reg);	/* Select Page 1 */
	memcpy_toio(baseAddr + DynPage_addr, ptr, 7168);
	writeb(2, baseAddr + Control_reg);	/* Select Page 2 */
	memcpy_toio(baseAddr + DynPage_addr, ptr + 7168, len - 7168);

	return 0;
}

512
static int moxa_real_load_code(struct moxa_board_conf *brd, const void *ptr,
J
Jiri Slaby 已提交
513 514 515 516 517
		size_t len)
{
	void __iomem *baseAddr = brd->basemem;
	const u16 *uptr = ptr;
	size_t wlen, len2, j;
518
	unsigned long key, loadbuf, loadlen, checksum, checksum_ok;
519
	unsigned int i, retry;
J
Jiri Slaby 已提交
520 521
	u16 usum, keycode;

522 523
	keycode = (brd->boardType == MOXA_BOARD_CP204J) ? CP204J_KeyCode :
				C218_KeyCode;
J
Jiri Slaby 已提交
524

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
	switch (brd->boardType) {
	case MOXA_BOARD_CP204J:
	case MOXA_BOARD_C218_ISA:
	case MOXA_BOARD_C218_PCI:
		key = C218_key;
		loadbuf = C218_LoadBuf;
		loadlen = C218DLoad_len;
		checksum = C218check_sum;
		checksum_ok = C218chksum_ok;
		break;
	default:
		key = C320_key;
		keycode = C320_KeyCode;
		loadbuf = C320_LoadBuf;
		loadlen = C320DLoad_len;
		checksum = C320check_sum;
		checksum_ok = C320chksum_ok;
		break;
J
Jiri Slaby 已提交
543 544 545 546 547 548 549 550 551 552 553 554 555
	}

	usum = 0;
	wlen = len >> 1;
	for (i = 0; i < wlen; i++)
		usum += le16_to_cpu(uptr[i]);
	retry = 0;
	do {
		wlen = len >> 1;
		j = 0;
		while (wlen) {
			len2 = (wlen > 2048) ? 2048 : wlen;
			wlen -= len2;
556
			memcpy_toio(baseAddr + loadbuf, ptr + j, len2 << 1);
J
Jiri Slaby 已提交
557
			j += len2 << 1;
558 559 560 561 562

			writew(len2, baseAddr + loadlen);
			writew(0, baseAddr + key);
			for (i = 0; i < 100; i++) {
				if (readw(baseAddr + key) == keycode)
J
Jiri Slaby 已提交
563 564 565
					break;
				msleep(10);
			}
566
			if (readw(baseAddr + key) != keycode)
J
Jiri Slaby 已提交
567 568
				return -EIO;
		}
569 570 571 572 573
		writew(0, baseAddr + loadlen);
		writew(usum, baseAddr + checksum);
		writew(0, baseAddr + key);
		for (i = 0; i < 100; i++) {
			if (readw(baseAddr + key) == keycode)
J
Jiri Slaby 已提交
574 575 576 577
				break;
			msleep(10);
		}
		retry++;
578 579
	} while ((readb(baseAddr + checksum_ok) != 1) && (retry < 3));
	if (readb(baseAddr + checksum_ok) != 1)
J
Jiri Slaby 已提交
580 581
		return -EIO;

582
	writew(0, baseAddr + key);
J
Jiri Slaby 已提交
583 584 585 586 587 588 589 590
	for (i = 0; i < 600; i++) {
		if (readw(baseAddr + Magic_no) == Magic_code)
			break;
		msleep(10);
	}
	if (readw(baseAddr + Magic_no) != Magic_code)
		return -EIO;

591
	if (MOXA_IS_320(brd)) {
592 593 594 595 596 597 598 599 600
		if (brd->busType == MOXA_BUS_TYPE_PCI) {	/* ASIC board */
			writew(0x3800, baseAddr + TMS320_PORT1);
			writew(0x3900, baseAddr + TMS320_PORT2);
			writew(28499, baseAddr + TMS320_CLOCK);
		} else {
			writew(0x3200, baseAddr + TMS320_PORT1);
			writew(0x3400, baseAddr + TMS320_PORT2);
			writew(19999, baseAddr + TMS320_CLOCK);
		}
J
Jiri Slaby 已提交
601 602 603 604 605 606 607 608 609 610 611
	}
	writew(1, baseAddr + Disable_IRQ);
	writew(0, baseAddr + Magic_no);
	for (i = 0; i < 500; i++) {
		if (readw(baseAddr + Magic_no) == Magic_code)
			break;
		msleep(10);
	}
	if (readw(baseAddr + Magic_no) != Magic_code)
		return -EIO;

612
	if (MOXA_IS_320(brd)) {
613 614 615 616 617 618 619 620 621 622 623 624 625
		j = readw(baseAddr + Module_cnt);
		if (j <= 0)
			return -EIO;
		brd->numPorts = j * 8;
		writew(j, baseAddr + Module_no);
		writew(0, baseAddr + Magic_no);
		for (i = 0; i < 600; i++) {
			if (readw(baseAddr + Magic_no) == Magic_code)
				break;
			msleep(10);
		}
		if (readw(baseAddr + Magic_no) != Magic_code)
			return -EIO;
J
Jiri Slaby 已提交
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
	}
	brd->intNdx = baseAddr + IRQindex;
	brd->intPend = baseAddr + IRQpending;
	brd->intTable = baseAddr + IRQtable;

	return 0;
}

static int moxa_load_code(struct moxa_board_conf *brd, const void *ptr,
		size_t len)
{
	void __iomem *ofsAddr, *baseAddr = brd->basemem;
	struct moxa_port *port;
	int retval, i;

	if (len % 2) {
J
Jiri Slaby 已提交
642
		printk(KERN_ERR "MOXA: bios length is not even\n");
J
Jiri Slaby 已提交
643 644 645
		return -EINVAL;
	}

646 647 648 649
	retval = moxa_real_load_code(brd, ptr, len); /* may change numPorts */
	if (retval)
		return retval;

J
Jiri Slaby 已提交
650 651 652 653 654 655
	switch (brd->boardType) {
	case MOXA_BOARD_C218_ISA:
	case MOXA_BOARD_C218_PCI:
	case MOXA_BOARD_CP204J:
		port = brd->ports;
		for (i = 0; i < brd->numPorts; i++, port++) {
J
Jiri Slaby 已提交
656
			port->board = brd;
J
Jiri Slaby 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
			port->DCDState = 0;
			port->tableAddr = baseAddr + Extern_table +
					Extern_size * i;
			ofsAddr = port->tableAddr;
			writew(C218rx_mask, ofsAddr + RX_mask);
			writew(C218tx_mask, ofsAddr + TX_mask);
			writew(C218rx_spage + i * C218buf_pageno, ofsAddr + Page_rxb);
			writew(readw(ofsAddr + Page_rxb) + C218rx_pageno, ofsAddr + EndPage_rxb);

			writew(C218tx_spage + i * C218buf_pageno, ofsAddr + Page_txb);
			writew(readw(ofsAddr + Page_txb) + C218tx_pageno, ofsAddr + EndPage_txb);

		}
		break;
	default:
		port = brd->ports;
		for (i = 0; i < brd->numPorts; i++, port++) {
J
Jiri Slaby 已提交
674
			port->board = brd;
J
Jiri Slaby 已提交
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
			port->DCDState = 0;
			port->tableAddr = baseAddr + Extern_table +
					Extern_size * i;
			ofsAddr = port->tableAddr;
			switch (brd->numPorts) {
			case 8:
				writew(C320p8rx_mask, ofsAddr + RX_mask);
				writew(C320p8tx_mask, ofsAddr + TX_mask);
				writew(C320p8rx_spage + i * C320p8buf_pgno, ofsAddr + Page_rxb);
				writew(readw(ofsAddr + Page_rxb) + C320p8rx_pgno, ofsAddr + EndPage_rxb);
				writew(C320p8tx_spage + i * C320p8buf_pgno, ofsAddr + Page_txb);
				writew(readw(ofsAddr + Page_txb) + C320p8tx_pgno, ofsAddr + EndPage_txb);

				break;
			case 16:
				writew(C320p16rx_mask, ofsAddr + RX_mask);
				writew(C320p16tx_mask, ofsAddr + TX_mask);
				writew(C320p16rx_spage + i * C320p16buf_pgno, ofsAddr + Page_rxb);
				writew(readw(ofsAddr + Page_rxb) + C320p16rx_pgno, ofsAddr + EndPage_rxb);
				writew(C320p16tx_spage + i * C320p16buf_pgno, ofsAddr + Page_txb);
				writew(readw(ofsAddr + Page_txb) + C320p16tx_pgno, ofsAddr + EndPage_txb);
				break;

			case 24:
				writew(C320p24rx_mask, ofsAddr + RX_mask);
				writew(C320p24tx_mask, ofsAddr + TX_mask);
				writew(C320p24rx_spage + i * C320p24buf_pgno, ofsAddr + Page_rxb);
				writew(readw(ofsAddr + Page_rxb) + C320p24rx_pgno, ofsAddr + EndPage_rxb);
				writew(C320p24tx_spage + i * C320p24buf_pgno, ofsAddr + Page_txb);
				writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
				break;
			case 32:
				writew(C320p32rx_mask, ofsAddr + RX_mask);
				writew(C320p32tx_mask, ofsAddr + TX_mask);
				writew(C320p32tx_ofs, ofsAddr + Ofs_txb);
				writew(C320p32rx_spage + i * C320p32buf_pgno, ofsAddr + Page_rxb);
				writew(readb(ofsAddr + Page_rxb), ofsAddr + EndPage_rxb);
				writew(C320p32tx_spage + i * C320p32buf_pgno, ofsAddr + Page_txb);
				writew(readw(ofsAddr + Page_txb), ofsAddr + EndPage_txb);
				break;
			}
		}
		break;
	}
	return 0;
}

static int moxa_load_fw(struct moxa_board_conf *brd, const struct firmware *fw)
{
	void *ptr = fw->data;
	char rsn[64];
	u16 lens[5];
	size_t len;
	unsigned int a, lenp, lencnt;
	int ret = -EINVAL;
	struct {
		__le32 magic;	/* 0x34303430 */
		u8 reserved1[2];
		u8 type;	/* UNIX = 3 */
		u8 model;	/* C218T=1, C320T=2, CP204=3 */
		u8 reserved2[8];
		__le16 len[5];
	} *hdr = ptr;

	BUILD_BUG_ON(ARRAY_SIZE(hdr->len) != ARRAY_SIZE(lens));

	if (fw->size < MOXA_FW_HDRLEN) {
		strcpy(rsn, "too short (even header won't fit)");
		goto err;
	}
	if (hdr->magic != cpu_to_le32(0x30343034)) {
		sprintf(rsn, "bad magic: %.8x", le32_to_cpu(hdr->magic));
		goto err;
	}
	if (hdr->type != 3) {
		sprintf(rsn, "not for linux, type is %u", hdr->type);
		goto err;
	}
	if (moxa_check_fw_model(brd, hdr->model)) {
		sprintf(rsn, "not for this card, model is %u", hdr->model);
		goto err;
	}

	len = MOXA_FW_HDRLEN;
	lencnt = hdr->model == 2 ? 5 : 3;
	for (a = 0; a < ARRAY_SIZE(lens); a++) {
		lens[a] = le16_to_cpu(hdr->len[a]);
		if (lens[a] && len + lens[a] <= fw->size &&
				moxa_check_fw(&fw->data[len]))
J
Jiri Slaby 已提交
764
			printk(KERN_WARNING "MOXA firmware: unexpected input "
J
Jiri Slaby 已提交
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
				"at offset %u, but going on\n", (u32)len);
		if (!lens[a] && a < lencnt) {
			sprintf(rsn, "too few entries in fw file");
			goto err;
		}
		len += lens[a];
	}

	if (len != fw->size) {
		sprintf(rsn, "bad length: %u (should be %u)", (u32)fw->size,
				(u32)len);
		goto err;
	}

	ptr += MOXA_FW_HDRLEN;
	lenp = 0; /* bios */

	strcpy(rsn, "read above");

	ret = moxa_load_bios(brd, ptr, lens[lenp]);
	if (ret)
		goto err;

	/* we skip the tty section (lens[1]), since we don't need it */
	ptr += lens[lenp] + lens[lenp + 1];
	lenp += 2; /* comm */

	if (hdr->model == 2) {
		ret = moxa_load_320b(brd, ptr, lens[lenp]);
		if (ret)
			goto err;
		/* skip another tty */
		ptr += lens[lenp] + lens[lenp + 1];
		lenp += 2;
	}

	ret = moxa_load_code(brd, ptr, lens[lenp]);
	if (ret)
		goto err;

	return 0;
err:
	printk(KERN_ERR "firmware failed to load, reason: %s\n", rsn);
	return ret;
}

static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
{
	const struct firmware *fw;
	const char *file;
815 816
	struct moxa_port *p;
	unsigned int i;
J
Jiri Slaby 已提交
817 818
	int ret;

819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
	brd->ports = kcalloc(MAX_PORTS_PER_BOARD, sizeof(*brd->ports),
			GFP_KERNEL);
	if (brd->ports == NULL) {
		printk(KERN_ERR "cannot allocate memory for ports\n");
		ret = -ENOMEM;
		goto err;
	}

	for (i = 0, p = brd->ports; i < MAX_PORTS_PER_BOARD; i++, p++) {
		p->type = PORT_16550A;
		p->close_delay = 5 * HZ / 10;
		p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
		init_waitqueue_head(&p->open_wait);
	}

J
Jiri Slaby 已提交
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
	switch (brd->boardType) {
	case MOXA_BOARD_C218_ISA:
	case MOXA_BOARD_C218_PCI:
		file = "c218tunx.cod";
		break;
	case MOXA_BOARD_CP204J:
		file = "cp204unx.cod";
		break;
	default:
		file = "c320tunx.cod";
		break;
	}

	ret = request_firmware(&fw, file, dev);
	if (ret) {
849 850 851 852
		printk(KERN_ERR "MOXA: request_firmware failed. Make sure "
				"you've placed '%s' file into your firmware "
				"loader directory (e.g. /lib/firmware)\n",
				file);
853
		goto err_free;
J
Jiri Slaby 已提交
854 855 856 857 858
	}

	ret = moxa_load_fw(brd, fw);

	release_firmware(fw);
859 860 861 862

	if (ret)
		goto err_free;

J
Jiri Slaby 已提交
863
	spin_lock_bh(&moxa_lock);
864
	brd->ready = 1;
J
Jiri Slaby 已提交
865 866
	if (!timer_pending(&moxaTimer))
		mod_timer(&moxaTimer, jiffies + HZ / 50);
J
Jiri Slaby 已提交
867
	spin_unlock_bh(&moxa_lock);
J
Jiri Slaby 已提交
868

869 870 871 872
	return 0;
err_free:
	kfree(brd->ports);
err:
J
Jiri Slaby 已提交
873 874 875
	return ret;
}

876 877
static void moxa_board_deinit(struct moxa_board_conf *brd)
{
J
Jiri Slaby 已提交
878 879 880
	unsigned int a, opened;

	mutex_lock(&moxa_openlock);
J
Jiri Slaby 已提交
881
	spin_lock_bh(&moxa_lock);
882
	brd->ready = 0;
J
Jiri Slaby 已提交
883
	spin_unlock_bh(&moxa_lock);
J
Jiri Slaby 已提交
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900

	/* pci hot-un-plug support */
	for (a = 0; a < brd->numPorts; a++)
		if (brd->ports[a].asyncflags & ASYNC_INITIALIZED)
			tty_hangup(brd->ports[a].tty);
	while (1) {
		opened = 0;
		for (a = 0; a < brd->numPorts; a++)
			if (brd->ports[a].asyncflags & ASYNC_INITIALIZED)
				opened++;
		mutex_unlock(&moxa_openlock);
		if (!opened)
			break;
		msleep(50);
		mutex_lock(&moxa_openlock);
	}

901 902 903 904 905
	iounmap(brd->basemem);
	brd->basemem = NULL;
	kfree(brd->ports);
}

L
Linus Torvalds 已提交
906
#ifdef CONFIG_PCI
907 908
static int __devinit moxa_pci_probe(struct pci_dev *pdev,
		const struct pci_device_id *ent)
L
Linus Torvalds 已提交
909
{
910 911 912 913 914 915
	struct moxa_board_conf *board;
	unsigned int i;
	int board_type = ent->driver_data;
	int retval;

	retval = pci_enable_device(pdev);
J
Jiri Slaby 已提交
916 917
	if (retval) {
		dev_err(&pdev->dev, "can't enable pci device\n");
918
		goto err;
J
Jiri Slaby 已提交
919
	}
920 921 922 923 924 925 926

	for (i = 0; i < MAX_BOARDS; i++)
		if (moxa_boards[i].basemem == NULL)
			break;

	retval = -ENODEV;
	if (i >= MAX_BOARDS) {
J
Jiri Slaby 已提交
927
		dev_warn(&pdev->dev, "more than %u MOXA Intellio family boards "
928 929 930 931 932
				"found. Board is ignored.\n", MAX_BOARDS);
		goto err;
	}

	board = &moxa_boards[i];
J
Jiri Slaby 已提交
933 934 935 936 937 938 939

	retval = pci_request_region(pdev, 2, "moxa-base");
	if (retval) {
		dev_err(&pdev->dev, "can't request pci region 2\n");
		goto err;
	}

940
	board->basemem = ioremap_nocache(pci_resource_start(pdev, 2), 0x4000);
J
Jiri Slaby 已提交
941 942
	if (board->basemem == NULL) {
		dev_err(&pdev->dev, "can't remap io space 2\n");
J
Jiri Slaby 已提交
943
		goto err_reg;
J
Jiri Slaby 已提交
944
	}
945

L
Linus Torvalds 已提交
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
	board->boardType = board_type;
	switch (board_type) {
	case MOXA_BOARD_C218_ISA:
	case MOXA_BOARD_C218_PCI:
		board->numPorts = 8;
		break;

	case MOXA_BOARD_CP204J:
		board->numPorts = 4;
		break;
	default:
		board->numPorts = 0;
		break;
	}
	board->busType = MOXA_BUS_TYPE_PCI;
J
Jiri Slaby 已提交
961

J
Jiri Slaby 已提交
962 963 964 965
	retval = moxa_init_board(board, &pdev->dev);
	if (retval)
		goto err_base;

966
	pci_set_drvdata(pdev, board);
L
Linus Torvalds 已提交
967

968 969 970
	dev_info(&pdev->dev, "board '%s' ready (%u ports, firmware loaded)\n",
			moxa_brdname[board_type - 1], board->numPorts);

J
Jiri Slaby 已提交
971
	return 0;
J
Jiri Slaby 已提交
972 973 974
err_base:
	iounmap(board->basemem);
	board->basemem = NULL;
J
Jiri Slaby 已提交
975 976
err_reg:
	pci_release_region(pdev, 2);
977 978 979 980 981 982 983 984
err:
	return retval;
}

static void __devexit moxa_pci_remove(struct pci_dev *pdev)
{
	struct moxa_board_conf *brd = pci_get_drvdata(pdev);

985 986
	moxa_board_deinit(brd);

J
Jiri Slaby 已提交
987
	pci_release_region(pdev, 2);
L
Linus Torvalds 已提交
988
}
J
Jiri Slaby 已提交
989 990 991 992 993 994 995

static struct pci_driver moxa_pci_driver = {
	.name = "moxa",
	.id_table = moxa_pcibrds,
	.probe = moxa_pci_probe,
	.remove = __devexit_p(moxa_pci_remove)
};
L
Linus Torvalds 已提交
996 997 998 999
#endif /* CONFIG_PCI */

static int __init moxa_init(void)
{
1000
	unsigned int isabrds = 0;
1001
	int retval = 0;
L
Linus Torvalds 已提交
1002

J
Jiri Slaby 已提交
1003 1004
	printk(KERN_INFO "MOXA Intellio family driver version %s\n",
			MOXA_VERSION);
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009
	moxaDriver = alloc_tty_driver(MAX_PORTS + 1);
	if (!moxaDriver)
		return -ENOMEM;

	moxaDriver->owner = THIS_MODULE;
1010
	moxaDriver->name = "ttyMX";
L
Linus Torvalds 已提交
1011 1012 1013 1014 1015 1016
	moxaDriver->major = ttymajor;
	moxaDriver->minor_start = 0;
	moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
	moxaDriver->subtype = SERIAL_TYPE_NORMAL;
	moxaDriver->init_termios = tty_std_termios;
	moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
A
Alan Cox 已提交
1017 1018
	moxaDriver->init_termios.c_ispeed = 9600;
	moxaDriver->init_termios.c_ospeed = 9600;
L
Linus Torvalds 已提交
1019 1020 1021 1022
	moxaDriver->flags = TTY_DRIVER_REAL_RAW;
	tty_set_operations(moxaDriver, &moxa_ops);

	if (tty_register_driver(moxaDriver)) {
J
Jiri Slaby 已提交
1023
		printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
L
Linus Torvalds 已提交
1024 1025 1026 1027
		put_tty_driver(moxaDriver);
		return -1;
	}

1028
	/* Find the boards defined from module args. */
L
Linus Torvalds 已提交
1029
#ifdef MODULE
1030 1031
	{
	struct moxa_board_conf *brd = moxa_boards;
1032
	unsigned int i;
L
Linus Torvalds 已提交
1033
	for (i = 0; i < MAX_BOARDS; i++) {
1034 1035 1036 1037
		if (!baseaddr[i])
			break;
		if (type[i] == MOXA_BOARD_C218_ISA ||
				type[i] == MOXA_BOARD_C320_ISA) {
J
Jiri Slaby 已提交
1038
			pr_debug("Moxa board %2d: %s board(baseAddr=%lx)\n",
1039 1040 1041 1042 1043 1044
					isabrds + 1, moxa_brdname[type[i] - 1],
					baseaddr[i]);
			brd->boardType = type[i];
			brd->numPorts = type[i] == MOXA_BOARD_C218_ISA ? 8 :
					numports[i];
			brd->busType = MOXA_BUS_TYPE_ISA;
1045
			brd->basemem = ioremap_nocache(baseaddr[i], 0x4000);
1046
			if (!brd->basemem) {
J
Jiri Slaby 已提交
1047
				printk(KERN_ERR "MOXA: can't remap %lx\n",
1048
						baseaddr[i]);
L
Linus Torvalds 已提交
1049 1050
				continue;
			}
J
Jiri Slaby 已提交
1051 1052 1053 1054 1055
			if (moxa_init_board(brd, NULL)) {
				iounmap(brd->basemem);
				brd->basemem = NULL;
				continue;
			}
1056

1057 1058 1059 1060
			printk(KERN_INFO "MOXA isa board found at 0x%.8lu and "
					"ready (%u ports, firmware loaded)\n",
					baseaddr[i], brd->numPorts);

1061 1062
			brd++;
			isabrds++;
L
Linus Torvalds 已提交
1063 1064
		}
	}
1065
	}
L
Linus Torvalds 已提交
1066
#endif
J
Jiri Slaby 已提交
1067

L
Linus Torvalds 已提交
1068
#ifdef CONFIG_PCI
J
Jiri Slaby 已提交
1069 1070
	retval = pci_register_driver(&moxa_pci_driver);
	if (retval) {
J
Jiri Slaby 已提交
1071
		printk(KERN_ERR "Can't register MOXA pci driver!\n");
1072
		if (isabrds)
J
Jiri Slaby 已提交
1073
			retval = 0;
L
Linus Torvalds 已提交
1074 1075
	}
#endif
J
Jiri Slaby 已提交
1076 1077

	return retval;
L
Linus Torvalds 已提交
1078 1079 1080 1081
}

static void __exit moxa_exit(void)
{
J
Jiri Slaby 已提交
1082
	unsigned int i;
L
Linus Torvalds 已提交
1083

1084
#ifdef CONFIG_PCI
J
Jiri Slaby 已提交
1085
	pci_unregister_driver(&moxa_pci_driver);
1086
#endif
J
Jiri Slaby 已提交
1087

1088 1089 1090
	for (i = 0; i < MAX_BOARDS; i++) /* ISA boards */
		if (moxa_boards[i].ready)
			moxa_board_deinit(&moxa_boards[i]);
J
Jiri Slaby 已提交
1091 1092 1093 1094 1095 1096 1097

	del_timer_sync(&moxaTimer);

	if (tty_unregister_driver(moxaDriver))
		printk(KERN_ERR "Couldn't unregister MOXA Intellio family "
				"serial driver\n");
	put_tty_driver(moxaDriver);
L
Linus Torvalds 已提交
1098 1099 1100 1101 1102
}

module_init(moxa_init);
module_exit(moxa_exit);

J
Jiri Slaby 已提交
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
static void moxa_close_port(struct moxa_port *ch)
{
	moxa_shut_down(ch);
	MoxaPortFlushData(ch, 2);
	ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
	ch->tty->driver_data = NULL;
	ch->tty = NULL;
}

static int moxa_block_till_ready(struct tty_struct *tty, struct file *filp,
			    struct moxa_port *ch)
{
	DEFINE_WAIT(wait);
	int retval = 0;
	u8 dcd;

	while (1) {
		prepare_to_wait(&ch->open_wait, &wait, TASK_INTERRUPTIBLE);
		if (tty_hung_up_p(filp)) {
#ifdef SERIAL_DO_RESTART
			retval = -ERESTARTSYS;
#else
			retval = -EAGAIN;
#endif
			break;
		}
		spin_lock_bh(&moxa_lock);
		dcd = ch->DCDState;
		spin_unlock_bh(&moxa_lock);
		if (dcd)
			break;

		if (signal_pending(current)) {
			retval = -ERESTARTSYS;
			break;
		}
		schedule();
	}
	finish_wait(&ch->open_wait, &wait);

	return retval;
}

L
Linus Torvalds 已提交
1146 1147
static int moxa_open(struct tty_struct *tty, struct file *filp)
{
1148
	struct moxa_board_conf *brd;
1149
	struct moxa_port *ch;
L
Linus Torvalds 已提交
1150 1151 1152
	int port;
	int retval;

J
Jiri Slaby 已提交
1153
	port = tty->index;
L
Linus Torvalds 已提交
1154
	if (port == MAX_PORTS) {
J
Jiri Slaby 已提交
1155
		return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
L
Linus Torvalds 已提交
1156
	}
J
Jiri Slaby 已提交
1157 1158
	if (mutex_lock_interruptible(&moxa_openlock))
		return -ERESTARTSYS;
1159
	brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
J
Jiri Slaby 已提交
1160 1161
	if (!brd->ready) {
		mutex_unlock(&moxa_openlock);
1162
		return -ENODEV;
J
Jiri Slaby 已提交
1163
	}
L
Linus Torvalds 已提交
1164

1165
	ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
L
Linus Torvalds 已提交
1166 1167 1168 1169 1170
	ch->count++;
	tty->driver_data = ch;
	ch->tty = tty;
	if (!(ch->asyncflags & ASYNC_INITIALIZED)) {
		ch->statusflags = 0;
A
Alan Cox 已提交
1171
		moxa_set_tty_param(tty, tty->termios);
J
Jiri Slaby 已提交
1172 1173
		MoxaPortLineCtrl(ch, 1, 1);
		MoxaPortEnable(ch);
J
Jiri Slaby 已提交
1174
		MoxaSetFifo(ch, ch->type == PORT_16550A);
L
Linus Torvalds 已提交
1175 1176
		ch->asyncflags |= ASYNC_INITIALIZED;
	}
J
Jiri Slaby 已提交
1177
	mutex_unlock(&moxa_openlock);
L
Linus Torvalds 已提交
1178

J
Jiri Slaby 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
	retval = 0;
	if (!(filp->f_flags & O_NONBLOCK) && !C_CLOCAL(tty))
		retval = moxa_block_till_ready(tty, filp, ch);
	mutex_lock(&moxa_openlock);
	if (retval) {
		if (ch->count) /* 0 means already hung up... */
			if (--ch->count == 0)
				moxa_close_port(ch);
	} else
		ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
	mutex_unlock(&moxa_openlock);
L
Linus Torvalds 已提交
1190

J
Jiri Slaby 已提交
1191
	return retval;
L
Linus Torvalds 已提交
1192 1193 1194 1195
}

static void moxa_close(struct tty_struct *tty, struct file *filp)
{
1196
	struct moxa_port *ch;
L
Linus Torvalds 已提交
1197 1198
	int port;

J
Jiri Slaby 已提交
1199
	port = tty->index;
J
Jiri Slaby 已提交
1200
	if (port == MAX_PORTS || tty_hung_up_p(filp))
L
Linus Torvalds 已提交
1201 1202
		return;

J
Jiri Slaby 已提交
1203 1204 1205 1206 1207
	mutex_lock(&moxa_openlock);
	ch = tty->driver_data;
	if (ch == NULL)
		goto unlock;
	if (tty->count == 1 && ch->count != 1) {
J
Jiri Slaby 已提交
1208 1209
		printk(KERN_WARNING "moxa_close: bad serial port count; "
			"tty->count is 1, ch->count is %d\n", ch->count);
L
Linus Torvalds 已提交
1210 1211 1212
		ch->count = 1;
	}
	if (--ch->count < 0) {
J
Jiri Slaby 已提交
1213 1214
		printk(KERN_WARNING "moxa_close: bad serial port count, "
			"device=%s\n", tty->name);
L
Linus Torvalds 已提交
1215 1216
		ch->count = 0;
	}
J
Jiri Slaby 已提交
1217 1218
	if (ch->count)
		goto unlock;
L
Linus Torvalds 已提交
1219 1220 1221

	ch->cflag = tty->termios->c_cflag;
	if (ch->asyncflags & ASYNC_INITIALIZED) {
J
Jiri Slaby 已提交
1222
		moxa_setup_empty_event(tty);
L
Linus Torvalds 已提交
1223 1224 1225
		tty_wait_until_sent(tty, 30 * HZ);	/* 30 seconds timeout */
	}

J
Jiri Slaby 已提交
1226 1227 1228
	moxa_close_port(ch);
unlock:
	mutex_unlock(&moxa_openlock);
L
Linus Torvalds 已提交
1229 1230 1231 1232 1233
}

static int moxa_write(struct tty_struct *tty,
		      const unsigned char *buf, int count)
{
J
Jiri Slaby 已提交
1234 1235
	struct moxa_port *ch = tty->driver_data;
	int len;
L
Linus Torvalds 已提交
1236 1237

	if (ch == NULL)
J
Jiri Slaby 已提交
1238
		return 0;
A
Alan Cox 已提交
1239

J
Jiri Slaby 已提交
1240
	spin_lock_bh(&moxa_lock);
J
Jiri Slaby 已提交
1241
	len = MoxaPortWriteData(ch, buf, count);
J
Jiri Slaby 已提交
1242
	spin_unlock_bh(&moxa_lock);
L
Linus Torvalds 已提交
1243 1244

	ch->statusflags |= LOWWAIT;
J
Jiri Slaby 已提交
1245
	return len;
L
Linus Torvalds 已提交
1246 1247 1248 1249
}

static int moxa_write_room(struct tty_struct *tty)
{
1250
	struct moxa_port *ch;
L
Linus Torvalds 已提交
1251 1252

	if (tty->stopped)
J
Jiri Slaby 已提交
1253
		return 0;
J
Jiri Slaby 已提交
1254
	ch = tty->driver_data;
L
Linus Torvalds 已提交
1255
	if (ch == NULL)
J
Jiri Slaby 已提交
1256
		return 0;
J
Jiri Slaby 已提交
1257
	return MoxaPortTxFree(ch);
L
Linus Torvalds 已提交
1258 1259 1260 1261
}

static void moxa_flush_buffer(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1262
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1263 1264 1265

	if (ch == NULL)
		return;
J
Jiri Slaby 已提交
1266
	MoxaPortFlushData(ch, 1);
L
Linus Torvalds 已提交
1267 1268 1269 1270 1271
	tty_wakeup(tty);
}

static int moxa_chars_in_buffer(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1272
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1273 1274 1275 1276 1277 1278 1279 1280 1281
	int chars;

	/*
	 * Sigh...I have to check if driver_data is NULL here, because
	 * if an open() fails, the TTY subsystem eventually calls
	 * tty_wait_until_sent(), which calls the driver's chars_in_buffer()
	 * routine.  And since the open() failed, we return 0 here.  TDJ
	 */
	if (ch == NULL)
J
Jiri Slaby 已提交
1282
		return 0;
1283
	lock_kernel();
J
Jiri Slaby 已提交
1284
	chars = MoxaPortTxQueue(ch);
L
Linus Torvalds 已提交
1285 1286 1287 1288 1289 1290
	if (chars) {
		/*
		 * Make it possible to wakeup anything waiting for output
		 * in tty_ioctl.c, etc.
		 */
		if (!(ch->statusflags & EMPTYWAIT))
J
Jiri Slaby 已提交
1291
			moxa_setup_empty_event(tty);
L
Linus Torvalds 已提交
1292
	}
1293
	unlock_kernel();
J
Jiri Slaby 已提交
1294
	return chars;
L
Linus Torvalds 已提交
1295 1296 1297 1298
}

static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
{
J
Jiri Slaby 已提交
1299
	struct moxa_port *ch;
L
Linus Torvalds 已提交
1300 1301
	int flag = 0, dtr, rts;

J
Jiri Slaby 已提交
1302 1303 1304 1305
	mutex_lock(&moxa_openlock);
	ch = tty->driver_data;
	if (!ch) {
		mutex_unlock(&moxa_openlock);
J
Jiri Slaby 已提交
1306
		return -EINVAL;
J
Jiri Slaby 已提交
1307
	}
L
Linus Torvalds 已提交
1308

J
Jiri Slaby 已提交
1309
	MoxaPortGetLineOut(ch, &dtr, &rts);
L
Linus Torvalds 已提交
1310 1311 1312 1313
	if (dtr)
		flag |= TIOCM_DTR;
	if (rts)
		flag |= TIOCM_RTS;
J
Jiri Slaby 已提交
1314
	dtr = MoxaPortLineStatus(ch);
L
Linus Torvalds 已提交
1315 1316 1317 1318 1319 1320
	if (dtr & 1)
		flag |= TIOCM_CTS;
	if (dtr & 2)
		flag |= TIOCM_DSR;
	if (dtr & 4)
		flag |= TIOCM_CD;
J
Jiri Slaby 已提交
1321
	mutex_unlock(&moxa_openlock);
L
Linus Torvalds 已提交
1322 1323 1324 1325 1326 1327
	return flag;
}

static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
			 unsigned int set, unsigned int clear)
{
J
Jiri Slaby 已提交
1328
	struct moxa_port *ch;
L
Linus Torvalds 已提交
1329 1330 1331
	int port;
	int dtr, rts;

J
Jiri Slaby 已提交
1332
	port = tty->index;
J
Jiri Slaby 已提交
1333 1334 1335 1336
	mutex_lock(&moxa_openlock);
	ch = tty->driver_data;
	if (!ch) {
		mutex_unlock(&moxa_openlock);
J
Jiri Slaby 已提交
1337
		return -EINVAL;
J
Jiri Slaby 已提交
1338
	}
L
Linus Torvalds 已提交
1339

J
Jiri Slaby 已提交
1340
	MoxaPortGetLineOut(ch, &dtr, &rts);
L
Linus Torvalds 已提交
1341 1342 1343 1344 1345 1346 1347 1348
	if (set & TIOCM_RTS)
		rts = 1;
	if (set & TIOCM_DTR)
		dtr = 1;
	if (clear & TIOCM_RTS)
		rts = 0;
	if (clear & TIOCM_DTR)
		dtr = 0;
J
Jiri Slaby 已提交
1349
	MoxaPortLineCtrl(ch, dtr, rts);
J
Jiri Slaby 已提交
1350
	mutex_unlock(&moxa_openlock);
L
Linus Torvalds 已提交
1351 1352 1353 1354 1355
	return 0;
}

static void moxa_throttle(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1356
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361 1362

	ch->statusflags |= THROTTLE;
}

static void moxa_unthrottle(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1363
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1364 1365 1366 1367 1368

	ch->statusflags &= ~THROTTLE;
}

static void moxa_set_termios(struct tty_struct *tty,
J
Jiri Slaby 已提交
1369
		struct ktermios *old_termios)
L
Linus Torvalds 已提交
1370
{
J
Jiri Slaby 已提交
1371
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1372 1373 1374

	if (ch == NULL)
		return;
A
Alan Cox 已提交
1375
	moxa_set_tty_param(tty, old_termios);
J
Jiri Slaby 已提交
1376
	if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
L
Linus Torvalds 已提交
1377 1378 1379 1380 1381
		wake_up_interruptible(&ch->open_wait);
}

static void moxa_stop(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1382
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1383 1384 1385

	if (ch == NULL)
		return;
J
Jiri Slaby 已提交
1386
	MoxaPortTxDisable(ch);
L
Linus Torvalds 已提交
1387 1388 1389 1390 1391 1392
	ch->statusflags |= TXSTOPPED;
}


static void moxa_start(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1393
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1394 1395 1396 1397 1398 1399 1400

	if (ch == NULL)
		return;

	if (!(ch->statusflags & TXSTOPPED))
		return;

J
Jiri Slaby 已提交
1401
	MoxaPortTxEnable(ch);
L
Linus Torvalds 已提交
1402 1403 1404 1405 1406
	ch->statusflags &= ~TXSTOPPED;
}

static void moxa_hangup(struct tty_struct *tty)
{
J
Jiri Slaby 已提交
1407
	struct moxa_port *ch;
L
Linus Torvalds 已提交
1408

J
Jiri Slaby 已提交
1409 1410 1411 1412 1413 1414
	mutex_lock(&moxa_openlock);
	ch = tty->driver_data;
	if (ch == NULL) {
		mutex_unlock(&moxa_openlock);
		return;
	}
L
Linus Torvalds 已提交
1415
	ch->count = 0;
J
Jiri Slaby 已提交
1416 1417 1418
	moxa_close_port(ch);
	mutex_unlock(&moxa_openlock);

L
Linus Torvalds 已提交
1419 1420 1421
	wake_up_interruptible(&ch->open_wait);
}

J
Jiri Slaby 已提交
1422
static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
L
Linus Torvalds 已提交
1423
{
J
Jiri Slaby 已提交
1424
	dcd = !!dcd;
L
Linus Torvalds 已提交
1425

J
Jiri Slaby 已提交
1426
	if (dcd != p->DCDState && p->tty && C_CLOCAL(p->tty)) {
J
Jiri Slaby 已提交
1427
		if (!dcd)
J
Jiri Slaby 已提交
1428 1429 1430 1431
			tty_hangup(p->tty);
	}
	p->DCDState = dcd;
}
L
Linus Torvalds 已提交
1432

J
Jiri Slaby 已提交
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
static int moxa_poll_port(struct moxa_port *p, unsigned int handle,
		u16 __iomem *ip)
{
	struct tty_struct *tty = p->tty;
	void __iomem *ofsAddr;
	unsigned int inited = p->asyncflags & ASYNC_INITIALIZED;
	u16 intr;

	if (tty) {
		if ((p->statusflags & EMPTYWAIT) &&
				MoxaPortTxQueue(p) == 0) {
			p->statusflags &= ~EMPTYWAIT;
			tty_wakeup(tty);
		}
		if ((p->statusflags & LOWWAIT) && !tty->stopped &&
				MoxaPortTxQueue(p) <= WAKEUP_CHARS) {
			p->statusflags &= ~LOWWAIT;
			tty_wakeup(tty);
		}

		if (inited && !(p->statusflags & THROTTLE) &&
				MoxaPortRxQueue(p) > 0) { /* RX */
			MoxaPortReadData(p);
			tty_schedule_flip(tty);
		}
	} else {
		p->statusflags &= ~EMPTYWAIT;
		MoxaPortFlushData(p, 0); /* flush RX */
L
Linus Torvalds 已提交
1461
	}
J
Jiri Slaby 已提交
1462

J
Jiri Slaby 已提交
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
	if (!handle) /* nothing else to do */
		return 0;

	intr = readw(ip); /* port irq status */
	if (intr == 0)
		return 0;

	writew(0, ip); /* ACK port */
	ofsAddr = p->tableAddr;
	if (intr & IntrTx) /* disable tx intr */
		writew(readw(ofsAddr + HostStat) & ~WakeupTx,
				ofsAddr + HostStat);

	if (!inited)
		return 0;

	if (tty && (intr & IntrBreak) && !I_IGNBRK(tty)) { /* BREAK */
		tty_insert_flip_char(tty, 0, TTY_BREAK);
		tty_schedule_flip(tty);
	}

	if (intr & IntrLine)
		moxa_new_dcdstate(p, readb(ofsAddr + FlagStat) & DCD_state);

	return 0;
}

static void moxa_poll(unsigned long ignored)
{
	struct moxa_board_conf *brd;
	u16 __iomem *ip;
J
Jiri Slaby 已提交
1494
	unsigned int card, port, served = 0;
J
Jiri Slaby 已提交
1495 1496

	spin_lock(&moxa_lock);
L
Linus Torvalds 已提交
1497
	for (card = 0; card < MAX_BOARDS; card++) {
J
Jiri Slaby 已提交
1498 1499
		brd = &moxa_boards[card];
		if (!brd->ready)
L
Linus Torvalds 已提交
1500
			continue;
J
Jiri Slaby 已提交
1501

J
Jiri Slaby 已提交
1502 1503
		served++;

J
Jiri Slaby 已提交
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
		ip = NULL;
		if (readb(brd->intPend) == 0xff)
			ip = brd->intTable + readb(brd->intNdx);

		for (port = 0; port < brd->numPorts; port++)
			moxa_poll_port(&brd->ports[port], !!ip, ip + port);

		if (ip)
			writeb(0, brd->intPend); /* ACK */

		if (moxaLowWaterChk) {
			struct moxa_port *p = brd->ports;
			for (port = 0; port < brd->numPorts; port++, p++)
				if (p->lowChkFlag) {
					p->lowChkFlag = 0;
					moxa_low_water_check(p->tableAddr);
L
Linus Torvalds 已提交
1520 1521 1522
				}
		}
	}
J
Jiri Slaby 已提交
1523
	moxaLowWaterChk = 0;
L
Linus Torvalds 已提交
1524

J
Jiri Slaby 已提交
1525 1526 1527
	if (served)
		mod_timer(&moxaTimer, jiffies + HZ / 50);
	spin_unlock(&moxa_lock);
L
Linus Torvalds 已提交
1528 1529 1530 1531
}

/******************************************************************************/

A
Alan Cox 已提交
1532
static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_termios)
L
Linus Torvalds 已提交
1533
{
J
Jiri Slaby 已提交
1534 1535
	register struct ktermios *ts = tty->termios;
	struct moxa_port *ch = tty->driver_data;
A
Alan Cox 已提交
1536
	int rts, cts, txflow, rxflow, xany, baud;
L
Linus Torvalds 已提交
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546

	rts = cts = txflow = rxflow = xany = 0;
	if (ts->c_cflag & CRTSCTS)
		rts = cts = 1;
	if (ts->c_iflag & IXON)
		txflow = 1;
	if (ts->c_iflag & IXOFF)
		rxflow = 1;
	if (ts->c_iflag & IXANY)
		xany = 1;
A
Alan Cox 已提交
1547 1548 1549

	/* Clear the features we don't support */
	ts->c_cflag &= ~CMSPAR;
J
Jiri Slaby 已提交
1550 1551
	MoxaPortFlowCtrl(ch, rts, cts, txflow, rxflow, xany);
	baud = MoxaPortSetTermio(ch, ts, tty_get_baud_rate(tty));
A
Alan Cox 已提交
1552 1553 1554 1555
	if (baud == -1)
		baud = tty_termios_baud_rate(old_termios);
	/* Not put the baud rate into the termios data */
	tty_encode_baud_rate(tty, baud, baud);
L
Linus Torvalds 已提交
1556 1557
}

J
Jiri Slaby 已提交
1558
static void moxa_setup_empty_event(struct tty_struct *tty)
L
Linus Torvalds 已提交
1559
{
1560
	struct moxa_port *ch = tty->driver_data;
L
Linus Torvalds 已提交
1561

J
Jiri Slaby 已提交
1562
	spin_lock_bh(&moxa_lock);
L
Linus Torvalds 已提交
1563
	ch->statusflags |= EMPTYWAIT;
J
Jiri Slaby 已提交
1564
	spin_unlock_bh(&moxa_lock);
L
Linus Torvalds 已提交
1565 1566
}

J
Jiri Slaby 已提交
1567
static void moxa_shut_down(struct moxa_port *ch)
L
Linus Torvalds 已提交
1568
{
J
Jiri Slaby 已提交
1569
	struct tty_struct *tp = ch->tty;
L
Linus Torvalds 已提交
1570 1571 1572 1573

	if (!(ch->asyncflags & ASYNC_INITIALIZED))
		return;

J
Jiri Slaby 已提交
1574
	MoxaPortDisable(ch);
L
Linus Torvalds 已提交
1575 1576 1577 1578

	/*
	 * If we're a modem control device and HUPCL is on, drop RTS & DTR.
	 */
J
Jiri Slaby 已提交
1579
	if (C_HUPCL(tp))
J
Jiri Slaby 已提交
1580
		MoxaPortLineCtrl(ch, 0, 0);
L
Linus Torvalds 已提交
1581

J
Jiri Slaby 已提交
1582
	spin_lock_bh(&moxa_lock);
L
Linus Torvalds 已提交
1583
	ch->asyncflags &= ~ASYNC_INITIALIZED;
J
Jiri Slaby 已提交
1584
	spin_unlock_bh(&moxa_lock);
L
Linus Torvalds 已提交
1585 1586 1587 1588 1589 1590
}

/*****************************************************************************
 *	Driver level functions: 					     *
 *****************************************************************************/

J
Jiri Slaby 已提交
1591
static void MoxaPortFlushData(struct moxa_port *port, int mode)
L
Linus Torvalds 已提交
1592 1593
{
	void __iomem *ofsAddr;
J
Jiri Slaby 已提交
1594
	if (mode < 0 || mode > 2)
L
Linus Torvalds 已提交
1595
		return;
J
Jiri Slaby 已提交
1596
	ofsAddr = port->tableAddr;
L
Linus Torvalds 已提交
1597 1598
	moxafunc(ofsAddr, FC_FlushQueue, mode);
	if (mode != 1) {
J
Jiri Slaby 已提交
1599
		port->lowChkFlag = 0;
J
Jiri Slaby 已提交
1600
		moxa_low_water_check(ofsAddr);
L
Linus Torvalds 已提交
1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
	}
}

/*
 *    Moxa Port Number Description:
 *
 *      MOXA serial driver supports up to 4 MOXA-C218/C320 boards. And,
 *      the port number using in MOXA driver functions will be 0 to 31 for
 *      first MOXA board, 32 to 63 for second, 64 to 95 for third and 96
 *      to 127 for fourth. For example, if you setup three MOXA boards,
 *      first board is C218, second board is C320-16 and third board is
 *      C320-32. The port number of first board (C218 - 8 ports) is from
 *      0 to 7. The port number of second board (C320 - 16 ports) is form
 *      32 to 47. The port number of third board (C320 - 32 ports) is from
 *      64 to 95. And those port numbers form 8 to 31, 48 to 63 and 96 to
 *      127 will be invalid.
 *
 *
 *      Moxa Functions Description:
 *
 *      Function 1:     Driver initialization routine, this routine must be
 *                      called when initialized driver.
 *      Syntax:
 *      void MoxaDriverInit();
 *
 *
 *      Function 2:     Moxa driver private IOCTL command processing.
 *      Syntax:
 *      int  MoxaDriverIoctl(unsigned int cmd, unsigned long arg, int port);
 *
 *           unsigned int cmd   : IOCTL command
 *           unsigned long arg  : IOCTL argument
 *           int port           : port number (0 - 127)
 *
 *           return:    0  (OK)
 *                      -EINVAL
 *                      -ENOIOCTLCMD
 *
 *
 *      Function 6:     Enable this port to start Tx/Rx data.
 *      Syntax:
 *      void MoxaPortEnable(int port);
 *           int port           : port number (0 - 127)
 *
 *
 *      Function 7:     Disable this port
 *      Syntax:
 *      void MoxaPortDisable(int port);
 *           int port           : port number (0 - 127)
 *
 *
 *      Function 10:    Setting baud rate of this port.
 *      Syntax:
1654
 *      speed_t MoxaPortSetBaud(int port, speed_t baud);
L
Linus Torvalds 已提交
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
 *           int port           : port number (0 - 127)
 *           long baud          : baud rate (50 - 115200)
 *
 *           return:    0       : this port is invalid or baud < 50
 *                      50 - 115200 : the real baud rate set to the port, if
 *                                    the argument baud is large than maximun
 *                                    available baud rate, the real setting
 *                                    baud rate will be the maximun baud rate.
 *
 *
 *      Function 12:    Configure the port.
 *      Syntax:
A
Alan Cox 已提交
1667
 *      int  MoxaPortSetTermio(int port, struct ktermios *termio, speed_t baud);
L
Linus Torvalds 已提交
1668
 *           int port           : port number (0 - 127)
A
Alan Cox 已提交
1669
 *           struct ktermios * termio : termio structure pointer
1670
 *	     speed_t baud	: baud rate
L
Linus Torvalds 已提交
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
 *
 *           return:    -1      : this port is invalid or termio == NULL
 *                      0       : setting O.K.
 *
 *
 *      Function 13:    Get the DTR/RTS state of this port.
 *      Syntax:
 *      int  MoxaPortGetLineOut(int port, int *dtrState, int *rtsState);
 *           int port           : port number (0 - 127)
 *           int * dtrState     : pointer to INT to receive the current DTR
 *                                state. (if NULL, this function will not
 *                                write to this address)
 *           int * rtsState     : pointer to INT to receive the current RTS
 *                                state. (if NULL, this function will not
 *                                write to this address)
 *
 *           return:    -1      : this port is invalid
 *                      0       : O.K.
 *
 *
 *      Function 14:    Setting the DTR/RTS output state of this port.
 *      Syntax:
 *      void MoxaPortLineCtrl(int port, int dtrState, int rtsState);
 *           int port           : port number (0 - 127)
 *           int dtrState       : DTR output state (0: off, 1: on)
 *           int rtsState       : RTS output state (0: off, 1: on)
 *
 *
 *      Function 15:    Setting the flow control of this port.
 *      Syntax:
 *      void MoxaPortFlowCtrl(int port, int rtsFlow, int ctsFlow, int rxFlow,
 *                            int txFlow,int xany);
 *           int port           : port number (0 - 127)
 *           int rtsFlow        : H/W RTS flow control (0: no, 1: yes)
 *           int ctsFlow        : H/W CTS flow control (0: no, 1: yes)
 *           int rxFlow         : S/W Rx XON/XOFF flow control (0: no, 1: yes)
 *           int txFlow         : S/W Tx XON/XOFF flow control (0: no, 1: yes)
 *           int xany           : S/W XANY flow control (0: no, 1: yes)
 *
 *
 *      Function 16:    Get ths line status of this port
 *      Syntax:
 *      int  MoxaPortLineStatus(int port);
 *           int port           : port number (0 - 127)
 *
 *           return:    Bit 0 - CTS state (0: off, 1: on)
 *                      Bit 1 - DSR state (0: off, 1: on)
 *                      Bit 2 - DCD state (0: off, 1: on)
 *
 *
 *      Function 19:    Flush the Rx/Tx buffer data of this port.
 *      Syntax:
 *      void MoxaPortFlushData(int port, int mode);
 *           int port           : port number (0 - 127)
 *           int mode    
 *                      0       : flush the Rx buffer 
 *                      1       : flush the Tx buffer 
 *                      2       : flush the Rx and Tx buffer 
 *
 *
 *      Function 20:    Write data.
 *      Syntax:
 *      int  MoxaPortWriteData(int port, unsigned char * buffer, int length);
 *           int port           : port number (0 - 127)
 *           unsigned char * buffer     : pointer to write data buffer.
 *           int length         : write data length
 *
 *           return:    0 - length      : real write data length
 *
 *
 *      Function 21:    Read data.
 *      Syntax:
A
Alan Cox 已提交
1743
 *      int  MoxaPortReadData(int port, struct tty_struct *tty);
L
Linus Torvalds 已提交
1744
 *           int port           : port number (0 - 127)
A
Alan Cox 已提交
1745
 *	     struct tty_struct *tty : tty for data
L
Linus Torvalds 已提交
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
 *
 *           return:    0 - length      : real read data length
 *
 *
 *      Function 24:    Get the Tx buffer current queued data bytes
 *      Syntax:
 *      int  MoxaPortTxQueue(int port);
 *           int port           : port number (0 - 127)
 *
 *           return:    ..      : Tx buffer current queued data bytes
 *
 *
 *      Function 25:    Get the Tx buffer current free space
 *      Syntax:
 *      int  MoxaPortTxFree(int port);
 *           int port           : port number (0 - 127)
 *
 *           return:    ..      : Tx buffer current free space
 *
 *
 *      Function 26:    Get the Rx buffer current queued data bytes
 *      Syntax:
 *      int  MoxaPortRxQueue(int port);
 *           int port           : port number (0 - 127)
 *
 *           return:    ..      : Rx buffer current queued data bytes
 *
 *
 *      Function 28:    Disable port data transmission.
 *      Syntax:
 *      void MoxaPortTxDisable(int port);
 *           int port           : port number (0 - 127)
 *
 *
 *      Function 29:    Enable port data transmission.
 *      Syntax:
 *      void MoxaPortTxEnable(int port);
 *           int port           : port number (0 - 127)
 *
 *
 *      Function 31:    Get the received BREAK signal count and reset it.
 *      Syntax:
 *      int  MoxaPortResetBrkCnt(int port);
 *           int port           : port number (0 - 127)
 *
 *           return:    0 - ..  : BREAK signal count
 *
 *
 */

J
Jiri Slaby 已提交
1796
static void MoxaPortEnable(struct moxa_port *port)
L
Linus Torvalds 已提交
1797 1798
{
	void __iomem *ofsAddr;
J
Jiri Slaby 已提交
1799
	u16 lowwater = 512;
L
Linus Torvalds 已提交
1800

J
Jiri Slaby 已提交
1801
	ofsAddr = port->tableAddr;
L
Linus Torvalds 已提交
1802
	writew(lowwater, ofsAddr + Low_water);
1803
	if (MOXA_IS_320(port->board))
L
Linus Torvalds 已提交
1804
		moxafunc(ofsAddr, FC_SetBreakIrq, 0);
J
Jiri Slaby 已提交
1805 1806 1807
	else
		writew(readw(ofsAddr + HostStat) | WakeupBreak,
				ofsAddr + HostStat);
L
Linus Torvalds 已提交
1808 1809 1810 1811 1812 1813 1814 1815

	moxafunc(ofsAddr, FC_SetLineIrq, Magic_code);
	moxafunc(ofsAddr, FC_FlushQueue, 2);

	moxafunc(ofsAddr, FC_EnableCH, Magic_code);
	MoxaPortLineStatus(port);
}

J
Jiri Slaby 已提交
1816
static void MoxaPortDisable(struct moxa_port *port)
L
Linus Torvalds 已提交
1817
{
J
Jiri Slaby 已提交
1818
	void __iomem *ofsAddr = port->tableAddr;
L
Linus Torvalds 已提交
1819 1820 1821 1822 1823 1824 1825

	moxafunc(ofsAddr, FC_SetFlowCtl, 0);	/* disable flow control */
	moxafunc(ofsAddr, FC_ClrLineIrq, Magic_code);
	writew(0, ofsAddr + HostStat);
	moxafunc(ofsAddr, FC_DisableCH, Magic_code);
}

1826
static speed_t MoxaPortSetBaud(struct moxa_port *port, speed_t baud)
L
Linus Torvalds 已提交
1827
{
1828 1829 1830
	void __iomem *ofsAddr = port->tableAddr;
	unsigned int clock, val;
	speed_t max;
L
Linus Torvalds 已提交
1831

1832 1833
	max = MOXA_IS_320(port->board) ? 460800 : 921600;
	if (baud < 50)
J
Jiri Slaby 已提交
1834
		return 0;
L
Linus Torvalds 已提交
1835 1836
	if (baud > max)
		baud = max;
1837
	clock = 921600;
L
Linus Torvalds 已提交
1838 1839 1840
	val = clock / baud;
	moxafunc(ofsAddr, FC_SetBaud, val);
	baud = clock / val;
J
Jiri Slaby 已提交
1841
	return baud;
L
Linus Torvalds 已提交
1842 1843
}

J
Jiri Slaby 已提交
1844 1845
static int MoxaPortSetTermio(struct moxa_port *port, struct ktermios *termio,
		speed_t baud)
L
Linus Torvalds 已提交
1846 1847 1848 1849 1850
{
	void __iomem *ofsAddr;
	tcflag_t cflag;
	tcflag_t mode = 0;

J
Jiri Slaby 已提交
1851
	ofsAddr = port->tableAddr;
L
Linus Torvalds 已提交
1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
	cflag = termio->c_cflag;	/* termio->c_cflag */

	mode = termio->c_cflag & CSIZE;
	if (mode == CS5)
		mode = MX_CS5;
	else if (mode == CS6)
		mode = MX_CS6;
	else if (mode == CS7)
		mode = MX_CS7;
	else if (mode == CS8)
		mode = MX_CS8;

	if (termio->c_cflag & CSTOPB) {
		if (mode == MX_CS5)
			mode |= MX_STOP15;
		else
			mode |= MX_STOP2;
	} else
		mode |= MX_STOP1;

	if (termio->c_cflag & PARENB) {
		if (termio->c_cflag & PARODD)
			mode |= MX_PARODD;
		else
			mode |= MX_PAREVEN;
	} else
		mode |= MX_PARNONE;

J
Jiri Slaby 已提交
1880
	moxafunc(ofsAddr, FC_SetDataMode, (u16)mode);
L
Linus Torvalds 已提交
1881

1882 1883 1884
	if (MOXA_IS_320(port->board) && baud >= 921600)
		return -1;

A
Alan Cox 已提交
1885
	baud = MoxaPortSetBaud(port, baud);
L
Linus Torvalds 已提交
1886 1887 1888 1889 1890

	if (termio->c_iflag & (IXON | IXOFF | IXANY)) {
		writeb(termio->c_cc[VSTART], ofsAddr + FuncArg);
		writeb(termio->c_cc[VSTOP], ofsAddr + FuncArg1);
		writeb(FC_SetXonXoff, ofsAddr + FuncCode);
J
Jiri Slaby 已提交
1891
		moxa_wait_finish(ofsAddr);
L
Linus Torvalds 已提交
1892 1893

	}
J
Jiri Slaby 已提交
1894
	return baud;
L
Linus Torvalds 已提交
1895 1896
}

J
Jiri Slaby 已提交
1897 1898
static int MoxaPortGetLineOut(struct moxa_port *port, int *dtrState,
		int *rtsState)
L
Linus Torvalds 已提交
1899
{
J
Jiri Slaby 已提交
1900 1901 1902 1903 1904
	if (dtrState)
		*dtrState = !!(port->lineCtrl & DTR_ON);
	if (rtsState)
		*rtsState = !!(port->lineCtrl & RTS_ON);

J
Jiri Slaby 已提交
1905
	return 0;
L
Linus Torvalds 已提交
1906 1907
}

J
Jiri Slaby 已提交
1908
static void MoxaPortLineCtrl(struct moxa_port *port, int dtr, int rts)
L
Linus Torvalds 已提交
1909
{
J
Jiri Slaby 已提交
1910
	u8 mode = 0;
L
Linus Torvalds 已提交
1911 1912 1913 1914 1915

	if (dtr)
		mode |= DTR_ON;
	if (rts)
		mode |= RTS_ON;
J
Jiri Slaby 已提交
1916 1917
	port->lineCtrl = mode;
	moxafunc(port->tableAddr, FC_LineControl, mode);
L
Linus Torvalds 已提交
1918 1919
}

J
Jiri Slaby 已提交
1920 1921
static void MoxaPortFlowCtrl(struct moxa_port *port, int rts, int cts,
		int txflow, int rxflow, int txany)
L
Linus Torvalds 已提交
1922
{
J
Jiri Slaby 已提交
1923
	int mode = 0;
L
Linus Torvalds 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934

	if (rts)
		mode |= RTS_FlowCtl;
	if (cts)
		mode |= CTS_FlowCtl;
	if (txflow)
		mode |= Tx_FlowCtl;
	if (rxflow)
		mode |= Rx_FlowCtl;
	if (txany)
		mode |= IXM_IXANY;
J
Jiri Slaby 已提交
1935
	moxafunc(port->tableAddr, FC_SetFlowCtl, mode);
L
Linus Torvalds 已提交
1936 1937
}

J
Jiri Slaby 已提交
1938
static int MoxaPortLineStatus(struct moxa_port *port)
L
Linus Torvalds 已提交
1939 1940 1941 1942
{
	void __iomem *ofsAddr;
	int val;

J
Jiri Slaby 已提交
1943
	ofsAddr = port->tableAddr;
1944
	if (MOXA_IS_320(port->board)) {
L
Linus Torvalds 已提交
1945 1946 1947 1948 1949 1950
		moxafunc(ofsAddr, FC_LineStatus, 0);
		val = readw(ofsAddr + FuncArg);
	} else {
		val = readw(ofsAddr + FlagStat) >> 4;
	}
	val &= 0x0B;
J
Jiri Slaby 已提交
1951
	if (val & 8)
L
Linus Torvalds 已提交
1952
		val |= 4;
J
Jiri Slaby 已提交
1953
	spin_lock_bh(&moxa_lock);
J
Jiri Slaby 已提交
1954
	moxa_new_dcdstate(port, val & 8);
J
Jiri Slaby 已提交
1955
	spin_unlock_bh(&moxa_lock);
L
Linus Torvalds 已提交
1956
	val &= 7;
J
Jiri Slaby 已提交
1957
	return val;
L
Linus Torvalds 已提交
1958 1959
}

J
Jiri Slaby 已提交
1960 1961
static int MoxaPortWriteData(struct moxa_port *port,
		const unsigned char *buffer, int len)
L
Linus Torvalds 已提交
1962 1963
{
	void __iomem *baseAddr, *ofsAddr, *ofs;
J
Jiri Slaby 已提交
1964 1965 1966
	unsigned int c, total;
	u16 head, tail, tx_mask, spage, epage;
	u16 pageno, pageofs, bufhead;
L
Linus Torvalds 已提交
1967

J
Jiri Slaby 已提交
1968 1969
	ofsAddr = port->tableAddr;
	baseAddr = port->board->basemem;
L
Linus Torvalds 已提交
1970 1971 1972 1973 1974
	tx_mask = readw(ofsAddr + TX_mask);
	spage = readw(ofsAddr + Page_txb);
	epage = readw(ofsAddr + EndPage_txb);
	tail = readw(ofsAddr + TXwptr);
	head = readw(ofsAddr + TXrptr);
J
Jiri Slaby 已提交
1975
	c = (head > tail) ? (head - tail - 1) : (head - tail + tx_mask);
L
Linus Torvalds 已提交
1976 1977
	if (c > len)
		c = len;
J
Jiri Slaby 已提交
1978
	moxaLog.txcnt[port->tty->index] += c;
L
Linus Torvalds 已提交
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
	total = c;
	if (spage == epage) {
		bufhead = readw(ofsAddr + Ofs_txb);
		writew(spage, baseAddr + Control_reg);
		while (c > 0) {
			if (head > tail)
				len = head - tail - 1;
			else
				len = tx_mask + 1 - tail;
			len = (c > len) ? len : c;
			ofs = baseAddr + DynPage_addr + bufhead + tail;
J
Jiri Slaby 已提交
1990 1991
			memcpy_toio(ofs, buffer, len);
			buffer += len;
L
Linus Torvalds 已提交
1992 1993 1994 1995 1996 1997
			tail = (tail + len) & tx_mask;
			c -= len;
		}
	} else {
		pageno = spage + (tail >> 13);
		pageofs = tail & Page_mask;
J
Jiri Slaby 已提交
1998 1999 2000 2001
		while (c > 0) {
			len = Page_size - pageofs;
			if (len > c)
				len = c;
L
Linus Torvalds 已提交
2002 2003
			writeb(pageno, baseAddr + Control_reg);
			ofs = baseAddr + DynPage_addr + pageofs;
J
Jiri Slaby 已提交
2004 2005
			memcpy_toio(ofs, buffer, len);
			buffer += len;
L
Linus Torvalds 已提交
2006 2007 2008
			if (++pageno == epage)
				pageno = spage;
			pageofs = 0;
J
Jiri Slaby 已提交
2009 2010 2011
			c -= len;
		}
		tail = (tail + total) & tx_mask;
L
Linus Torvalds 已提交
2012
	}
J
Jiri Slaby 已提交
2013
	writew(tail, ofsAddr + TXwptr);
L
Linus Torvalds 已提交
2014
	writeb(1, ofsAddr + CD180TXirq);	/* start to send */
J
Jiri Slaby 已提交
2015
	return total;
L
Linus Torvalds 已提交
2016 2017
}

J
Jiri Slaby 已提交
2018
static int MoxaPortReadData(struct moxa_port *port)
L
Linus Torvalds 已提交
2019
{
J
Jiri Slaby 已提交
2020
	struct tty_struct *tty = port->tty;
J
Jiri Slaby 已提交
2021
	unsigned char *dst;
L
Linus Torvalds 已提交
2022
	void __iomem *baseAddr, *ofsAddr, *ofs;
J
Jiri Slaby 已提交
2023 2024 2025
	unsigned int count, len, total;
	u16 tail, rx_mask, spage, epage;
	u16 pageno, pageofs, bufhead, head;
L
Linus Torvalds 已提交
2026

J
Jiri Slaby 已提交
2027 2028
	ofsAddr = port->tableAddr;
	baseAddr = port->board->basemem;
L
Linus Torvalds 已提交
2029 2030 2031 2032 2033
	head = readw(ofsAddr + RXrptr);
	tail = readw(ofsAddr + RXwptr);
	rx_mask = readw(ofsAddr + RX_mask);
	spage = readw(ofsAddr + Page_rxb);
	epage = readw(ofsAddr + EndPage_rxb);
J
Jiri Slaby 已提交
2034
	count = (tail >= head) ? (tail - head) : (tail - head + rx_mask + 1);
L
Linus Torvalds 已提交
2035
	if (count == 0)
A
Alan Cox 已提交
2036
		return 0;
L
Linus Torvalds 已提交
2037

A
Alan Cox 已提交
2038
	total = count;
J
Jiri Slaby 已提交
2039
	moxaLog.rxcnt[tty->index] += total;
L
Linus Torvalds 已提交
2040 2041 2042 2043 2044
	if (spage == epage) {
		bufhead = readw(ofsAddr + Ofs_rxb);
		writew(spage, baseAddr + Control_reg);
		while (count > 0) {
			ofs = baseAddr + DynPage_addr + bufhead + head;
J
Jiri Slaby 已提交
2045 2046 2047 2048 2049
			len = (tail >= head) ? (tail - head) :
					(rx_mask + 1 - head);
			len = tty_prepare_flip_string(tty, &dst,
					min(len, count));
			memcpy_fromio(dst, ofs, len);
L
Linus Torvalds 已提交
2050 2051 2052 2053 2054 2055
			head = (head + len) & rx_mask;
			count -= len;
		}
	} else {
		pageno = spage + (head >> 13);
		pageofs = head & Page_mask;
J
Jiri Slaby 已提交
2056
		while (count > 0) {
L
Linus Torvalds 已提交
2057 2058
			writew(pageno, baseAddr + Control_reg);
			ofs = baseAddr + DynPage_addr + pageofs;
J
Jiri Slaby 已提交
2059 2060 2061 2062 2063 2064 2065
			len = tty_prepare_flip_string(tty, &dst,
					min(Page_size - pageofs, count));
			memcpy_fromio(dst, ofs, len);

			count -= len;
			pageofs = (pageofs + len) & Page_mask;
			if (pageofs == 0 && ++pageno == epage)
L
Linus Torvalds 已提交
2066
				pageno = spage;
J
Jiri Slaby 已提交
2067 2068
		}
		head = (head + total) & rx_mask;
L
Linus Torvalds 已提交
2069
	}
J
Jiri Slaby 已提交
2070 2071
	writew(head, ofsAddr + RXrptr);
	if (readb(ofsAddr + FlagStat) & Xoff_state) {
L
Linus Torvalds 已提交
2072
		moxaLowWaterChk = 1;
J
Jiri Slaby 已提交
2073
		port->lowChkFlag = 1;
L
Linus Torvalds 已提交
2074
	}
J
Jiri Slaby 已提交
2075
	return total;
L
Linus Torvalds 已提交
2076 2077 2078
}


J
Jiri Slaby 已提交
2079
static int MoxaPortTxQueue(struct moxa_port *port)
L
Linus Torvalds 已提交
2080
{
J
Jiri Slaby 已提交
2081
	void __iomem *ofsAddr = port->tableAddr;
J
Jiri Slaby 已提交
2082
	u16 rptr, wptr, mask;
L
Linus Torvalds 已提交
2083 2084 2085 2086

	rptr = readw(ofsAddr + TXrptr);
	wptr = readw(ofsAddr + TXwptr);
	mask = readw(ofsAddr + TX_mask);
J
Jiri Slaby 已提交
2087
	return (wptr - rptr) & mask;
L
Linus Torvalds 已提交
2088 2089
}

J
Jiri Slaby 已提交
2090
static int MoxaPortTxFree(struct moxa_port *port)
L
Linus Torvalds 已提交
2091
{
J
Jiri Slaby 已提交
2092
	void __iomem *ofsAddr = port->tableAddr;
J
Jiri Slaby 已提交
2093
	u16 rptr, wptr, mask;
L
Linus Torvalds 已提交
2094 2095 2096 2097

	rptr = readw(ofsAddr + TXrptr);
	wptr = readw(ofsAddr + TXwptr);
	mask = readw(ofsAddr + TX_mask);
J
Jiri Slaby 已提交
2098
	return mask - ((wptr - rptr) & mask);
L
Linus Torvalds 已提交
2099 2100
}

J
Jiri Slaby 已提交
2101
static int MoxaPortRxQueue(struct moxa_port *port)
L
Linus Torvalds 已提交
2102
{
J
Jiri Slaby 已提交
2103
	void __iomem *ofsAddr = port->tableAddr;
J
Jiri Slaby 已提交
2104
	u16 rptr, wptr, mask;
L
Linus Torvalds 已提交
2105 2106 2107 2108

	rptr = readw(ofsAddr + RXrptr);
	wptr = readw(ofsAddr + RXwptr);
	mask = readw(ofsAddr + RX_mask);
J
Jiri Slaby 已提交
2109
	return (wptr - rptr) & mask;
L
Linus Torvalds 已提交
2110 2111
}

J
Jiri Slaby 已提交
2112
static void MoxaPortTxDisable(struct moxa_port *port)
L
Linus Torvalds 已提交
2113
{
J
Jiri Slaby 已提交
2114
	moxafunc(port->tableAddr, FC_SetXoffState, Magic_code);
L
Linus Torvalds 已提交
2115 2116
}

J
Jiri Slaby 已提交
2117
static void MoxaPortTxEnable(struct moxa_port *port)
L
Linus Torvalds 已提交
2118
{
J
Jiri Slaby 已提交
2119
	moxafunc(port->tableAddr, FC_SetXonState, Magic_code);
L
Linus Torvalds 已提交
2120 2121
}

2122
static int moxa_get_serial_info(struct moxa_port *info,
J
Jiri Slaby 已提交
2123
		struct serial_struct __user *retinfo)
L
Linus Torvalds 已提交
2124
{
J
Jiri Slaby 已提交
2125 2126 2127 2128 2129 2130 2131 2132
	struct serial_struct tmp = {
		.type = info->type,
		.line = info->tty->index,
		.flags = info->asyncflags,
		.baud_base = 921600,
		.close_delay = info->close_delay
	};
	return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
L
Linus Torvalds 已提交
2133 2134 2135
}


2136
static int moxa_set_serial_info(struct moxa_port *info,
J
Jiri Slaby 已提交
2137
		struct serial_struct __user *new_info)
L
Linus Torvalds 已提交
2138 2139 2140
{
	struct serial_struct new_serial;

J
Jiri Slaby 已提交
2141
	if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
L
Linus Torvalds 已提交
2142 2143
		return -EFAULT;

J
Jiri Slaby 已提交
2144 2145 2146 2147
	if (new_serial.irq != 0 || new_serial.port != 0 ||
			new_serial.custom_divisor != 0 ||
			new_serial.baud_base != 921600)
		return -EPERM;
L
Linus Torvalds 已提交
2148 2149 2150 2151

	if (!capable(CAP_SYS_ADMIN)) {
		if (((new_serial.flags & ~ASYNC_USR_MASK) !=
		     (info->asyncflags & ~ASYNC_USR_MASK)))
J
Jiri Slaby 已提交
2152 2153
			return -EPERM;
	} else
L
Linus Torvalds 已提交
2154 2155 2156 2157 2158
		info->close_delay = new_serial.close_delay * HZ / 100;

	new_serial.flags = (new_serial.flags & ~ASYNC_FLAGS);
	new_serial.flags |= (info->asyncflags & ASYNC_FLAGS);

J
Jiri Slaby 已提交
2159
	MoxaSetFifo(info, new_serial.type == PORT_16550A);
L
Linus Torvalds 已提交
2160 2161

	info->type = new_serial.type;
J
Jiri Slaby 已提交
2162
	return 0;
L
Linus Torvalds 已提交
2163 2164 2165 2166 2167 2168 2169 2170
}



/*****************************************************************************
 *	Static local functions: 					     *
 *****************************************************************************/

J
Jiri Slaby 已提交
2171
static void MoxaSetFifo(struct moxa_port *port, int enable)
L
Linus Torvalds 已提交
2172
{
J
Jiri Slaby 已提交
2173
	void __iomem *ofsAddr = port->tableAddr;
L
Linus Torvalds 已提交
2174 2175 2176 2177 2178 2179 2180 2181 2182

	if (!enable) {
		moxafunc(ofsAddr, FC_SetRxFIFOTrig, 0);
		moxafunc(ofsAddr, FC_SetTxFIFOCnt, 1);
	} else {
		moxafunc(ofsAddr, FC_SetRxFIFOTrig, 3);
		moxafunc(ofsAddr, FC_SetTxFIFOCnt, 16);
	}
}