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

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

嵌入式Linux

开发平台：

Unix_Linux

serial_s3c2410.c：源码内容
  1. /*
  2.  * device for S3C2410 Development Board
  3.  *
  4.  * Author: Janghoon Lyu <nandy@mizi.com>
  5.  * Date  : $Date: 2002/05/14 02:19:42 $ 
  6.  *
  7.  * $Revision: 1.1.2.4 $
  9.    Mon May 20 2002 Janghoon Lyu <nandy@mizi.com>
  10.    - initial, based on linux/drivers/serial/serial_s3c2400.c
  12.    Wed Aug 14 2002 Yong-iL Joh <tolkien@mizi.com>
  13.    - adopt new irq scheme
  15.  *
  16.  * This file is subject to the terms and conditions of the GNU General Public
  17.  * License.  See the file COPYING in the main directory of this archive
  18.  * for more details.
  19.  */
  20. #include <linux/config.h>
  21. #include <linux/module.h>
  22. #include <linux/kernel.h>
  23. #include <linux/init.h>
  24. #include <linux/slab.h>
  25. #include <linux/console.h>
  26. #include <linux/serial_core.h>
  28. #include <asm/irq.h>
  29. #include <asm/hardware.h>
  30. #include <asm/arch/cpu_s3c2410.h>
  32. #define CONFIG_USE_ERR_IRQ 1     
  34. #define SERIAL_S3C2410_MAJOR 204
  35. #define CALLOUT_S3C2410_MAJOR 205
  36. #define MINOR_START 5
  38. #define UART_NR 3
  39. #define UART_ULCON(port) __REG((port)->iobase + 0x00)
  40. #define UART_UCON(port) __REG((port)->iobase + 0x04)
  41. #define UART_UFCON(port) __REG((port)->iobase + 0x08)
  42. #define UART_UTRSTAT(port) __REG((port)->iobase + 0x10)
  43. #define UART_UERSTAT(port) __REG((port)->iobase + 0x14)
  44. #define UART_UTXH(port) __REG((port)->iobase + 0x20)
  45. #define UART_URXH(port) __REG((port)->iobase + 0x24)
  46. #define UART_UBRDIV(port) __REG((port)->iobase + 0x28)
  48. #define ERR_IRQ(port) ((port)->irq + 2)
  49. #define TX_IRQ(port) ((port)->irq + 1)
  50. #define RX_IRQ(port) ((port)->irq)
  52. static struct tty_driver normal, callout;
  53. static struct tty_struct *s3c2410_table[UART_NR];
  54. static struct termios *s3c2410_termios[UART_NR], *s3c2410_termios_locked[UART_NR];
  56. static void s3c2410uart_stop_tx(struct uart_port *port, u_int from_tty) {
  57. disable_irq(TX_IRQ(port));
  58. }
  60. static void s3c2410uart_start_tx(struct uart_port *port, u_int nonempty,
  61.  u_int from_tty) {
  62. enable_irq(TX_IRQ(port));
  63. }
  65. static void s3c2410uart_stop_rx(struct uart_port *port) {
  66. disable_irq(RX_IRQ(port));
  67. }
  69. static void s3c2410uart_enable_ms(struct uart_port *port)
  70. {
  71. }
  73. static u_int s3c2410uart_tx_empty(struct uart_port *port)
  74. {
  75.     return (UART_UTRSTAT(port) & UTRSTAT_TR_EMP ? 0 : TIOCSER_TEMT);
  76. }
  78. static u_int s3c2410uart_get_mctrl(struct uart_port *port)
  79. {
  80.     return (TIOCM_CTS | TIOCM_DSR | TIOCM_CAR);
  81. }
  83. static void s3c2410uart_set_mctrl(struct uart_port *port, u_int mctrl)
  84. {
  85. }
  87. static void s3c2410uart_break_ctl(struct uart_port *port, int break_state)
  88. {
  89.     u_int ucon;
  91.     ucon = UART_UCON(port);
  93.     if (break_state == -1)
  94. ucon |= UCON_BRK_SIG;
  95.     else
  96. ucon &= ~UCON_BRK_SIG;
  98.     UART_UCON(port) = ucon;
  99. }
  101. static void s3c2410uart_rx_interrupt(int irq, void *dev_id,
  102.      struct pt_regs *regs) {
  103.     struct uart_info *info = dev_id;
  104.     struct tty_struct *tty = info->tty;
  105.     unsigned int status, ch, max_count = 256;
  106.     struct uart_port *port = info->port;
  108.     status = UART_UTRSTAT(port);
  109.     while ((status & UTRSTAT_RX_RDY) && max_count--) {
  110.       if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  111. tty->flip.tqueue.routine((void *) tty);
  112. if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  113.   printk(KERN_WARNING "TTY_DONT_FLIP setn");
  114.   return;
  115. }
  116.       }
  118.       ch = UART_URXH(port);
  120.       *tty->flip.char_buf_ptr = ch;
  121.       *tty->flip.flag_buf_ptr = TTY_NORMAL;
  122.       port->icount.rx++;
  123.       tty->flip.flag_buf_ptr++;
  124.       tty->flip.char_buf_ptr++;
  125.       tty->flip.count++;
  126.       /* No error handling just yet.
  127.        * On the MX1 these are seperate
  128.        * IRQs, so we need to deal with
  129.        * the sanity of 5 IRQs for one
  130.        * serial port before we deal
  131.        * with the error path properly.
  132.        */
  133.       status = UART_UTRSTAT(port);
  134.     }
  135.     tty_flip_buffer_push(tty);
  136.     return;
  137. }
  139. static void s3c2410uart_tx_interrupt(int irq, void *dev_id,
  140.      struct pt_regs *reg) {
  141.     struct uart_info *info = dev_id;
  142.     struct uart_port *port = info->port;
  143.     int count;
  145.     if (port->x_char) {
  146. UART_UTXH(port) = port->x_char;
  147. port->icount.tx++;
  148. port->x_char = 0;
  149. return;
  150.     }
  152.     if (info->xmit.head == info->xmit.tail
  153.         || info->tty->stopped || info->tty->hw_stopped) {
  154.       s3c2410uart_stop_tx(info->port, 0);
  155.       return;
  156.     }
  158.     count = port->fifosize >> 1;
  159.     do {
  160. UART_UTXH(port) = info->xmit.buf[info->xmit.tail];
  161. info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1);
  162. port->icount.tx++;
  163. if (info->xmit.head == info->xmit.tail)
  164.     break;
  165.     } while (--count > 0);
  167.     if (CIRC_CNT(info->xmit.head, info->xmit.tail,
  168.  UART_XMIT_SIZE) < WAKEUP_CHARS)
  169. uart_event(info, EVT_WRITE_WAKEUP);
  171.     if (info->xmit.head == info->xmit.tail)
  172. s3c2410uart_stop_tx(info->port, 0);
  174. }
  176. #ifdef CONFIG_USE_ERR_IRQ
  177. static void s3c2410uart_err_interrupt(int irq, void *dev_id,
  178.       struct pt_regs *reg) {
  179.     struct uart_info *info = dev_id;
  180.     struct uart_port *port = info->port;
  181.     struct tty_struct *tty = info->tty;
  182.     unsigned char err = UART_UERSTAT(port) & UART_ERR_MASK;
  183.     unsigned int ch, flg;
  185.     ch = UART_URXH(port);
  186.     if (!(err & (UERSTAT_BRK | UERSTAT_FRAME |
  187.  UERSTAT_PARITY | UERSTAT_OVERRUN)))
  188.       return;
  190.     if (err & UERSTAT_BRK)
  191.       port->icount.brk++;
  192.     if (err & UERSTAT_FRAME)
  193.       port->icount.frame++;
  194.     if (err & UERSTAT_PARITY)
  195.       port->icount.parity++;
  196.     if (err & UERSTAT_OVERRUN)
  197.       port->icount.overrun++;
  199.     err &= port->read_status_mask;
  201.     if (err & UERSTAT_PARITY)
  202.       flg = TTY_PARITY;
  203.     else if (err & UERSTAT_FRAME)
  204.       flg = TTY_FRAME;
  205.     else
  206.       flg = TTY_NORMAL;
  208.     if (err & UERSTAT_OVERRUN) {
  209.       *tty->flip.char_buf_ptr = ch;
  210.       *tty->flip.flag_buf_ptr = flg;
  211.       tty->flip.flag_buf_ptr++;
  212.       tty->flip.char_buf_ptr++;
  213.       tty->flip.count++;
  214.       if (tty->flip.count < TTY_FLIPBUF_SIZE) {
  215. ch = 0;
  216. flg = TTY_OVERRUN;
  217.       }
  218.     }
  219.      
  220.     *tty->flip.flag_buf_ptr++ = flg;
  221.     *tty->flip.char_buf_ptr++ = ch;
  222.     tty->flip.count++;
  223. }
  224. #endif
  226. static int s3c2410uart_startup(struct uart_port *port, struct uart_info *info)
  227. {
  228.     int ret, flags;
  229.     u_int ucon;
  231.     ret = request_irq(RX_IRQ(port), s3c2410uart_rx_interrupt, SA_INTERRUPT,
  232.       "serial_s3c2410_rx", info);
  233.     if (ret) goto rx_failed;
  234.     ret = request_irq(TX_IRQ(port), s3c2410uart_tx_interrupt, SA_INTERRUPT,
  235.       "serial_s3c2410_tx", info);
  236.     if (ret) goto tx_failed;
  237. #ifdef CONFIG_USE_ERR_IRQ
  238.     ret = request_irq(ERR_IRQ(port), s3c2410uart_err_interrupt, SA_INTERRUPT,
  239.       "serial_s3c2410_err", info);
  240.     if (ret) goto err_failed;
  241. #endif
  243.     ucon = (UCON_TX_INT_LVL | UCON_RX_INT_LVL |
  244.     UCON_TX_INT | UCON_RX_INT | UCON_RX_TIMEOUT);
  246. #if defined(CONFIG_IRDA) || defined(CONFIG_IRDA_MODULE)
  247.       ULCON2 |= ULCON_IR | ULCON_PAR_NONE | ULCON_WL8 | ULCON_ONE_STOP;
  248. #endif
  249.     save_flags(flags);
  250.     cli();
  251.     
  252.     UART_UCON(port) = ucon;
  253.     
  254.     sti();
  255.     restore_flags(flags);
  257.     return 0;
  259. #ifdef CONFIG_USE_ERR_IRQ
  260.  err_failed:
  261.     free_irq(TX_IRQ(port), info);
  262. #endif
  263.  tx_failed:
  264.     free_irq(RX_IRQ(port), info);
  265.  rx_failed:
  266.     return ret;
  267. }
  269. static void s3c2410uart_shutdown(struct uart_port *port, struct uart_info *info)
  270. {
  271.     free_irq(RX_IRQ(port), info);
  272.     free_irq(TX_IRQ(port), info);
  273. #ifdef CONFIG_USE_ERR_IRQ
  274.     free_irq(ERR_IRQ(port), info);
  275. #endif
  276.     UART_UCON(port) = 0x0;
  277. }
  279. static void s3c2410uart_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot)
  280. {
  281.     u_int ulcon, ufcon;
  282.     int flags;
  284.     ufcon = UART_UFCON(port);
  286.     switch (cflag & CSIZE) {
  287. case CS5: ulcon = ULCON_WL5; break;
  288. case CS6: ulcon = ULCON_WL6; break;
  289. case CS7: ulcon = ULCON_WL7; break;
  290. default: ulcon = ULCON_WL8; break;
  291.     }
  293.     if (cflag & CSTOPB)
  294. ulcon |= ULCON_STOP;
  295.     if (cflag & PARENB) {
  296. if (!(cflag & PARODD))
  297.     ulcon |= ULCON_PAR_EVEN;
  298.     }
  299.     
  300.     if (port->fifosize > 1)
  301. ufcon |= UFCON_FIFO_EN;
  302.     
  303.     port->read_status_mask =  UERSTAT_OVERRUN;
  304.     if (iflag & INPCK)
  305. port->read_status_mask |= UERSTAT_PARITY | UERSTAT_FRAME;
  307.     port->ignore_status_mask = 0;
  308.     if (iflag & IGNPAR)
  309. port->ignore_status_mask |= UERSTAT_FRAME | UERSTAT_PARITY;
  310.     if (iflag & IGNBRK) {
  311. if (iflag & IGNPAR)
  312.     port->ignore_status_mask |= UERSTAT_OVERRUN;
  313.     }
  315.     quot -= 1;
  317.     save_flags(flags);
  318.     cli();
  320.     UART_UFCON(port) = ufcon;
  321.     UART_ULCON(port) = (UART_ULCON(port) & ~(ULCON_PAR | ULCON_WL)) | ulcon;
  322.     UART_UBRDIV(port) = quot;
  324.     sti();
  325.     restore_flags(flags);
  326. }
  328. static const char *s3c2410uart_type(struct uart_port *port)
  329. {
  330.     return port->type == PORT_S3C2410 ? "S3C2410" : NULL;
  331. }
  333. static void s3c2410uart_config_port(struct uart_port *port, int flags)
  334. {
  335.     if (flags & UART_CONFIG_TYPE)
  336. port->type = PORT_S3C2410;
  337. }
  339. static void s3c2410uart_release_port(struct uart_port *port)
  340. {
  341. }
  343. static int s3c2410uart_request_port(struct uart_port *port)
  344. {
  345. return 0;
  346. }
  348. static struct uart_ops s3c2410_pops = {
  349.         tx_empty: s3c2410uart_tx_empty,
  350. set_mctrl: s3c2410uart_set_mctrl,
  351. get_mctrl: s3c2410uart_get_mctrl,
  352. stop_tx: s3c2410uart_stop_tx,
  353. start_tx: s3c2410uart_start_tx,
  354. stop_rx: s3c2410uart_stop_rx,
  355. enable_ms: s3c2410uart_enable_ms,
  356. break_ctl: s3c2410uart_break_ctl,
  357. startup: s3c2410uart_startup,
  358. shutdown: s3c2410uart_shutdown,
  359. change_speed: s3c2410uart_change_speed,
  360. type: s3c2410uart_type,
  361. config_port: s3c2410uart_config_port,
  362. release_port: s3c2410uart_release_port,
  363. request_port: s3c2410uart_request_port,
  364. };
  366. static struct uart_port s3c2410_ports[UART_NR] = {
  367.   {
  368. iobase: (unsigned long)(UART0_CTL_BASE),
  369. iotype: SERIAL_IO_PORT,
  370. irq: IRQ_RXD0,
  371. uartclk: 130252800,
  372. fifosize: 16,
  373. ops: &s3c2410_pops,
  374. type: PORT_S3C2410,
  375. flags: ASYNC_BOOT_AUTOCONF,
  376.   }, {
  377. iobase: (unsigned long)(UART1_CTL_BASE),
  378. iotype: SERIAL_IO_PORT,
  379. irq: IRQ_RXD1,
  380. uartclk: 130252800,
  381. fifosize: 16,
  382. ops: &s3c2410_pops,
  383. type: PORT_S3C2410,
  384. flags: ASYNC_BOOT_AUTOCONF,
  385.   }, {
  386. iobase: (unsigned long)(UART2_CTL_BASE),
  387. iotype: SERIAL_IO_PORT,
  388. irq: IRQ_RXD2,
  389. uartclk: 130252800,
  390. fifosize: 16,
  391. ops: &s3c2410_pops,
  392. type: PORT_S3C2410,
  393. flags: ASYNC_BOOT_AUTOCONF,
  394.   }
  395. };
  397. void __init s3c2410_register_uart(int idx, int port)
  398. {
  399.         if (idx >= UART_NR) {
  400.                 printk(KERN_ERR "%s: bad index number %dn", __FUNCTION__, idx);
  401.                 return;
  402.         }
  403. s3c2410_ports[idx].uartclk = s3c2410_get_bus_clk(GET_PCLK);
  405.         switch (port) {
  406.         case 0:
  407.   s3c2410_ports[idx].iobase = (unsigned long)(UART0_CTL_BASE);
  408.   s3c2410_ports[idx].irq  = IRQ_RXD0;
  409.   CLKCON |= CLKCON_UART0;
  410.   break;
  411.         case 1:
  412.   s3c2410_ports[idx].iobase = (unsigned long)(UART1_CTL_BASE);
  413.   s3c2410_ports[idx].irq  = IRQ_RXD1;
  414.   CLKCON |= CLKCON_UART1;
  415.   break;
  416.         case 2:
  417.   s3c2410_ports[idx].iobase = (unsigned long)(UART2_CTL_BASE);
  418.   s3c2410_ports[idx].irq  = IRQ_RXD2;
  419.   CLKCON |= CLKCON_UART2;
  420.   break;
  421.         default:
  422.   printk(KERN_ERR "%s : bad port number %dn", __FUNCTION__, port);
  423.         }
  424. }
  427. #ifdef CONFIG_SERIAL_S3C2410_CONSOLE
  429. static void s3c2410_console_write(struct console *co, const char *s, u_int count)
  430. {
  431.     int i;
  432.     struct uart_port *port = s3c2410_ports + co->index;
  434.     for (i = 0; i < count; i++) {
  435. while (!(UART_UTRSTAT(port) & UTRSTAT_TX_EMP));
  436. UART_UTXH(port) = s[i];
  437. if (s[i] == 'n') {
  438.     while (!(UART_UTRSTAT(port) & UTRSTAT_TX_EMP));
  439.      UART_UTXH(port) = 'r';
  440. }
  441.     }
  442. }
  444. static int s3c2410_console_wait_key(struct console *co)
  445. {
  446.     int c;
  447.     struct uart_port *port = s3c2410_ports + co->index;
  449.     while (!(UART_UTRSTAT(port) & UTRSTAT_RX_RDY));
  450.      c = UART_URXH(port);
  451.     return c;
  452. }
  454. static kdev_t s3c2410_console_device(struct console *co)
  455. {
  456. return MKDEV(SERIAL_S3C2410_MAJOR, MINOR_START + co->index);
  457. }
  459. static int __init s3c2410_console_setup(struct console *co, char *options)
  460. {
  461. struct uart_port *port;
  462. int baud = 115200;
  463. int bits = 8;
  464. int parity = 'n';
  465. int flow = 'n';
  467. port = uart_get_console(s3c2410_ports, UART_NR, co);
  469. if (options)
  470. uart_parse_options(options, &baud, &parity, &bits, &flow);
  472. return uart_set_options(port, co, baud, parity, bits, flow);
  473. }
  475. static struct console s3c2410_cons = {
  476. name: "ttyS",
  477. write: s3c2410_console_write,
  478. device: s3c2410_console_device,
  479. wait_key: s3c2410_console_wait_key,
  480. setup: s3c2410_console_setup,
  481. flags: CON_PRINTBUFFER,
  482. index: -1,
  483. };
  485. void __init s3c2410_console_init(void)
  486. {
  487. register_console(&s3c2410_cons);
  488. }
  489. #define S3C2410_CONSOLE &s3c2410_cons
  490. #else /* CONFIG_SERIAL_S3C2410_CONSOLE */
  491. #define S3C2410_CONSOLE NULL
  492. #endif /* CONFIG_SERIAL_S3C2410_CONSOLE */
  494. static struct uart_driver s3c2410_reg = {
  495. owner: THIS_MODULE,
  496. normal_major: SERIAL_S3C2410_MAJOR,
  497. #ifdef CONFIG_DEVFS_FS
  498. normal_name: "ttyS%d",
  499. callout_name: "cua%d",
  500. #else
  501. normal_name: "ttyS",
  502. callout_name: "cua",
  503. #endif
  504. normal_driver: &normal,
  505. callout_major: CALLOUT_S3C2410_MAJOR,
  506. callout_driver: &callout,
  507. table: s3c2410_table,
  508. termios: s3c2410_termios,
  509. termios_locked: s3c2410_termios_locked,
  510. minor: MINOR_START,
  511. nr: UART_NR,
  512. port: s3c2410_ports,
  513. cons: S3C2410_CONSOLE,
  514. };
  516. static int __init s3c2410uart_init(void)
  517. {
  518. return uart_register_driver(&s3c2410_reg);
  519. }
  521. static void __exit s3c2410uart_exit(void)
  522. {
  523. uart_unregister_driver(&s3c2410_reg);
  524. }
  526. module_init(s3c2410uart_init);
  527. module_exit(s3c2410uart_exit);
  529. EXPORT_NO_SYMBOLS;
  531. MODULE_AUTHOR("MIZI Research Inc");
  532. MODULE_DESCRIPTION("S3C2410 generic serial port driver");
  533. MODULE_LICENSE("GPL");