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

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

嵌入式Linux

开发平台：

Unix_Linux

serial_sa1100.c：源码内容
  1. /*
  2.  *  linux/drivers/char/serial_sa1100.c
  3.  *
  4.  *  Driver for SA11x0 serial ports
  5.  *
  6.  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
  7.  *
  8.  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
  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_sa1100.c,v 1.14.2.3 2001/11/27 17:35:39 rmk Exp $
  25.  *
  26.  */
  27. #include <linux/config.h>
  28. #include <linux/module.h>
  29. #include <linux/errno.h>
  30. #include <linux/signal.h>
  31. #include <linux/sched.h>
  32. #include <linux/interrupt.h>
  33. #include <linux/tty.h>
  34. #include <linux/tty_flip.h>
  35. #include <linux/major.h>
  36. #include <linux/string.h>
  37. #include <linux/fcntl.h>
  38. #include <linux/ptrace.h>
  39. #include <linux/ioport.h>
  40. #include <linux/mm.h>
  41. #include <linux/slab.h>
  42. #include <linux/init.h>
  43. #include <linux/circ_buf.h>
  44. #include <linux/serial.h>
  45. #include <linux/console.h>
  46. #include <linux/sysrq.h>
  48. #include <asm/system.h>
  49. #include <asm/io.h>
  50. #include <asm/irq.h>
  51. #include <asm/uaccess.h>
  52. #include <asm/bitops.h>
  53. #include <asm/hardware.h>
  54. #include <asm/mach/serial_sa1100.h>
  56. #if defined(CONFIG_SERIAL_SA1100_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  57. #define SUPPORT_SYSRQ
  58. #endif
  60. #include <linux/serial_core.h>
  62. /* We've been assigned a range on the "Low-density serial ports" major */
  63. #define SERIAL_SA1100_MAJOR 204
  64. #define CALLOUT_SA1100_MAJOR 205
  65. #define MINOR_START 5
  67. #define NR_PORTS 3
  69. #define SA1100_ISR_PASS_LIMIT 256
  71. /*
  72.  * Convert from ignore_status_mask or read_status_mask to UTSR[01]
  73.  */
  74. #define SM_TO_UTSR0(x) ((x) & 0xff)
  75. #define SM_TO_UTSR1(x) ((x) >> 8)
  76. #define UTSR0_TO_SM(x) ((x))
  77. #define UTSR1_TO_SM(x) ((x) << 8)
  79. #define UART_GET_UTCR0(port) __raw_readl((port)->membase + UTCR0)
  80. #define UART_GET_UTCR1(port) __raw_readl((port)->membase + UTCR1)
  81. #define UART_GET_UTCR2(port) __raw_readl((port)->membase + UTCR2)
  82. #define UART_GET_UTCR3(port) __raw_readl((port)->membase + UTCR3)
  83. #define UART_GET_UTSR0(port) __raw_readl((port)->membase + UTSR0)
  84. #define UART_GET_UTSR1(port) __raw_readl((port)->membase + UTSR1)
  85. #define UART_GET_CHAR(port) __raw_readl((port)->membase + UTDR)
  87. #define UART_PUT_UTCR0(port,v) __raw_writel((v),(port)->membase + UTCR0)
  88. #define UART_PUT_UTCR1(port,v) __raw_writel((v),(port)->membase + UTCR1)
  89. #define UART_PUT_UTCR2(port,v) __raw_writel((v),(port)->membase + UTCR2)
  90. #define UART_PUT_UTCR3(port,v) __raw_writel((v),(port)->membase + UTCR3)
  91. #define UART_PUT_UTSR0(port,v) __raw_writel((v),(port)->membase + UTSR0)
  92. #define UART_PUT_UTSR1(port,v) __raw_writel((v),(port)->membase + UTSR1)
  93. #define UART_PUT_CHAR(port,v) __raw_writel((v),(port)->membase + UTDR)
  95. /*
  96.  * This is the size of our serial port register set.
  97.  */
  98. #define UART_PORT_SIZE 0x24
  100. static struct tty_driver normal, callout;
  101. static struct tty_struct *sa1100_table[NR_PORTS];
  102. static struct termios *sa1100_termios[NR_PORTS], *sa1100_termios_locked[NR_PORTS];
  103. static int (*sa1100_open)(struct uart_port *, struct uart_info *);
  104. static void (*sa1100_close)(struct uart_port *, struct uart_info *);
  105. #ifdef SUPPORT_SYSRQ
  106. static struct console sa1100_console;
  107. #endif
  109. /*
  110.  * interrupts disabled on entry
  111.  */
  112. static void sa1100_stop_tx(struct uart_port *port, u_int from_tty)
  113. {
  114. u32 utcr3 = UART_GET_UTCR3(port);
  115. UART_PUT_UTCR3(port, utcr3 & ~UTCR3_TIE);
  116. port->read_status_mask &= ~UTSR0_TO_SM(UTSR0_TFS);
  117. }
  119. /*
  120.  * interrupts may not be disabled on entry
  121.  */
  122. static void sa1100_start_tx(struct uart_port *port, u_int nonempty, u_int from_tty)
  123. {
  124. if (nonempty) {
  125. unsigned long flags;
  126. u32 utcr3;
  128. local_irq_save(flags);
  129. utcr3 = UART_GET_UTCR3(port);
  130. port->read_status_mask |= UTSR0_TO_SM(UTSR0_TFS);
  131. UART_PUT_UTCR3(port, utcr3 | UTCR3_TIE);
  132. local_irq_restore(flags);
  133. }
  134. }
  136. /*
  137.  * Interrupts enabled
  138.  */
  139. static void sa1100_stop_rx(struct uart_port *port)
  140. {
  141. u32 utcr3 = UART_GET_UTCR3(port);
  142. UART_PUT_UTCR3(port, utcr3 & ~UTCR3_RIE);
  143. }
  145. /*
  146.  * No modem control lines
  147.  */
  148. static void sa1100_enable_ms(struct uart_port *port)
  149. {
  150. }
  152. static void
  153. sa1100_rx_chars(struct uart_info *info, struct pt_regs *regs)
  154. {
  155. struct tty_struct *tty = info->tty;
  156. unsigned int status, ch, flg, ignored = 0;
  157. struct uart_port *port = info->port;
  159. status = UTSR1_TO_SM(UART_GET_UTSR1(port)) | UTSR0_TO_SM(UART_GET_UTSR0(port));
  160. while (status & UTSR1_TO_SM(UTSR1_RNE)) {
  161. ch = UART_GET_CHAR(port);
  163. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  164. goto ignore_char;
  165. port->icount.rx++;
  167. flg = TTY_NORMAL;
  169. /*
  170.  * note that the error handling code is
  171.  * out of the main execution path
  172.  */
  173. if (status & UTSR1_TO_SM(UTSR1_PRE | UTSR1_FRE | UTSR1_ROR))
  174. goto handle_error;
  176. if (uart_handle_sysrq_char(info, ch, regs))
  177. goto ignore_char;
  179. error_return:
  180. *tty->flip.flag_buf_ptr++ = flg;
  181. *tty->flip.char_buf_ptr++ = ch;
  182. tty->flip.count++;
  183. ignore_char:
  184. status = UTSR1_TO_SM(UART_GET_UTSR1(port)) | UTSR0_TO_SM(UART_GET_UTSR0(port));
  185. }
  186. out:
  187. tty_flip_buffer_push(tty);
  188. return;
  190. handle_error:
  191. if (status & UTSR1_TO_SM(UTSR1_PRE))
  192. port->icount.parity++;
  193. else if (status & UTSR1_TO_SM(UTSR1_FRE))
  194. port->icount.frame++;
  195. if (status & UTSR1_TO_SM(UTSR1_ROR))
  196. port->icount.overrun++;
  198. if (status & port->ignore_status_mask) {
  199. if (++ignored > 100)
  200. goto out;
  201. goto ignore_char;
  202. }
  204. status &= port->read_status_mask;
  206. if (status & UTSR1_TO_SM(UTSR1_PRE))
  207. flg = TTY_PARITY;
  208. else if (status & UTSR1_TO_SM(UTSR1_FRE))
  209. flg = TTY_FRAME;
  211. if (status & UTSR1_TO_SM(UTSR1_ROR)) {
  212. /*
  213.  * overrun does *not* affect the character
  214.  * we read from the FIFO
  215.  */
  216. *tty->flip.flag_buf_ptr++ = flg;
  217. *tty->flip.char_buf_ptr++ = ch;
  218. tty->flip.count++;
  219. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  220. goto ignore_char;
  221. ch = 0;
  222. flg = TTY_OVERRUN;
  223. }
  224. #ifdef SUPPORT_SYSRQ
  225. info->sysrq = 0;
  226. #endif
  227. goto error_return;
  228. }
  230. static void sa1100_tx_chars(struct uart_info *info)
  231. {
  232. struct uart_port *port = info->port;
  234. if (port->x_char) {
  235. UART_PUT_CHAR(port, port->x_char);
  236. port->icount.tx++;
  237. port->x_char = 0;
  238. return;
  239. }
  240. if (info->xmit.head == info->xmit.tail
  241.     || info->tty->stopped
  242.     || info->tty->hw_stopped) {
  243. sa1100_stop_tx(info->port, 0);
  244. return;
  245. }
  247. /*
  248.  * Tried using FIFO (not checking TNF) for fifo fill:
  249.  * still had the '4 bytes repeated' problem.
  250.  */
  251. while (UART_GET_UTSR1(port) & UTSR1_TNF) {
  252. UART_PUT_CHAR(port, info->xmit.buf[info->xmit.tail]);
  253. info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1);
  254. port->icount.tx++;
  255. if (info->xmit.head == info->xmit.tail)
  256. break;
  257. }
  259. if (CIRC_CNT(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE) <
  260. WAKEUP_CHARS)
  261. uart_event(info, EVT_WRITE_WAKEUP);
  263. if (info->xmit.head == info->xmit.tail)
  264. sa1100_stop_tx(info->port, 0);
  265. }
  267. static void sa1100_int(int irq, void *dev_id, struct pt_regs *regs)
  268. {
  269. struct uart_info *info = dev_id;
  270. struct uart_port *port = info->port;
  271. unsigned int status, pass_counter = 0;
  273. status = UART_GET_UTSR0(port);
  274. status &= (SM_TO_UTSR0(port->read_status_mask) | ~UTSR0_TFS);
  275. do {
  276. if (status & (UTSR0_RFS | UTSR0_RID)) {
  277. /* Clear the receiver idle bit, if set */
  278. if (status & UTSR0_RID)
  279. UART_PUT_UTSR0(port, UTSR0_RID);
  280. sa1100_rx_chars(info, regs);
  281. }
  283. /* Clear the relevent break bits */
  284. if (status & (UTSR0_RBB | UTSR0_REB))
  285. UART_PUT_UTSR0(port, status & (UTSR0_RBB | UTSR0_REB));
  287. if (status & UTSR0_RBB)
  288. port->icount.brk++;
  290. if (status & UTSR0_REB) {
  291. #ifdef SUPPORT_SYSRQ
  292. if (port->line == sa1100_console.index &&
  293.     !info->sysrq) {
  294. info->sysrq = jiffies + HZ*5;
  295. }
  296. #endif
  297. }
  298. if (status & UTSR0_TFS)
  299. sa1100_tx_chars(info);
  300. if (pass_counter++ > SA1100_ISR_PASS_LIMIT)
  301. break;
  302. status = UART_GET_UTSR0(port);
  303. status &= (SM_TO_UTSR0(port->read_status_mask) | ~UTSR0_TFS);
  304. } while (status & (UTSR0_TFS | UTSR0_RFS | UTSR0_RID));
  305. }
  307. /*
  308.  * Return TIOCSER_TEMT when transmitter is not busy.
  309.  */
  310. static u_int sa1100_tx_empty(struct uart_port *port)
  311. {
  312. return UART_GET_UTSR1(port) & UTSR1_TBY ? 0 : TIOCSER_TEMT;
  313. }
  315. static u_int sa1100_get_mctrl(struct uart_port *port)
  316. {
  317. return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
  318. }
  320. static void sa1100_set_mctrl(struct uart_port *port, u_int mctrl)
  321. {
  322. }
  324. /*
  325.  * Interrupts always disabled.
  326.  */
  327. static void sa1100_break_ctl(struct uart_port *port, int break_state)
  328. {
  329. u_int utcr3;
  331. utcr3 = UART_GET_UTCR3(port);
  332. if (break_state == -1)
  333. utcr3 |= UTCR3_BRK;
  334. else
  335. utcr3 &= ~UTCR3_BRK;
  336. UART_PUT_UTCR3(port, utcr3);
  337. }
  339. static int sa1100_startup(struct uart_port *port, struct uart_info *info)
  340. {
  341. int retval;
  343. /*
  344.  * Allocate the IRQ
  345.  */
  346. retval = request_irq(port->irq, sa1100_int, 0, "serial_sa1100", info);
  347. if (retval)
  348. return retval;
  350. /*
  351.  * If there is a specific "open" function (to register
  352.  * control line interrupts)
  353.  */
  354. if (sa1100_open) {
  355. retval = sa1100_open(port, info);
  356. if (retval) {
  357. free_irq(port->irq, info);
  358. return retval;
  359. }
  360. }
  362. /*
  363.  * Finally, clear and enable interrupts
  364.  */
  365. UART_PUT_UTSR0(port, -1);
  366. UART_PUT_UTCR3(port, UTCR3_RXE | UTCR3_TXE | UTCR3_RIE);
  368. return 0;
  369. }
  371. static void sa1100_shutdown(struct uart_port *port, struct uart_info *info)
  372. {
  373. /*
  374.  * Free the interrupt
  375.  */
  376. free_irq(port->irq, info);
  378. /*
  379.  * If there is a specific "close" function (to unregister
  380.  * control line interrupts)
  381.  */
  382. if (sa1100_close)
  383. sa1100_close(port, info);
  385. /*
  386.  * Disable all interrupts, port and break condition.
  387.  */
  388. UART_PUT_UTCR3(port, 0);
  389. }
  391. static void sa1100_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot)
  392. {
  393. unsigned long flags;
  394. u_int utcr0, old_utcr3;
  396. /* byte size and parity */
  397. switch (cflag & CSIZE) {
  398. case CS7: utcr0 = 0; break;
  399. default: utcr0 = UTCR0_DSS; break;
  400. }
  401. if (cflag & CSTOPB)
  402. utcr0 |= UTCR0_SBS;
  403. if (cflag & PARENB) {
  404. utcr0 |= UTCR0_PE;
  405. if (!(cflag & PARODD))
  406. utcr0 |= UTCR0_OES;
  407. }
  409. port->read_status_mask &= UTSR0_TO_SM(UTSR0_TFS);
  410. port->read_status_mask |= UTSR1_TO_SM(UTSR1_ROR);
  411. if (iflag & INPCK)
  412. port->read_status_mask |= UTSR1_TO_SM(UTSR1_FRE | UTSR1_PRE);
  413. if (iflag & (BRKINT | PARMRK))
  414. port->read_status_mask |= UTSR0_TO_SM(UTSR0_RBB | UTSR0_REB);
  416. /*
  417.  * Characters to ignore
  418.  */
  419. port->ignore_status_mask = 0;
  420. if (iflag & IGNPAR)
  421. port->ignore_status_mask |= UTSR1_TO_SM(UTSR1_FRE | UTSR1_PRE);
  422. if (iflag & IGNBRK) {
  423. port->ignore_status_mask |= UTSR0_TO_SM(UTSR0_RBB | UTSR0_REB);
  424. /*
  425.  * If we're ignoring parity and break indicators,
  426.  * ignore overruns too (for real raw support).
  427.  */
  428. if (iflag & IGNPAR)
  429. port->ignore_status_mask |= UTSR1_TO_SM(UTSR1_ROR);
  430. }
  432. /* first, disable interrupts and drain transmitter */
  433. local_irq_save(flags);
  434. old_utcr3 = UART_GET_UTCR3(port);
  435. UART_PUT_UTCR3(port, old_utcr3 & ~(UTCR3_RIE | UTCR3_TIE));
  436. local_irq_restore(flags);
  437. while (UART_GET_UTSR1(port) & UTSR1_TBY);
  439. /* then, disable everything */
  440. UART_PUT_UTCR3(port, 0);
  442. /* set the parity, stop bits and data size */
  443. UART_PUT_UTCR0(port, utcr0);
  445. /* set the baud rate */
  446. quot -= 1;
  447. UART_PUT_UTCR1(port, ((quot & 0xf00) >> 8));
  448. UART_PUT_UTCR2(port, (quot & 0xff));
  450. UART_PUT_UTSR0(port, -1);
  452. UART_PUT_UTCR3(port, old_utcr3);
  453. }
  455. static const char *sa1100_type(struct uart_port *port)
  456. {
  457. return port->type == PORT_SA1100 ? "SA1100" : NULL;
  458. }
  460. /*
  461.  * Release the memory region(s) being used by 'port'.
  462.  */
  463. static void sa1100_release_port(struct uart_port *port)
  464. {
  465. release_mem_region(port->mapbase, UART_PORT_SIZE);
  466. }
  468. /*
  469.  * Request the memory region(s) being used by 'port'.
  470.  */
  471. static int sa1100_request_port(struct uart_port *port)
  472. {
  473. return request_mem_region(port->mapbase, UART_PORT_SIZE,
  474. "serial_sa1100") != NULL ? 0 : -EBUSY;
  475. }
  477. /*
  478.  * Configure/autoconfigure the port.
  479.  */
  480. static void sa1100_config_port(struct uart_port *port, int flags)
  481. {
  482. if (flags & UART_CONFIG_TYPE && sa1100_request_port(port) == 0)
  483. port->type = PORT_SA1100;
  484. }
  486. /*
  487.  * Verify the new serial_struct (for TIOCSSERIAL).
  488.  * The only change we allow are to the flags and type, and
  489.  * even then only between PORT_SA1100 and PORT_UNKNOWN
  490.  */
  491. static int sa1100_verify_port(struct uart_port *port, struct serial_struct *ser)
  492. {
  493. int ret = 0;
  494. if (ser->type != PORT_UNKNOWN && ser->type != PORT_SA1100)
  495. ret = -EINVAL;
  496. if (port->irq != ser->irq)
  497. ret = -EINVAL;
  498. if (ser->io_type != SERIAL_IO_MEM)
  499. ret = -EINVAL;
  500. if (port->uartclk / 16 != ser->baud_base)
  501. ret = -EINVAL;
  502. if ((void *)port->mapbase != ser->iomem_base)
  503. ret = -EINVAL;
  504. if (port->iobase != ser->port)
  505. ret = -EINVAL;
  506. if (ser->hub6 != 0)
  507. ret = -EINVAL;
  508. return ret;
  509. }
  511. static struct uart_ops sa1100_pops = {
  512. tx_empty: sa1100_tx_empty,
  513. set_mctrl: sa1100_set_mctrl,
  514. get_mctrl: sa1100_get_mctrl,
  515. stop_tx: sa1100_stop_tx,
  516. start_tx: sa1100_start_tx,
  517. stop_rx: sa1100_stop_rx,
  518. enable_ms: sa1100_enable_ms,
  519. break_ctl: sa1100_break_ctl,
  520. startup: sa1100_startup,
  521. shutdown: sa1100_shutdown,
  522. change_speed: sa1100_change_speed,
  523. type: sa1100_type,
  524. release_port: sa1100_release_port,
  525. request_port: sa1100_request_port,
  526. config_port: sa1100_config_port,
  527. verify_port: sa1100_verify_port,
  528. };
  530. static struct uart_port sa1100_ports[NR_PORTS];
  532. /*
  533.  * Setup the SA1100 serial ports.  Note that we don't include the IrDA
  534.  * port here since we have our own SIR/FIR driver (see drivers/net/irda)
  535.  *
  536.  * Note also that we support "console=ttySAx" where "x" is either 0 or 1.
  537.  * Which serial port this ends up being depends on the machine you're
  538.  * running this kernel on.  I'm not convinced that this is a good idea,
  539.  * but that's the way it traditionally works.
  540.  *
  541.  * Note that NanoEngine UART3 becomes UART2, and UART2 is no longer
  542.  * used here.
  543.  */
  544. static void sa1100_init_ports(void)
  545. {
  546. static int first = 1;
  547. int i;
  549. if (!first)
  550. return;
  551. first = 0;
  553. for (i = 0; i < NR_PORTS; i++) {
  554. sa1100_ports[i].uartclk  = 3686400;
  555. sa1100_ports[i].ops      = &sa1100_pops;
  556. sa1100_ports[i].fifosize = 8;
  557. }
  559. /*
  560.  * make transmit lines outputs, so that when the port
  561.  * is closed, the output is in the MARK state.
  562.  */
  563. PPDR |= PPC_TXD1 | PPC_TXD3;
  564. PPSR |= PPC_TXD1 | PPC_TXD3;
  565. }
  567. void __init sa1100_register_uart_fns(struct sa1100_port_fns *fns)
  568. {
  569. if (fns->enable_ms)
  570. sa1100_pops.enable_ms = fns->enable_ms;
  571. if (fns->get_mctrl)
  572. sa1100_pops.get_mctrl = fns->get_mctrl;
  573. if (fns->set_mctrl)
  574. sa1100_pops.set_mctrl = fns->set_mctrl;
  575. sa1100_open          = fns->open;
  576. sa1100_close         = fns->close;
  577. sa1100_pops.pm       = fns->pm;
  578. sa1100_pops.set_wake = fns->set_wake;
  579. }
  581. void __init sa1100_register_uart(int idx, int port)
  582. {
  583. if (idx >= NR_PORTS) {
  584. printk(KERN_ERR __FUNCTION__ ": bad index number %dn", idx);
  585. return;
  586. }
  588. switch (port) {
  589. case 1:
  590. sa1100_ports[idx].membase = (void *)&Ser1UTCR0;
  591. sa1100_ports[idx].mapbase = _Ser1UTCR0;
  592. sa1100_ports[idx].irq     = IRQ_Ser1UART;
  593. sa1100_ports[idx].iotype  = SERIAL_IO_MEM;
  594. sa1100_ports[idx].flags   = ASYNC_BOOT_AUTOCONF;
  595. break;
  597. case 2:
  598. sa1100_ports[idx].membase = (void *)&Ser2UTCR0;
  599. sa1100_ports[idx].mapbase = _Ser2UTCR0;
  600. sa1100_ports[idx].irq     = IRQ_Ser2ICP;
  601. sa1100_ports[idx].iotype  = SERIAL_IO_MEM;
  602. sa1100_ports[idx].flags   = ASYNC_BOOT_AUTOCONF;
  603. break;
  605. case 3:
  606. sa1100_ports[idx].membase = (void *)&Ser3UTCR0;
  607. sa1100_ports[idx].mapbase = _Ser3UTCR0;
  608. sa1100_ports[idx].irq     = IRQ_Ser3UART;
  609. sa1100_ports[idx].iotype  = SERIAL_IO_MEM;
  610. sa1100_ports[idx].flags   = ASYNC_BOOT_AUTOCONF;
  611. break;
  613. default:
  614. printk(KERN_ERR __FUNCTION__ ": bad port number %dn", port);
  615. }
  616. }
  619. #ifdef CONFIG_SERIAL_SA1100_CONSOLE
  621. /*
  622.  * Interrupts are disabled on entering
  623.  */
  624. static void sa1100_console_write(struct console *co, const char *s, u_int count)
  625. {
  626. struct uart_port *port = sa1100_ports + co->index;
  627. u_int old_utcr3, status, i;
  629. /*
  630.  * First, save UTCR3 and then disable interrupts
  631.  */
  632. old_utcr3 = UART_GET_UTCR3(port);
  633. UART_PUT_UTCR3(port, (old_utcr3 & ~(UTCR3_RIE | UTCR3_TIE)) | UTCR3_TXE);
  635. /*
  636.  * Now, do each character
  637.  */
  638. for (i = 0; i < count; i++) {
  639. do {
  640. status = UART_GET_UTSR1(port);
  641. } while (!(status & UTSR1_TNF));
  642. UART_PUT_CHAR(port, s[i]);
  643. if (s[i] == 'n') {
  644. do {
  645. status = UART_GET_UTSR1(port);
  646. } while (!(status & UTSR1_TNF));
  647. UART_PUT_CHAR(port, 'r');
  648. }
  649. }
  651. /*
  652.  * Finally, wait for transmitter to become empty
  653.  * and restore UTCR3
  654.  */
  655. do {
  656. status = UART_GET_UTSR1(port);
  657. } while (status & UTSR1_TBY);
  658. UART_PUT_UTCR3(port, old_utcr3);
  659. }
  661. static kdev_t sa1100_console_device(struct console *co)
  662. {
  663. return MKDEV(SERIAL_SA1100_MAJOR, MINOR_START + co->index);
  664. }
  666. static int sa1100_console_wait_key(struct console *co)
  667. {
  668. struct uart_port *port = sa1100_ports + co->index;
  669. unsigned long flags;
  670. u_int old_utcr3, status, ch;
  672. /*
  673.  * Save UTCR3 and disable interrupts
  674.  */
  675. save_flags(flags);
  676. cli();
  677. old_utcr3 = UART_GET_UTCR3(port);
  678. UART_PUT_UTCR3(port, old_utcr3 & ~(UTCR3_RIE | UTCR3_TIE));
  679. restore_flags(flags);
  681. /*
  682.  * Wait for a character
  683.  */
  684. do {
  685. status = UART_GET_UTSR1(port);
  686. } while (!(status & UTSR1_RNE));
  687. ch = UART_GET_CHAR(port);
  689. /*
  690.  * Restore UTCR3
  691.  */
  692. UART_PUT_UTCR3(port, old_utcr3);
  694. return ch;
  695. }
  697. /*
  698.  * If the port was already initialised (eg, by a boot loader), try to determine
  699.  * the current setup.
  700.  */
  701. static void __init
  702. sa1100_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits)
  703. {
  704. u_int utcr3;
  706. utcr3 = UART_GET_UTCR3(port) & (UTCR3_RXE | UTCR3_TXE);
  707. if (utcr3 == (UTCR3_RXE | UTCR3_TXE)) {
  708. /* ok, the port was enabled */
  709. u_int utcr0, quot;
  711. utcr0 = UART_GET_UTCR0(port);
  713. *parity = 'n';
  714. if (utcr0 & UTCR0_PE) {
  715. if (utcr0 & UTCR0_OES)
  716. *parity = 'e';
  717. else
  718. *parity = 'o';
  719. }
  721. if (utcr0 & UTCR0_DSS)
  722. *bits = 8;
  723. else
  724. *bits = 7;
  726. quot = UART_GET_UTCR2(port) | UART_GET_UTCR1(port) << 8;
  727. quot &= 0xfff;
  728. *baud = port->uartclk / (16 * (quot + 1));
  729. }
  730. }
  732. static int __init
  733. sa1100_console_setup(struct console *co, char *options)
  734. {
  735. struct uart_port *port;
  736. int baud = CONFIG_SA1100_DEFAULT_BAUDRATE;
  737. int bits = 8;
  738. int parity = 'n';
  739. int flow = 'n';
  741. /*
  742.  * Check whether an invalid uart number has been specified, and
  743.  * if so, search for the first available port that does have
  744.  * console support.
  745.  */
  746. port = uart_get_console(sa1100_ports, NR_PORTS, co);
  748. if (options)
  749. uart_parse_options(options, &baud, &parity, &bits, &flow);
  750. else
  751. sa1100_console_get_options(port, &baud, &parity, &bits);
  753. return uart_set_options(port, co, baud, parity, bits, flow);
  754. }
  756. static struct console sa1100_console = {
  757. name: "ttySA",
  758. write: sa1100_console_write,
  759. device: sa1100_console_device,
  760. wait_key: sa1100_console_wait_key,
  761. setup: sa1100_console_setup,
  762. flags: CON_PRINTBUFFER,
  763. index: -1,
  764. };
  766. void __init sa1100_rs_console_init(void)
  767. {
  768. sa1100_init_ports();
  769. register_console(&sa1100_console);
  770. }
  772. #define SA1100_CONSOLE &sa1100_console
  773. #else
  774. #define SA1100_CONSOLE NULL
  775. #endif
  777. static struct uart_driver sa1100_reg = {
  778. owner: THIS_MODULE,
  779. normal_major: SERIAL_SA1100_MAJOR,
  780. #ifdef CONFIG_DEVFS_FS
  781. normal_name: "ttySA%d",
  782. callout_name: "cusa%d",
  783. #else
  784. normal_name: "ttySA",
  785. callout_name: "cusa",
  786. #endif
  787. normal_driver: &normal,
  788. callout_major: CALLOUT_SA1100_MAJOR,
  789. callout_driver: &callout,
  790. table: sa1100_table,
  791. termios: sa1100_termios,
  792. termios_locked: sa1100_termios_locked,
  793. minor: MINOR_START,
  794. nr: NR_PORTS,
  795. port: sa1100_ports,
  796. cons: SA1100_CONSOLE,
  797. };
  799. static int __init sa1100_serial_init(void)
  800. {
  801. sa1100_init_ports();
  802. return uart_register_driver(&sa1100_reg);
  803. }
  805. static void __exit sa1100_serial_exit(void)
  806. {
  807. uart_unregister_driver(&sa1100_reg);
  808. }
  810. module_init(sa1100_serial_init);
  811. module_exit(sa1100_serial_exit);
  813. EXPORT_NO_SYMBOLS;
  815. MODULE_AUTHOR("Deep Blue Solutions Ltd");
  816. MODULE_DESCRIPTION("SA1100 generic serial port driver");
  817. MODULE_LICENSE("GPL");