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

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

嵌入式Linux

开发平台：

Unix_Linux

serial_uart00.c：源码内容
  1. /*
  2.  *  linux/drivers/char/serial_uart00.c
  3.  *
  4.  *  Driver for UART00 serial ports
  5.  *
  6.  *  Based on drivers/char/serial_amba.c, by ARM Limited & 
  7.  *                                          Deep Blue Solutions Ltd.
  8.  *  Copyright 2001 Altera Corporation
  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23.  *
  24.  *  $Id: serial_uart00.c,v 1.3.2.4 2002/03/27 23:32:40 rmk Exp $
  25.  *
  26.  */
  27. #include <linux/config.h>
  28. #include <linux/module.h>
  30. #include <linux/errno.h>
  31. #include <linux/signal.h>
  32. #include <linux/sched.h>
  33. #include <linux/interrupt.h>
  34. #include <linux/tty.h>
  35. #include <linux/tty_flip.h>
  36. #include <linux/major.h>
  37. #include <linux/string.h>
  38. #include <linux/fcntl.h>
  39. #include <linux/ptrace.h>
  40. #include <linux/ioport.h>
  41. #include <linux/mm.h>
  42. #include <linux/slab.h>
  43. #include <linux/init.h>
  44. #include <linux/circ_buf.h>
  45. #include <linux/serial.h>
  46. #include <linux/console.h>
  47. #include <linux/sysrq.h>
  49. #include <asm/system.h>
  50. #include <asm/io.h>
  51. #include <asm/irq.h>
  52. #include <asm/uaccess.h>
  53. #include <asm/bitops.h>
  54. #include <asm/sizes.h>
  56. #if defined(CONFIG_SERIAL_UART00_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  57. #define SUPPORT_SYSRQ
  58. #endif
  60. #include <linux/serial_core.h>
  61. #include <asm/arch/excalibur.h>
  62. #define UART00_TYPE (volatile unsigned int*)
  63. #include <asm/arch/uart00.h>
  64. #include <asm/arch/int_ctrl00.h>
  66. #undef DEBUG
  67. #define UART_NR 2
  69. #define SERIAL_UART00_NAME "ttyUA"
  70. #define SERIAL_UART00_MAJOR 204
  71. #define SERIAL_UART00_MINOR 16      /* Temporary - will change in future */
  72. #define SERIAL_UART00_NR UART_NR
  73. #define UART_PORT_SIZE 0x50
  75. #define CALLOUT_UART00_NAME "cuaua"
  76. #define CALLOUT_UART00_MAJOR 205
  77. #define CALLOUT_UART00_MINOR 16      /* Temporary - will change in future */
  78. #define CALLOUT_UART00_NR UART_NR
  82. static struct tty_driver normal, callout;
  83. static struct tty_struct *uart00_table[UART_NR];
  84. static struct termios *uart00_termios[UART_NR], *uart00_termios_locked[UART_NR];
  85. //static struct uart_state uart00_state[UART_NR];
  86. static struct console uart00_console;
  88. #define UART00_ISR_PASS_LIMIT 256
  90. /*
  91.  * Access macros for the UART00 UARTs
  92.  */
  93. #define UART_GET_INT_STATUS(p) inl(UART_ISR((p)->membase))
  94. #define UART_PUT_IES(p, c)      outl(c,UART_IES((p)->membase))
  95. #define UART_GET_IES(p)         inl(UART_IES((p)->membase))
  96. #define UART_PUT_IEC(p, c)      outl(c,UART_IEC((p)->membase))
  97. #define UART_GET_IEC(p)         inl(UART_IEC((p)->membase))
  98. #define UART_PUT_CHAR(p, c)     outl(c,UART_TD((p)->membase))
  99. #define UART_GET_CHAR(p)        inl(UART_RD((p)->membase))
  100. #define UART_GET_RSR(p)         inl(UART_RSR((p)->membase))
  101. #define UART_GET_RDS(p)         inl(UART_RDS((p)->membase))
  102. #define UART_GET_MSR(p)         inl(UART_MSR((p)->membase))
  103. #define UART_GET_MCR(p)         inl(UART_MCR((p)->membase))
  104. #define UART_PUT_MCR(p, c)      outl(c,UART_MCR((p)->membase))
  105. #define UART_GET_MC(p)          inl(UART_MC((p)->membase))
  106. #define UART_PUT_MC(p, c)       outl(c,UART_MC((p)->membase))
  107. #define UART_GET_TSR(p)         inl(UART_TSR((p)->membase))
  108. #define UART_GET_DIV_HI(p) inl(UART_DIV_HI((p)->membase))
  109. #define UART_PUT_DIV_HI(p,c) outl(c,UART_DIV_HI((p)->membase))
  110. #define UART_GET_DIV_LO(p) inl(UART_DIV_LO((p)->membase))
  111. #define UART_PUT_DIV_LO(p,c) outl(c,UART_DIV_LO((p)->membase))
  112. #define UART_RX_DATA(s) ((s) & UART_RSR_RX_LEVEL_MSK)
  113. #define UART_TX_READY(s) (((s) & UART_TSR_TX_LEVEL_MSK) < 15)
  114. //#define UART_TX_EMPTY(p) ((UART_GET_FR(p) & UART00_UARTFR_TMSK) == 0)
  116. static void uart00_stop_tx(struct uart_port *port, u_int from_tty)
  117. {
  119. UART_PUT_IEC(port, UART_IEC_TIE_MSK);
  120. }
  122. static void uart00_stop_rx(struct uart_port *port)
  123. {
  125. UART_PUT_IEC(port, UART_IEC_RE_MSK);
  126. }
  128. static void uart00_enable_ms(struct uart_port *port)
  129. {
  131. UART_PUT_IES(port, UART_IES_ME_MSK);
  132. }
  134. static void
  135. uart00_rx_chars(struct uart_info *info, struct pt_regs *regs)
  136. {
  137. struct tty_struct *tty = info->tty;
  138. unsigned int status, ch, rds, flg, ignored = 0;
  139. struct uart_port *port = info->port;
  142. status = UART_GET_RSR(port);
  143. while (UART_RX_DATA(status)) {
  145. /* 
  146.  * We need to read rds before reading the 
  147.  * character from the fifo
  148.  */
  149. rds = UART_GET_RDS(port);
  150. ch = UART_GET_CHAR(port);
  151. port->icount.rx++;
  153. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  154. goto ignore_char;
  156. flg = TTY_NORMAL;
  158. /*
  159.  * Note that the error handling code is
  160.  * out of the main execution path
  161.  */
  162. if (rds & (UART_RDS_BI_MSK |UART_RDS_FE_MSK|
  163.    UART_RDS_PE_MSK |UART_RDS_PE_MSK))
  164. goto handle_error;
  165. if (uart_handle_sysrq_char(info, ch, regs))
  166. goto ignore_char;
  168. error_return:
  169. *tty->flip.flag_buf_ptr++ = flg;
  170. *tty->flip.char_buf_ptr++ = ch;
  171. tty->flip.count++;
  172. ignore_char:
  173. status = UART_GET_RSR(port);
  174. }
  175. out:
  176. tty_flip_buffer_push(tty);
  177. return;
  179. handle_error:
  180. if (rds & UART_RDS_BI_MSK) {
  181. status &= ~(UART_RDS_FE_MSK | UART_RDS_PE_MSK);
  182. port->icount.brk++;
  184. #ifdef SUPPORT_SYSRQ
  185. if (uart_handle_break(info, &uart00_console))
  186. goto ignore_char;
  187. #endif
  188. } else if (rds & UART_RDS_PE_MSK)
  189. port->icount.parity++;
  190. else if (rds & UART_RDS_PE_MSK)
  191. port->icount.frame++;
  192. if (rds & UART_RDS_OE_MSK)
  193. port->icount.overrun++;
  195. if (rds & port->ignore_status_mask) {
  196. if (++ignored > 100)
  197. goto out;
  198. goto ignore_char;
  199. }
  200. rds &= port->read_status_mask;
  202. if (rds & UART_RDS_BI_MSK)
  203. flg = TTY_BREAK;
  204. else if (rds & UART_RDS_PE_MSK)
  205. flg = TTY_PARITY;
  206. else if (rds & UART_RDS_FE_MSK)
  207. flg = TTY_FRAME;
  209. if (status & UART_RDS_OE_MSK) {
  210. /*
  211.  * CHECK: does overrun affect the current character?
  212.  * ASSUMPTION: it does not.
  213.  */
  214. *tty->flip.flag_buf_ptr++ = flg;
  215. *tty->flip.char_buf_ptr++ = ch;
  216. tty->flip.count++;
  217. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  218. goto ignore_char;
  219. ch = 0;
  220. flg = TTY_OVERRUN;
  221. }
  222. #ifdef SUPPORT_SYSRQ
  223. info->sysrq = 0;
  224. #endif
  225. goto error_return;
  226. }
  228. static void uart00_tx_chars(struct uart_info *info)
  229. {
  230. int count;
  231. struct uart_port *port=info->port;
  233. if (port->x_char) {
  234. while((UART_GET_TSR(port)& UART_TSR_TX_LEVEL_MSK)==15);
  235. UART_PUT_CHAR(port, port->x_char);
  236. port->icount.tx++;
  237. port->x_char = 0;
  239. return;
  240. }
  241. if (info->xmit.head == info->xmit.tail
  242.     || info->tty->stopped
  243.     || info->tty->hw_stopped) {
  244. uart00_stop_tx(info->port, 0);
  245. return;
  246. }
  248. count = port->fifosize >> 1;
  249. do {
  250. while((UART_GET_TSR(port)& UART_TSR_TX_LEVEL_MSK)==15);
  251. UART_PUT_CHAR(port, info->xmit.buf[info->xmit.tail]);
  252. info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1);
  253. port->icount.tx++;
  254. if (info->xmit.head == info->xmit.tail)
  255. break;
  256. } while (--count > 0);
  258. if (CIRC_CNT(info->xmit.head,
  259.      info->xmit.tail,
  260.      UART_XMIT_SIZE) < WAKEUP_CHARS)
  261. uart_event(info, EVT_WRITE_WAKEUP);
  263. if (info->xmit.head == info->xmit.tail)
  264. uart00_stop_tx(info->port, 0);
  265. }
  267. static void uart00_start_tx(struct uart_port *port, u_int nonempty, u_int from_tty)
  268. {
  269. struct uart_info *info=(struct uart_info*)(port->iobase);
  271. UART_PUT_IES(port,UART_IES_TIE_MSK );
  272. uart00_tx_chars(info);
  273. }
  275. static void uart00_modem_status(struct uart_info *info)
  276. {
  277. unsigned int status;
  278. struct uart_icount *icount = &info->port->icount;
  281. status = UART_GET_MSR(info->port);
  283. if (!status & (UART_MSR_DCTS_MSK | UART_MSR_DDSR_MSK | 
  284.        UART_MSR_TERI_MSK | UART_MSR_DDCD_MSK))
  285. return;
  287. if (status & UART_MSR_DDCD_MSK) {
  288. icount->dcd++;
  289. #ifdef CONFIG_HARD_PPS
  290. if ((info->flags & ASYNC_HARDPPS_CD) &&
  291.     (status & UART_MSR_DCD_MSK))
  292. hardpps();
  293. #endif
  294. if (info->flags & ASYNC_CHECK_CD) {
  295. if (status & UART_MSR_DCD_MSK)
  296. wake_up_interruptible(&info->open_wait);
  297. else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  298.    (info->flags & ASYNC_CALLOUT_NOHUP))) {
  299. if (info->tty)
  300. tty_hangup(info->tty);
  301. }
  302. }
  303. }
  305. if (status & UART_MSR_DDSR_MSK)
  306. icount->dsr++;
  308. if (status & UART_MSR_DCTS_MSK) {
  309. icount->cts++;
  311. if (info->flags & ASYNC_CTS_FLOW) {
  312. status &= UART_MSR_CTS_MSK;
  314. if (info->tty->hw_stopped) {
  315. if (status) {
  316. info->tty->hw_stopped = 0;
  317. info->ops->start_tx(info->port, 1, 0);
  318. uart_event(info, EVT_WRITE_WAKEUP);
  319. }
  320. } else {
  321. if (!status) {
  322. info->tty->hw_stopped = 1;
  323. info->ops->stop_tx(info->port, 0);
  324. }
  325. }
  326. }
  327. }
  328. wake_up_interruptible(&info->delta_msr_wait);
  330. }
  332. static void uart00_int(int irq, void *dev_id, struct pt_regs *regs)
  333. {
  334. struct uart_info *info = dev_id;
  335. unsigned int status, pass_counter = 0;
  337. status = UART_GET_INT_STATUS(info->port);
  338. do {
  340. if (status & UART_ISR_RI_MSK)
  341. uart00_rx_chars(info, regs);
  342. if (status & (UART_ISR_TI_MSK | UART_ISR_TII_MSK))
  343. uart00_tx_chars(info);
  344. if (status & UART_ISR_MI_MSK)
  345. uart00_modem_status(info);
  346. if (pass_counter++ > UART00_ISR_PASS_LIMIT)
  347. break;
  349. status = UART_GET_INT_STATUS(info->port);
  350. } while (status);
  351. }
  353. static u_int uart00_tx_empty(struct uart_port *port)
  354. {
  355. return UART_GET_TSR(port) & UART_TSR_TX_LEVEL_MSK? 0 : TIOCSER_TEMT;
  356. }
  358. static u_int uart00_get_mctrl(struct uart_port *port)
  359. {
  360. unsigned int result = 0;
  361. unsigned int status;
  363. status = UART_GET_MSR(port);
  364. if (status & UART_MSR_DCD_MSK)
  365. result |= TIOCM_CAR;
  366. if (status & UART_MSR_DSR_MSK)
  367. result |= TIOCM_DSR;
  368. if (status & UART_MSR_CTS_MSK)
  369. result |= TIOCM_CTS;
  370. if (status & UART_MSR_RI_MSK)
  371. result |= TIOCM_RI;
  373. return result;
  374. }
  376. static void uart00_set_mctrl_null(struct uart_port *port, u_int mctrl)
  377. {
  378. }
  380. static void uart00_break_ctl(struct uart_port *port, int break_state)
  381. {
  382. unsigned int mcr;
  384. mcr = UART_GET_MCR(port);
  385. if (break_state == -1)
  386. mcr |= UART_MCR_BR_MSK;
  387. else
  388. mcr &= ~UART_MCR_BR_MSK;
  389. UART_PUT_MCR(port, mcr);
  390. }
  392. static inline u_int uart_calculate_quot(struct uart_info *info, u_int baud)
  393. {
  394. u_int quot;
  396. /* Special case: B0 rate */
  397. if (!baud)
  398. baud = 9600;
  400. quot = (info->port->uartclk / (16 * baud)-1)  ;
  402. return quot;
  403. }
  404. static void uart00_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot)
  405. {
  406. u_int uart_mc=0, old_ies;
  407. unsigned long flags;
  409. #ifdef DEBUG
  410. printk("uart00_set_cflag(0x%x) calledn", cflag);
  411. #endif
  412. /* byte size and parity */
  413. switch (cflag & CSIZE) {
  414. case CS5: uart_mc = UART_MC_CLS_CHARLEN_5; break;
  415. case CS6: uart_mc = UART_MC_CLS_CHARLEN_6; break;
  416. case CS7: uart_mc = UART_MC_CLS_CHARLEN_7; break;
  417. default:  uart_mc = UART_MC_CLS_CHARLEN_8; break; // CS8
  418. }
  419. if (cflag & CSTOPB)
  420. uart_mc|= UART_MC_ST_TWO;
  421. if (cflag & PARENB) {
  422. uart_mc |= UART_MC_PE_MSK;
  423. if (!(cflag & PARODD))
  424. uart_mc |= UART_MC_EP_MSK;
  425. }
  427. port->read_status_mask = UART_RDS_OE_MSK;
  428. if (iflag & INPCK)
  429. port->read_status_mask |= UART_RDS_FE_MSK | UART_RDS_PE_MSK;
  430. if (iflag & (BRKINT | PARMRK))
  431. port->read_status_mask |= UART_RDS_BI_MSK;
  433. /*
  434.  * Characters to ignore
  435.  */
  436. port->ignore_status_mask = 0;
  437. if (iflag & IGNPAR)
  438. port->ignore_status_mask |= UART_RDS_FE_MSK | UART_RDS_PE_MSK;
  439. if (iflag & IGNBRK) {
  440. port->ignore_status_mask |= UART_RDS_BI_MSK;
  441. /*
  442.  * If we're ignoring parity and break indicators,
  443.  * ignore overruns to (for real raw support).
  444.  */
  445. if (iflag & IGNPAR)
  446. port->ignore_status_mask |= UART_RDS_OE_MSK;
  447. }
  449. /* first, disable everything */
  450. save_flags(flags); cli();
  451. old_ies = UART_GET_IES(port); 
  453. if ((port->flags & ASYNC_HARDPPS_CD) ||
  454.     (cflag & CRTSCTS) || !(cflag & CLOCAL))
  455. old_ies |= UART_IES_ME_MSK;
  458. /* Set baud rate */
  459. UART_PUT_DIV_LO(port, (quot & 0xff));
  460. UART_PUT_DIV_HI(port, ((quot & 0xf00) >> 8));
  461.    
  463. UART_PUT_MC(port, uart_mc);
  464. UART_PUT_IES(port, old_ies);
  466. restore_flags(flags);
  467. }
  469. static int uart00_startup(struct uart_port *port, struct uart_info *info)
  470. {
  471. int retval;
  473. /* 
  474.  * Use iobase to store a pointer to info. We need this to start a 
  475.  * transmission as the tranmittr interrupt is only generated on
  476.  * the transition to the idle state 
  477.  */
  479. port->iobase=(u_int)info;
  481. /*
  482.  * Allocate the IRQ
  483.  */
  484. retval = request_irq(port->irq, uart00_int, 0, "uart00", info);
  485. if (retval)
  486. return retval;
  488. /*
  489.  * Finally, enable interrupts. Use the TII interrupt to minimise 
  490.  * the number of interrupts generated. If higher performance is 
  491.  * needed, consider using the TI interrupt with a suitable FIFO
  492.  * threshold
  493.  */
  494. UART_PUT_IES(port, UART_IES_RE_MSK | UART_IES_TIE_MSK);
  496. return 0;
  497. }
  499. static void uart00_shutdown(struct uart_port *port, struct uart_info *info)
  500. {
  501. /*
  502.  * disable all interrupts, disable the port
  503.  */
  504. UART_PUT_IEC(port, 0xff);
  506. /* disable break condition and fifos */
  507. UART_PUT_MCR(port, UART_GET_MCR(port) &~UART_MCR_BR_MSK);
  509. /*
  510.  * Free the interrupt
  511.  */
  512. free_irq(port->irq, info);
  513. }
  515. static const char *uart00_type(struct uart_port *port)
  516. {
  517. return port->type == PORT_UART00 ? "UART00" : NULL;
  518. }
  520. /*
  521.  * Release the memory region(s) being used by 'port'
  522.  */
  523. static void uart00_release_port(struct uart_port *port)
  524. {
  525. release_mem_region(port->mapbase, UART_PORT_SIZE);
  527. #ifdef CONFIG_ARCH_CAMELOT
  528. if(port->membase!=(void*)IO_ADDRESS(EXC_UART00_BASE)){
  529. iounmap(port->membase);
  530. }
  531. #endif
  532. }
  534. /*
  535.  * Request the memory region(s) being used by 'port'
  536.  */
  537. static int uart00_request_port(struct uart_port *port)
  538. {
  539. int result;
  541. result = request_mem_region(port->mapbase, UART_PORT_SIZE,
  542.     "serial_uart00") != NULL ? 0 : -EBUSY;
  543. if (result)
  544. return result;
  546. port->membase = ioremap(port->mapbase, SZ_4K);
  547. if (!port->membase) {
  548. printk(KERN_ERR "serial00: cannot map io memoryn");
  549. release_mem_region(port->mapbase, UART_PORT_SIZE);
  550. }
  552. return port->membase ? 0 : -ENOMEM;
  553. }
  555. /*
  556.  * Configure/autoconfigure the port.
  557.  */
  558. static void uart00_config_port(struct uart_port *port, int flags)
  559. {
  560. if (flags & UART_CONFIG_TYPE) {
  561. if (uart00_request_port(port) == 0)
  562. port->type = PORT_UART00;
  563. }
  564. }
  566. /*
  567.  * verify the new serial_struct (for TIOCSSERIAL).
  568.  */
  569. static int uart00_verify_port(struct uart_port *port, struct serial_struct *ser)
  570. {
  571. int ret = 0;
  572. if (ser->type != PORT_UNKNOWN && ser->type != PORT_UART00)
  573. ret = -EINVAL;
  574. if (ser->irq < 0 || ser->irq >= NR_IRQS)
  575. ret = -EINVAL;
  576. if (ser->baud_base < 9600)
  577. ret = -EINVAL;
  578. return ret;
  579. }
  581. static struct uart_ops uart00_pops = {
  582. tx_empty: uart00_tx_empty,
  583. set_mctrl: uart00_set_mctrl_null,
  584. get_mctrl: uart00_get_mctrl,
  585. stop_tx: uart00_stop_tx,
  586. start_tx: uart00_start_tx,
  587. stop_rx: uart00_stop_rx,
  588. enable_ms: uart00_enable_ms,
  589. break_ctl: uart00_break_ctl,
  590. startup: uart00_startup,
  591. shutdown: uart00_shutdown,
  592. change_speed: uart00_change_speed,
  593. type: uart00_type,
  594. release_port: uart00_release_port,
  595. request_port: uart00_request_port,
  596. config_port: uart00_config_port,
  597. verify_port: uart00_verify_port,
  598. };
  600. static struct uart_port uart00_ports[UART_NR] = {
  601. #ifdef CONFIG_ARCH_CAMELOT
  602. {
  603. membase: (void*)IO_ADDRESS(EXC_UART00_BASE),
  604. mapbase:        EXC_UART00_BASE,
  605. iotype: SERIAL_IO_MEM,
  606. irq: IRQ_UART,
  607. uartclk: EXC_AHB2_CLK_FREQUENCY,
  608. fifosize: 16,
  609. ops: &uart00_pops,
  610. flags:          ASYNC_BOOT_AUTOCONF,
  611. }
  612. #endif
  613. };
  616. #ifdef CONFIG_SERIAL_UART00_CONSOLE
  617. #ifdef used_and_not_const_char_pointer
  618. static int uart00_console_read(struct uart_port *port, char *s, u_int count)
  619. {
  620. unsigned int status;
  621. int c;
  622. #ifdef DEBUG
  623. printk("uart00_console_read() calledn");
  624. #endif
  626. c = 0;
  627. while (c < count) {
  628. status = UART_GET_RSR(port);
  629.   if (UART_RX_DATA(status)) {
  630. *s++ = UART_GET_CHAR(port);
  631. c++;
  632. } else {
  633. // nothing more to get, return
  634. return c;
  635. }
  636. }
  637. // return the count
  638. return c;
  639. }
  640. #endif
  641. static void uart00_console_write(struct console *co, const char *s, unsigned count)
  642. {
  643. #ifdef CONFIG_ARCH_CAMELOT
  644. struct uart_port *port = &uart00_ports[0];
  645. unsigned int status, old_ies;
  646. int i;
  648. /*
  649.  * First save the CR then disable the interrupts
  650.  */
  651. old_ies = UART_GET_IES(port);
  652. UART_PUT_IEC(port,0xff);
  654. /*
  655.  * Now, do each character
  656.  */
  657. for (i = 0; i < count; i++) {
  658. do {
  659. status = UART_GET_TSR(port);
  660. } while (!UART_TX_READY(status));
  661. UART_PUT_CHAR(port, s[i]);
  662. if (s[i] == 'n') {
  663. do {
  664. status = UART_GET_TSR(port);
  665. } while (!UART_TX_READY(status));
  666. UART_PUT_CHAR(port, 'r');
  667. }
  668. }
  670. /*
  671.  * Finally, wait for transmitter to become empty
  672.  * and restore the IES
  673.  */
  674. do {
  675. status = UART_GET_TSR(port);
  676. } while (status & UART_TSR_TX_LEVEL_MSK);
  677. UART_PUT_IES(port, old_ies);
  678. #endif
  679. }
  681. static kdev_t uart00_console_device(struct console *co)
  682. {
  683. return MKDEV(SERIAL_UART00_MAJOR, SERIAL_UART00_MINOR + co->index);
  684. }
  686. static int uart00_console_wait_key(struct console *co)
  687. {
  688. #ifdef CONFIG_ARCH_CAMELOT
  689. struct uart_port *port = &uart00_ports[0];
  690. unsigned int status;
  692. do {
  693. status = UART_GET_RSR(port);
  694. } while (!UART_RX_DATA(status));
  695. return UART_GET_CHAR(port);
  696. #else
  697. return 0;
  698. #endif
  699. }
  701. static void /*__init*/ uart00_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits)
  702. {
  703. u_int uart_mc, quot;
  704. uart_mc= UART_GET_MC(port);
  706. *parity = 'n';
  707. if (uart_mc & UART_MC_PE_MSK) {
  708. if (uart_mc & UART_MC_EP_MSK)
  709. *parity = 'e';
  710. else
  711. *parity = 'o';
  712. }
  714. switch (uart_mc & UART_MC_CLS_MSK){
  716. case UART_MC_CLS_CHARLEN_5:
  717. *bits = 5;
  718. break;
  719. case UART_MC_CLS_CHARLEN_6:
  720. *bits = 6;
  721. break;
  722. case UART_MC_CLS_CHARLEN_7:
  723. *bits = 7;
  724. break;
  725. case UART_MC_CLS_CHARLEN_8:
  726. *bits = 8;
  727. break;
  728. }
  729. quot = UART_GET_DIV_LO(port) | (UART_GET_DIV_HI(port) << 8);
  730. *baud = port->uartclk / (16 *quot );
  731. }
  733. static int __init uart00_console_setup(struct console *co, char *options)
  734. {
  735. struct uart_port *port;
  736. int baud = 38400;
  737. int bits = 8;
  738. int parity = 'n';
  739. int flow= 'n';
  741. #ifdef CONFIG_ARCH_CAMELOT
  742. /*
  743.  * Check whether an invalid uart number has been specified, and
  744.  * if so, search for the first available port that does have
  745.  * console support.
  746.  */
  747. port = &uart00_ports[0];
  748. co->index = 0;
  749. #else
  750. return -ENODEV;
  751. #endif
  753. if (options)
  754. uart_parse_options(options, &baud, &parity, &bits, &flow);
  755. else
  756. uart00_console_get_options(port, &baud, &parity, &bits);
  758. return uart_set_options(port, co, baud, parity, bits, flow);
  759. }
  761. static struct console uart00_console = {
  762. name:           SERIAL_UART00_NAME,
  763. write: uart00_console_write,
  764. #ifdef used_and_not_const_char_pointer
  765. read: uart00_console_read,
  766. #endif
  767. device: uart00_console_device,
  768. wait_key: uart00_console_wait_key,
  769. setup: uart00_console_setup,
  770. flags: CON_PRINTBUFFER,
  771. index: 0,
  772. };
  774. void __init uart00_console_init(void)
  775. {
  776. register_console(&uart00_console);
  777. }
  779. #define UART00_CONSOLE &uart00_console
  780. #else
  781. #define UART00_CONSOLE NULL
  782. #endif
  784. static struct uart_driver uart00_reg = {
  785. owner:                  NULL,
  786. normal_major: SERIAL_UART00_MAJOR,
  787. normal_name: SERIAL_UART00_NAME,
  788. normal_driver: &normal,
  789. callout_major: CALLOUT_UART00_MAJOR,
  790. callout_name: CALLOUT_UART00_NAME,
  791. callout_driver: &callout,
  792. table: uart00_table,
  793. termios: uart00_termios,
  794. termios_locked: uart00_termios_locked,
  795. minor: SERIAL_UART00_MINOR,
  796. nr: UART_NR,
  797. port: &uart00_ports,
  798. state: NULL,
  799. cons: UART00_CONSOLE,
  800. };
  802. static int __init uart00_init(void)
  803. {
  804. printk(KERN_WARNING "serial_uart00:Using temporary major/minor pairs - these WILL change in the futuren");
  806. return uart_register_driver(&uart00_reg);
  807. }
  810. __initcall(uart00_init);