开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mxser.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：62k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

mxser.c：源码内容
  1. /*****************************************************************************/
  2. /*
  3.  *          mxser.c  -- MOXA Smartio 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.
  14.  *
  15.  *      This program is distributed in the hope that it will be useful,
  16.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *      GNU General Public License for more details.
  19.  *
  20.  *      You should have received a copy of the GNU General Public License
  21.  *      along with this program; if not, write to the Free Software
  22.  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  25. /*
  26.  *    MOXA Smartio Family Serial Driver
  27.  *
  28.  *      Copyright (C) 1999,2000  Moxa Technologies Co., LTD.
  29.  *
  30.  *      for             : LINUX 2.0.X, 2.2.X, 2.4.X
  31.  *      date            : 2001/05/01
  32.  *      version         : 1.2 
  33.  *      
  34.  *    Fixes for C104H/PCI by Tim Hockin <thockin@sun.com>
  35.  */
  37. #include <linux/config.h>
  38. #include <linux/module.h>
  39. #include <linux/version.h>
  40. #include <linux/errno.h>
  41. #include <linux/signal.h>
  42. #include <linux/sched.h>
  43. #include <linux/timer.h>
  44. #include <linux/interrupt.h>
  45. #include <linux/tty.h>
  46. #include <linux/tty_flip.h>
  47. #include <linux/serial.h>
  48. #include <linux/serial_reg.h>
  49. #include <linux/major.h>
  50. #include <linux/string.h>
  51. #include <linux/fcntl.h>
  52. #include <linux/ptrace.h>
  53. #include <linux/ioport.h>
  54. #include <linux/mm.h>
  55. #include <linux/smp_lock.h>
  56. #include <linux/pci.h>
  58. #include <asm/system.h>
  59. #include <asm/io.h>
  60. #include <asm/irq.h>
  61. #include <asm/segment.h>
  62. #include <asm/bitops.h>
  63. #include <asm/uaccess.h>
  65. #define MXSER_VERSION "1.2"
  67. #define MXSERMAJOR   174
  68. #define MXSERCUMAJOR 175
  71. #define MXSER_EVENT_TXLOW  1
  72. #define MXSER_EVENT_HANGUP  2
  75. #define  SERIAL_DO_RESTART
  77. #define  MXSER_BOARDS 4 /* Max. boards */
  78. #define  MXSER_PORTS 32 /* Max. ports */
  79. #define  MXSER_PORTS_PER_BOARD 8 /* Max. ports per board */
  80. #define  MXSER_ISR_PASS_LIMIT 256
  82. #define MXSER_ERR_IOADDR -1
  83. #define MXSER_ERR_IRQ -2
  84. #define MXSER_ERR_IRQ_CONFLIT -3
  85. #define MXSER_ERR_VECTOR -4
  87. #define  SERIAL_TYPE_NORMAL 1
  88. #define  SERIAL_TYPE_CALLOUT 2
  90. #define  WAKEUP_CHARS 256
  92. #define  UART_MCR_AFE 0x20
  93. #define  UART_LSR_SPECIAL 0x1E
  95. #define PORTNO(x) (MINOR((x)->device) - (x)->driver.minor_start)
  97. #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  99. #define IRQ_T(info) ((info->flags & ASYNC_SHARE_IRQ) ? SA_SHIRQ : SA_INTERRUPT)
  101. #ifndef MIN
  102. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  103. #endif
  105. /*
  106.  *    Define the Moxa PCI vendor and device IDs.
  107.  */
  109. #ifndef PCI_VENDOR_ID_MOXA
  110. #define PCI_VENDOR_ID_MOXA 0x1393
  111. #endif
  112. #ifndef PCI_DEVICE_ID_C168
  113. #define PCI_DEVICE_ID_C168 0x1680
  114. #endif
  115. #ifndef PCI_DEVICE_ID_C104
  116. #define PCI_DEVICE_ID_C104 0x1040
  117. #endif
  119. #define C168_ASIC_ID    1
  120. #define C104_ASIC_ID    2
  121. #define CI104J_ASIC_ID  5
  123. enum {
  124. MXSER_BOARD_C168_ISA = 0,
  125. MXSER_BOARD_C104_ISA,
  126. MXSER_BOARD_CI104J,
  127. MXSER_BOARD_C168_PCI,
  128. MXSER_BOARD_C104_PCI,
  129. };
  131. static char *mxser_brdname[] =
  132. {
  133. "C168 series",
  134. "C104 series",
  135. "CI-104J series",
  136. "C168H/PCI series",
  137. "C104H/PCI series",
  138. };
  140. static int mxser_numports[] =
  141. {
  142. 8,
  143. 4,
  144. 4,
  145. 8,
  146. 4,
  147. };
  149. /*
  150.  *    MOXA ioctls
  151.  */
  152. #define  MOXA 0x400
  153. #define  MOXA_GETDATACOUNT     (MOXA + 23)
  154. #define MOXA_GET_CONF         (MOXA + 35)
  155. #define  MOXA_DIAGNOSE         (MOXA + 50)
  156. #define  MOXA_CHKPORTENABLE    (MOXA + 60)
  157. #define  MOXA_HighSpeedOn      (MOXA + 61)
  158. #define         MOXA_GET_MAJOR        (MOXA + 63)
  159. #define         MOXA_GET_CUMAJOR      (MOXA + 64)
  160. #define         MOXA_GETMSTATUS       (MOXA + 65)
  162. static struct pci_device_id mxser_pcibrds[] = {
  163. { PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_C168, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 
  164.   MXSER_BOARD_C168_PCI },
  165. { PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_C104, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 
  166.   MXSER_BOARD_C104_PCI },
  167. { 0 }
  168. };
  169. MODULE_DEVICE_TABLE(pci, mxser_pcibrds);
  171. static int ioaddr[MXSER_BOARDS];
  172. static int ttymajor = MXSERMAJOR;
  173. static int calloutmajor = MXSERCUMAJOR;
  174. static int verbose;
  176. /* Variables for insmod */
  178. MODULE_AUTHOR("William Chen");
  179. MODULE_DESCRIPTION("MOXA Smartio Family Multiport Board Device Driver");
  180. MODULE_LICENSE("GPL");
  181. MODULE_PARM(ioaddr, "1-4i");
  182. MODULE_PARM(ttymajor, "i");
  183. MODULE_PARM(calloutmajor, "i");
  184. MODULE_PARM(verbose, "i");
  186. EXPORT_NO_SYMBOLS;
  188. struct mxser_hwconf {
  189. int board_type;
  190. int ports;
  191. int irq;
  192. int vector;
  193. int vector_mask;
  194. int uart_type;
  195. int ioaddr[MXSER_PORTS_PER_BOARD];
  196. int baud_base[MXSER_PORTS_PER_BOARD];
  197. struct pci_dev *pdev;
  198. };
  200. struct mxser_struct {
  201. int port;
  202. int base; /* port base address */
  203. int irq; /* port using irq no. */
  204. int vector; /* port irq vector */
  205. int vectormask; /* port vector mask */
  206. int rx_trigger; /* Rx fifo trigger level */
  207. int baud_base; /* max. speed */
  208. int flags; /* defined in tty.h */
  209. int type; /* UART type */
  210. struct tty_struct *tty;
  211. int read_status_mask;
  212. int ignore_status_mask;
  213. int xmit_fifo_size;
  214. int custom_divisor;
  215. int x_char; /* xon/xoff character */
  216. int close_delay;
  217. unsigned short closing_wait;
  218. int IER; /* Interrupt Enable Register */
  219. int MCR; /* Modem control register */
  220. unsigned long event;
  221. int count; /* # of fd on device */
  222. int blocked_open; /* # of blocked opens */
  223. long session; /* Session of opening process */
  224. long pgrp; /* pgrp of opening process */
  225. unsigned char *xmit_buf;
  226. int xmit_head;
  227. int xmit_tail;
  228. int xmit_cnt;
  229. struct tq_struct tqueue;
  230. struct termios normal_termios;
  231. struct termios callout_termios;
  232. wait_queue_head_t open_wait;
  233. wait_queue_head_t close_wait;
  234. wait_queue_head_t delta_msr_wait;
  235. struct async_icount icount; /* kernel counters for the 4 input interrupts */
  236. };
  238. struct mxser_log {
  239. int tick;
  240. int rxcnt[MXSER_PORTS];
  241. int txcnt[MXSER_PORTS];
  242. };
  244. struct mxser_mstatus {
  245. tcflag_t cflag;
  246. int cts;
  247. int dsr;
  248. int ri;
  249. int dcd;
  250. };
  252. static struct mxser_mstatus GMStatus[MXSER_PORTS];
  254. static int mxserBoardCAP[MXSER_BOARDS] =
  255. {
  256. 0, 0, 0, 0
  257.        /*  0x180, 0x280, 0x200, 0x320   */
  258. };
  261. static struct tty_driver mxvar_sdriver, mxvar_cdriver;
  262. static int mxvar_refcount;
  263. static struct mxser_struct mxvar_table[MXSER_PORTS];
  264. static struct tty_struct *mxvar_tty[MXSER_PORTS + 1];
  265. static struct termios *mxvar_termios[MXSER_PORTS + 1];
  266. static struct termios *mxvar_termios_locked[MXSER_PORTS + 1];
  267. static struct mxser_log mxvar_log;
  268. static int mxvar_diagflag;
  269. /*
  270.  * mxvar_tmp_buf is used as a temporary buffer by serial_write. We need
  271.  * to lock it in case the memcpy_fromfs blocks while swapping in a page,
  272.  * and some other program tries to do a serial write at the same time.
  273.  * Since the lock will only come under contention when the system is
  274.  * swapping and available memory is low, it makes sense to share one
  275.  * buffer across all the serial ports, since it significantly saves
  276.  * memory if large numbers of serial ports are open.
  277.  */
  278. static unsigned char *mxvar_tmp_buf;
  279. static struct semaphore mxvar_tmp_buf_sem;
  281. /*
  282.  * This is used to figure out the divisor speeds and the timeouts
  283.  */
  284. static int mxvar_baud_table[] =
  285. {
  286. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  287. 9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600, 0};
  289. struct mxser_hwconf mxsercfg[MXSER_BOARDS];
  291. /*
  292.  * static functions:
  293.  */
  295. #ifdef MODULE
  296. int init_module(void);
  297. void cleanup_module(void);
  298. #endif
  300. static void mxser_getcfg(int board, struct mxser_hwconf *hwconf);
  301. int mxser_init(void);
  302. static int mxser_get_ISA_conf(int, struct mxser_hwconf *);
  303. static int mxser_get_PCI_conf(struct pci_dev *, int, struct mxser_hwconf *);
  304. static void mxser_do_softint(void *);
  305. static int mxser_open(struct tty_struct *, struct file *);
  306. static void mxser_close(struct tty_struct *, struct file *);
  307. static int mxser_write(struct tty_struct *, int, const unsigned char *, int);
  308. static int mxser_write_room(struct tty_struct *);
  309. static void mxser_flush_buffer(struct tty_struct *);
  310. static int mxser_chars_in_buffer(struct tty_struct *);
  311. static void mxser_flush_chars(struct tty_struct *);
  312. static void mxser_put_char(struct tty_struct *, unsigned char);
  313. static int mxser_ioctl(struct tty_struct *, struct file *, uint, ulong);
  314. static int mxser_ioctl_special(unsigned int, unsigned long);
  315. static void mxser_throttle(struct tty_struct *);
  316. static void mxser_unthrottle(struct tty_struct *);
  317. static void mxser_set_termios(struct tty_struct *, struct termios *);
  318. static void mxser_stop(struct tty_struct *);
  319. static void mxser_start(struct tty_struct *);
  320. static void mxser_hangup(struct tty_struct *);
  321. static void mxser_interrupt(int, void *, struct pt_regs *);
  322. static inline void mxser_receive_chars(struct mxser_struct *, int *);
  323. static inline void mxser_transmit_chars(struct mxser_struct *);
  324. static inline void mxser_check_modem_status(struct mxser_struct *, int);
  325. static int mxser_block_til_ready(struct tty_struct *, struct file *, struct mxser_struct *);
  326. static int mxser_startup(struct mxser_struct *);
  327. static void mxser_shutdown(struct mxser_struct *);
  328. static int mxser_change_speed(struct mxser_struct *, struct termios *old_termios);
  329. static int mxser_get_serial_info(struct mxser_struct *, struct serial_struct *);
  330. static int mxser_set_serial_info(struct mxser_struct *, struct serial_struct *);
  331. static int mxser_get_lsr_info(struct mxser_struct *, unsigned int *);
  332. static void mxser_send_break(struct mxser_struct *, int);
  333. static int mxser_get_modem_info(struct mxser_struct *, unsigned int *);
  334. static int mxser_set_modem_info(struct mxser_struct *, unsigned int, unsigned int *);
  336. /*
  337.  * The MOXA C168/C104 serial driver boot-time initialization code!
  338.  */
  341. #ifdef MODULE
  342. int init_module(void)
  343. {
  344. int ret;
  346. if (verbose)
  347. printk("Loading module mxser ...n");
  348. ret = mxser_init();
  349. if (verbose)
  350. printk("Done.n");
  351. return (ret);
  352. }
  354. void cleanup_module(void)
  355. {
  356. int i, err = 0;
  359. if (verbose)
  360. printk("Unloading module mxser ...n");
  361. if ((err |= tty_unregister_driver(&mxvar_cdriver)))
  362. printk("Couldn't unregister MOXA Smartio family callout drivern");
  363. if ((err |= tty_unregister_driver(&mxvar_sdriver)))
  364. printk("Couldn't unregister MOXA Smartio family serial drivern");
  366. for (i = 0; i < MXSER_BOARDS; i++) {
  367. if (mxsercfg[i].board_type == -1)
  368. continue;
  369. else {
  370. free_irq(mxsercfg[i].irq, &mxvar_table[i * MXSER_PORTS_PER_BOARD]);
  371. }
  372. }
  374. if (verbose)
  375. printk("Done.n");
  377. }
  378. #endif
  381. int mxser_initbrd(int board, struct mxser_hwconf *hwconf)
  382. {
  383. struct mxser_struct *info;
  384. unsigned long flags;
  385. int retval;
  386. int i, n;
  388. init_MUTEX(&mxvar_tmp_buf_sem);
  390. n = board * MXSER_PORTS_PER_BOARD;
  391. info = &mxvar_table[n];
  392. for (i = 0; i < hwconf->ports; i++, n++, info++) {
  393. if (verbose) {
  394. printk("        ttyM%d/cum%d at 0x%04x ", n, n, hwconf->ioaddr[i]);
  395. if (hwconf->baud_base[i] == 115200)
  396. printk(" max. baud rate up to 115200 bps.n");
  397. else
  398. printk(" max. baud rate up to 921600 bps.n");
  399. }
  400. info->port = n;
  401. info->base = hwconf->ioaddr[i];
  402. info->irq = hwconf->irq;
  403. info->vector = hwconf->vector;
  404. info->vectormask = hwconf->vector_mask;
  405. info->rx_trigger = 14;
  406. info->baud_base = hwconf->baud_base[i];
  407. info->flags = ASYNC_SHARE_IRQ;
  408. info->type = hwconf->uart_type;
  409. if ((info->type == PORT_16450) || (info->type == PORT_8250))
  410. info->xmit_fifo_size = 1;
  411. else
  412. info->xmit_fifo_size = 16;
  413. info->custom_divisor = hwconf->baud_base[i] * 16;
  414. info->close_delay = 5 * HZ / 10;
  415. info->closing_wait = 30 * HZ;
  416. info->tqueue.routine = mxser_do_softint;
  417. info->tqueue.data = info;
  418. info->callout_termios = mxvar_cdriver.init_termios;
  419. info->normal_termios = mxvar_sdriver.init_termios;
  420. init_waitqueue_head(&info->open_wait);
  421. init_waitqueue_head(&info->close_wait);
  422. init_waitqueue_head(&info->delta_msr_wait);
  423. }
  425. /*
  426.  * Allocate the IRQ if necessary
  427.  */
  428. save_flags(flags);
  430. n = board * MXSER_PORTS_PER_BOARD;
  431. info = &mxvar_table[n];
  433. cli();
  434. retval = request_irq(hwconf->irq, mxser_interrupt, IRQ_T(info),
  435.      "mxser", info);
  436. if (retval) {
  437. restore_flags(flags);
  438. printk("Board %d: %s", board, mxser_brdname[hwconf->board_type]);
  439. printk("  Request irq fail,IRQ (%d) may be conflit with another device.n", info->irq);
  440. return (retval);
  441. }
  442. restore_flags(flags);
  444. return 0;
  445. }
  448. static void mxser_getcfg(int board, struct mxser_hwconf *hwconf)
  449. {
  450. mxsercfg[board] = *hwconf;
  451. }
  453. static int mxser_get_PCI_conf(struct pci_dev *pdev, int board_type, struct mxser_hwconf *hwconf)
  454. {
  455. int i;
  456. unsigned int ioaddress;
  458. hwconf->board_type = board_type;
  459. hwconf->ports = mxser_numports[board_type];
  460. ioaddress = pci_resource_start (pdev, 2);
  461. for (i = 0; i < hwconf->ports; i++)
  462. hwconf->ioaddr[i] = ioaddress + 8 * i;
  464. ioaddress = pci_resource_start (pdev, 3);
  465. hwconf->vector = ioaddress;
  467. hwconf->irq = pdev->irq;
  469. hwconf->uart_type = PORT_16550A;
  470. hwconf->vector_mask = 0;
  471. for (i = 0; i < hwconf->ports; i++) {
  472. hwconf->vector_mask |= (1 << i);
  473. hwconf->baud_base[i] = 921600;
  474. }
  475. return (0);
  476. }
  478. int mxser_init(void)
  479. {
  480. int i, m, retval, b;
  481. int n, index;
  482. int ret1, ret2;
  483. struct mxser_hwconf hwconf;
  485. printk("MOXA Smartio family driver version %sn", MXSER_VERSION);
  487. /* Initialize the tty_driver structure */
  489. memset(&mxvar_sdriver, 0, sizeof(struct tty_driver));
  490. mxvar_sdriver.magic = TTY_DRIVER_MAGIC;
  491. mxvar_sdriver.name = "ttyM";
  492. mxvar_sdriver.major = ttymajor;
  493. mxvar_sdriver.minor_start = 0;
  494. mxvar_sdriver.num = MXSER_PORTS + 1;
  495. mxvar_sdriver.type = TTY_DRIVER_TYPE_SERIAL;
  496. mxvar_sdriver.subtype = SERIAL_TYPE_NORMAL;
  497. mxvar_sdriver.init_termios = tty_std_termios;
  498. mxvar_sdriver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  499. mxvar_sdriver.flags = TTY_DRIVER_REAL_RAW;
  500. mxvar_sdriver.refcount = &mxvar_refcount;
  501. mxvar_sdriver.table = mxvar_tty;
  502. mxvar_sdriver.termios = mxvar_termios;
  503. mxvar_sdriver.termios_locked = mxvar_termios_locked;
  505. mxvar_sdriver.open = mxser_open;
  506. mxvar_sdriver.close = mxser_close;
  507. mxvar_sdriver.write = mxser_write;
  508. mxvar_sdriver.put_char = mxser_put_char;
  509. mxvar_sdriver.flush_chars = mxser_flush_chars;
  510. mxvar_sdriver.write_room = mxser_write_room;
  511. mxvar_sdriver.chars_in_buffer = mxser_chars_in_buffer;
  512. mxvar_sdriver.flush_buffer = mxser_flush_buffer;
  513. mxvar_sdriver.ioctl = mxser_ioctl;
  514. mxvar_sdriver.throttle = mxser_throttle;
  515. mxvar_sdriver.unthrottle = mxser_unthrottle;
  516. mxvar_sdriver.set_termios = mxser_set_termios;
  517. mxvar_sdriver.stop = mxser_stop;
  518. mxvar_sdriver.start = mxser_start;
  519. mxvar_sdriver.hangup = mxser_hangup;
  521. /*
  522.  * The callout device is just like normal device except for
  523.  * major number and the subtype code.
  524.  */
  525. mxvar_cdriver = mxvar_sdriver;
  526. mxvar_cdriver.name = "cum";
  527. mxvar_cdriver.major = calloutmajor;
  528. mxvar_cdriver.subtype = SERIAL_TYPE_CALLOUT;
  530. printk("Tty devices major number = %d, callout devices major number = %dn", ttymajor, calloutmajor);
  532. mxvar_diagflag = 0;
  533. memset(mxvar_table, 0, MXSER_PORTS * sizeof(struct mxser_struct));
  534. memset(&mxvar_log, 0, sizeof(struct mxser_log));
  537. m = 0;
  538. /* Start finding ISA boards here */
  539. for (b = 0; b < MXSER_BOARDS && m < MXSER_BOARDS; b++) {
  540. int cap;
  541. if (!(cap = mxserBoardCAP[b]))
  542. continue;
  544. retval = mxser_get_ISA_conf(cap, &hwconf);
  546. if (retval != 0)
  547. printk("Found MOXA %s board (CAP=0x%x)n",
  548.        mxser_brdname[hwconf.board_type],
  549.        ioaddr[b]);
  551. if (retval <= 0) {
  552. if (retval == MXSER_ERR_IRQ)
  553. printk("Invalid interrupt number,board not configuredn");
  554. else if (retval == MXSER_ERR_IRQ_CONFLIT)
  555. printk("Invalid interrupt number,board not configuredn");
  556. else if (retval == MXSER_ERR_VECTOR)
  557. printk("Invalid interrupt vector,board not configuredn");
  558. else if (retval == MXSER_ERR_IOADDR)
  559. printk("Invalid I/O address,board not configuredn");
  561. continue;
  562. }
  563. hwconf.pdev = NULL;
  565. if (mxser_initbrd(m, &hwconf) < 0)
  566. continue;
  568. mxser_getcfg(m, &hwconf);
  570. m++;
  571. }
  573. /* Start finding ISA boards from module arg */
  574. for (b = 0; b < MXSER_BOARDS && m < MXSER_BOARDS; b++) {
  575. int cap;
  576. if (!(cap = ioaddr[b]))
  577. continue;
  579. retval = mxser_get_ISA_conf(cap, &hwconf);
  581. if (retval != 0)
  582. printk("Found MOXA %s board (CAP=0x%x)n",
  583.        mxser_brdname[hwconf.board_type],
  584.        ioaddr[b]);
  586. if (retval <= 0) {
  587. if (retval == MXSER_ERR_IRQ)
  588. printk("Invalid interrupt number,board not configuredn");
  589. else if (retval == MXSER_ERR_IRQ_CONFLIT)
  590. printk("Invalid interrupt number,board not configuredn");
  591. else if (retval == MXSER_ERR_VECTOR)
  592. printk("Invalid interrupt vector,board not configuredn");
  593. else if (retval == MXSER_ERR_IOADDR)
  594. printk("Invalid I/O address,board not configuredn");
  596. continue;
  597. }
  598. hwconf.pdev = NULL;
  600. if (mxser_initbrd(m, &hwconf) < 0)
  601. continue;
  603. mxser_getcfg(m, &hwconf);
  605. m++;
  606. }
  608. /* start finding PCI board here */
  610. #ifdef CONFIG_PCI
  611. {
  612. struct pci_dev *pdev = NULL;
  614. n = (sizeof(mxser_pcibrds) / sizeof(mxser_pcibrds[0])) - 1;
  615. index = 0;
  616. for (b = 0; b < n; b++) {
  617. while (pdev = pci_find_device(mxser_pcibrds[b].vendor, mxser_pcibrds[b].device, pdev)) 
  618. {
  619. if (pci_enable_device(pdev))
  620. continue;
  621. hwconf.pdev = pdev;
  622. printk("Found MOXA %s board(BusNo=%d,DevNo=%d)n",
  623. mxser_brdname[mxser_pcibrds[b].driver_data],
  624. pdev->bus->number, PCI_SLOT(pdev->devfn));
  625. if (m >= MXSER_BOARDS) {
  626. printk("Too many Smartio family boards found (maximum %d),board not configuredn", MXSER_BOARDS);
  627. } else {
  628. retval = mxser_get_PCI_conf(pdev, mxser_pcibrds[b].driver_data, &hwconf);
  629. if (retval < 0) {
  630. if (retval == MXSER_ERR_IRQ)
  631. printk("Invalid interrupt number,board not configuredn");
  632. else if (retval == MXSER_ERR_IRQ_CONFLIT)
  633. printk("Invalid interrupt number,board not configuredn");
  634. else if (retval == MXSER_ERR_VECTOR)
  635. printk("Invalid interrupt vector,board not configuredn");
  636. else if (retval == MXSER_ERR_IOADDR)
  637. printk("Invalid I/O address,board not configuredn");
  638. continue;
  639. }
  640. if (mxser_initbrd(m, &hwconf) < 0)
  641. continue;
  642. mxser_getcfg(m, &hwconf);
  643. m++;
  644. }
  645. }
  646. }
  647. }
  648. #endif
  650. for (i = m; i < MXSER_BOARDS; i++) {
  651. mxsercfg[i].board_type = -1;
  652. }
  655. ret1 = 0;
  656. ret2 = 0;
  657. if (!(ret1 = tty_register_driver(&mxvar_sdriver))) {
  658. if (!(ret2 = tty_register_driver(&mxvar_cdriver))) {
  659. return 0;
  660. } else {
  661. tty_unregister_driver(&mxvar_sdriver);
  662. printk("Couldn't install MOXA Smartio family callout driver !n");
  663. }
  664. } else
  665. printk("Couldn't install MOXA Smartio family driver !n");
  668. if (ret1 || ret2) {
  669. for (i = 0; i < MXSER_BOARDS; i++) {
  670. if (mxsercfg[i].board_type == -1)
  671. continue;
  672. else {
  673. free_irq(mxsercfg[i].irq, &mxvar_table[i * MXSER_PORTS_PER_BOARD]);
  674. }
  675. }
  676. return -1;
  677. }
  678. return (0);
  679. }
  681. static void mxser_do_softint(void *private_)
  682. {
  683. struct mxser_struct *info = (struct mxser_struct *) private_;
  684. struct tty_struct *tty;
  686. tty = info->tty;
  687. if (tty) {
  688. if (test_and_clear_bit(MXSER_EVENT_TXLOW, &info->event)) {
  689. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  690.     tty->ldisc.write_wakeup)
  691. (tty->ldisc.write_wakeup) (tty);
  692. wake_up_interruptible(&tty->write_wait);
  693. }
  694. if (test_and_clear_bit(MXSER_EVENT_HANGUP, &info->event)) {
  695. tty_hangup(tty); /* FIXME: module removal race here - AKPM */
  696. }
  697. }
  698. MOD_DEC_USE_COUNT;
  699. }
  701. /*
  702.  * This routine is called whenever a serial port is opened.  It
  703.  * enables interrupts for a serial port, linking in its async structure into
  704.  * the IRQ chain.   It also performs the serial-specific
  705.  * initialization for the tty structure.
  706.  */
  708. static int mxser_open(struct tty_struct *tty, struct file *filp)
  709. {
  710. struct mxser_struct *info;
  711. int retval, line;
  712. unsigned long page;
  714. line = PORTNO(tty);
  715. if (line == MXSER_PORTS)
  716. return (0);
  717. if ((line < 0) || (line > MXSER_PORTS))
  718. return (-ENODEV);
  719. info = mxvar_table + line;
  720. if (!info->base)
  721. return (-ENODEV);
  723. info->count++;
  724. tty->driver_data = info;
  725. info->tty = tty;
  727. if (!mxvar_tmp_buf) {
  728. page = get_free_page(GFP_KERNEL);
  729. if (!page)
  730. return (-ENOMEM);
  731. if (mxvar_tmp_buf)
  732. free_page(page);
  733. else
  734. mxvar_tmp_buf = (unsigned char *) page;
  735. }
  736. /*
  737.  * Start up serial port
  738.  */
  739. retval = mxser_startup(info);
  740. if (retval)
  741. return (retval);
  743. retval = mxser_block_til_ready(tty, filp, info);
  744. if (retval)
  745. return (retval);
  747. if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
  748. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  749. *tty->termios = info->normal_termios;
  750. else
  751. *tty->termios = info->callout_termios;
  752. mxser_change_speed(info, 0);
  753. }
  754. info->session = current->session;
  755. info->pgrp = current->pgrp;
  757. MOD_INC_USE_COUNT;
  759. return (0);
  760. }
  762. /*
  763.  * This routine is called when the serial port gets closed.  First, we
  764.  * wait for the last remaining data to be sent.  Then, we unlink its
  765.  * async structure from the interrupt chain if necessary, and we free
  766.  * that IRQ if nothing is left in the chain.
  767.  */
  769. static void mxser_close(struct tty_struct *tty, struct file *filp)
  770. {
  771. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  772. unsigned long flags;
  773. unsigned long timeout;
  775. if (PORTNO(tty) == MXSER_PORTS)
  776. return;
  777. if (!info)
  778. return;
  780. save_flags(flags);
  781. cli();
  783. if (tty_hung_up_p(filp)) {
  784. restore_flags(flags);
  785. MOD_DEC_USE_COUNT;
  786. return;
  787. }
  788. if ((tty->count == 1) && (info->count != 1)) {
  789. /*
  790.  * Uh, oh.        tty->count is 1, which means that the tty
  791.  * structure will be freed.  Info->count should always
  792.  * be one in these conditions.  If it's greater than
  793.  * one, we've got real problems, since it means the
  794.  * serial port won't be shutdown.
  795.  */
  796. printk("mxser_close: bad serial port count; tty->count is 1, "
  797.        "info->count is %dn", info->count);
  798. info->count = 1;
  799. }
  800. if (--info->count < 0) {
  801. printk("mxser_close: bad serial port count for ttys%d: %dn",
  802.        info->port, info->count);
  803. info->count = 0;
  804. }
  805. if (info->count) {
  806. restore_flags(flags);
  807. MOD_DEC_USE_COUNT;
  808. return;
  809. }
  810. info->flags |= ASYNC_CLOSING;
  811. /*
  812.  * Save the termios structure, since this port may have
  813.  * separate termios for callout and dialin.
  814.  */
  815. if (info->flags & ASYNC_NORMAL_ACTIVE)
  816. info->normal_termios = *tty->termios;
  817. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  818. info->callout_termios = *tty->termios;
  819. /*
  820.  * Now we wait for the transmit buffer to clear; and we notify
  821.  * the line discipline to only process XON/XOFF characters.
  822.  */
  823. tty->closing = 1;
  824. if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  825. tty_wait_until_sent(tty, info->closing_wait);
  826. /*
  827.  * At this point we stop accepting input.  To do this, we
  828.  * disable the receive line status interrupts, and tell the
  829.  * interrupt driver to stop checking the data ready bit in the
  830.  * line status register.
  831.  */
  832. info->IER &= ~UART_IER_RLSI;
  833. /* by William
  834.    info->read_status_mask &= ~UART_LSR_DR;
  835.  */
  836. if (info->flags & ASYNC_INITIALIZED) {
  837. outb(info->IER, info->base + UART_IER);
  838. /*
  839.  * Before we drop DTR, make sure the UART transmitter
  840.  * has completely drained; this is especially
  841.  * important if there is a transmit FIFO!
  842.  */
  843. timeout = jiffies + HZ;
  844. while (!(inb(info->base + UART_LSR) & UART_LSR_TEMT)) {
  845. set_current_state(TASK_INTERRUPTIBLE);
  846. schedule_timeout(5);
  847. if (jiffies > timeout)
  848. break;
  849. }
  850. }
  851. mxser_shutdown(info);
  852. if (tty->driver.flush_buffer)
  853. tty->driver.flush_buffer(tty);
  854. if (tty->ldisc.flush_buffer)
  855. tty->ldisc.flush_buffer(tty);
  856. tty->closing = 0;
  857. info->event = 0;
  858. info->tty = 0;
  859. if (info->blocked_open) {
  860. if (info->close_delay) {
  861. set_current_state(TASK_INTERRUPTIBLE);
  862. schedule_timeout(info->close_delay);
  863. }
  864. wake_up_interruptible(&info->open_wait);
  865. }
  866. info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE |
  867.  ASYNC_CLOSING);
  868. wake_up_interruptible(&info->close_wait);
  869. restore_flags(flags);
  871. MOD_DEC_USE_COUNT;
  872. }
  874. static int mxser_write(struct tty_struct *tty, int from_user,
  875.        const unsigned char *buf, int count)
  876. {
  877. int c, total = 0;
  878. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  879. unsigned long flags;
  881. if (!tty || !info->xmit_buf || !mxvar_tmp_buf)
  882. return (0);
  884. save_flags(flags);
  885. if (from_user) {
  886. down(&mxvar_tmp_buf_sem);
  887. while (1) {
  888. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  889.    SERIAL_XMIT_SIZE - info->xmit_head));
  890. if (c <= 0)
  891. break;
  893. c -= copy_from_user(mxvar_tmp_buf, buf, c);
  894. if (!c) {
  895. if (!total)
  896. total = -EFAULT;
  897. break;
  898. }
  900. cli();
  901. c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  902.        SERIAL_XMIT_SIZE - info->xmit_head));
  903. memcpy(info->xmit_buf + info->xmit_head, mxvar_tmp_buf, c);
  904. info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
  905. info->xmit_cnt += c;
  906. restore_flags(flags);
  908. buf += c;
  909. count -= c;
  910. total += c;
  911. }
  912. up(&mxvar_tmp_buf_sem);
  913. } else {
  914. while (1) {
  915. cli();
  916. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  917.    SERIAL_XMIT_SIZE - info->xmit_head));
  918. if (c <= 0) {
  919. restore_flags(flags);
  920. break;
  921. }
  923. memcpy(info->xmit_buf + info->xmit_head, buf, c);
  924. info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
  925. info->xmit_cnt += c;
  926. restore_flags(flags);
  928. buf += c;
  929. count -= c;
  930. total += c;
  931. }
  932. }
  934. cli();
  935. if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
  936.     !(info->IER & UART_IER_THRI)) {
  937. info->IER |= UART_IER_THRI;
  938. outb(info->IER, info->base + UART_IER);
  939. }
  940. restore_flags(flags);
  941. return (total);
  942. }
  944. static void mxser_put_char(struct tty_struct *tty, unsigned char ch)
  945. {
  946. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  947. unsigned long flags;
  949. if (!tty || !info->xmit_buf)
  950. return;
  952. save_flags(flags);
  953. cli();
  954. if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  955. restore_flags(flags);
  956. return;
  957. }
  958. info->xmit_buf[info->xmit_head++] = ch;
  959. info->xmit_head &= SERIAL_XMIT_SIZE - 1;
  960. info->xmit_cnt++;
  961. /********************************************** why ??? ***********
  962. if ( !tty->stopped && !tty->hw_stopped &&
  963.      !(info->IER & UART_IER_THRI) ) {
  964.     info->IER |= UART_IER_THRI;
  965.     outb(info->IER, info->base + UART_IER);
  966. }
  967. *****************************************************************/
  968. restore_flags(flags);
  969. }
  971. static void mxser_flush_chars(struct tty_struct *tty)
  972. {
  973. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  974. unsigned long flags;
  976. if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  977.     !info->xmit_buf)
  978. return;
  980. save_flags(flags);
  981. cli();
  982. info->IER |= UART_IER_THRI;
  983. outb(info->IER, info->base + UART_IER);
  984. restore_flags(flags);
  985. }
  987. static int mxser_write_room(struct tty_struct *tty)
  988. {
  989. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  990. int ret;
  992. ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  993. if (ret < 0)
  994. ret = 0;
  995. return (ret);
  996. }
  998. static int mxser_chars_in_buffer(struct tty_struct *tty)
  999. {
  1000. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1002. return (info->xmit_cnt);
  1003. }
  1005. static void mxser_flush_buffer(struct tty_struct *tty)
  1006. {
  1007. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1008. unsigned long flags;
  1010. save_flags(flags);
  1011. cli();
  1012. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  1013. restore_flags(flags);
  1014. wake_up_interruptible(&tty->write_wait);
  1015. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1016.     tty->ldisc.write_wakeup)
  1017. (tty->ldisc.write_wakeup) (tty);
  1018. }
  1020. static int mxser_ioctl(struct tty_struct *tty, struct file *file,
  1021.        unsigned int cmd, unsigned long arg)
  1022. {
  1023. unsigned long flags;
  1024. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1025. int retval;
  1026. struct async_icount cprev, cnow; /* kernel counter temps */
  1027. struct serial_icounter_struct *p_cuser; /* user space */
  1028. unsigned long templ;
  1030. if (PORTNO(tty) == MXSER_PORTS)
  1031. return (mxser_ioctl_special(cmd, arg));
  1032. if ((cmd != TIOCGSERIAL) && (cmd != TIOCMIWAIT) &&
  1033.     (cmd != TIOCGICOUNT)) {
  1034. if (tty->flags & (1 << TTY_IO_ERROR))
  1035. return (-EIO);
  1036. }
  1037. switch (cmd) {
  1038. case TCSBRK: /* SVID version: non-zero arg --> no break */
  1039. retval = tty_check_change(tty);
  1040. if (retval)
  1041. return (retval);
  1042. tty_wait_until_sent(tty, 0);
  1043. if (!arg)
  1044. mxser_send_break(info, HZ / 4); /* 1/4 second */
  1045. return (0);
  1046. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1047. retval = tty_check_change(tty);
  1048. if (retval)
  1049. return (retval);
  1050. tty_wait_until_sent(tty, 0);
  1051. mxser_send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
  1052. return (0);
  1053. case TIOCGSOFTCAR:
  1054. return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long *) arg);
  1055. case TIOCSSOFTCAR:
  1056. if(get_user(templ, (unsigned long *) arg))
  1057. return -EFAULT;
  1058. arg = templ;
  1059. tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) |
  1060.  (arg ? CLOCAL : 0));
  1061. return (0);
  1062. case TIOCMGET:
  1063. return (mxser_get_modem_info(info, (unsigned int *) arg));
  1064. case TIOCMBIS:
  1065. case TIOCMBIC:
  1066. case TIOCMSET:
  1067. return (mxser_set_modem_info(info, cmd, (unsigned int *) arg));
  1068. case TIOCGSERIAL:
  1069. return (mxser_get_serial_info(info, (struct serial_struct *) arg));
  1070. case TIOCSSERIAL:
  1071. return (mxser_set_serial_info(info, (struct serial_struct *) arg));
  1072. case TIOCSERGETLSR: /* Get line status register */
  1073. return (mxser_get_lsr_info(info, (unsigned int *) arg));
  1074. /*
  1075.  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
  1076.  * - mask passed in arg for lines of interest
  1077.  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  1078.  * Caller should use TIOCGICOUNT to see which one it was
  1079.  */
  1080. case TIOCMIWAIT:
  1081. save_flags(flags);
  1082. cli();
  1083. cprev = info->icount; /* note the counters on entry */
  1084. restore_flags(flags);
  1085. while (1) {
  1086. interruptible_sleep_on(&info->delta_msr_wait);
  1087. /* see if a signal did it */
  1088. if (signal_pending(current))
  1089. return (-ERESTARTSYS);
  1090. save_flags(flags);
  1091. cli();
  1092. cnow = info->icount; /* atomic copy */
  1093. restore_flags(flags);
  1094. if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
  1095.   cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
  1096. return (-EIO); /* no change => error */
  1097. if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  1098. ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  1099.  ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
  1100. ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
  1101. return (0);
  1102. }
  1103. cprev = cnow;
  1104. }
  1105. /* NOTREACHED */
  1106. /*
  1107.  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
  1108.  * Return: write counters to the user passed counter struct
  1109.  * NB: both 1->0 and 0->1 transitions are counted except for
  1110.  *     RI where only 0->1 is counted.
  1111.  */
  1112. case TIOCGICOUNT:
  1113. save_flags(flags);
  1114. cli();
  1115. cnow = info->icount;
  1116. restore_flags(flags);
  1117. p_cuser = (struct serial_icounter_struct *) arg;
  1118. if(put_user(cnow.cts, &p_cuser->cts))
  1119. return -EFAULT;
  1120. if(put_user(cnow.dsr, &p_cuser->dsr))
  1121. return -EFAULT;
  1122. if(put_user(cnow.rng, &p_cuser->rng))
  1123. return -EFAULT;
  1124. return put_user(cnow.dcd, &p_cuser->dcd);
  1125. case MOXA_HighSpeedOn:
  1126. return put_user(info->baud_base != 115200 ? 1 : 0, (int *) arg);
  1127. default:
  1128. return (-ENOIOCTLCMD);
  1129. }
  1130. return (0);
  1131. }
  1133. static int mxser_ioctl_special(unsigned int cmd, unsigned long arg)
  1134. {
  1135. int i, result, status;
  1137. switch (cmd) {
  1138. case MOXA_GET_CONF:
  1139. if(copy_to_user((struct mxser_hwconf *) arg, mxsercfg,
  1140.      sizeof(struct mxser_hwconf) * 4))
  1141.       return -EFAULT;
  1142. return 0;
  1143. case MOXA_GET_MAJOR:
  1144. if(copy_to_user((int *) arg, &ttymajor, sizeof(int)))
  1145. return -EFAULT;
  1146. return 0;
  1148. case MOXA_GET_CUMAJOR:
  1149. if(copy_to_user((int *) arg, &calloutmajor, sizeof(int)))
  1150. return -EFAULT;
  1151. return 0;
  1153. case MOXA_CHKPORTENABLE:
  1154. result = 0;
  1155. for (i = 0; i < MXSER_PORTS; i++) {
  1156. if (mxvar_table[i].base)
  1157. result |= (1 << i);
  1158. }
  1159. return put_user(result, (unsigned long *) arg);
  1160. case MOXA_GETDATACOUNT:
  1161. if(copy_to_user((struct mxser_log *) arg, &mxvar_log, sizeof(mxvar_log)))
  1162. return -EFAULT;
  1163. return (0);
  1164. case MOXA_GETMSTATUS:
  1165. for (i = 0; i < MXSER_PORTS; i++) {
  1166. GMStatus[i].ri = 0;
  1167. if (!mxvar_table[i].base) {
  1168. GMStatus[i].dcd = 0;
  1169. GMStatus[i].dsr = 0;
  1170. GMStatus[i].cts = 0;
  1171. continue;
  1172. }
  1173. if (!mxvar_table[i].tty || !mxvar_table[i].tty->termios)
  1174. GMStatus[i].cflag = mxvar_table[i].normal_termios.c_cflag;
  1175. else
  1176. GMStatus[i].cflag = mxvar_table[i].tty->termios->c_cflag;
  1178. status = inb(mxvar_table[i].base + UART_MSR);
  1179. if (status & 0x80 /*UART_MSR_DCD */ )
  1180. GMStatus[i].dcd = 1;
  1181. else
  1182. GMStatus[i].dcd = 0;
  1184. if (status & 0x20 /*UART_MSR_DSR */ )
  1185. GMStatus[i].dsr = 1;
  1186. else
  1187. GMStatus[i].dsr = 0;
  1190. if (status & 0x10 /*UART_MSR_CTS */ )
  1191. GMStatus[i].cts = 1;
  1192. else
  1193. GMStatus[i].cts = 0;
  1194. }
  1195. if(copy_to_user((struct mxser_mstatus *) arg, GMStatus,
  1196.      sizeof(struct mxser_mstatus) * MXSER_PORTS))
  1197. return -EFAULT;
  1198. return 0;
  1199. default:
  1200. return (-ENOIOCTLCMD);
  1201. }
  1202. return (0);
  1203. }
  1205. /*
  1206.  * This routine is called by the upper-layer tty layer to signal that
  1207.  * incoming characters should be throttled.
  1208.  */
  1209. static void mxser_throttle(struct tty_struct *tty)
  1210. {
  1211. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1212. unsigned long flags;
  1214. if (I_IXOFF(tty)) {
  1215. info->x_char = STOP_CHAR(tty);
  1216. save_flags(flags);
  1217. cli();
  1218. outb(info->IER, 0);
  1219. info->IER |= UART_IER_THRI;
  1220. outb(info->IER, info->base + UART_IER); /* force Tx interrupt */
  1221. restore_flags(flags);
  1222. }
  1223. if (info->tty->termios->c_cflag & CRTSCTS) {
  1224. info->MCR &= ~UART_MCR_RTS;
  1225. save_flags(flags);
  1226. cli();
  1227. outb(info->MCR, info->base + UART_MCR);
  1228. restore_flags(flags);
  1229. }
  1230. }
  1232. static void mxser_unthrottle(struct tty_struct *tty)
  1233. {
  1234. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1235. unsigned long flags;
  1237. if (I_IXOFF(tty)) {
  1238. if (info->x_char)
  1239. info->x_char = 0;
  1240. else {
  1241. info->x_char = START_CHAR(tty);
  1242. save_flags(flags);
  1243. cli();
  1244. outb(info->IER, 0);
  1245. info->IER |= UART_IER_THRI; /* force Tx interrupt */
  1246. outb(info->IER, info->base + UART_IER);
  1247. restore_flags(flags);
  1248. }
  1249. }
  1250. if (info->tty->termios->c_cflag & CRTSCTS) {
  1251. info->MCR |= UART_MCR_RTS;
  1252. save_flags(flags);
  1253. cli();
  1254. outb(info->MCR, info->base + UART_MCR);
  1255. restore_flags(flags);
  1256. }
  1257. }
  1259. static void mxser_set_termios(struct tty_struct *tty,
  1260.       struct termios *old_termios)
  1261. {
  1262. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1264. /* 8-2-99 by William
  1265.    if ( (tty->termios->c_cflag == old_termios->c_cflag) &&
  1266.    (RELEVANT_IFLAG(tty->termios->c_iflag) ==
  1267.    RELEVANT_IFLAG(old_termios->c_iflag)) )
  1268.    return;
  1270.    mxser_change_speed(info, old_termios);
  1272.    if ( (old_termios->c_cflag & CRTSCTS) &&
  1273.    !(tty->termios->c_cflag & CRTSCTS) ) {
  1274.    tty->hw_stopped = 0;
  1275.    mxser_start(tty);
  1276.    }
  1277.  */
  1278. if ((tty->termios->c_cflag != old_termios->c_cflag) ||
  1279.     (RELEVANT_IFLAG(tty->termios->c_iflag) !=
  1280.      RELEVANT_IFLAG(old_termios->c_iflag))) {
  1282. mxser_change_speed(info, old_termios);
  1284. if ((old_termios->c_cflag & CRTSCTS) &&
  1285.     !(tty->termios->c_cflag & CRTSCTS)) {
  1286. tty->hw_stopped = 0;
  1287. mxser_start(tty);
  1288. }
  1289. }
  1290. /* Handle sw stopped */
  1291. if ((old_termios->c_iflag & IXON) &&
  1292.     !(tty->termios->c_iflag & IXON)) {
  1293. tty->stopped = 0;
  1294. mxser_start(tty);
  1295. }
  1296. }
  1298. /*
  1299.  * mxser_stop() and mxser_start()
  1300.  *
  1301.  * This routines are called before setting or resetting tty->stopped.
  1302.  * They enable or disable transmitter interrupts, as necessary.
  1303.  */
  1304. static void mxser_stop(struct tty_struct *tty)
  1305. {
  1306. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1307. unsigned long flags;
  1309. save_flags(flags);
  1310. cli();
  1311. if (info->IER & UART_IER_THRI) {
  1312. info->IER &= ~UART_IER_THRI;
  1313. outb(info->IER, info->base + UART_IER);
  1314. }
  1315. restore_flags(flags);
  1316. }
  1318. static void mxser_start(struct tty_struct *tty)
  1319. {
  1320. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1321. unsigned long flags;
  1323. save_flags(flags);
  1324. cli();
  1325. if (info->xmit_cnt && info->xmit_buf &&
  1326.     !(info->IER & UART_IER_THRI)) {
  1327. info->IER |= UART_IER_THRI;
  1328. outb(info->IER, info->base + UART_IER);
  1329. }
  1330. restore_flags(flags);
  1331. }
  1333. /*
  1334.  * This routine is called by tty_hangup() when a hangup is signaled.
  1335.  */
  1336. void mxser_hangup(struct tty_struct *tty)
  1337. {
  1338. struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
  1340. mxser_flush_buffer(tty);
  1341. mxser_shutdown(info);
  1342. info->event = 0;
  1343. info->count = 0;
  1344. info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE);
  1345. info->tty = 0;
  1346. wake_up_interruptible(&info->open_wait);
  1347. }
  1349. /*
  1350.  * This is the serial driver's generic interrupt routine
  1351.  */
  1352. static void mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  1353. {
  1354. int status, i;
  1355. struct mxser_struct *info;
  1356. struct mxser_struct *port;
  1357. int max, irqbits, bits, msr;
  1358. int pass_counter = 0;
  1360. port = 0;
  1361. for (i = 0; i < MXSER_BOARDS; i++) {
  1362. if (dev_id == &(mxvar_table[i * MXSER_PORTS_PER_BOARD])) {
  1363. port = dev_id;
  1364. break;
  1365. }
  1366. }
  1368. if (i == MXSER_BOARDS)
  1369. return;
  1370. if (port == 0)
  1371. return;
  1372. max = mxser_numports[mxsercfg[i].board_type];
  1374. while (1) {
  1375. irqbits = inb(port->vector) & port->vectormask;
  1376. if (irqbits == port->vectormask)
  1377. break;
  1378. for (i = 0, bits = 1; i < max; i++, irqbits |= bits, bits <<= 1) {
  1379. if (irqbits == port->vectormask)
  1380. break;
  1381. if (bits & irqbits)
  1382. continue;
  1383. info = port + i;
  1384. if (!info->tty ||
  1385.   (inb(info->base + UART_IIR) & UART_IIR_NO_INT))
  1386. continue;
  1387. status = inb(info->base + UART_LSR) & info->read_status_mask;
  1388. if (status & UART_LSR_DR)
  1389. mxser_receive_chars(info, &status);
  1390. msr = inb(info->base + UART_MSR);
  1391. if (msr & UART_MSR_ANY_DELTA)
  1392. mxser_check_modem_status(info, msr);
  1393. if (status & UART_LSR_THRE) {
  1394. /* 8-2-99 by William
  1395.    if ( info->x_char || (info->xmit_cnt > 0) )
  1396.  */
  1397. mxser_transmit_chars(info);
  1398. }
  1399. }
  1400. if (pass_counter++ > MXSER_ISR_PASS_LIMIT) {
  1401. #if 0
  1402. printk("MOXA Smartio/Indusrtio family driver interrupt loop breakn");
  1403. #endif
  1404. break; /* Prevent infinite loops */
  1405. }
  1406. }
  1407. }
  1409. static inline void mxser_receive_chars(struct mxser_struct *info,
  1410.  int *status)
  1411. {
  1412. struct tty_struct *tty = info->tty;
  1413. unsigned char ch;
  1414. int ignored = 0;
  1415. int cnt = 0;
  1417. do {
  1418. ch = inb(info->base + UART_RX);
  1419. if (*status & info->ignore_status_mask) {
  1420. if (++ignored > 100)
  1421. break;
  1422. } else {
  1423. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  1424. break;
  1425. tty->flip.count++;
  1426. if (*status & UART_LSR_SPECIAL) {
  1427. if (*status & UART_LSR_BI) {
  1428. *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  1429. if (info->flags & ASYNC_SAK)
  1430. do_SAK(tty);
  1431. } else if (*status & UART_LSR_PE) {
  1432. *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  1433. } else if (*status & UART_LSR_FE) {
  1434. *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  1435. } else if (*status & UART_LSR_OE) {
  1436. *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  1437. } else
  1438. *tty->flip.flag_buf_ptr++ = 0;
  1439. } else
  1440. *tty->flip.flag_buf_ptr++ = 0;
  1441. *tty->flip.char_buf_ptr++ = ch;
  1442. cnt++;
  1443. }
  1444. *status = inb(info->base + UART_LSR) & info->read_status_mask;
  1445. } while (*status & UART_LSR_DR);
  1446. mxvar_log.rxcnt[info->port] += cnt;
  1447. queue_task(&tty->flip.tqueue, &tq_timer);
  1449. }
  1451. static inline void mxser_transmit_chars(struct mxser_struct *info)
  1452. {
  1453. int count, cnt;
  1455. if (info->x_char) {
  1456. outb(info->x_char, info->base + UART_TX);
  1457. info->x_char = 0;
  1458. mxvar_log.txcnt[info->port]++;
  1459. return;
  1460. }
  1461. if ((info->xmit_cnt <= 0) || info->tty->stopped ||
  1462.     info->tty->hw_stopped) {
  1463. info->IER &= ~UART_IER_THRI;
  1464. outb(info->IER, info->base + UART_IER);
  1465. return;
  1466. }
  1467. cnt = info->xmit_cnt;
  1468. count = info->xmit_fifo_size;
  1469. do {
  1470. outb(info->xmit_buf[info->xmit_tail++], info->base + UART_TX);
  1471. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE - 1);
  1472. if (--info->xmit_cnt <= 0)
  1473. break;
  1474. } while (--count > 0);
  1475. mxvar_log.txcnt[info->port] += (cnt - info->xmit_cnt);
  1477. if (info->xmit_cnt < WAKEUP_CHARS) {
  1478. set_bit(MXSER_EVENT_TXLOW, &info->event);
  1479. MOD_INC_USE_COUNT;
  1480. if (schedule_task(&info->tqueue) == 0)
  1481.     MOD_DEC_USE_COUNT;
  1482. }
  1483. if (info->xmit_cnt <= 0) {
  1484. info->IER &= ~UART_IER_THRI;
  1485. outb(info->IER, info->base + UART_IER);
  1486. }
  1487. }
  1489. static inline void mxser_check_modem_status(struct mxser_struct *info,
  1490.       int status)
  1491. {
  1493. /* update input line counters */
  1494. if (status & UART_MSR_TERI)
  1495. info->icount.rng++;
  1496. if (status & UART_MSR_DDSR)
  1497. info->icount.dsr++;
  1498. if (status & UART_MSR_DDCD)
  1499. info->icount.dcd++;
  1500. if (status & UART_MSR_DCTS)
  1501. info->icount.cts++;
  1502. wake_up_interruptible(&info->delta_msr_wait);
  1504. if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
  1505. if (status & UART_MSR_DCD)
  1506. wake_up_interruptible(&info->open_wait);
  1507. else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1508.    (info->flags & ASYNC_CALLOUT_NOHUP)))
  1509. set_bit(MXSER_EVENT_HANGUP, &info->event);
  1510. MOD_INC_USE_COUNT;
  1511. if (schedule_task(&info->tqueue) == 0)
  1512.     MOD_DEC_USE_COUNT;
  1513. }
  1514. if (info->flags & ASYNC_CTS_FLOW) {
  1515. if (info->tty->hw_stopped) {
  1516. if (status & UART_MSR_CTS) {
  1517. info->tty->hw_stopped = 0;
  1518. info->IER |= UART_IER_THRI;
  1519. outb(info->IER, info->base + UART_IER);
  1521. set_bit(MXSER_EVENT_TXLOW, &info->event);
  1522. MOD_INC_USE_COUNT;
  1523. if (schedule_task(&info->tqueue) == 0)
  1524. MOD_DEC_USE_COUNT;
  1525. }
  1526. } else {
  1527. if (!(status & UART_MSR_CTS)) {
  1528. info->tty->hw_stopped = 1;
  1529. info->IER &= ~UART_IER_THRI;
  1530. outb(info->IER, info->base + UART_IER);
  1531. }
  1532. }
  1533. }
  1534. }
  1536. static int mxser_block_til_ready(struct tty_struct *tty, struct file *filp,
  1537.  struct mxser_struct *info)
  1538. {
  1539. DECLARE_WAITQUEUE(wait, current);
  1540. unsigned long flags;
  1541. int retval;
  1542. int do_clocal = 0;
  1544. /*
  1545.  * If the device is in the middle of being closed, then block
  1546.  * until it's done, and then try again.
  1547.  */
  1548. if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
  1549. if (info->flags & ASYNC_CLOSING)
  1550. interruptible_sleep_on(&info->close_wait);
  1551. #ifdef SERIAL_DO_RESTART
  1552. if (info->flags & ASYNC_HUP_NOTIFY)
  1553. return (-EAGAIN);
  1554. else
  1555. return (-ERESTARTSYS);
  1556. #else
  1557. return (-EAGAIN);
  1558. #endif
  1559. }
  1560. /*
  1561.  * If this is a callout device, then just make sure the normal
  1562.  * device isn't being used.
  1563.  */
  1564. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1565. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1566. return (-EBUSY);
  1567. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1568.     (info->flags & ASYNC_SESSION_LOCKOUT) &&
  1569.     (info->session != current->session))
  1570. return (-EBUSY);
  1571. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1572.     (info->flags & ASYNC_PGRP_LOCKOUT) &&
  1573.     (info->pgrp != current->pgrp))
  1574. return (-EBUSY);
  1575. info->flags |= ASYNC_CALLOUT_ACTIVE;
  1576. return (0);
  1577. }
  1578. /*
  1579.  * If non-blocking mode is set, or the port is not enabled,
  1580.  * then make the check up front and then exit.
  1581.  */
  1582. if ((filp->f_flags & O_NONBLOCK) ||
  1583.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1584. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1585. return (-EBUSY);
  1586. info->flags |= ASYNC_NORMAL_ACTIVE;
  1587. return (0);
  1588. }
  1589. if (info->flags & ASYNC_CALLOUT_ACTIVE) {
  1590. if (info->normal_termios.c_cflag & CLOCAL)
  1591. do_clocal = 1;
  1592. } else {
  1593. if (tty->termios->c_cflag & CLOCAL)
  1594. do_clocal = 1;
  1595. }
  1597. /*
  1598.  * Block waiting for the carrier detect and the line to become
  1599.  * free (i.e., not in use by the callout).  While we are in
  1600.  * this loop, info->count is dropped by one, so that
  1601.  * mxser_close() knows when to free things.  We restore it upon
  1602.  * exit, either normal or abnormal.
  1603.  */
  1604. retval = 0;
  1605. add_wait_queue(&info->open_wait, &wait);
  1606. save_flags(flags);
  1607. cli();
  1608. if (!tty_hung_up_p(filp))
  1609. info->count--;
  1610. restore_flags(flags);
  1611. info->blocked_open++;
  1612. while (1) {
  1613. save_flags(flags);
  1614. cli();
  1615. if (!(info->flags & ASYNC_CALLOUT_ACTIVE))
  1616. outb(inb(info->base + UART_MCR) | UART_MCR_DTR | UART_MCR_RTS,
  1617.      info->base + UART_MCR);
  1618. restore_flags(flags);
  1619. set_current_state(TASK_INTERRUPTIBLE);
  1620. if (tty_hung_up_p(filp) || !(info->flags & ASYNC_INITIALIZED)) {
  1621. #ifdef SERIAL_DO_RESTART
  1622. if (info->flags & ASYNC_HUP_NOTIFY)
  1623. retval = -EAGAIN;
  1624. else
  1625. retval = -ERESTARTSYS;
  1626. #else
  1627. retval = -EAGAIN;
  1628. #endif
  1629. break;
  1630. }
  1631. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1632.     !(info->flags & ASYNC_CLOSING) &&
  1633.     (do_clocal || (inb(info->base + UART_MSR) & UART_MSR_DCD)))
  1634. break;
  1635. if (signal_pending(current)) {
  1636. retval = -ERESTARTSYS;
  1637. break;
  1638. }
  1639. schedule();
  1640. }
  1641. set_current_state(TASK_RUNNING);
  1642. remove_wait_queue(&info->open_wait, &wait);
  1643. if (!tty_hung_up_p(filp))
  1644. info->count++;
  1645. info->blocked_open--;
  1646. if (retval)
  1647. return (retval);
  1648. info->flags |= ASYNC_NORMAL_ACTIVE;
  1649. return (0);
  1650. }
  1652. static int mxser_startup(struct mxser_struct *info)
  1653. {
  1654. unsigned long flags;
  1655. unsigned long page;
  1657. page = get_free_page(GFP_KERNEL);
  1658. if (!page)
  1659. return (-ENOMEM);
  1661. save_flags(flags);
  1662. cli();
  1664. if (info->flags & ASYNC_INITIALIZED) {
  1665. free_page(page);
  1666. restore_flags(flags);
  1667. return (0);
  1668. }
  1669. if (!info->base || !info->type) {
  1670. if (info->tty)
  1671. set_bit(TTY_IO_ERROR, &info->tty->flags);
  1672. free_page(page);
  1673. restore_flags(flags);
  1674. return (0);
  1675. }
  1676. if (info->xmit_buf)
  1677. free_page(page);
  1678. else
  1679. info->xmit_buf = (unsigned char *) page;
  1681. /*
  1682.  * Clear the FIFO buffers and disable them
  1683.  * (they will be reenabled in mxser_change_speed())
  1684.  */
  1685. if (info->xmit_fifo_size == 16)
  1686. outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT),
  1687.      info->base + UART_FCR);
  1689. /*
  1690.  * At this point there's no way the LSR could still be 0xFF;
  1691.  * if it is, then bail out, because there's likely no UART
  1692.  * here.
  1693.  */
  1694. if (inb(info->base + UART_LSR) == 0xff) {
  1695. restore_flags(flags);
  1696. if (capable(CAP_SYS_ADMIN)) {
  1697. if (info->tty)
  1698. set_bit(TTY_IO_ERROR, &info->tty->flags);
  1699. return (0);
  1700. } else
  1701. return (-ENODEV);
  1702. }
  1703. /*
  1704.  * Clear the interrupt registers.
  1705.  */
  1706. (void) inb(info->base + UART_LSR);
  1707. (void) inb(info->base + UART_RX);
  1708. (void) inb(info->base + UART_IIR);
  1709. (void) inb(info->base + UART_MSR);
  1711. /*
  1712.  * Now, initialize the UART
  1713.  */
  1714. outb(UART_LCR_WLEN8, info->base + UART_LCR); /* reset DLAB */
  1715. info->MCR = UART_MCR_DTR | UART_MCR_RTS;
  1716. outb(info->MCR, info->base + UART_MCR);
  1718. /*
  1719.  * Finally, enable interrupts
  1720.  */
  1721. info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
  1722. outb(info->IER, info->base + UART_IER); /* enable interrupts */
  1724. /*
  1725.  * And clear the interrupt registers again for luck.
  1726.  */
  1727. (void) inb(info->base + UART_LSR);
  1728. (void) inb(info->base + UART_RX);
  1729. (void) inb(info->base + UART_IIR);
  1730. (void) inb(info->base + UART_MSR);
  1732. if (info->tty)
  1733. test_and_clear_bit(TTY_IO_ERROR, &info->tty->flags);
  1735. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  1737. /*
  1738.  * and set the speed of the serial port
  1739.  */
  1740. mxser_change_speed(info, 0);
  1742. info->flags |= ASYNC_INITIALIZED;
  1743. restore_flags(flags);
  1744. return (0);
  1745. }
  1747. /*
  1748.  * This routine will shutdown a serial port; interrupts maybe disabled, and
  1749.  * DTR is dropped if the hangup on close termio flag is on.
  1750.  */
  1751. static void mxser_shutdown(struct mxser_struct *info)
  1752. {
  1753. unsigned long flags;
  1755. if (!(info->flags & ASYNC_INITIALIZED))
  1756. return;
  1758. save_flags(flags);
  1759. cli(); /* Disable interrupts */
  1761. /*
  1762.  * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
  1763.  * here so the queue might never be waken up
  1764.  */
  1765. wake_up_interruptible(&info->delta_msr_wait);
  1767. /*
  1768.  * Free the IRQ, if necessary
  1769.  */
  1770. if (info->xmit_buf) {
  1771. free_page((unsigned long) info->xmit_buf);
  1772. info->xmit_buf = 0;
  1773. }
  1774. info->IER = 0;
  1775. outb(0x00, info->base + UART_IER); /* disable all intrs */
  1777. if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
  1778. info->MCR &= ~(UART_MCR_DTR | UART_MCR_RTS);
  1779. outb(info->MCR, info->base + UART_MCR);
  1781. /* clear Rx/Tx FIFO's */
  1782. outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT), info->base + UART_FCR);
  1783. /* read data port to reset things */
  1784. (void) inb(info->base + UART_RX);
  1786. if (info->tty)
  1787. set_bit(TTY_IO_ERROR, &info->tty->flags);
  1789. info->flags &= ~ASYNC_INITIALIZED;
  1790. restore_flags(flags);
  1791. }
  1793. /*
  1794.  * This routine is called to set the UART divisor registers to match
  1795.  * the specified baud rate for a serial port.
  1796.  */
  1797. static int mxser_change_speed(struct mxser_struct *info,
  1798.       struct termios *old_termios)
  1799. {
  1800. int quot = 0;
  1801. unsigned cflag, cval, fcr;
  1802. int i;
  1803. int ret = 0;
  1804. unsigned long flags;
  1806. if (!info->tty || !info->tty->termios)
  1807. return ret;
  1808. cflag = info->tty->termios->c_cflag;
  1809. if (!(info->base))
  1810. return ret;
  1812. #ifndef B921600
  1813. #define B921600 (B460800 +1)
  1814. #endif
  1815. switch (cflag & (CBAUD | CBAUDEX)) {
  1816. case B921600:
  1817. i = 20;
  1818. break;
  1819. case B460800:
  1820. i = 19;
  1821. break;
  1822. case B230400:
  1823. i = 18;
  1824. break;
  1825. case B115200:
  1826. i = 17;
  1827. break;
  1828. case B57600:
  1829. i = 16;
  1830. break;
  1831. case B38400:
  1832. i = 15;
  1833. break;
  1834. case B19200:
  1835. i = 14;
  1836. break;
  1837. case B9600:
  1838. i = 13;
  1839. break;
  1840. case B4800:
  1841. i = 12;
  1842. break;
  1843. case B2400:
  1844. i = 11;
  1845. break;
  1846. case B1800:
  1847. i = 10;
  1848. break;
  1849. case B1200:
  1850. i = 9;
  1851. break;
  1852. case B600:
  1853. i = 8;
  1854. break;
  1855. case B300:
  1856. i = 7;
  1857. break;
  1858. case B200:
  1859. i = 6;
  1860. break;
  1861. case B150:
  1862. i = 5;
  1863. break;
  1864. case B134:
  1865. i = 4;
  1866. break;
  1867. case B110:
  1868. i = 3;
  1869. break;
  1870. case B75:
  1871. i = 2;
  1872. break;
  1873. case B50:
  1874. i = 1;
  1875. break;
  1876. default:
  1877. i = 0;
  1878. break;
  1879. }
  1881. if (i == 15) {
  1882. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  1883. i = 16; /* 57600 bps */
  1884. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  1885. i = 17; /* 115200 bps */
  1887. #ifdef ASYNC_SPD_SHI
  1888. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
  1889. i = 18;
  1890. #endif
  1892. #ifdef ASYNC_SPD_WARP
  1893. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
  1894. i = 19;
  1895. #endif
  1896. }
  1897. if (mxvar_baud_table[i] == 134) {
  1898. quot = (2 * info->baud_base / 269);
  1899. } else if (mxvar_baud_table[i]) {
  1900. quot = info->baud_base / mxvar_baud_table[i];
  1901. if (!quot && old_termios) {
  1902. /* re-calculate */
  1903. info->tty->termios->c_cflag &= ~CBAUD;
  1904. info->tty->termios->c_cflag |= (old_termios->c_cflag & CBAUD);
  1905. switch (info->tty->termios->c_cflag & (CBAUD | CBAUDEX)) {
  1906. case B921600:
  1907. i = 20;
  1908. break;
  1909. case B460800:
  1910. i = 19;
  1911. break;
  1912. case B230400:
  1913. i = 18;
  1914. break;
  1915. case B115200:
  1916. i = 17;
  1917. break;
  1918. case B57600:
  1919. i = 16;
  1920. break;
  1921. case B38400:
  1922. i = 15;
  1923. break;
  1924. case B19200:
  1925. i = 14;
  1926. break;
  1927. case B9600:
  1928. i = 13;
  1929. break;
  1930. case B4800:
  1931. i = 12;
  1932. break;
  1933. case B2400:
  1934. i = 11;
  1935. break;
  1936. case B1800:
  1937. i = 10;
  1938. break;
  1939. case B1200:
  1940. i = 9;
  1941. break;
  1942. case B600:
  1943. i = 8;
  1944. break;
  1945. case B300:
  1946. i = 7;
  1947. break;
  1948. case B200:
  1949. i = 6;
  1950. break;
  1951. case B150:
  1952. i = 5;
  1953. break;
  1954. case B134:
  1955. i = 4;
  1956. break;
  1957. case B110:
  1958. i = 3;
  1959. break;
  1960. case B75:
  1961. i = 2;
  1962. break;
  1963. case B50:
  1964. i = 1;
  1965. break;
  1966. default:
  1967. i = 0;
  1968. break;
  1969. }
  1970. if (i == 15) {
  1971. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  1972. i = 16; /* 57600 bps */
  1973. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  1974. i = 17; /* 115200 bps */
  1975. #ifdef ASYNC_SPD_SHI
  1976. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
  1977. i = 18;
  1978. #endif
  1979. #ifdef ASYNC_SPD_WARP
  1980. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
  1981. i = 19;
  1982. #endif
  1983. }
  1984. if (mxvar_baud_table[i] == 134) {
  1985. quot = (2 * info->baud_base / 269);
  1986. } else if (mxvar_baud_table[i]) {
  1987. quot = info->baud_base / mxvar_baud_table[i];
  1988. if (quot == 0)
  1989. quot = 1;
  1990. } else {
  1991. quot = 0;
  1992. }
  1993. } else if (quot == 0)
  1994. quot = 1;
  1995. } else {
  1996. quot = 0;
  1997. }
  1999. if (quot) {
  2000. info->MCR |= UART_MCR_DTR;
  2001. save_flags(flags);
  2002. cli();
  2003. outb(info->MCR, info->base + UART_MCR);
  2004. restore_flags(flags);
  2005. } else {
  2006. info->MCR &= ~UART_MCR_DTR;
  2007. save_flags(flags);
  2008. cli();
  2009. outb(info->MCR, info->base + UART_MCR);
  2010. restore_flags(flags);
  2011. return ret;
  2012. }
  2013. /* byte size and parity */
  2014. switch (cflag & CSIZE) {
  2015. case CS5:
  2016. cval = 0x00;
  2017. break;
  2018. case CS6:
  2019. cval = 0x01;
  2020. break;
  2021. case CS7:
  2022. cval = 0x02;
  2023. break;
  2024. case CS8:
  2025. cval = 0x03;
  2026. break;
  2027. default:
  2028. cval = 0x00;
  2029. break; /* too keep GCC shut... */
  2030. }
  2031. if (cflag & CSTOPB)
  2032. cval |= 0x04;
  2033. if (cflag & PARENB)
  2034. cval |= UART_LCR_PARITY;
  2035. if (!(cflag & PARODD))
  2036. cval |= UART_LCR_EPAR;
  2037. if ((info->type == PORT_8250) || (info->type == PORT_16450)) {
  2038. fcr = 0;
  2039. } else {
  2040. fcr = UART_FCR_ENABLE_FIFO;
  2041. switch (info->rx_trigger) {
  2042. case 1:
  2043. fcr |= UART_FCR_TRIGGER_1;
  2044. break;
  2045. case 4:
  2046. fcr |= UART_FCR_TRIGGER_4;
  2047. break;
  2048. case 8:
  2049. fcr |= UART_FCR_TRIGGER_8;
  2050. break;
  2051. default:
  2052. fcr |= UART_FCR_TRIGGER_14;
  2053. }
  2054. }
  2056. /* CTS flow control flag and modem status interrupts */
  2057. info->IER &= ~UART_IER_MSI;
  2058. info->MCR &= ~UART_MCR_AFE;
  2059. if (cflag & CRTSCTS) {
  2060. info->flags |= ASYNC_CTS_FLOW;
  2061. info->IER |= UART_IER_MSI;
  2062. if (info->type == PORT_16550A)
  2063. info->MCR |= UART_MCR_AFE;
  2064. } else {
  2065. info->flags &= ~ASYNC_CTS_FLOW;
  2066. }
  2067. outb(info->MCR, info->base + UART_MCR);
  2068. if (cflag & CLOCAL)
  2069. info->flags &= ~ASYNC_CHECK_CD;
  2070. else {
  2071. info->flags |= ASYNC_CHECK_CD;
  2072. info->IER |= UART_IER_MSI;
  2073. }
  2074. outb(info->IER, info->base + UART_IER);
  2076. /*
  2077.  * Set up parity check flag
  2078.  */
  2079. info->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
  2080. if (I_INPCK(info->tty))
  2081. info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
  2082. if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
  2083. info->read_status_mask |= UART_LSR_BI;
  2085. info->ignore_status_mask = 0;
  2086. #if 0
  2087. /* This should be safe, but for some broken bits of hardware... */
  2088. if (I_IGNPAR(info->tty)) {
  2089. info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
  2090. info->read_status_mask |= UART_LSR_PE | UART_LSR_FE;
  2091. }
  2092. #endif
  2093. if (I_IGNBRK(info->tty)) {
  2094. info->ignore_status_mask |= UART_LSR_BI;
  2095. info->read_status_mask |= UART_LSR_BI;
  2096. /*
  2097.  * If we're ignore parity and break indicators, ignore
  2098.  * overruns too.  (For real raw support).
  2099.  */
  2100. if (I_IGNPAR(info->tty)) {
  2101. info->ignore_status_mask |= UART_LSR_OE | UART_LSR_PE | UART_LSR_FE;
  2102. info->read_status_mask |= UART_LSR_OE | UART_LSR_PE | UART_LSR_FE;
  2103. }
  2104. }
  2105. save_flags(flags);
  2106. cli();
  2107. outb(cval | UART_LCR_DLAB, info->base + UART_LCR); /* set DLAB */
  2108. outb(quot & 0xff, info->base + UART_DLL); /* LS of divisor */
  2109. outb(quot >> 8, info->base + UART_DLM); /* MS of divisor */
  2110. outb(cval, info->base + UART_LCR); /* reset DLAB */
  2111. outb(fcr, info->base + UART_FCR); /* set fcr */
  2112. restore_flags(flags);
  2114. return ret;
  2115. }
  2117. /*
  2118.  * ------------------------------------------------------------
  2119.  * friends of mxser_ioctl()
  2120.  * ------------------------------------------------------------
  2121.  */
  2122. static int mxser_get_serial_info(struct mxser_struct *info,
  2123.  struct serial_struct *retinfo)
  2124. {
  2125. struct serial_struct tmp;
  2127. if (!retinfo)
  2128. return (-EFAULT);
  2129. memset(&tmp, 0, sizeof(tmp));
  2130. tmp.type = info->type;
  2131. tmp.line = info->port;
  2132. tmp.port = info->base;
  2133. tmp.irq = info->irq;
  2134. tmp.flags = info->flags;
  2135. tmp.baud_base = info->baud_base;
  2136. tmp.close_delay = info->close_delay;
  2137. tmp.closing_wait = info->closing_wait;
  2138. tmp.custom_divisor = info->custom_divisor;
  2139. tmp.hub6 = 0;
  2140. copy_to_user(retinfo, &tmp, sizeof(*retinfo));
  2141. return (0);
  2142. }
  2144. static int mxser_set_serial_info(struct mxser_struct *info,
  2145.  struct serial_struct *new_info)
  2146. {
  2147. struct serial_struct new_serial;
  2148. unsigned int flags;
  2149. int retval = 0;
  2151. if (!new_info || !info->base)
  2152. return (-EFAULT);
  2153. copy_from_user(&new_serial, new_info, sizeof(new_serial));
  2155. if ((new_serial.irq != info->irq) ||
  2156.     (new_serial.port != info->base) ||
  2157.     (new_serial.type != info->type) ||
  2158.     (new_serial.custom_divisor != info->custom_divisor) ||
  2159.     (new_serial.baud_base != info->baud_base))
  2160. return (-EPERM);
  2162. flags = info->flags & ASYNC_SPD_MASK;
  2164. if (!suser()) {
  2165. if ((new_serial.baud_base != info->baud_base) ||
  2166.     (new_serial.close_delay != info->close_delay) ||
  2167.     ((new_serial.flags & ~ASYNC_USR_MASK) !=
  2168.      (info->flags & ~ASYNC_USR_MASK)))
  2169. return (-EPERM);
  2170. info->flags = ((info->flags & ~ASYNC_USR_MASK) |
  2171.        (new_serial.flags & ASYNC_USR_MASK));
  2172. } else {
  2173. /*
  2174.  * OK, past this point, all the error checking has been done.
  2175.  * At this point, we start making changes.....
  2176.  */
  2177. info->flags = ((info->flags & ~ASYNC_FLAGS) |
  2178.        (new_serial.flags & ASYNC_FLAGS));
  2179. info->close_delay = new_serial.close_delay * HZ / 100;
  2180. info->closing_wait = new_serial.closing_wait * HZ / 100;
  2181. }
  2183. if (info->flags & ASYNC_INITIALIZED) {
  2184. if (flags != (info->flags & ASYNC_SPD_MASK)) {
  2185. mxser_change_speed(info, 0);
  2186. }
  2187. } else
  2188. retval = mxser_startup(info);
  2189. return (retval);
  2190. }
  2192. /*
  2193.  * mxser_get_lsr_info - get line status register info
  2194.  *
  2195.  * Purpose: Let user call ioctl() to get info when the UART physically
  2196.  *          is emptied.  On bus types like RS485, the transmitter must
  2197.  *          release the bus after transmitting. This must be done when
  2198.  *          the transmit shift register is empty, not be done when the
  2199.  *          transmit holding register is empty.  This functionality
  2200.  *          allows an RS485 driver to be written in user space.
  2201.  */
  2202. static int mxser_get_lsr_info(struct mxser_struct *info, unsigned int *value)
  2203. {
  2204. unsigned char status;
  2205. unsigned int result;
  2206. unsigned long flags;
  2208. save_flags(flags);
  2209. cli();
  2210. status = inb(info->base + UART_LSR);
  2211. restore_flags(flags);
  2212. result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
  2213. return put_user(result, value);
  2214. }
  2216. /*
  2217.  * This routine sends a break character out the serial port.
  2218.  */
  2219. static void mxser_send_break(struct mxser_struct *info, int duration)
  2220. {
  2221. unsigned long flags;
  2222. if (!info->base)
  2223. return;
  2224. set_current_state(TASK_INTERRUPTIBLE);
  2225. save_flags(flags);
  2226. cli();
  2227. outb(inb(info->base + UART_LCR) | UART_LCR_SBC, info->base + UART_LCR);
  2228. schedule_timeout(duration);
  2229. outb(inb(info->base + UART_LCR) & ~UART_LCR_SBC, info->base + UART_LCR);
  2230. restore_flags(flags);
  2231. }
  2233. static int mxser_get_modem_info(struct mxser_struct *info,
  2234. unsigned int *value)
  2235. {
  2236. unsigned char control, status;
  2237. unsigned int result;
  2238. unsigned long flags;
  2240. control = info->MCR;
  2241. save_flags(flags);
  2242. cli();
  2243. status = inb(info->base + UART_MSR);
  2244. if (status & UART_MSR_ANY_DELTA)
  2245. mxser_check_modem_status(info, status);
  2246. restore_flags(flags);
  2247. result = ((control & UART_MCR_RTS) ? TIOCM_RTS : 0) |
  2248.     ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) |
  2249.     ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) |
  2250.     ((status & UART_MSR_RI) ? TIOCM_RNG : 0) |
  2251.     ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) |
  2252.     ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
  2253. return put_user(result, value);
  2254. }
  2256. static int mxser_set_modem_info(struct mxser_struct *info, unsigned int cmd,
  2257. unsigned int *value)
  2258. {
  2259. unsigned int arg;
  2260. unsigned long flags;
  2262. if(get_user(arg, value))
  2263. return -EFAULT;
  2264. switch (cmd) {
  2265. case TIOCMBIS:
  2266. if (arg & TIOCM_RTS)
  2267. info->MCR |= UART_MCR_RTS;
  2268. if (arg & TIOCM_DTR)
  2269. info->MCR |= UART_MCR_DTR;
  2270. break;
  2271. case TIOCMBIC:
  2272. if (arg & TIOCM_RTS)
  2273. info->MCR &= ~UART_MCR_RTS;
  2274. if (arg & TIOCM_DTR)
  2275. info->MCR &= ~UART_MCR_DTR;
  2276. break;
  2277. case TIOCMSET:
  2278. info->MCR = ((info->MCR & ~(UART_MCR_RTS | UART_MCR_DTR)) |
  2279.      ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0) |
  2280.      ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  2281. break;
  2282. default:
  2283. return (-EINVAL);
  2284. }
  2285. save_flags(flags);
  2286. cli();
  2287. outb(info->MCR, info->base + UART_MCR);
  2288. restore_flags(flags);
  2289. return (0);
  2290. }
  2292. static int mxser_read_register(int, unsigned short *);
  2293. static int mxser_program_mode(int);
  2294. static void mxser_normal_mode(int);
  2296. static int mxser_get_ISA_conf(int cap, struct mxser_hwconf *hwconf)
  2297. {
  2298. int id, i, bits;
  2299. unsigned short regs[16], irq;
  2300. unsigned char scratch, scratch2;
  2302. id = mxser_read_register(cap, regs);
  2303. if (id == C168_ASIC_ID)
  2304. hwconf->board_type = MXSER_BOARD_C168_ISA;
  2305. else if (id == C104_ASIC_ID)
  2306. hwconf->board_type = MXSER_BOARD_C104_ISA;
  2307. else if (id == CI104J_ASIC_ID)
  2308. hwconf->board_type = MXSER_BOARD_CI104J;
  2309. else
  2310. return (0);
  2311. irq = regs[9] & 0x0F;
  2312. irq = irq | (irq << 4);
  2313. irq = irq | (irq << 8);
  2314. if ((irq != regs[9]) || ((id == 1) && (irq != regs[10]))) {
  2315. return (MXSER_ERR_IRQ_CONFLIT);
  2316. }
  2317. if (!irq) {
  2318. return (MXSER_ERR_IRQ);
  2319. }
  2320. for (i = 0; i < 8; i++)
  2321. hwconf->ioaddr[i] = (int) regs[i + 1] & 0xFFF8;
  2322. hwconf->irq = (int) (irq & 0x0F);
  2323. if ((regs[12] & 0x80) == 0) {
  2324. return (MXSER_ERR_VECTOR);
  2325. }
  2326. hwconf->vector = (int) regs[11]; /* interrupt vector */
  2327. if (id == 1)
  2328. hwconf->vector_mask = 0x00FF;
  2329. else
  2330. hwconf->vector_mask = 0x000F;
  2331. for (i = 7, bits = 0x0100; i >= 0; i--, bits <<= 1) {
  2332. if (regs[12] & bits)
  2333. hwconf->baud_base[i] = 921600;
  2334. else
  2335. hwconf->baud_base[i] = 115200;
  2336. }
  2337. scratch2 = inb(cap + UART_LCR) & (~UART_LCR_DLAB);
  2338. outb(scratch2 | UART_LCR_DLAB, cap + UART_LCR);
  2339. outb(0, cap + UART_EFR); /* EFR is the same as FCR */
  2340. outb(scratch2, cap + UART_LCR);
  2341. outb(UART_FCR_ENABLE_FIFO, cap + UART_FCR);
  2342. scratch = inb(cap + UART_IIR);
  2343. if (scratch & 0xC0)
  2344. hwconf->uart_type = PORT_16550A;
  2345. else
  2346. hwconf->uart_type = PORT_16450;
  2347. if (id == 1)
  2348. hwconf->ports = 8;
  2349. else
  2350. hwconf->ports = 4;
  2351. return (hwconf->ports);
  2352. }
  2354. #define CHIP_SK  0x01 /* Serial Data Clock  in Eprom */
  2355. #define CHIP_DO  0x02 /* Serial Data Output in Eprom */
  2356. #define CHIP_CS  0x04 /* Serial Chip Select in Eprom */
  2357. #define CHIP_DI  0x08 /* Serial Data Input  in Eprom */
  2358. #define EN_CCMD  0x000 /* Chip's command register     */
  2359. #define EN0_RSARLO 0x008 /* Remote start address reg 0  */
  2360. #define EN0_RSARHI 0x009 /* Remote start address reg 1  */
  2361. #define EN0_RCNTLO 0x00A /* Remote byte count reg WR    */
  2362. #define EN0_RCNTHI 0x00B /* Remote byte count reg WR    */
  2363. #define EN0_DCFG 0x00E /* Data configuration reg WR   */
  2364. #define EN0_PORT 0x010 /* Rcv missed frame error counter RD */
  2365. #define ENC_PAGE0 0x000 /* Select page 0 of chip registers   */
  2366. #define ENC_PAGE3 0x0C0 /* Select page 3 of chip registers   */
  2367. static int mxser_read_register(int port, unsigned short *regs)
  2368. {
  2369. int i, k, value, id;
  2370. unsigned int j;
  2372. id = mxser_program_mode(port);
  2373. if (id < 0)
  2374. return (id);
  2375. for (i = 0; i < 14; i++) {
  2376. k = (i & 0x3F) | 0x180;
  2377. for (j = 0x100; j > 0; j >>= 1) {
  2378. outb(CHIP_CS, port);
  2379. if (k & j) {
  2380. outb(CHIP_CS | CHIP_DO, port);
  2381. outb(CHIP_CS | CHIP_DO | CHIP_SK, port); /* A? bit of read */
  2382. } else {
  2383. outb(CHIP_CS, port);
  2384. outb(CHIP_CS | CHIP_SK, port); /* A? bit of read */
  2385. }
  2386. }
  2387. (void) inb(port);
  2388. value = 0;
  2389. for (k = 0, j = 0x8000; k < 16; k++, j >>= 1) {
  2390. outb(CHIP_CS, port);
  2391. outb(CHIP_CS | CHIP_SK, port);
  2392. if (inb(port) & CHIP_DI)
  2393. value |= j;
  2394. }
  2395. regs[i] = value;
  2396. outb(0, port);
  2397. }
  2398. mxser_normal_mode(port);
  2399. return (id);
  2400. }
  2402. static int mxser_program_mode(int port)
  2403. {
  2404. int id, i, j, n;
  2405. unsigned long flags;
  2407. save_flags(flags);
  2408. cli();
  2409. outb(0, port);
  2410. outb(0, port);
  2411. outb(0, port);
  2412. (void) inb(port);
  2413. (void) inb(port);
  2414. outb(0, port);
  2415. (void) inb(port);
  2416. restore_flags(flags);
  2417. id = inb(port + 1) & 0x1F;
  2418. if ((id != C168_ASIC_ID) && (id != C104_ASIC_ID) && (id != CI104J_ASIC_ID))
  2419. return (-1);
  2420. for (i = 0, j = 0; i < 4; i++) {
  2421. n = inb(port + 2);
  2422. if (n == 'M') {
  2423. j = 1;
  2424. } else if ((j == 1) && (n == 1)) {
  2425. j = 2;
  2426. break;
  2427. } else
  2428. j = 0;
  2429. }
  2430. if (j != 2)
  2431. id = -2;
  2432. return (id);
  2433. }
  2435. static void mxser_normal_mode(int port)
  2436. {
  2437. int i, n;
  2439. outb(0xA5, port + 1);
  2440. outb(0x80, port + 3);
  2441. outb(12, port + 0); /* 9600 bps */
  2442. outb(0, port + 1);
  2443. outb(0x03, port + 3); /* 8 data bits */
  2444. outb(0x13, port + 4); /* loop back mode */
  2445. for (i = 0; i < 16; i++) {
  2446. n = inb(port + 5);
  2447. if ((n & 0x61) == 0x60)
  2448. break;
  2449. if ((n & 1) == 1)
  2450. (void) inb(port);
  2451. }
  2452. outb(0x00, port + 4);
  2453. }