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

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

嵌入式Linux

开发平台：

Unix_Linux

serial_8250.c：源码内容
  1. /*
  2.  *  linux/drivers/char/serial_8250.c
  3.  *
  4.  *  Driver for 8250/16550-type serial ports
  5.  *
  6.  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
  7.  *
  8.  *  Copyright (C) 2001 Russell King.
  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.  *  $Id: serial_8250.c,v 1.14.2.6 2002/02/04 17:51:22 rmk Exp $
  16.  *
  17.  * A note about mapbase / membase
  18.  *
  19.  *  mapbase is the physical address of the IO port.  Currently, we don't
  20.  *  support this very well, and it may well be dropped from this driver
  21.  *  in future.  As such, mapbase should be NULL.
  22.  *
  23.  *  membase is an 'ioremapped' cookie.  This is compatible with the old
  24.  *  serial.c driver, and is currently the preferred form.
  25.  */
  26. #include <linux/config.h>
  27. #include <linux/module.h>
  28. #include <linux/errno.h>
  29. #include <linux/sched.h>
  30. #include <linux/tty.h>
  31. #include <linux/tty_flip.h>
  32. #include <linux/major.h>
  33. #include <linux/ptrace.h>
  34. #include <linux/ioport.h>
  35. #include <linux/init.h>
  36. #include <linux/serial.h>
  37. #include <linux/console.h>
  38. #include <linux/sysrq.h>
  39. #include <linux/serial_reg.h>
  40. #include <linux/serialP.h>
  41. #include <linux/delay.h>
  42. #include <linux/serial_core.h>
  43. #include <linux/kmod.h>
  45. #include <asm/system.h>
  46. #include <asm/io.h>
  47. #include <asm/irq.h>
  48. #include <asm/uaccess.h>
  49. #include <asm/bitops.h>
  51. #include "serial_8250.h"
  53. /*
  54.  * This converts from our new CONFIG_ symbols to the symbols
  55.  * that asm/serial.h expects.  You _NEED_ to comment out the
  56.  * linux/config.h include contained inside asm/serial.h for
  57.  * this to work.
  58.  */
  59. #undef CONFIG_SERIAL_MANY_PORTS
  60. #undef CONFIG_SERIAL_DETECT_IRQ
  61. #undef CONFIG_SERIAL_MULTIPORT
  62. #undef CONFIG_HUB6
  64. #ifdef CONFIG_SERIAL_8250_MANY_PORTS
  65. #define CONFIG_SERIAL_MANY_PORTS 1
  66. #endif
  67. #ifdef CONFIG_SERIAL_8250_DETECT_IRQ
  68. #define CONFIG_SERIAL_DETECT_IRQ 1
  69. #endif
  70. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  71. #define CONFIG_SERIAL_MULTIPORT 1
  72. #endif
  73. #ifdef CONFIG_SERIAL_8250_HUB6
  74. #define CONFIG_HUB6 1
  75. #endif
  77. #include <asm/serial.h>
  79. static struct old_serial_port old_serial_port[] = {
  80. SERIAL_PORT_DFNS /* defined in asm/serial.h */
  81. };
  83. #define UART_NR ARRAY_SIZE(old_serial_port)
  85. static struct tty_driver normal, callout;
  86. static struct tty_struct *serial8250_table[UART_NR];
  87. static struct termios *serial8250_termios[UART_NR], *serial8250_termios_locked[UART_NR];
  88. #ifdef CONFIG_SERIAL_8250_CONSOLE
  89. static struct console serial8250_console;
  90. static unsigned int lsr_break_flag;
  91. #endif
  92. static struct uart_info *IRQ_ports[NR_IRQS];
  94. #if defined(CONFIG_SERIAL_RSA) && defined(MODULE)
  96. #define PORT_RSA_MAX 4
  97. static int probe_rsa[PORT_RSA_MAX];
  98. static int force_rsa[PORT_RSA_MAX];
  100. MODULE_PARM(probe_rsa, "1-" __MODULE_STRING(PORT_RSA_MAX) "i");
  101. MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
  102. MODULE_PARM(force_rsa, "1-" __MODULE_STRING(PORT_RSA_MAX) "i");
  103. MODULE_PARM_DESC(force_rsa, "Force I/O ports for RSA");
  104. #endif /* CONFIG_SERIAL_RSA  */
  106. #define port_acr unused[0] /* 8bit */
  107. #define port_ier unused[1] /* 8bit */
  108. #define port_rev unused[2] /* 8bit */
  109. #define port_lcr unused[3] /* 8bit */
  111. /*
  112.  * Here we define the default xmit fifo size used for each type of UART.
  113.  */
  114. static const struct serial_uart_config uart_config[PORT_MAX_8250+1] = {
  115. { "unknown", 1, 0 },
  116. { "8250", 1, 0 },
  117. { "16450", 1, 0 },
  118. { "16550", 1, 0 },
  119. { "16550A", 16, UART_CLEAR_FIFO | UART_USE_FIFO },
  120. { "Cirrus", 1,  0 },
  121. { "ST16650", 1, UART_CLEAR_FIFO | UART_STARTECH },
  122. { "ST16650V2", 32, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
  123. { "TI16750", 64, UART_CLEAR_FIFO | UART_USE_FIFO },
  124. { "Startech", 1, 0 },
  125. { "16C950/954", 128, UART_CLEAR_FIFO | UART_USE_FIFO },
  126. { "ST16654", 64, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
  127. { "XR16850", 128, UART_CLEAR_FIFO | UART_USE_FIFO | UART_STARTECH },
  128. { "RSA", 2048, UART_CLEAR_FIFO | UART_USE_FIFO }
  129. };
  131. static _INLINE_ unsigned int serial_in(struct uart_port *port, int offset)
  132. {
  133. offset <<= port->regshift;
  135. switch (port->iotype) {
  136. #ifdef CONFIG_SERIAL_8250_HUB6
  137. case SERIAL_IO_HUB6:
  138. outb(port->hub6 - 1 + offset, port->iobase);
  139. return inb(port->iobase + 1);
  140. #endif
  142. case SERIAL_IO_MEM:
  143. return readb((unsigned long)port->membase + offset);
  145. default:
  146. return inb(port->iobase + offset);
  147. }
  148. }
  150. static _INLINE_ void
  151. serial_out(struct uart_port *port, int offset, int value)
  152. {
  153. offset <<= port->regshift;
  155. switch (port->iotype) {
  156. #ifdef CONFIG_SERIAL_8250_HUB6
  157. case SERIAL_IO_HUB6:
  158. outb(port->hub6 - 1 + offset, port->iobase);
  159. outb(value, port->iobase + 1);
  160. break;
  161. #endif
  163. case SERIAL_IO_MEM:
  164. writeb(value, (unsigned long)port->membase + offset);
  165. break;
  167. default:
  168. outb(value, port->iobase + offset);
  169. }
  170. }
  172. /*
  173.  * We used to support using pause I/O for certain machines.  We
  174.  * haven't supported this for a while, but just in case it's badly
  175.  * needed for certain old 386 machines, I've left these #define's
  176.  * in....
  177.  */
  178. #define serial_inp(port, offset) serial_in(port, offset)
  179. #define serial_outp(port, offset, value) serial_out(port, offset, value)
  182. /*
  183.  * For the 16C950
  184.  */
  185. static void serial_icr_write(struct uart_port *port, int offset, int  value)
  186. {
  187. serial_out(port, UART_SCR, offset);
  188. serial_out(port, UART_ICR, value);
  189. }
  191. static unsigned int serial_icr_read(struct uart_port *port, int offset)
  192. {
  193. unsigned int value;
  195. serial_icr_write(port, UART_ACR, port->port_acr | UART_ACR_ICRRD);
  196. serial_out(port, UART_SCR, offset);
  197. value = serial_in(port, UART_ICR);
  198. serial_icr_write(port, UART_ACR, port->port_acr);
  200. return value;
  201. }
  203. #ifdef CONFIG_SERIAL_RSA
  204. /* Attempts to turn on the RSA FIFO.  Returns zero on failure */
  205. static int enable_rsa(struct uart_port *port)
  206. {
  207. unsigned char mode;
  208. int result;
  209. unsigned long flags;
  211. save_flags(flags); cli();
  212. mode = serial_inp(port, UART_RSA_MSR);
  213. result = mode & UART_RSA_MSR_FIFO;
  215. if (!result) {
  216. serial_outp(port, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
  217. mode = serial_inp(port, UART_RSA_MSR);
  218. result = mode & UART_RSA_MSR_FIFO;
  219. }
  221. restore_flags(flags);
  222. return result;
  223. }
  225. /* Attempts to turn off the RSA FIFO.  Returns zero on failure */
  226. static int disable_rsa(struct uart_port *port)
  227. {
  228. unsigned char mode;
  229. int result;
  230. unsigned long flags;
  232. save_flags(flags); cli();
  233. mode = serial_inp(port, UART_RSA_MSR);
  234. result = !(mode & UART_RSA_MSR_FIFO);
  236. if (!result) {
  237. serial_outp(port, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
  238. mode = serial_inp(port, UART_RSA_MSR);
  239. result = !(mode & UART_RSA_MSR_FIFO);
  240. }
  242. restore_flags(flags);
  243. return result;
  244. }
  245. #endif /* CONFIG_SERIAL_RSA */
  247. /*
  248.  * This is a quickie test to see how big the FIFO is.
  249.  * It doesn't work at all the time, more's the pity.
  250.  */
  251. static int size_fifo(struct uart_port *port)
  252. {
  253. unsigned char old_fcr, old_mcr, old_dll, old_dlm;
  254. int count;
  256. old_fcr = serial_inp(port, UART_FCR);
  257. old_mcr = serial_inp(port, UART_MCR);
  258. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO |
  259.     UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
  260. serial_outp(port, UART_MCR, UART_MCR_LOOP);
  261. serial_outp(port, UART_LCR, UART_LCR_DLAB);
  262. old_dll = serial_inp(port, UART_DLL);
  263. old_dlm = serial_inp(port, UART_DLM);
  264. serial_outp(port, UART_DLL, 0x01);
  265. serial_outp(port, UART_DLM, 0x00);
  266. serial_outp(port, UART_LCR, 0x03);
  267. for (count = 0; count < 256; count++)
  268. serial_outp(port, UART_TX, count);
  269. mdelay(20);
  270. for (count = 0; (serial_inp(port, UART_LSR) & UART_LSR_DR) &&
  271.      (count < 256); count++)
  272. serial_inp(port, UART_RX);
  273. serial_outp(port, UART_FCR, old_fcr);
  274. serial_outp(port, UART_MCR, old_mcr);
  275. serial_outp(port, UART_LCR, UART_LCR_DLAB);
  276. serial_outp(port, UART_DLL, old_dll);
  277. serial_outp(port, UART_DLM, old_dlm);
  279. return count;
  280. }
  282. /*
  283.  * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's.
  284.  * When this function is called we know it is at least a StarTech
  285.  * 16650 V2, but it might be one of several StarTech UARTs, or one of
  286.  * its clones.  (We treat the broken original StarTech 16650 V1 as a
  287.  * 16550, and why not?  Startech doesn't seem to even acknowledge its
  288.  * existence.)
  289.  * 
  290.  * What evil have men's minds wrought...
  291.  */
  292. static void
  293. autoconfig_startech_uarts(struct uart_port *port)
  294. {
  295. unsigned char scratch, scratch2, scratch3, scratch4;
  297. /*
  298.  * First we check to see if it's an Oxford Semiconductor UART.
  299.  *
  300.  * If we have to do this here because some non-National
  301.  * Semiconductor clone chips lock up if you try writing to the
  302.  * LSR register (which serial_icr_read does)
  303.  */
  304. if (port->type == PORT_16550A) {
  305. /*
  306.  * EFR [4] must be set else this test fails
  307.  *
  308.  * This shouldn't be necessary, but Mike Hudson
  309.  * (Exoray@isys.ca) claims that it's needed for 952
  310.  * dual UART's (which are not recommended for new designs).
  311.  */
  312. port->port_acr = 0;
  313. serial_out(port, UART_LCR, 0xBF);
  314. serial_out(port, UART_EFR, 0x10);
  315. serial_out(port, UART_LCR, 0x00);
  316. /* Check for Oxford Semiconductor 16C950 */
  317. scratch = serial_icr_read(port, UART_ID1);
  318. scratch2 = serial_icr_read(port, UART_ID2);
  319. scratch3 = serial_icr_read(port, UART_ID3);
  321. if (scratch == 0x16 && scratch2 == 0xC9 &&
  322.     (scratch3 == 0x50 || scratch3 == 0x52 ||
  323.      scratch3 == 0x54)) {
  324. port->type = PORT_16C950;
  325. port->port_rev = serial_icr_read(port, UART_REV) |
  326. (scratch3 << 8);
  327. return;
  328. }
  329. }
  331. /*
  332.  * We check for a XR16C850 by setting DLL and DLM to 0, and then
  333.  * reading back DLL and DLM.  The chip type depends on the DLM
  334.  * value read back:
  335.  *  0x10 - XR16C850 and the DLL contains the chip revision.
  336.  *  0x12 - XR16C2850.
  337.  *  0x14 - XR16C854.
  338.  */
  340. /* Save the DLL and DLM */
  342. serial_outp(port, UART_LCR, UART_LCR_DLAB);
  343. scratch3 = serial_inp(port, UART_DLL);
  344. scratch4 = serial_inp(port, UART_DLM);
  346. serial_outp(port, UART_DLL, 0);
  347. serial_outp(port, UART_DLM, 0);
  348. scratch2 = serial_inp(port, UART_DLL);
  349. scratch = serial_inp(port, UART_DLM);
  350. serial_outp(port, UART_LCR, 0);
  352. if (scratch == 0x10 || scratch == 0x12 || scratch == 0x14) {
  353. if (scratch == 0x10)
  354. port->port_rev = scratch2;
  355. port->type = PORT_16850;
  356. return;
  357. }
  359. /* Restore the DLL and DLM */
  361. serial_outp(port, UART_LCR, UART_LCR_DLAB);
  362. serial_outp(port, UART_DLL, scratch3);
  363. serial_outp(port, UART_DLM, scratch4);
  364. serial_outp(port, UART_LCR, 0);
  366. /*
  367.  * We distinguish between the '654 and the '650 by counting
  368.  * how many bytes are in the FIFO.  I'm using this for now,
  369.  * since that's the technique that was sent to me in the
  370.  * serial driver update, but I'm not convinced this works.
  371.  * I've had problems doing this in the past.  -TYT
  372.  */
  373. if (size_fifo(port) == 64)
  374. port->type = PORT_16654;
  375. else
  376. port->type = PORT_16650V2;
  377. }
  379. /*
  380.  * This routine is called by rs_init() to initialize a specific serial
  381.  * port.  It determines what type of UART chip this serial port is
  382.  * using: 8250, 16450, 16550, 16550A.  The important question is
  383.  * whether or not this UART is a 16550A or not, since this will
  384.  * determine whether or not we can use its FIFO features or not.
  385.  */
  386. static void autoconfig(struct uart_port *port, unsigned int probeflags)
  387. {
  388. unsigned char status1, status2, scratch, scratch2, scratch3;
  389. unsigned char save_lcr, save_mcr;
  390. unsigned long flags;
  392. #ifdef SERIAL_DEBUG_AUTOCONF
  393. printk("Testing ttyS%d (0x%04x, 0x%08lx)...n",
  394. port->line, port->iobase, port->membase);
  395. #endif
  397. if (!port->iobase && !port->membase)
  398. return;
  400. save_flags(flags); cli();
  402. if (!(port->flags & ASYNC_BUGGY_UART)) {
  403. /*
  404.  * Do a simple existence test first; if we fail this,
  405.  * there's no point trying anything else.
  406.  * 
  407.  * 0x80 is used as a nonsense port to prevent against
  408.  * false positives due to ISA bus float.  The
  409.  * assumption is that 0x80 is a non-existent port;
  410.  * which should be safe since include/asm/io.h also
  411.  * makes this assumption.
  412.  */
  413. scratch = serial_inp(port, UART_IER);
  414. serial_outp(port, UART_IER, 0);
  415. #ifdef __i386__
  416. outb(0xff, 0x080);
  417. #endif
  418. scratch2 = serial_inp(port, UART_IER);
  419. serial_outp(port, UART_IER, 0x0F);
  420. #ifdef __i386__
  421. outb(0, 0x080);
  422. #endif
  423. scratch3 = serial_inp(port, UART_IER);
  424. serial_outp(port, UART_IER, scratch);
  425. if (scratch2 || scratch3 != 0x0F) {
  426. #ifdef SERIAL_DEBUG_AUTOCONF
  427. printk("serial: ttyS%d: simple autoconfig failed "
  428.        "(%02x, %02x)n", port->line, 
  429.        scratch2, scratch3);
  430. #endif
  431. restore_flags(flags);
  432. return; /* We failed; there's nothing here */
  433. }
  434. }
  436. save_mcr = serial_in(port, UART_MCR);
  437. save_lcr = serial_in(port, UART_LCR);
  439. /* 
  440.  * Check to see if a UART is really there.  Certain broken
  441.  * internal modems based on the Rockwell chipset fail this
  442.  * test, because they apparently don't implement the loopback
  443.  * test mode.  So this test is skipped on the COM 1 through
  444.  * COM 4 ports.  This *should* be safe, since no board
  445.  * manufacturer would be stupid enough to design a board
  446.  * that conflicts with COM 1-4 --- we hope!
  447.  */
  448. if (!(port->flags & ASYNC_SKIP_TEST)) {
  449. serial_outp(port, UART_MCR, UART_MCR_LOOP | 0x0A);
  450. status1 = serial_inp(port, UART_MSR) & 0xF0;
  451. serial_outp(port, UART_MCR, save_mcr);
  452. if (status1 != 0x90) {
  453. #ifdef SERIAL_DEBUG_AUTOCONF
  454. printk("serial: ttyS%d: no UART loopback failedn",
  455.        port->line);
  456. #endif
  457. restore_flags(flags);
  458. return;
  459. }
  460. }
  461. serial_outp(port, UART_LCR, 0xBF); /* set up for StarTech test */
  462. serial_outp(port, UART_EFR, 0); /* EFR is the same as FCR */
  463. serial_outp(port, UART_LCR, 0);
  464. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO);
  465. scratch = serial_in(port, UART_IIR) >> 6;
  466. switch (scratch) {
  467. case 0:
  468. port->type = PORT_16450;
  469. break;
  470. case 1:
  471. port->type = PORT_UNKNOWN;
  472. break;
  473. case 2:
  474. port->type = PORT_16550;
  475. break;
  476. case 3:
  477. port->type = PORT_16550A;
  478. break;
  479. }
  480. if (port->type == PORT_16550A) {
  481. /* Check for Startech UART's */
  482. serial_outp(port, UART_LCR, UART_LCR_DLAB);
  483. if (serial_in(port, UART_EFR) == 0) {
  484. port->type = PORT_16650;
  485. } else {
  486. serial_outp(port, UART_LCR, 0xBF);
  487. if (serial_in(port, UART_EFR) == 0)
  488. autoconfig_startech_uarts(port);
  489. }
  490. }
  491. if (port->type == PORT_16550A) {
  492. /* Check for TI 16750 */
  493. serial_outp(port, UART_LCR, save_lcr | UART_LCR_DLAB);
  494. serial_outp(port, UART_FCR,
  495.     UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
  496. scratch = serial_in(port, UART_IIR) >> 5;
  497. if (scratch == 7) {
  498. /*
  499.  * If this is a 16750, and not a cheap UART
  500.  * clone, then it should only go into 64 byte
  501.  * mode if the UART_FCR7_64BYTE bit was set
  502.  * while UART_LCR_DLAB was latched.
  503.  */
  504.   serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO);
  505. serial_outp(port, UART_LCR, 0);
  506. serial_outp(port, UART_FCR,
  507.     UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
  508. scratch = serial_in(port, UART_IIR) >> 5;
  509. if (scratch == 6)
  510. port->type = PORT_16750;
  511. }
  512. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO);
  513. }
  514. #if defined(CONFIG_SERIAL_RSA) && defined(MODULE)
  515. /*
  516.  * Only probe for RSA ports if we got the region.
  517.  */
  518. if (port->type == PORT_16550A && probeflags & PROBE_RSA) {
  519. int i;
  521. for (i = 0 ; i < PORT_RSA_MAX ; ++i) {
  522. if (!probe_rsa[i] && !force_rsa[i])
  523. break;
  524. if (((probe_rsa[i] != port->iobase) ||
  525.      check_region(port->iobase + UART_RSA_BASE, 16)) &&
  526.     (force_rsa[i] != port->iobase))
  527. continue;
  528. if (!enable_rsa(port))
  529. continue;
  530. port->type = PORT_RSA;
  531. port->uartclk = SERIAL_RSA_BAUD_BASE * 16;
  532. break;
  533. }
  534. }
  535. #endif
  536. serial_outp(port, UART_LCR, save_lcr);
  537. if (port->type == PORT_16450) {
  538. scratch = serial_in(port, UART_SCR);
  539. serial_outp(port, UART_SCR, 0xa5);
  540. status1 = serial_in(port, UART_SCR);
  541. serial_outp(port, UART_SCR, 0x5a);
  542. status2 = serial_in(port, UART_SCR);
  543. serial_outp(port, UART_SCR, scratch);
  545. if ((status1 != 0xa5) || (status2 != 0x5a))
  546. port->type = PORT_8250;
  547. }
  548. port->fifosize = uart_config[port->type].dfl_xmit_fifo_size;
  550. if (port->type == PORT_UNKNOWN) {
  551. restore_flags(flags);
  552. return;
  553. }
  555. #ifdef CONFIG_SERIAL_RSA
  556. if (port->iobase && port->type == PORT_RSA) {
  557. release_region(port->iobase, 8);
  558. request_region(port->iobase + UART_RSA_BASE, 16,
  559.        "serial_rsa");
  560. }
  561. #endif
  563. /*
  564.  * Reset the UART.
  565.  */
  566. #ifdef CONFIG_SERIAL_RSA
  567. if (port->type == PORT_RSA)
  568. serial_outp(port, UART_RSA_FRR, 0);
  569. #endif
  570. serial_outp(port, UART_MCR, save_mcr);
  571. serial_outp(port, UART_FCR, (UART_FCR_ENABLE_FIFO |
  572.      UART_FCR_CLEAR_RCVR |
  573.      UART_FCR_CLEAR_XMIT));
  574. serial_outp(port, UART_FCR, 0);
  575. (void)serial_in(port, UART_RX);
  576. serial_outp(port, UART_IER, 0);
  578. restore_flags(flags);
  579. }
  581. static void autoconfig_irq(struct uart_port *port)
  582. {
  583. unsigned char save_mcr, save_ier;
  584. unsigned long irqs;
  585. int irq;
  587. #ifdef CONFIG_SERIAL_MANY_PORTS
  588. unsigned char save_ICP = 0;
  589. unsigned short ICP = 0;
  591. if (port->flags & ASYNC_FOURPORT) {
  592. ICP = (port->iobase & 0xfe0) | 0x1f;
  593. save_ICP = inb_p(ICP);
  594. outb_p(0x80, ICP);
  595. (void) inb_p(ICP);
  596. }
  597. #endif
  599. /* forget possible initially masked and pending IRQ */
  600. probe_irq_off(probe_irq_on());
  601. save_mcr = serial_inp(port, UART_MCR);
  602. save_ier = serial_inp(port, UART_IER);
  603. serial_outp(port, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2);
  605. irqs = probe_irq_on();
  606. serial_outp(port, UART_MCR, 0);
  607. udelay (10);
  608. if (port->flags & ASYNC_FOURPORT)  {
  609. serial_outp(port, UART_MCR,
  610.     UART_MCR_DTR | UART_MCR_RTS);
  611. } else {
  612. serial_outp(port, UART_MCR,
  613.     UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
  614. }
  615. serial_outp(port, UART_IER, 0x0f); /* enable all intrs */
  616. (void)serial_inp(port, UART_LSR);
  617. (void)serial_inp(port, UART_RX);
  618. (void)serial_inp(port, UART_IIR);
  619. (void)serial_inp(port, UART_MSR);
  620. serial_outp(port, UART_TX, 0xFF);
  621. udelay (20);
  622. irq = probe_irq_off(irqs);
  624. serial_outp(port, UART_MCR, save_mcr);
  625. serial_outp(port, UART_IER, save_ier);
  626. #ifdef CONFIG_SERIAL_MANY_PORTS
  627. if (port->flags & ASYNC_FOURPORT)
  628. outb_p(save_ICP, ICP);
  629. #endif
  630. port->irq = (irq > 0)? irq : 0;
  631. }
  633. static void serial8250_stop_tx(struct uart_port *port, u_int from_tty)
  634. {
  635. if (port->port_ier & UART_IER_THRI) {
  636. port->port_ier &= ~UART_IER_THRI;
  637. serial_out(port, UART_IER, port->port_ier);
  638. }
  639. if (port->type == PORT_16C950) {
  640. port->port_acr |= UART_ACR_TXDIS;
  641. serial_icr_write(port, UART_ACR, port->port_acr);
  642. }
  643. }
  645. static void serial8250_start_tx(struct uart_port *port, u_int nonempty, u_int from_tty)
  646. {
  647. if (nonempty && !(port->port_ier & UART_IER_THRI)) {
  648. port->port_ier |= UART_IER_THRI;
  649. serial_out(port, UART_IER, port->port_ier);
  650. }
  651. /*
  652.  * We only do this from uart_start
  653.  */
  654. if (from_tty && port->type == PORT_16C950) {
  655. port->port_acr &= ~UART_ACR_TXDIS;
  656. serial_icr_write(port, UART_ACR, port->port_acr);
  657. }
  658. }
  660. static void serial8250_stop_rx(struct uart_port *port)
  661. {
  662. port->port_ier &= ~UART_IER_RLSI;
  663. port->read_status_mask &= ~UART_LSR_DR;
  664. serial_out(port, UART_IER, port->port_ier);
  665. }
  667. static void serial8250_enable_ms(struct uart_port *port)
  668. {
  669. port->port_ier |= UART_IER_MSI;
  670. serial_out(port, UART_IER, port->port_ier);
  671. }
  673. static _INLINE_ void
  674. receive_chars(struct uart_info *info, int *status, struct pt_regs *regs)
  675. {
  676. struct tty_struct *tty = info->tty;
  677. struct uart_port *port = info->port;
  678. unsigned char ch;
  679. int max_count = 256;
  681. do {
  682. if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  683. tty->flip.tqueue.routine((void *)tty);
  684. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  685. return; // if TTY_DONT_FLIP is set
  686. }
  687. ch = serial_inp(port, UART_RX);
  688. *tty->flip.char_buf_ptr = ch;
  689. *tty->flip.flag_buf_ptr = TTY_NORMAL;
  690. port->icount.rx++;
  692. if (*status & (UART_LSR_BI | UART_LSR_PE |
  693.        UART_LSR_FE | UART_LSR_OE)) {
  694. /*
  695.  * For statistics only
  696.  */
  697. if (*status & UART_LSR_BI) {
  698. *status &= ~(UART_LSR_FE | UART_LSR_PE);
  699. port->icount.brk++;
  700. /*
  701.  * We do the SysRQ and SAK checking
  702.  * here because otherwise the break
  703.  * may get masked by ignore_status_mask
  704.  * or read_status_mask.
  705.  */
  706. uart_handle_break(info, &serial8250_console);
  707. } else if (*status & UART_LSR_PE)
  708. port->icount.parity++;
  709. else if (*status & UART_LSR_FE)
  710. port->icount.frame++;
  711. if (*status & UART_LSR_OE)
  712. port->icount.overrun++;
  714. /*
  715.  * Mask off conditions which should be ingored.
  716.  */
  717. *status &= port->read_status_mask;
  719. #ifdef CONFIG_SERIAL_8250_CONSOLE
  720. if (port->line == serial8250_console.index) {
  721. /* Recover the break flag from console xmit */
  722. *status |= lsr_break_flag;
  723. lsr_break_flag = 0;
  724. }
  725. #endif
  726. if (*status & UART_LSR_BI) {
  727. #ifdef SERIAL_DEBUG_INTR
  728. printk("handling break....");
  729. #endif
  730. *tty->flip.flag_buf_ptr = TTY_BREAK;
  731. } else if (*status & UART_LSR_PE)
  732. *tty->flip.flag_buf_ptr = TTY_PARITY;
  733. else if (*status & UART_LSR_FE)
  734. *tty->flip.flag_buf_ptr = TTY_FRAME;
  735. }
  736. if (uart_handle_sysrq_char(info, ch, regs))
  737. goto ignore_char;
  738. if ((*status & port->ignore_status_mask) == 0) {
  739. tty->flip.flag_buf_ptr++;
  740. tty->flip.char_buf_ptr++;
  741. tty->flip.count++;
  742. }
  743. if ((*status & UART_LSR_OE) &&
  744.     tty->flip.count < TTY_FLIPBUF_SIZE) {
  745. /*
  746.  * Overrun is special, since it's reported
  747.  * immediately, and doesn't affect the current
  748.  * character.
  749.  */
  750. *tty->flip.flag_buf_ptr = TTY_OVERRUN;
  751. tty->flip.flag_buf_ptr++;
  752. tty->flip.char_buf_ptr++;
  753. tty->flip.count++;
  754. }
  755. ignore_char:
  756. *status = serial_inp(port, UART_LSR);
  757. } while ((*status & UART_LSR_DR) && (max_count-- > 0));
  758. tty_flip_buffer_push(tty);
  759. }
  761. static _INLINE_ void transmit_chars(struct uart_info *info, int *intr_done)
  762. {
  763. struct uart_port *port = info->port;
  764. int count;
  766. if (port->x_char) {
  767. serial_outp(port, UART_TX, port->x_char);
  768. port->icount.tx++;
  769. port->x_char = 0;
  770. if (intr_done)
  771. *intr_done = 0;
  772. return;
  773. }
  774. if (info->xmit.head == info->xmit.tail
  775.     || info->tty->stopped
  776.     || info->tty->hw_stopped) {
  777. serial8250_stop_tx(port, 0);
  778. return;
  779. }
  781. count = port->fifosize;
  782. do {
  783. serial_out(port, UART_TX, info->xmit.buf[info->xmit.tail]);
  784. info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1);
  785. port->icount.tx++;
  786. if (info->xmit.head == info->xmit.tail)
  787. break;
  788. } while (--count > 0);
  790. if (CIRC_CNT(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE) <
  791. WAKEUP_CHARS)
  792. uart_event(info, EVT_WRITE_WAKEUP);
  794. #ifdef SERIAL_DEBUG_INTR
  795. printk("THRE...");
  796. #endif
  797. if (intr_done)
  798. *intr_done = 0;
  800. if (info->xmit.head == info->xmit.tail)
  801. serial8250_stop_tx(info->port, 0);
  802. }
  804. static _INLINE_ void check_modem_status(struct uart_info *info)
  805. {
  806. struct uart_port *port = info->port;
  807. int status;
  809. status = serial_in(port, UART_MSR);
  811. if (status & UART_MSR_ANY_DELTA) {
  812. if (status & UART_MSR_TERI)
  813. port->icount.rng++;
  814. if (status & UART_MSR_DDSR)
  815. port->icount.dsr++;
  816. if (status & UART_MSR_DDCD)
  817. uart_handle_dcd_change(info, status & UART_MSR_DCD);
  818. if (status & UART_MSR_DCTS)
  819. uart_handle_cts_change(info, status & UART_MSR_CTS);
  821. wake_up_interruptible(&info->delta_msr_wait);
  822. }
  823. }
  825. /*
  826.  * This handles the interrupt from one port.
  827.  */
  828. static inline void
  829. serial8250_handle_port(struct uart_info *info, struct pt_regs *regs)
  830. {
  831. int status = serial_inp(info->port, UART_LSR);
  832. #ifdef SERIAL_DEBUG_INTR
  833. printk("status = %x...", status);
  834. #endif
  835. if (status & UART_LSR_DR)
  836. receive_chars(info, &status, regs);
  837. check_modem_status(info);
  838. if (status & UART_LSR_THRE)
  839. transmit_chars(info, 0);
  840. }
  842. #ifdef CONFIG_SERIAL_8250_SHARE_IRQ
  843. /*
  844.  * This is the serial driver's generic interrupt routine
  845.  */
  846. static void rs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  847. {
  848. struct uart_info *info, *end_mark = NULL;
  849. int pass_counter = 0;
  850. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  851. int first_multi = 0;
  852. unsigned long port_monitor = rs_multiport[irq].port_monitor;
  853. #endif
  855. #ifdef SERIAL_DEBUG_INTR
  856. printk("rs_interrupt(%d)...", irq);
  857. #endif
  859. info = *(struct uart_info **)dev_id;
  860. if (!info)
  861. return;
  863. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  864. if (port_monitor)
  865. first_multi = inb(port_monitor);
  866. #endif
  868. do {
  869. if (!info->tty ||
  870.     (serial_in(info->port, UART_IIR) & UART_IIR_NO_INT)) {
  871.      if (!end_mark)
  872.      end_mark = info;
  873. goto next;
  874. }
  875. #ifdef SERIAL_DEBUG_INTR
  876. printk("IIR = %x...", serial_in(info->port, UART_IIR));
  877. #endif
  878. end_mark = NULL;
  880. serial8250_handle_port(info, regs);
  882. next:
  883. info = info->next_info;
  884. if (info)
  885. continue;
  886. info = *(struct uart_info **)dev_id;
  887. if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  888. #if 0
  889. printk("rs loop breakn");
  890. #endif
  891. break; /* Prevent infinite loops */
  892. }
  893. } while (end_mark != info);
  894. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  895. if (port_monitor)
  896. printk("rs port monitor (normal) irq %d: 0x%x, 0x%xn",
  897. info->port->irq, first_multi, inb(port_monitor));
  898. #endif
  899. #ifdef SERIAL_DEBUG_INTR
  900. printk("end.n");
  901. #endif
  902. }
  903. #endif
  905. /*
  906.  * This is the serial driver's interrupt routine for a single port
  907.  */
  908. static void rs_interrupt_single(int irq, void *dev_id, struct pt_regs *regs)
  909. {
  910. struct uart_info *info;
  911. int pass_counter = 0;
  912. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  913. int first_multi = 0;
  914. unsigned long port_monitor = rs_multiport[irq].port_monitor;
  915. #endif
  917. #ifdef SERIAL_DEBUG_INTR
  918. printk("rs_interrupt_single(%d)...", irq);
  919. #endif
  921. info = *(struct uart_info **)dev_id;
  922. if (!info || !info->tty)
  923. return;
  925. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  926. if (port_monitor)
  927. first_multi = inb(port_monitor);
  928. #endif
  930. do {
  931. serial8250_handle_port(info, regs);
  932. if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  933. #if 0
  934. printk("rs_single loop break.n");
  935. #endif
  936. break;
  937. }
  938. #ifdef SERIAL_DEBUG_INTR
  939. printk("IIR = %x...", serial_in(info->port, UART_IIR));
  940. #endif
  941. } while (!(serial_in(info->port, UART_IIR) & UART_IIR_NO_INT));
  942. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  943. if (port_monitor)
  944. printk("rs port monitor (single) irq %d: 0x%x, 0x%xn",
  945. info->port->irq, first_multi, inb(port_monitor));
  946. #endif
  947. #ifdef SERIAL_DEBUG_INTR
  948. printk("end.n");
  949. #endif
  950. }
  952. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  953. /*
  954.  * This is the serial driver's interrupt routine for multiport boards
  955.  */
  956. static void rs_interrupt_multi(int irq, void *dev_id, struct pt_regs *regs)
  957. {
  958. struct uart_info *info;
  959. int pass_counter = 0;
  960. struct rs_multiport_struct *multi = &rs_multiport[irq];
  961. int first_multi = 0;
  963. #ifdef SERIAL_DEBUG_INTR
  964. printk("rs_interrupt_multi(%d)...", irq);
  965. #endif
  967. info = *(struct uart_info **)dev_id;
  968. if (!info)
  969. return;
  971. if (!multi->port1) {
  972. /* should never happen */
  973. printk("rs_interrupt_multi: port1 NULL!n");
  974. return;
  975. }
  976. if (multi->port_monitor)
  977. first_multi = inb(multi->port_monitor);
  979. while (1) {
  980. if (!info->tty ||
  981.     (serial_in(info->port, UART_IIR) & UART_IIR_NO_INT))
  982. goto next;
  984. serial8250_handle_port(info, regs);
  986. next:
  987. info = info->next;
  988. if (info)
  989. continue;
  990. info = *(struct uart_info **)dev_id;
  992. /*
  993.  * The user was a bonehead, and misconfigured their
  994.  * multiport info.  Rather than lock up the kernel
  995.  * in an infinite loop, if we loop too many times,
  996.  * print a message and break out of the loop.
  997.  */
  998. if (pass_counter++ > RS_ISR_PASS_LIMIT) {
  999. printk("Misconfigured multiport serial info "
  1000.        "for irq %d.  Breaking out irq loopn", irq);
  1001. break;
  1002. }
  1003. if (multi->port_monitor)
  1004. printk("rs port monitor irq %d: 0x%x, 0x%xn",
  1005. info->port->irq, first_multi,
  1006. inb(multi->port_monitor));
  1007. if ((inb(multi->port1) & multi->mask1) != multi->match1)
  1008. continue;
  1009. if (!multi->port2)
  1010. break;
  1011. if ((inb(multi->port2) & multi->mask2) != multi->match2)
  1012. continue;
  1013. if (!multi->port3)
  1014. break;
  1015. if ((inb(multi->port3) & multi->mask3) != multi->match3)
  1016. continue;
  1017. if (!multi->port4)
  1018. break;
  1019. if ((inb(multi->port4) & multi->mask4) != multi->match4)
  1020. continue;
  1021. break;
  1022. }
  1023. #ifdef SERIAL_DEBUG_INTR
  1024. printk("end.n");
  1025. #endif
  1026. }
  1027. #endif
  1029. static u_int serial8250_tx_empty(struct uart_port *port)
  1030. {
  1031. return serial_in(port, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
  1032. }
  1034. static u_int serial8250_get_mctrl(struct uart_port *port)
  1035. {
  1036. unsigned long flags;
  1037. unsigned char status;
  1038. unsigned int ret;
  1040. save_flags(flags); cli();
  1041. status = serial_in(port, UART_MSR);
  1042. restore_flags(flags);
  1044. ret = 0;
  1045. if (status & UART_MSR_DCD)
  1046. ret |= TIOCM_CAR;
  1047. if (status & UART_MSR_RI)
  1048. ret |= TIOCM_RNG;
  1049. if (status & UART_MSR_DSR)
  1050. ret |= TIOCM_DSR;
  1051. if (status & UART_MSR_CTS)
  1052. ret |= TIOCM_CTS;
  1053. return ret;
  1054. }
  1056. static void serial8250_set_mctrl(struct uart_port *port, u_int mctrl)
  1057. {
  1058. unsigned char mcr = 0;
  1060. if (mctrl & TIOCM_RTS)
  1061. mcr |= UART_MCR_RTS;
  1062. if (mctrl & TIOCM_DTR)
  1063. mcr |= UART_MCR_DTR;
  1064. if (mctrl & TIOCM_OUT1)
  1065. mcr |= UART_MCR_OUT1;
  1066. if (mctrl & TIOCM_OUT2)
  1067. mcr |= UART_MCR_OUT2;
  1068. if (mctrl & TIOCM_LOOP)
  1069. mcr |= UART_MCR_LOOP;
  1071. serial_out(port, UART_MCR, mcr);
  1072. }
  1074. static void serial8250_break_ctl(struct uart_port *port, int break_state)
  1075. {
  1076. if (break_state == -1)
  1077. port->port_lcr |= UART_LCR_SBC;
  1078. else
  1079. port->port_lcr &= ~UART_LCR_SBC;
  1080. serial_out(port, UART_LCR, port->port_lcr);
  1081. }
  1083. static int serial8250_startup(struct uart_port *port, struct uart_info *info)
  1084. {
  1085. void (*handler)(int, void *, struct pt_regs *);
  1086. unsigned long flags;
  1087. int retval;
  1089. if (port->type == PORT_16C950) {
  1090. /* Wake up and initialize UART */
  1091. port->port_acr = 0;
  1092. serial_outp(port, UART_LCR, 0xBF);
  1093. serial_outp(port, UART_EFR, UART_EFR_ECB);
  1094. serial_outp(port, UART_IER, 0);
  1095. serial_outp(port, UART_LCR, 0);
  1096. serial_icr_write(port, UART_CSR, 0); /* Reset the UART */
  1097. serial_outp(port, UART_LCR, 0xBF);
  1098. serial_outp(port, UART_EFR, UART_EFR_ECB);
  1099. serial_outp(port, UART_LCR, 0);
  1100. }
  1102. #ifdef CONFIG_SERIAL_RSA
  1103. /*
  1104.  * If this is an RSA port, see if we can kick it up to the
  1105.  * higher speed clock.
  1106.  */
  1107. if (port->type == PORT_RSA) {
  1108. if (port->uartclk != SERIAL_RSA_BAUD_BASE * 16 &&
  1109.     enable_rsa(port))
  1110. port->uartclk = SERIAL_RSA_BAUD_BASE * 16;
  1111. if (port->uartclk == SERIAL_RSA_BAUD_BASE * 16)
  1112. serial_outp(port, UART_RSA_FRR, 0);
  1113. }
  1114. #endif
  1116. /*
  1117.  * Clear the FIFO buffers and disable them.
  1118.  * (they will be reeanbled in change_speed())
  1119.  */
  1120. if (uart_config[port->type].flags & UART_CLEAR_FIFO) {
  1121. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO);
  1122. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO |
  1123. UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
  1124. serial_outp(port, UART_FCR, 0);
  1125. }
  1127. /*
  1128.  * Clear the interrupt registers.
  1129.  */
  1130. (void) serial_inp(port, UART_LSR);
  1131. (void) serial_inp(port, UART_RX);
  1132. (void) serial_inp(port, UART_IIR);
  1133. (void) serial_inp(port, UART_MSR);
  1135. /*
  1136.  * At this point, there's no way the LSR could still be 0xff;
  1137.  * if it is, then bail out, because there's likely no UART
  1138.  * here.
  1139.  */
  1140. if (!(port->flags & ASYNC_BUGGY_UART) &&
  1141.     (serial_inp(port, UART_LSR) == 0xff)) {
  1142. printk("ttyS%d: LSR safety check engaged!n", port->line);
  1143. return -ENODEV;
  1144. }
  1146. /*
  1147.  * Allocate the IRQ if necessary
  1148.  */
  1149. if (port->irq && (!IRQ_ports[port->irq] ||
  1150.   !IRQ_ports[port->irq]->next_info)) {
  1151. handler = rs_interrupt_single;
  1152. if (IRQ_ports[port->irq]) {
  1153. #ifdef CONFIG_SERIAL_8250_SHARE_IRQ
  1154. handler = rs_interrupt;
  1155. free_irq(port->irq, &IRQ_ports[port->irq]);
  1156. #ifdef CONFIG_SERIAL_8250_MULTIPORT
  1157. if (rs_multiport[port->irq].port1)
  1158. handler = serial8250_interrupt_multi;
  1159. #endif
  1160. #else
  1161. return -EBUSY;
  1162. #endif /* CONFIG_SERIAL_8250_SHARE_IRQ */
  1163. }
  1165. retval = request_irq(port->irq, handler, SA_SHIRQ,
  1166.      "serial", &IRQ_ports[port->irq]);
  1167. if (retval)
  1168. return retval;
  1169. }
  1171. /*
  1172.  * Insert serial port into IRQ chain.
  1173.  */
  1174. info->next_info = IRQ_ports[port->irq];
  1175. IRQ_ports[port->irq] = info;
  1177. /*
  1178.  * Now, initialize the UART
  1179.  */
  1180. serial_outp(port, UART_LCR, UART_LCR_WLEN8);
  1182. #ifdef CONFIG_SERIAL_MANY_PORTS
  1183. if (port->flags & ASYNC_FOURPORT) {
  1184. if (port->irq == 0)
  1185. info->mctrl |= TIOCM_OUT1;
  1186. } else
  1187. #endif
  1188. /*
  1189.  * Most PC uarts need OUT2 raised to enable interrupts.
  1190.  */
  1191. if (port->irq != 0)
  1192. info->mctrl |= TIOCM_OUT2;
  1194. /* FIXME: ALPHA_KLUDGE_MCR; */
  1195. serial8250_set_mctrl(port, info->mctrl);
  1197. /*
  1198.  * Finally, enable interrupts.  Note: Modem status interrupts
  1199.  * are set via change_speed(), which will be occuring imminently
  1200.  * anyway, so we don't enable them here.
  1201.  */
  1202. port->port_ier = UART_IER_RLSI | UART_IER_RDI;
  1203. serial_outp(port, UART_IER, port->port_ier);
  1205. #ifdef CONFIG_SERIAL_MANY_PORTS
  1206. if (port->flags & ASYNC_FOURPORT) {
  1207. unsigned int ICP;
  1208. /*
  1209.  * Enable interrupts on the AST Fourport board
  1210.  */
  1211. ICP = (port->iobase & 0xfe0) | 0x01f;
  1212. outb_p(0x80, ICP);
  1213. (void) inb_p(ICP);
  1214. }
  1215. #endif
  1217. /*
  1218.  * And clear the interrupt registers again for luck.
  1219.  */
  1220. (void) serial_inp(port, UART_LSR);
  1221. (void) serial_inp(port, UART_RX);
  1222. (void) serial_inp(port, UART_IIR);
  1223. (void) serial_inp(port, UART_MSR);
  1225. return 0;
  1226. }
  1228. static void serial8250_shutdown(struct uart_port *port, struct uart_info *info)
  1229. {
  1230. struct uart_info **infop;
  1231. unsigned long flags;
  1232. int retval;
  1234. /*
  1235.  * First, disable all intrs from the port.
  1236.  */
  1237. port->port_ier = 0;
  1238. serial_outp(port, UART_IER, 0);
  1240. synchronize_irq();
  1242. /*
  1243.  * unlink the serial port from the IRQ chain...
  1244.  */
  1245. for (infop = &IRQ_ports[port->irq]; *infop; infop = &(*infop)->next_info)
  1246. if (*infop == info)
  1247. break;
  1249. if (*infop == info)
  1250. *infop = info->next_info;
  1252. /*
  1253.  * Free the IRQ, if necessary
  1254.  */
  1255. if (port->irq && (!IRQ_ports[port->irq] ||
  1256.   !IRQ_ports[port->irq]->next_info)) {
  1257. free_irq(port->irq, &IRQ_ports[port->irq]);
  1258. if (IRQ_ports[port->irq]) {
  1259. retval = request_irq(port->irq, rs_interrupt_single,
  1260.      SA_SHIRQ, "serial", &IRQ_ports[port->irq]);
  1261. if (retval)
  1262. printk("serial shutdown: request_irq: error %d"
  1263.        " couldn't reacquire IRQ.n", retval);
  1264. }
  1265. }
  1267. #ifdef CONFIG_SERIAL_MANY_PORTS
  1268. if (port->flags & ASYNC_FOURPORT) {
  1269. /* reset interrupts on the AST Fourport board */
  1270. inb((port->iobase & 0xfe0) | 0x1f);
  1271. info->mctrl |= TIOCM_OUT1;
  1272. } else
  1273. #endif
  1274. info->mctrl &= ~TIOCM_OUT2;
  1276. /* FIXME: ALPHA_KLUDGE_MCR; */
  1277. serial8250_set_mctrl(port, info->mctrl);
  1279. /*
  1280.  * Disable break condition and FIFOs
  1281.  */
  1282. serial_out(port, UART_LCR, serial_inp(port, UART_LCR) & ~UART_LCR_SBC);
  1283. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO |
  1284.     UART_FCR_CLEAR_RCVR |
  1285.     UART_FCR_CLEAR_XMIT);
  1286. serial_outp(port, UART_FCR, 0);
  1288. #ifdef CONFIG_SERIAL_RSA
  1289. /*
  1290.  * Reset the RSA board back to 115kbps compat mode.
  1291.  */
  1292. if (port->type == PORT_RSA &&
  1293.     port->uartclk == SERIAL_RSA_BAUD_BASE * 16 &&
  1294.     disable_rsa(port))
  1295. port->uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
  1296. #endif
  1298. /*
  1299.  * Read data port to reset things
  1300.  */
  1301. (void) serial_in(port, UART_RX);
  1302. }
  1304. static void serial8250_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot)
  1305. {
  1306. unsigned char cval, fcr = 0;
  1307. unsigned long flags;
  1309. switch (cflag & CSIZE) {
  1310. case CS5: cval = 0x00; break;
  1311. case CS6: cval = 0x01; break;
  1312. case CS7: cval = 0x02; break;
  1313. default:
  1314. case CS8: cval = 0x03; break;
  1315. }
  1317. if (cflag & CSTOPB)
  1318. cval |= 0x04;
  1319. if (cflag & PARENB)
  1320. cval |= UART_LCR_PARITY;
  1321. if (!(cflag & PARODD))
  1322. cval |= UART_LCR_EPAR;
  1323. #ifdef CMSPAR
  1324. if (cflag & CMSPAR)
  1325. cval |= UART_LCR_SPAR;
  1326. #endif
  1328. /*
  1329.  * Work around a bug in the Oxford Semiconductor 952 rev B
  1330.  * chip which causes it to seriously miscalculate baud rates
  1331.  * when DLL is 0.
  1332.  */
  1333. if ((quot & 0xff) == 0 && port->type == PORT_16C950 &&
  1334.     port->port_rev == 0x5201)
  1335. quot ++;
  1337. if (uart_config[port->type].flags & UART_USE_FIFO) {
  1338. if ((port->uartclk / quot) < (2400 * 16))
  1339. fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
  1340. #ifdef CONFIG_SERIAL_RSA
  1341. else if (port->type == PORT_RSA)
  1342. fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_14;
  1343. #endif
  1344. else
  1345. fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
  1346. }
  1347. if (port->type == PORT_16750)
  1348. fcr |= UART_FCR7_64BYTE;
  1350. port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
  1351. if (iflag & IGNPAR)
  1352. port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
  1353. if (iflag & (BRKINT | PARMRK))
  1354. port->read_status_mask |= UART_LSR_BI;
  1356. /*
  1357.  * Characteres to ignore
  1358.  */
  1359. port->ignore_status_mask = 0;
  1360. if (iflag & IGNPAR)
  1361. port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
  1362. if (iflag & IGNBRK) {
  1363. port->ignore_status_mask |= UART_LSR_BI;
  1364. /*
  1365.  * If we're ignoring parity and break indicators,
  1366.  * ignore overruns too (for real raw support).
  1367.  */
  1368. if (iflag & IGNPAR)
  1369. port->ignore_status_mask |= UART_LSR_OE;
  1370. }
  1372. /*
  1373.  * ignore all characters if CREAD is not set
  1374.  */
  1375. if ((cflag & CREAD) == 0)
  1376. port->ignore_status_mask |= UART_LSR_DR;
  1378. /*
  1379.  * CTS flow control flag and modem status interrupts
  1380.  */
  1381. port->port_ier &= ~UART_IER_MSI;
  1382. if (port->flags & ASYNC_HARDPPS_CD || cflag & CRTSCTS ||
  1383.     !(cflag & CLOCAL))
  1384. port->port_ier |= UART_IER_MSI;
  1386. /*
  1387.  * Ok, we're now changing the port state.  Do it with
  1388.  * interrupts disabled.
  1389.  */
  1390. save_flags(flags); cli();
  1391. serial_out(port, UART_IER, port->port_ier);
  1393. if (uart_config[port->type].flags & UART_STARTECH) {
  1394. serial_outp(port, UART_LCR, 0xBF);
  1395. serial_outp(port, UART_EFR, cflag & CRTSCTS ? UART_EFR_CTS :0);
  1396. }
  1397. serial_outp(port, UART_LCR, cval | UART_LCR_DLAB); /* set DLAB */
  1398. serial_outp(port, UART_DLL, quot & 0xff); /* LS of divisor */
  1399. serial_outp(port, UART_DLM, quot >> 8); /* MS of divisor */
  1400. if (port->type == PORT_16750)
  1401. serial_outp(port, UART_FCR, fcr); /* set fcr */
  1402. serial_outp(port, UART_LCR, cval); /* reset DLAB */
  1403. port->port_lcr = cval; /* Save LCR */
  1404. if (port->type != PORT_16750) {
  1405. if (fcr & UART_FCR_ENABLE_FIFO) {
  1406. /* emulated UARTs (Lucent Venus 167x) need two steps */
  1407. serial_outp(port, UART_FCR, UART_FCR_ENABLE_FIFO);
  1408. }
  1409. serial_outp(port, UART_FCR, fcr); /* set fcr */
  1410. }
  1411. restore_flags(flags);
  1412. }
  1414. static void serial8250_pm(struct uart_port *port, u_int state, u_int oldstate)
  1415. {
  1416. if (state) {
  1417. /* sleep */
  1418. if (uart_config[port->type].flags & UART_STARTECH) {
  1419. /* Arrange to enter sleep mode */
  1420. serial_outp(port, UART_LCR, 0xBF);
  1421. serial_outp(port, UART_EFR, UART_EFR_ECB);
  1422. serial_outp(port, UART_LCR, 0);
  1423. serial_outp(port, UART_IER, UART_IERX_SLEEP);
  1424. serial_outp(port, UART_LCR, 0xBF);
  1425. serial_outp(port, UART_EFR, 0);
  1426. serial_outp(port, UART_LCR, 0);
  1427. }
  1428. if (port->type == PORT_16750) {
  1429. /* Arrange to enter sleep mode */
  1430. serial_outp(port, UART_IER, UART_IERX_SLEEP);
  1431. }
  1432. } else {
  1433. /* wake */
  1434. if (uart_config[port->type].flags & UART_STARTECH) {
  1435. /* Wake up UART */
  1436. serial_outp(port, UART_LCR, 0xBF);
  1437. serial_outp(port, UART_EFR, UART_EFR_ECB);
  1438. /*
  1439.  * Turn off LCR == 0xBF so we actually set the IER
  1440.  * register on the XR16C850
  1441.  */
  1442. serial_outp(port, UART_LCR, 0);
  1443. serial_outp(port, UART_IER, 0);
  1444. /*
  1445.  * Now reset LCR so we can turn off the ECB bit
  1446.  */
  1447. serial_outp(port, UART_LCR, 0xBF);
  1448. serial_outp(port, UART_EFR, 0);
  1449. /*
  1450.  * For a XR16C850, we need to set the trigger levels
  1451.  */
  1452. if (port->type == PORT_16850) {
  1453. unsigned char fctr;
  1455. fctr = serial_inp(port, UART_FCTR) &
  1456.  ~(UART_FCTR_RX | UART_FCTR_TX);
  1457. serial_outp(port, UART_FCTR, fctr |
  1458. UART_FCTR_TRGD |
  1459. UART_FCTR_RX);
  1460. serial_outp(port, UART_TRG, UART_TRG_96);
  1461. serial_outp(port, UART_FCTR, fctr |
  1462. UART_FCTR_TRGD |
  1463. UART_FCTR_TX);
  1464. serial_outp(port, UART_TRG, UART_TRG_96);
  1465. }
  1466. serial_outp(port, UART_LCR, 0);
  1467. }
  1469. if (port->type == PORT_16750) {
  1470. /* Wake up UART */
  1471. serial_outp(port, UART_IER, 0);
  1472. }
  1473. }
  1474. }
  1476. /*
  1477.  * Resource handling.  This is complicated by the fact that resources
  1478.  * depend on the port type.  Maybe we should be claiming the standard
  1479.  * 8250 ports, and then trying to get other resources as necessary?
  1480.  */
  1481. static int
  1482. serial8250_request_std_resource(struct uart_port *port, struct resource **res)
  1483. {
  1484. unsigned int size = 8 << port->regshift;
  1485. int ret = 0;
  1487. switch (port->iotype) {
  1488. case SERIAL_IO_MEM:
  1489. if (port->mapbase) {
  1490. *res = request_mem_region(port->mapbase, size, "serial");
  1491. if (!*res)
  1492. ret = -EBUSY;
  1493. }
  1494. break;
  1496. case SERIAL_IO_HUB6:
  1497. case SERIAL_IO_PORT:
  1498. *res = request_region(port->iobase, size, "serial");
  1499. if (!*res)
  1500. ret = -EBUSY;
  1501. break;
  1502. }
  1503. return ret;
  1504. }
  1506. static int
  1507. serial8250_request_rsa_resource(struct uart_port *port, struct resource **res)
  1508. {
  1509. unsigned long start, size = 8 << port->regshift;
  1510. int ret = 0;
  1512. switch (port->iotype) {
  1513. case SERIAL_IO_MEM:
  1514. if (port->mapbase) {
  1515. start = port->mapbase;
  1516. start += UART_RSA_BASE << port->regshift;
  1517. *res = request_mem_region(start, size, "serial-rsa");
  1518. if (!*res)
  1519. ret = -EBUSY;
  1520. }
  1521. break;
  1523. case SERIAL_IO_HUB6:
  1524. case SERIAL_IO_PORT:
  1525. start = port->iobase;
  1526. start += UART_RSA_BASE << port->regshift;
  1527. *res = request_region(start, size, "serial-rsa");
  1528. if (!*res)
  1529. ret = -EBUSY;
  1530. break;
  1531. }
  1533. return ret;
  1534. }
  1536. static void serial8250_release_port(struct uart_port *port)
  1537. {
  1538. unsigned long start, offset = 0, size = 0;
  1540. if (port->type == PORT_RSA) {
  1541. offset = UART_RSA_BASE << port->regshift;
  1542. size = 8;
  1543. }
  1545. offset <<= port->regshift;
  1546. size <<= port->regshift;
  1548. switch (port->iotype) {
  1549. case SERIAL_IO_MEM:
  1550. if (port->mapbase) {
  1551. /*
  1552.  * Unmap the area.
  1553.  */
  1554. iounmap(port->membase);
  1555. port->membase = NULL;
  1557. start = port->mapbase;
  1559. if (size)
  1560. release_mem_region(start + offset, size);
  1561. release_mem_region(start, 8 << port->regshift);
  1562. }
  1563. break;
  1565. case SERIAL_IO_HUB6:
  1566. case SERIAL_IO_PORT:
  1567. start = port->iobase;
  1569. if (size)
  1570. release_region(start + offset, size);
  1571. release_region(start + offset, 8 << port->regshift);
  1572. break;
  1574. default:
  1575. break;
  1576. }
  1577. }
  1579. static int serial8250_request_port(struct uart_port *port)
  1580. {
  1581. struct resource *res = NULL, *res_rsa = NULL;
  1582. int ret = -EBUSY;
  1584. if (port->type == PORT_RSA) {
  1585. ret = serial8250_request_rsa_resource(port, &res_rsa);
  1586. if (ret)
  1587. return ret;
  1588. }
  1590. ret = serial8250_request_std_resource(port, &res);
  1592. /*
  1593.  * If we have a mapbase, then request that as well.
  1594.  */
  1595. if (res != NULL && port->iotype == SERIAL_IO_MEM &&
  1596.     port->mapbase) {
  1597. int size = res->end - res->start + 1;
  1599. port->membase = ioremap(port->mapbase, size);
  1600. if (!port->membase)
  1601. ret = -ENOMEM;
  1602. }
  1604. if (ret) {
  1605. if (res_rsa)
  1606. release_resource(res_rsa);
  1607. if (res)
  1608. release_resource(res);
  1609. }
  1610. return ret;
  1611. }
  1613. static void serial8250_config_port(struct uart_port *port, int flags)
  1614. {
  1615. struct resource *res_std = NULL, *res_rsa = NULL;
  1616. int probeflags = PROBE_ANY;
  1617. int ret;
  1619. #ifdef CONFIG_MCA
  1620. /*
  1621.  * Don't probe for MCA ports on non-MCA machines.
  1622.  */
  1623. if (port->flags & ASYNC_BOOT_ONLYMCA && !MCA_bus)
  1624. return;
  1625. #endif
  1627. /*
  1628.  * Find the region that we can probe for.  This in turn
  1629.  * tells us whether we can probe for the type of port.
  1630.  */
  1631. ret = serial8250_request_std_resource(port, &res_std);
  1632. if (ret)
  1633. return;
  1635. ret = serial8250_request_rsa_resource(port, &res_rsa);
  1636. if (ret)
  1637. probeflags &= ~PROBE_RSA;
  1639. if (flags & UART_CONFIG_TYPE)
  1640. autoconfig(port, probeflags);
  1641. if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
  1642. autoconfig_irq(port);
  1644. /*
  1645.  * If the port wasn't an RSA port, release the resource.
  1646.  */
  1647. if (port->type != PORT_RSA && res_rsa)
  1648. release_resource(res_rsa);
  1650. if (port->type == PORT_UNKNOWN)
  1651. release_resource(res_std);
  1652. }
  1654. static int
  1655. serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
  1656. {
  1657. if (ser->irq >= NR_IRQS || ser->irq < 0 ||
  1658.     ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
  1659.     ser->type > PORT_MAX_8250 || ser->type == PORT_CIRRUS ||
  1660.     ser->type == PORT_STARTECH)
  1661. return -EINVAL;
  1662. return 0;
  1663. }
  1665. static const char *
  1666. serial8250_type(struct uart_port *port)
  1667. {
  1668. int type = port->type;
  1670. if (type >= PORT_MAX_8250)
  1671. type = 0;
  1672. return uart_config[type].name;
  1673. }
  1675. static struct uart_ops serial8250_pops = {
  1676. tx_empty: serial8250_tx_empty,
  1677. set_mctrl: serial8250_set_mctrl,
  1678. get_mctrl: serial8250_get_mctrl,
  1679. stop_tx: serial8250_stop_tx,
  1680. start_tx: serial8250_start_tx,
  1681. stop_rx: serial8250_stop_rx,
  1682. enable_ms: serial8250_enable_ms,
  1683. break_ctl: serial8250_break_ctl,
  1684. startup: serial8250_startup,
  1685. shutdown: serial8250_shutdown,
  1686. change_speed: serial8250_change_speed,
  1687. pm: serial8250_pm,
  1688. type: serial8250_type,
  1689. release_port: serial8250_release_port,
  1690. request_port: serial8250_request_port,
  1691. config_port: serial8250_config_port,
  1692. verify_port: serial8250_verify_port,
  1693. };
  1695. static struct uart_port serial8250_ports[UART_NR];
  1697. static void __init serial8250_isa_init_ports(void)
  1698. {
  1699. static int first = 1;
  1700. int i;
  1702. if (!first)
  1703. return;
  1704. first = 0;
  1706. for (i = 0; i < ARRAY_SIZE(old_serial_port); i++) {
  1707. serial8250_ports[i].iobase  = old_serial_port[i].port;
  1708. serial8250_ports[i].irq     = irq_cannonicalize(old_serial_port[i].irq);
  1709. serial8250_ports[i].uartclk = old_serial_port[i].base_baud * 16;
  1710. serial8250_ports[i].flags   = old_serial_port[i].flags;
  1711. serial8250_ports[i].ops     = &serial8250_pops;
  1712. }
  1713. }
  1715. #ifdef CONFIG_SERIAL_8250_CONSOLE
  1716. #ifdef used_and_not_const_char_pointer
  1717. static int serial8250_console_read(struct uart_port *port, char *s, u_int count)
  1718. {
  1719. }
  1720. #endif
  1722. #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
  1724. /*
  1725.  * Wait for transmitter & holding register to empty
  1726.  */
  1727. static inline void wait_for_xmitr(struct uart_port *port)
  1728. {
  1729. unsigned int status, tmout = 1000000;
  1731. do {
  1732. status = serial_in(port, UART_LSR);
  1734. if (status & UART_LSR_BI)
  1735. lsr_break_flag = UART_LSR_BI;
  1737. if (--tmout == 0)
  1738. break;
  1739. } while ((status & BOTH_EMPTY) != BOTH_EMPTY);
  1741. /* Wait for flow control if necessary */
  1742. if (port->flags & ASYNC_CONS_FLOW) {
  1743. tmout = 1000000;
  1744. while (--tmout &&
  1745.        ((serial_in(port, UART_MSR) & UART_MSR_CTS) == 0));
  1746. }
  1747. }
  1749. /*
  1750.  * Print a string to the serial port trying not to disturb
  1751.  * any possible real use of the port...
  1752.  *
  1753.  * The console_lock must be held when we get here.
  1754.  */
  1755. static void serial8250_console_write(struct console *co, const char *s, u_int count)
  1756. {
  1757. struct uart_port *port = serial8250_ports + co->index;
  1758. unsigned int ier;
  1759. int i;
  1761. /*
  1762.  * First save the UER then disable the interrupts
  1763.  */
  1764. ier = serial_in(port, UART_IER);
  1765. serial_out(port, UART_IER, 0);
  1767. /*
  1768.  * Now, do each character
  1769.  */
  1770. for (i = 0; i < count; i++, s++) {
  1771. wait_for_xmitr(port);
  1773. /*
  1774.  * Send the character out.
  1775.  * If a LF, also do CR...
  1776.  */
  1777. serial_out(port, UART_TX, *s);
  1778. if (*s == 10) {
  1779. wait_for_xmitr(port);
  1780. serial_out(port, UART_TX, 13);
  1781. }
  1782. }
  1784. /*
  1785.  * Finally, wait for transmitter to become empty
  1786.  * and restore the IER
  1787.  */
  1788. wait_for_xmitr(port);
  1789. serial_out(port, UART_IER, ier);
  1790. }
  1792. static kdev_t serial8250_console_device(struct console *co)
  1793. {
  1794. return MKDEV(TTY_MAJOR, 64 + co->index);
  1795. }
  1797. static int serial8250_console_wait_key(struct console *co)
  1798. {
  1799. struct uart_port *port = serial8250_ports + co->index;
  1800. int ier, c;
  1802. /*
  1803.  * First save the IER then disable the interrupts so
  1804.  * that the real driver for the port does not get the
  1805.  * character.
  1806.  */
  1807. ier = serial_in(port, UART_IER);
  1808. serial_out(port, UART_IER, 0);
  1810. while ((serial_in(port, UART_LSR) & UART_LSR_DR) == 0);
  1811. c = serial_in(port, UART_RX);
  1813. /*
  1814.  * Restore the interrupts
  1815.  */
  1816. serial_out(port, UART_IER, ier);
  1818. return c;
  1819. }
  1821. static int __init serial8250_console_setup(struct console *co, char *options)
  1822. {
  1823. struct uart_port *port;
  1824. int baud = 9600;
  1825. int bits = 8;
  1826. int parity = 'n';
  1827. int flow = 'n';
  1829. /*
  1830.  * Check whether an invalid uart number has been specified, and
  1831.  * if so, search for the first available port that does have
  1832.  * console support.
  1833.  */
  1834. port = uart_get_console(serial8250_ports, UART_NR, co);
  1836. if (options)
  1837. uart_parse_options(options, &baud, &parity, &bits, &flow);
  1839. return uart_set_options(port, co, baud, parity, bits, flow);
  1840. }
  1842. static struct console serial8250_console = {
  1843. name: "ttyS",
  1844. write: serial8250_console_write,
  1845. #ifdef used_and_not_const_char_pointer
  1846. read: serial8250_console_read,
  1847. #endif
  1848. device: serial8250_console_device,
  1849. wait_key: serial8250_console_wait_key,
  1850. setup: serial8250_console_setup,
  1851. flags: CON_PRINTBUFFER,
  1852. index: -1,
  1853. };
  1855. void __init serial8250_console_init(void)
  1856. {
  1857. serial8250_isa_init_ports();
  1858. register_console(&serial8250_console);
  1859. }
  1861. #define SERIAL8250_CONSOLE &serial8250_console
  1862. #else
  1863. #define SERIAL8250_CONSOLE NULL
  1864. #endif
  1866. static struct uart_driver serial8250_reg = {
  1867. owner: THIS_MODULE,
  1868. #ifdef CONFIG_DEVFS_FS
  1869. normal_name: "tts/%d",
  1870. callout_name: "cua/%d",
  1871. #else
  1872. normal_name: "ttyS",
  1873. callout_name: "cua",
  1874. #endif
  1875. normal_major: TTY_MAJOR,
  1876. callout_major: TTYAUX_MAJOR,
  1877. normal_driver: &normal,
  1878. callout_driver: &callout,
  1879. table: serial8250_table,
  1880. termios: serial8250_termios,
  1881. termios_locked: serial8250_termios_locked,
  1882. minor: 64,
  1883. nr: ARRAY_SIZE(old_serial_port),
  1884. port: serial8250_ports,
  1885. cons: SERIAL8250_CONSOLE,
  1886. };
  1888. /*
  1889.  * register_serial and unregister_serial allows for 16x50 serial ports to be
  1890.  * configured at run-time, to support PCMCIA modems.
  1891.  */
  1892.  
  1893. /**
  1894.  * register_serial - configure a 16x50 serial port at runtime
  1895.  * @req: request structure
  1896.  *
  1897.  * Configure the serial port specified by the request. If the
  1898.  * port exists and is in use an error is returned. If the port
  1899.  * is not currently in the table it is added.
  1900.  *
  1901.  * The port is then probed and if neccessary the IRQ is autodetected
  1902.  * If this fails an error is returned.
  1903.  *
  1904.  * On success the port is ready to use and the line number is returned.
  1905.  */
  1906. int register_serial(struct serial_struct *req)
  1907. {
  1908. struct uart_port port;
  1910. port.iobase   = req->port;
  1911. port.membase  = req->iomem_base;
  1912. port.irq      = req->irq;
  1913. port.uartclk  = req->baud_base * 16;
  1914. port.fifosize = req->xmit_fifo_size;
  1915. port.regshift = req->iomem_reg_shift;
  1916. port.iotype   = req->io_type;
  1917. port.flags    = req->flags | ASYNC_BOOT_AUTOCONF;
  1919. if (HIGH_BITS_OFFSET)
  1920. port.iobase |= req->port_high << HIGH_BITS_OFFSET;
  1922. /*
  1923.  * If a clock rate wasn't specified by the low level
  1924.  * driver, then default to the standard clock rate.
  1925.  */
  1926. if (port.uartclk == 0)
  1927. port.uartclk = BASE_BAUD * 16;
  1929. return uart_register_port(&serial8250_reg, &port);
  1930. }
  1932. void unregister_serial(int line)
  1933. {
  1934. uart_unregister_port(&serial8250_reg, line);
  1935. }
  1937. static int __init serial8250_init(void)
  1938. {
  1939. serial8250_isa_init_ports();
  1940. return uart_register_driver(&serial8250_reg);
  1941. }
  1943. static void __exit serial8250_exit(void)
  1944. {
  1945. uart_unregister_driver(&serial8250_reg);
  1946. }
  1948. module_init(serial8250_init);
  1949. module_exit(serial8250_exit);
  1951. EXPORT_SYMBOL(register_serial);
  1952. EXPORT_SYMBOL(unregister_serial);
  1954. MODULE_LICENSE("GPL");
  1955. MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");