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

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

嵌入式Linux

开发平台：

Unix_Linux

serial_core.c：源码内容
  1. /*
  2.  *  linux/drivers/char/serial_core.c
  3.  *
  4.  *  Driver core for serial ports
  5.  *
  6.  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
  7.  *
  8.  *  Copyright 1999 ARM Limited
  9.  *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24.  *
  25.  *  $Id: serial_core.c,v 1.20.2.5 2002/03/13 15:22:26 rmk Exp $
  26.  *
  27.  */
  28. #include <linux/config.h>
  29. #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/console.h>
  46. #include <linux/sysrq.h>
  47. #include <linux/pm.h>
  48. #include <linux/serial_core.h>
  50. #include <asm/system.h>
  51. #include <asm/io.h>
  52. #include <asm/irq.h>
  53. #include <asm/uaccess.h>
  54. #include <asm/bitops.h>
  56. #undef DEBUG
  58. #ifndef CONFIG_PM
  59. #define pm_access(pm) do { } while (0)
  60. #define pm_unregister(pm) do { } while (0)
  61. #endif
  63. /*
  64.  * tmp_buf is used as a temporary buffer by serial_write.  We need to
  65.  * lock it in case the copy_from_user blocks while swapping in a page,
  66.  * and some other program tries to do a serial write at the same time.
  67.  * Since the lock will only come under contention when the system is
  68.  * swapping and available memory is low, it makes sense to share one
  69.  * buffer across all the serial ports, since it significantly saves
  70.  * memory if large numbers of serial ports are open.
  71.  */
  72. static u_char *tmp_buf;
  73. static DECLARE_MUTEX(tmp_buf_sem);
  75. /*
  76.  * This is used to lock changes in serial line configuration.
  77.  */
  78. static DECLARE_MUTEX(port_sem);
  80. #define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
  82. static void uart_change_speed(struct uart_info *info, struct termios *old_termios);
  83. static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
  85. /*
  86.  * This routine is used by the interrupt handler to schedule processing in
  87.  * the software interrupt portion of the driver.  It is expected that
  88.  * interrupts will be disabled (and so the tasklet will be prevented
  89.  * from running (CHECK)).
  90.  */
  91. void uart_event(struct uart_info *info, int event)
  92. {
  93. info->event |= 1 << event;
  94. tasklet_schedule(&info->tlet);
  95. }
  97. static void uart_stop(struct tty_struct *tty)
  98. {
  99. struct uart_info *info = tty->driver_data;
  100. unsigned long flags;
  102. spin_lock_irqsave(&info->lock, flags);
  103. info->ops->stop_tx(info->port, 1);
  104. spin_unlock_irqrestore(&info->lock, flags);
  105. }
  107. static void __uart_start(struct tty_struct *tty)
  108. {
  109. struct uart_info *info = tty->driver_data;
  110. if (info->xmit.head != info->xmit.tail && info->xmit.buf &&
  111.     !tty->stopped && !tty->hw_stopped)
  112. info->ops->start_tx(info->port, 1, 1);
  113. }
  115. static void uart_start(struct tty_struct *tty)
  116. {
  117. struct uart_info *info = tty->driver_data;
  118. unsigned long flags;
  120. pm_access(info->state->pm);
  122. spin_lock_irqsave(&info->lock, flags);
  123. __uart_start(tty);
  124. spin_unlock_irqrestore(&info->lock, flags);
  125. }
  127. static void uart_tasklet_action(unsigned long data)
  128. {
  129. struct uart_info *info = (struct uart_info *)data;
  130. struct tty_struct *tty;
  132. tty = info->tty;
  133. if (!tty || !test_and_clear_bit(EVT_WRITE_WAKEUP, &info->event))
  134. return;
  136. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  137.     tty->ldisc.write_wakeup)
  138. (tty->ldisc.write_wakeup)(tty);
  139. wake_up_interruptible(&tty->write_wait);
  140. }
  142. static inline void uart_update_altspeed(struct uart_info *info)
  143. {
  144. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  145. info->tty->alt_speed = 57600;
  146. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  147. info->tty->alt_speed = 115200;
  148. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
  149. info->tty->alt_speed = 230400;
  150. if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
  151. info->tty->alt_speed = 460800;
  152. }
  154. static int uart_startup(struct uart_info *info)
  155. {
  156. unsigned long flags;
  157. unsigned long page;
  158. int retval = 0;
  160. page = get_zeroed_page(GFP_KERNEL);
  161. if (!page)
  162. return -ENOMEM;
  164. save_flags(flags); cli();
  166. if (info->flags & ASYNC_INITIALIZED) {
  167. free_page(page);
  168. goto errout;
  169. }
  171. if (info->port->type == PORT_UNKNOWN) {
  172. if (info->tty)
  173. set_bit(TTY_IO_ERROR, &info->tty->flags);
  174. free_page(page);
  175. goto errout;
  176. }
  178. if (info->xmit.buf)
  179. free_page(page);
  180. else
  181. info->xmit.buf = (unsigned char *) page;
  183. info->mctrl = 0;
  185. retval = info->ops->startup(info->port, info);
  186. if (retval) {
  187. if (capable(CAP_SYS_ADMIN)) {
  188. if (info->tty)
  189. set_bit(TTY_IO_ERROR, &info->tty->flags);
  190. retval = 0;
  191. }
  192. goto errout;
  193. }
  195. if (info->tty)
  196. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  197. info->xmit.head = info->xmit.tail = 0;
  199. /*
  200.  * Set up the tty->alt_speed kludge
  201.  */
  202. if (info->tty)
  203. uart_update_altspeed(info);
  205. /*
  206.  * and set the speed of the serial port
  207.  */
  208. uart_change_speed(info, NULL);
  210. /*
  211.  * Setup the RTS and DTR signals once the port
  212.  * is open and ready to respond.
  213.  */
  214. if (info->tty->termios->c_cflag & CBAUD)
  215. info->mctrl |= TIOCM_RTS | TIOCM_DTR;
  216. info->ops->set_mctrl(info->port, info->mctrl);
  218. info->flags |= ASYNC_INITIALIZED;
  219. retval = 0;
  221. errout:
  222. restore_flags(flags);
  223. return retval;
  224. }
  226. /*
  227.  * This routine will shutdown a serial port; interrupts are disabled, and
  228.  * DTR is dropped if the hangup on close termio flag is on.
  229.  */
  230. static void uart_shutdown(struct uart_info *info)
  231. {
  232. unsigned long flags;
  234. if (!(info->flags & ASYNC_INITIALIZED))
  235. return;
  237. save_flags(flags); cli(); /* Disable interrupts */
  239. /*
  240.  * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
  241.  * here so the queue might never be woken up
  242.  */
  243. wake_up_interruptible(&info->delta_msr_wait);
  245. /*
  246.  * Free the IRQ and disable the port
  247.  */
  248. info->ops->shutdown(info->port, info);
  250. if (info->xmit.buf) {
  251. unsigned long pg = (unsigned long) info->xmit.buf;
  252. info->xmit.buf = NULL;
  253. free_page(pg);
  254. }
  256. if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
  257. info->mctrl &= ~(TIOCM_DTR|TIOCM_RTS);
  258. info->ops->set_mctrl(info->port, info->mctrl);
  260. /* kill off our tasklet */
  261. tasklet_kill(&info->tlet);
  262. if (info->tty)
  263. set_bit(TTY_IO_ERROR, &info->tty->flags);
  265. info->flags &= ~ASYNC_INITIALIZED;
  266. restore_flags(flags);
  267. }
  269. static inline u_int uart_calculate_quot(struct uart_info *info, u_int baud)
  270. {
  271. u_int quot;
  273. /* Special case: B0 rate */
  274. if (!baud)
  275. baud = 9600;
  277. /* Old HI/VHI/custom speed handling */
  278. if (baud == 38400 &&
  279.     ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST))
  280. quot = info->state->custom_divisor;
  281. else
  282. quot = info->port->uartclk / (16 * baud);
  284. return quot;
  285. }
  287. static void uart_change_speed(struct uart_info *info, struct termios *old_termios)
  288. {
  289. struct uart_port *port = info->port;
  290. u_int quot, baud, cflag, bits, try;
  292. /*
  293.  * If we have no tty, termios, or the port does not exist,
  294.  * then we can't set the parameters for this port.
  295.  */
  296. if (!info->tty || !info->tty->termios ||
  297.     info->port->type == PORT_UNKNOWN)
  298. return;
  300. cflag = info->tty->termios->c_cflag;
  302. /* byte size and parity */
  303. switch (cflag & CSIZE) {
  304. case CS5: bits = 7;  break;
  305. case CS6: bits = 8;  break;
  306. case CS7: bits = 9;  break;
  307. default:  bits = 10; break; // CS8
  308. }
  310. if (cflag & CSTOPB)
  311. bits++;
  312. if (cflag & PARENB)
  313. bits++;
  315. for (try = 0; try < 2; try ++) {
  316. /* Determine divisor based on baud rate */
  317. baud = tty_get_baud_rate(info->tty);
  318. quot = uart_calculate_quot(info, baud);
  319. if (quot)
  320. break;
  322. /*
  323.  * Oops, the quotient was zero.  Try again with
  324.  * the old baud rate if possible.
  325.  */
  326. info->tty->termios->c_cflag &= ~CBAUD;
  327. if (old_termios) {
  328. info->tty->termios->c_cflag |=
  329.  (old_termios->c_cflag & CBAUD);
  330. old_termios = NULL;
  331. continue;
  332. }
  334. /*
  335.  * As a last resort, if the quotient is zero,
  336.  * default to 9600 bps
  337.  */
  338. info->tty->termios->c_cflag |= B9600;
  339. }
  341. info->timeout = (port->fifosize * HZ * bits * quot) /
  342.  (port->uartclk / 16);
  343. info->timeout += HZ/50; /* Add .02 seconds of slop */
  345. if (cflag & CRTSCTS)
  346. info->flags |= ASYNC_CTS_FLOW;
  347. else
  348. info->flags &= ~ASYNC_CTS_FLOW;
  349. if (cflag & CLOCAL)
  350. info->flags &= ~ASYNC_CHECK_CD;
  351. else
  352. info->flags |= ASYNC_CHECK_CD;
  354. /*
  355.  * Set up parity check flag
  356.  */
  357. #define RELEVENT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  359. pm_access(info->state->pm);
  361. info->ops->change_speed(port, cflag, info->tty->termios->c_iflag, quot);
  362. }
  364. static void uart_put_char(struct tty_struct *tty, u_char ch)
  365. {
  366. struct uart_info *info = tty->driver_data;
  367. unsigned long flags;
  369. if (!tty || !info->xmit.buf)
  370. return;
  372. spin_lock_irqsave(&info->lock, flags);
  373. if (CIRC_SPACE(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE) != 0) {
  374. info->xmit.buf[info->xmit.head] = ch;
  375. info->xmit.head = (info->xmit.head + 1) & (UART_XMIT_SIZE - 1);
  376. }
  377. spin_unlock_irqrestore(&info->lock, flags);
  378. }
  380. static void uart_flush_chars(struct tty_struct *tty)
  381. {
  382. uart_start(tty);
  383. }
  385. static int uart_write(struct tty_struct *tty, int from_user,
  386.   const u_char * buf, int count)
  387. {
  388. struct uart_info *info = tty->driver_data;
  389. unsigned long flags;
  390. int c, ret = 0;
  392. if (!tty || !info->xmit.buf || !tmp_buf)
  393. return 0;
  395. if (from_user) {
  396. down(&tmp_buf_sem);
  397. while (1) {
  398. int c1;
  399. c = CIRC_SPACE_TO_END(info->xmit.head,
  400.       info->xmit.tail,
  401.       UART_XMIT_SIZE);
  402. if (count < c)
  403. c = count;
  404. if (c <= 0)
  405. break;
  407. c -= copy_from_user(tmp_buf, buf, c);
  408. if (!c) {
  409. if (!ret)
  410. ret = -EFAULT;
  411. break;
  412. }
  413. spin_lock_irqsave(&info->lock, flags);
  414. c1 = CIRC_SPACE_TO_END(info->xmit.head,
  415.        info->xmit.tail,
  416.        UART_XMIT_SIZE);
  417. if (c1 < c)
  418. c = c1;
  419. memcpy(info->xmit.buf + info->xmit.head, tmp_buf, c);
  420. info->xmit.head = (info->xmit.head + c) &
  421.   (UART_XMIT_SIZE - 1);
  422. spin_unlock_irqrestore(&info->lock, flags);
  423. buf += c;
  424. count -= c;
  425. ret += c;
  426. }
  427. up(&tmp_buf_sem);
  428. } else {
  429. spin_lock_irqsave(&info->lock, flags);
  430. while (1) {
  431. c = CIRC_SPACE_TO_END(info->xmit.head,
  432.       info->xmit.tail,
  433.       UART_XMIT_SIZE);
  434. if (count < c)
  435. c = count;
  436. if (c <= 0)
  437. break;
  438. memcpy(info->xmit.buf + info->xmit.head, buf, c);
  439. info->xmit.head = (info->xmit.head + c) &
  440.   (UART_XMIT_SIZE - 1);
  441. buf += c;
  442. count -= c;
  443. ret += c;
  444. }
  445. spin_unlock_irqrestore(&info->lock, flags);
  446. }
  448. uart_start(tty);
  449. return ret;
  450. }
  452. static int uart_write_room(struct tty_struct *tty)
  453. {
  454. struct uart_info *info = tty->driver_data;
  456. return CIRC_SPACE(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE);
  457. }
  459. static int uart_chars_in_buffer(struct tty_struct *tty)
  460. {
  461. struct uart_info *info = tty->driver_data;
  463. return CIRC_CNT(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE);
  464. }
  466. static void uart_flush_buffer(struct tty_struct *tty)
  467. {
  468. struct uart_info *info = tty->driver_data;
  469. unsigned long flags;
  471. #ifdef DEBUG
  472. printk("uart_flush_buffer(%d) calledn",
  473.        MINOR(tty->device) - tty->driver.minor_start);
  474. #endif
  475. spin_lock_irqsave(&info->lock, flags);
  476. info->xmit.head = info->xmit.tail = 0;
  477. spin_unlock_irqrestore(&info->lock, flags);
  478. wake_up_interruptible(&tty->write_wait);
  479. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  480.     tty->ldisc.write_wakeup)
  481. (tty->ldisc.write_wakeup)(tty);
  482. }
  484. /*
  485.  * This function is used to send a high-priority XON/XOFF character to
  486.  * the device
  487.  */
  488. static void uart_send_xchar(struct tty_struct *tty, char ch)
  489. {
  490. struct uart_info *info = tty->driver_data;
  492. info->port->x_char = ch;
  493. if (ch)
  494. info->ops->start_tx(info->port, 1, 0);
  495. }
  497. static void uart_throttle(struct tty_struct *tty)
  498. {
  499. struct uart_info *info = tty->driver_data;
  500. unsigned long flags;
  502. if (I_IXOFF(tty))
  503. uart_send_xchar(tty, STOP_CHAR(tty));
  505. if (tty->termios->c_cflag & CRTSCTS) {
  506. spin_lock_irqsave(&info->lock, flags);
  507. info->mctrl &= ~TIOCM_RTS;
  508. info->ops->set_mctrl(info->port, info->mctrl);
  509. spin_unlock_irqrestore(&info->lock, flags);
  510. }
  511. }
  513. static void uart_unthrottle(struct tty_struct *tty)
  514. {
  515. struct uart_info *info = (struct uart_info *) tty->driver_data;
  516. unsigned long flags;
  518. if (I_IXOFF(tty)) {
  519. if (info->port->x_char)
  520. info->port->x_char = 0;
  521. else
  522. uart_send_xchar(tty, START_CHAR(tty));
  523. }
  525. if (tty->termios->c_cflag & CRTSCTS) {
  526. spin_lock_irqsave(&info->lock, flags);
  527. info->mctrl |= TIOCM_RTS;
  528. info->ops->set_mctrl(info->port, info->mctrl);
  529. spin_unlock_irqrestore(&info->lock, flags);
  530. }
  531. }
  533. static int uart_get_info(struct uart_info *info, struct serial_struct *retinfo)
  534. {
  535. struct uart_state *state = info->state;
  536. struct uart_port *port = info->port;
  537. struct serial_struct tmp;
  539. memset(&tmp, 0, sizeof(tmp));
  540. tmp.type    = port->type;
  541. tmp.line    = port->line;
  542. tmp.port    = port->iobase;
  543. if (HIGH_BITS_OFFSET)
  544. tmp.port_high = port->iobase >> HIGH_BITS_OFFSET;
  545. tmp.irq    = port->irq;
  546. tmp.flags    = port->flags;
  547. tmp.xmit_fifo_size = port->fifosize;
  548. tmp.baud_base    = port->uartclk / 16;
  549. tmp.close_delay    = state->close_delay;
  550. tmp.closing_wait   = state->closing_wait;
  551. tmp.custom_divisor = state->custom_divisor;
  552. tmp.hub6    = port->hub6;
  553. tmp.io_type        = port->iotype;
  554. tmp.iomem_reg_shift= port->regshift;
  555. tmp.iomem_base     = (void *)port->mapbase;
  557. if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
  558. return -EFAULT;
  559. return 0;
  560. }
  562. static int uart_set_info(struct uart_info *info,
  563.  struct serial_struct *newinfo)
  564. {
  565. struct serial_struct new_serial;
  566. struct uart_state *state = info->state;
  567. struct uart_port *port = info->port;
  568. unsigned long new_port;
  569. unsigned int change_irq, change_port, old_flags;
  570. unsigned int old_custom_divisor;
  571. int retval = 0;
  573. if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
  574. return -EFAULT;
  576. new_port = new_serial.port;
  577. if (HIGH_BITS_OFFSET)
  578. new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET;
  580. new_serial.irq = irq_cannonicalize(new_serial.irq);
  582. /*
  583.  * This semaphore protects state->count.  It is also
  584.  * very useful to prevent opens.  Also, take the
  585.  * port configuration semaphore to make sure that a
  586.  * module insertion/removal doesn't change anything
  587.  * under us.
  588.  */
  589. down(&port_sem);
  590. down(&state->count_sem);
  592. change_irq  = new_serial.irq != port->irq;
  594. /*
  595.  * Since changing the 'type' of the port changes its resource
  596.  * allocations, we should treat type changes the same as
  597.  * IO port changes.
  598.  */
  599. change_port = new_port != port->iobase ||
  600.       (unsigned long)new_serial.iomem_base != port->mapbase ||
  601.       new_serial.hub6 != port->hub6 ||
  602.       new_serial.io_type != port->iotype ||
  603.       new_serial.iomem_reg_shift != port->regshift ||
  604.       new_serial.type != port->type;
  606. old_flags = port->flags;
  607. old_custom_divisor = state->custom_divisor;
  609. if (!capable(CAP_SYS_ADMIN)) {
  610. retval = -EPERM;
  611. if (change_irq || change_port ||
  612.     (new_serial.baud_base != port->uartclk / 16) ||
  613.     (new_serial.close_delay != state->close_delay) ||
  614.     (new_serial.closing_wait != state->closing_wait) ||
  615.     (new_serial.xmit_fifo_size != port->fifosize) ||
  616.     ((new_serial.flags & ~ASYNC_USR_MASK) !=
  617.      (port->flags & ~ASYNC_USR_MASK)))
  618. goto exit;
  619. port->flags = ((port->flags & ~ASYNC_USR_MASK) |
  620.        (new_serial.flags & ASYNC_USR_MASK));
  621. info->flags = ((info->flags & ~ASYNC_USR_MASK) |
  622.        (new_serial.flags & ASYNC_USR_MASK));
  623. state->custom_divisor = new_serial.custom_divisor;
  624. goto check_and_exit;
  625. }
  627. /*
  628.  * Ask the low level driver to verify the settings.
  629.  */
  630. if (port->ops->verify_port)
  631. retval = port->ops->verify_port(port, &new_serial);
  633. if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) ||
  634.     (new_serial.baud_base < 9600))
  635. retval = -EINVAL;
  637. if (retval)
  638. goto exit;
  640. if (change_port || change_irq) {
  641. retval = -EBUSY;
  643. /*
  644.  * Make sure that we are the sole user of this port.
  645.  */
  646. if (state->count > 1)
  647. goto exit;
  649. /*
  650.  * We need to shutdown the serial port at the old
  651.  * port/type/irq combination.
  652.  */
  653. uart_shutdown(info);
  654. }
  656. if (change_port) {
  657. unsigned long old_iobase, old_mapbase;
  658. unsigned int old_type, old_iotype, old_hub6, old_shift;
  660. old_iobase = port->iobase;
  661. old_mapbase = port->mapbase;
  662. old_type = port->type;
  663. old_hub6 = port->hub6;
  664. old_iotype = port->iotype;
  665. old_shift = port->regshift;
  667. /*
  668.  * Free and release old regions
  669.  */
  670. if (old_type != PORT_UNKNOWN)
  671. port->ops->release_port(port);
  673. port->iobase = new_port;
  674. port->type = new_serial.type;
  675. port->hub6 = new_serial.hub6;
  676. port->iotype = new_serial.io_type;
  677. port->regshift = new_serial.iomem_reg_shift;
  678. port->mapbase = (unsigned long)new_serial.iomem_base;
  680. /*
  681.  * Claim and map the new regions
  682.  */
  683. if (port->type != PORT_UNKNOWN)
  684. retval = port->ops->request_port(port);
  686. /*
  687.  * If we fail to request resources for the
  688.  * new port, try to restore the old settings.
  689.  */
  690. if (retval && old_type != PORT_UNKNOWN) {
  691. port->iobase = old_iobase;
  692. port->type = old_type;
  693. port->hub6 = old_hub6;
  694. port->iotype = old_iotype;
  695. port->regshift = old_shift;
  696. port->mapbase = old_mapbase;
  697. retval = port->ops->request_port(port);
  698. /*
  699.  * If we failed to restore the old settings,
  700.  * we fail like this.
  701.  */
  702. if (retval)
  703. port->type = PORT_UNKNOWN;
  705. /*
  706.  * We failed anyway.
  707.  */
  708. retval = -EBUSY;
  709. }
  710. }
  712. port->irq  = new_serial.irq;
  713. port->uartclk = new_serial.baud_base * 16;
  714. port->flags = ((port->flags & ~ASYNC_FLAGS) |
  715. (new_serial.flags & ASYNC_FLAGS));
  716. info->flags = ((port->flags & ~ASYNC_INTERNAL_FLAGS) |
  717.        (info->flags & ASYNC_INTERNAL_FLAGS));
  718. state->custom_divisor = new_serial.custom_divisor;
  719. state->close_delay = new_serial.close_delay * HZ / 100;
  720. state->closing_wait = new_serial.closing_wait * HZ / 100;
  721. info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
  722. port->fifosize = new_serial.xmit_fifo_size;
  724. check_and_exit:
  725. retval = 0;
  726. if (port->type == PORT_UNKNOWN)
  727. goto exit;
  728. if (info->flags & ASYNC_INITIALIZED) {
  729. if (((old_flags & info->flags) & ASYNC_SPD_MASK) ||
  730.     old_custom_divisor != state->custom_divisor) {
  731. uart_update_altspeed(info);
  732. uart_change_speed(info, NULL);
  733. }
  734. } else
  735. retval = uart_startup(info);
  736. exit:
  737. up(&state->count_sem);
  738. up(&port_sem);
  739. return retval;
  740. }
  743. /*
  744.  * uart_get_lsr_info - get line status register info
  745.  */
  746. static int uart_get_lsr_info(struct uart_info *info, unsigned int *value)
  747. {
  748. u_int result;
  749. unsigned long flags;
  751. spin_lock_irqsave(&info->lock, flags);
  752. result = info->ops->tx_empty(info->port);
  753. spin_unlock_irqrestore(&info->lock, flags);
  755. /*
  756.  * If we're about to load something into the transmit
  757.  * register, we'll pretend the transmitter isn't empty to
  758.  * avoid a race condition (depending on when the transmit
  759.  * interrupt happens).
  760.  */
  761. if (info->port->x_char ||
  762.     ((CIRC_CNT(info->xmit.head, info->xmit.tail,
  763.        UART_XMIT_SIZE) > 0) &&
  764.      !info->tty->stopped && !info->tty->hw_stopped))
  765. result &= ~TIOCSER_TEMT;
  767. return put_user(result, value);
  768. }
  770. static int uart_get_modem_info(struct uart_info *info, unsigned int *value)
  771. {
  772. unsigned int result = info->mctrl;
  774. result |= info->ops->get_mctrl(info->port);
  776. return put_user(result, value);
  777. }
  779. static int uart_set_modem_info(struct uart_info *info, unsigned int cmd,
  780.   unsigned int *value)
  781. {
  782. unsigned int arg, old;
  783. int ret = 0;
  785. if (get_user(arg, value))
  786. return -EFAULT;
  788. spin_lock_irq(&info->lock);
  789. old = info->mctrl;
  790. switch (cmd) {
  791. case TIOCMBIS: info->mctrl |= arg; break;
  792. case TIOCMBIC: info->mctrl &= ~arg; break;
  793. case TIOCMSET: info->mctrl = arg; break;
  794. default: ret = -EINVAL; break;
  795. }
  796. if (old != info->mctrl)
  797. info->ops->set_mctrl(info->port, info->mctrl);
  798. spin_unlock_irq(&info->lock);
  799. return ret;
  800. }
  802. static void uart_break_ctl(struct tty_struct *tty, int break_state)
  803. {
  804. struct uart_info *info = tty->driver_data;
  805. unsigned long flags;
  807. if (info->port->type != PORT_UNKNOWN) {
  808. spin_lock_irqsave(&info->lock, flags);
  809. info->ops->break_ctl(info->port, break_state);
  810. spin_unlock_irqrestore(&info->lock, flags);
  811. }
  812. }
  814. static int uart_do_autoconfig(struct uart_info *info)
  815. {
  816. struct uart_port *port = info->port;
  817. int flags, ret;
  819. if (!capable(CAP_SYS_ADMIN))
  820. return -EPERM;
  822. /*
  823.  * Take the 'count' lock.  This prevents count
  824.  * from incrementing, and hence any extra opens
  825.  * of the port while we're auto-configging.
  826.  */
  827. down(&info->state->count_sem);
  829. ret = -EBUSY;
  830. if (info->state->count == 1) {
  831. uart_shutdown(info);
  833. /*
  834.  * If we already have a port type configured,
  835.  * we must release its resources.
  836.  */
  837. if (port->type != PORT_UNKNOWN)
  838. port->ops->release_port(port);
  840. flags = UART_CONFIG_TYPE;
  841. if (port->flags & ASYNC_AUTO_IRQ)
  842. flags |= UART_CONFIG_IRQ;
  844. /*
  845.  * This will claim the ports resources if
  846.  * a port is found.
  847.  */
  848. port->ops->config_port(port, flags);
  850. ret = uart_startup(info);
  851. }
  852. up(&info->state->count_sem);
  853. return ret;
  854. }
  856. /*
  857.  * Called from userspace.  We can use spin_lock_irq() here.
  858.  */
  859. static int uart_ioctl(struct tty_struct *tty, struct file *file,
  860.    unsigned int cmd, unsigned long arg)
  861. {
  862. struct uart_info *info = tty->driver_data;
  863. struct uart_icount cprev, cnow;
  864. struct serial_icounter_struct icount;
  865. int ret = -ENOIOCTLCMD;
  867. if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  868.     (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
  869.     (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
  870. if (tty->flags & (1 << TTY_IO_ERROR))
  871. return -EIO;
  872. }
  874. switch (cmd) {
  875. case TIOCMGET:
  876. ret = uart_get_modem_info(info, (unsigned int *)arg);
  877. break;
  879. case TIOCMBIS:
  880. case TIOCMBIC:
  881. case TIOCMSET:
  882. ret = uart_set_modem_info(info, cmd,
  883.   (unsigned int *)arg);
  884. break;
  886. case TIOCGSERIAL:
  887. ret = uart_get_info(info, (struct serial_struct *)arg);
  888. break;
  890. case TIOCSSERIAL:
  891. ret = uart_set_info(info, (struct serial_struct *)arg);
  892. break;
  894. case TIOCSERCONFIG:
  895. ret = uart_do_autoconfig(info);
  896. break;
  898. case TIOCSERGETLSR: /* Get line status register */
  899. ret = uart_get_lsr_info(info, (unsigned int *)arg);
  900. break;
  902. /*
  903.  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
  904.  * - mask passed in arg for lines of interest
  905.  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  906.  * Caller should use TIOCGICOUNT to see which one it was
  907.  */
  908. case TIOCMIWAIT:
  909. spin_lock_irq(&info->lock);
  910. /* note the counters on entry */
  911. cprev = info->port->icount;
  912. /* Force modem status interrupts on */
  913. info->ops->enable_ms(info->port);
  914. spin_unlock_irq(&info->lock);
  915. while (1) {
  916. interruptible_sleep_on(&info->delta_msr_wait);
  917. /* see if a signal did it */
  918. if (signal_pending(current)) {
  919. ret = -ERESTARTSYS;
  920. break;
  921. }
  922. spin_lock_irq(&info->lock);
  923. cnow = info->port->icount; /* atomic copy */
  924. spin_unlock_irq(&info->lock);
  925. if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
  926.     cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
  927.      ret = -EIO; /* no change => error */
  928.      break;
  929. }
  930. if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  931.     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  932.     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
  933.     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
  934.      ret = 0;
  935.      break;
  936. }
  937. cprev = cnow;
  938. }
  939. break;
  941. /*
  942.  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
  943.  * Return: write counters to the user passed counter struct
  944.  * NB: both 1->0 and 0->1 transitions are counted except for
  945.  *     RI where only 0->1 is counted.
  946.  */
  947. case TIOCGICOUNT:
  948. spin_lock_irq(&info->lock);
  949. cnow = info->port->icount;
  950. spin_unlock_irq(&info->lock);
  952. icount.cts         = cnow.cts;
  953. icount.dsr         = cnow.dsr;
  954. icount.rng         = cnow.rng;
  955. icount.dcd         = cnow.dcd;
  956. icount.rx          = cnow.rx;
  957. icount.tx          = cnow.tx;
  958. icount.frame       = cnow.frame;
  959. icount.overrun     = cnow.overrun;
  960. icount.parity      = cnow.parity;
  961. icount.brk         = cnow.brk;
  962. icount.buf_overrun = cnow.buf_overrun;
  964. ret = copy_to_user((void *)arg, &icount, sizeof(icount))
  965. ? -EFAULT : 0;
  966. break;
  968. case TIOCSERGWILD: /* obsolete */
  969. case TIOCSERSWILD: /* obsolete */
  970. ret = 0;
  971. break;
  973. default:
  974. if (info->ops->ioctl)
  975. ret = info->ops->ioctl(info->port, cmd, arg);
  976. break;
  977. }
  978. return ret;
  979. }
  981. static void uart_set_termios(struct tty_struct *tty, struct termios *old_termios)
  982. {
  983. struct uart_info *info = tty->driver_data;
  984. unsigned long flags;
  985. unsigned int cflag = tty->termios->c_cflag;
  987. if ((cflag ^ old_termios->c_cflag) == 0 &&
  988.     RELEVENT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
  989. return;
  991. uart_change_speed(info, old_termios);
  993. spin_lock_irqsave(&info->lock, flags);
  995. /* Handle transition to B0 status */
  996. if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) {
  997. info->mctrl &= ~(TIOCM_RTS | TIOCM_DTR);
  998. info->ops->set_mctrl(info->port, info->mctrl);
  999. }
  1001. /* Handle transition away from B0 status */
  1002. if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
  1003. info->mctrl |= TIOCM_DTR;
  1004. if (!(cflag & CRTSCTS) ||
  1005.     !test_bit(TTY_THROTTLED, &tty->flags))
  1006. info->mctrl |= TIOCM_RTS;
  1007. info->ops->set_mctrl(info->port, info->mctrl);
  1008. }
  1010. /* Handle turning off CRTSCTS */
  1011. if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
  1012. tty->hw_stopped = 0;
  1013. __uart_start(tty);
  1014. }
  1015. spin_unlock_irqrestore(&info->lock, flags);
  1017. #if 0
  1018. /*
  1019.  * No need to wake up processes in open wait, since they
  1020.  * sample the CLOCAL flag once, and don't recheck it.
  1021.  * XXX  It's not clear whether the current behavior is correct
  1022.  * or not.  Hence, this may change.....
  1023.  */
  1024. if (!(old_termios->c_cflag & CLOCAL) &&
  1025.     (tty->termios->c_cflag & CLOCAL))
  1026. wake_up_interruptible(&info->open_wait);
  1027. #endif
  1028. }
  1030. /*
  1031.  * In 2.4.5, calls to this will be serialized via the BKL in
  1032.  *  linux/drivers/char/tty_io.c:tty_release()
  1033.  *  linux/drivers/char/tty_io.c:do_tty_handup()
  1034.  */
  1035. static void uart_close(struct tty_struct *tty, struct file *filp)
  1036. {
  1037. struct uart_driver *drv = (struct uart_driver *)tty->driver.driver_state;
  1038. struct uart_info *info = tty->driver_data;
  1039. struct uart_state *state;
  1040. unsigned long flags;
  1042. if (!info)
  1043. return;
  1045. state = info->state;
  1047. #ifdef DEBUG
  1048. printk("uart_close() calledn");
  1049. #endif
  1051. /*
  1052.  * This is safe, as long as the BKL exists in
  1053.  * do_tty_hangup(), and we're protected by the BKL.
  1054.  */
  1055. if (tty_hung_up_p(filp))
  1056. goto done;
  1058. down(&state->count_sem);
  1059. spin_lock_irqsave(&info->lock, flags);
  1060. if ((tty->count == 1) && (state->count != 1)) {
  1061. /*
  1062.  * Uh, oh.  tty->count is 1, which means that the tty
  1063.  * structure will be freed.  state->count should always
  1064.  * be one in these conditions.  If it's greater than
  1065.  * one, we've got real problems, since it means the
  1066.  * serial port won't be shutdown.
  1067.  */
  1068. printk("uart_close: bad serial port count; tty->count is 1, "
  1069.        "state->count is %dn", state->count);
  1070. state->count = 1;
  1071. }
  1072. if (--state->count < 0) {
  1073. printk("rs_close: bad serial port count for %s%d: %dn",
  1074.        tty->driver.name, info->port->line, state->count);
  1075. state->count = 0;
  1076. }
  1077. if (state->count) {
  1078. spin_unlock_irqrestore(&info->lock, flags);
  1079. up(&state->count_sem);
  1080. goto done;
  1081. }
  1082. info->flags |= ASYNC_CLOSING;
  1083. spin_unlock_irqrestore(&info->lock, flags);
  1084. up(&state->count_sem);
  1086. /*
  1087.  * Save the termios structure, since this port may have
  1088.  * separate termios for callout and dialin.
  1089.  */
  1090. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1091. info->state->normal_termios = *tty->termios;
  1092. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1093. info->state->callout_termios = *tty->termios;
  1094. /*
  1095.  * Now we wait for the transmit buffer to clear; and we notify
  1096.  * the line discipline to only process XON/XOFF characters.
  1097.  */
  1098. tty->closing = 1;
  1099. if (info->state->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  1100. tty_wait_until_sent(tty, info->state->closing_wait);
  1101. /*
  1102.  * At this point, we stop accepting input.  To do this, we
  1103.  * disable the receive line status interrupts.
  1104.  */
  1105. if (info->flags & ASYNC_INITIALIZED) {
  1106. info->ops->stop_rx(info->port);
  1107. /*
  1108.  * Before we drop DTR, make sure the UART transmitter
  1109.  * has completely drained; this is especially
  1110.  * important if there is a transmit FIFO!
  1111.  */
  1112. uart_wait_until_sent(tty, info->timeout);
  1113. }
  1114. uart_shutdown(info);
  1115. if (tty->driver.flush_buffer)
  1116. tty->driver.flush_buffer(tty);
  1117. if (tty->ldisc.flush_buffer)
  1118. tty->ldisc.flush_buffer(tty);
  1119. tty->closing = 0;
  1120. info->event = 0;
  1121. info->tty = NULL;
  1122. if (info->blocked_open) {
  1123. if (info->state->close_delay) {
  1124. set_current_state(TASK_INTERRUPTIBLE);
  1125. schedule_timeout(info->state->close_delay);
  1126. set_current_state(TASK_RUNNING);
  1127. }
  1128. wake_up_interruptible(&info->open_wait);
  1129. } else {
  1130. #ifdef CONFIG_PM
  1131. /*
  1132.  * Put device into D3 state.
  1133.  */
  1134. pm_send(info->state->pm, PM_SUSPEND, (void *)3);
  1135. #else
  1136. if (info->ops->pm)
  1137. info->ops->pm(info->port, 3, 0);
  1138. #endif
  1139. }
  1141. info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  1142.  ASYNC_CLOSING);
  1143. wake_up_interruptible(&info->close_wait);
  1145. done:
  1146. if (drv->owner)
  1147. __MOD_DEC_USE_COUNT(drv->owner);
  1148. }
  1150. static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
  1151. {
  1152. struct uart_info *info = (struct uart_info *) tty->driver_data;
  1153. unsigned long char_time, expire;
  1155. if (info->port->type == PORT_UNKNOWN ||
  1156.     info->port->fifosize == 0)
  1157. return;
  1159. /*
  1160.  * Set the check interval to be 1/5 of the estimated time to
  1161.  * send a single character, and make it at least 1.  The check
  1162.  * interval should also be less than the timeout.
  1163.  *
  1164.  * Note: we have to use pretty tight timings here to satisfy
  1165.  * the NIST-PCTS.
  1166.  */
  1167. char_time = (info->timeout - HZ/50) / info->port->fifosize;
  1168. char_time = char_time / 5;
  1169. if (char_time == 0)
  1170. char_time = 1;
  1171. if (timeout && timeout < char_time)
  1172. char_time = timeout;
  1173. /*
  1174.  * If the transmitter hasn't cleared in twice the approximate
  1175.  * amount of time to send the entire FIFO, it probably won't
  1176.  * ever clear.  This assumes the UART isn't doing flow
  1177.  * control, which is currently the case.  Hence, if it ever
  1178.  * takes longer than info->timeout, this is probably due to a
  1179.  * UART bug of some kind.  So, we clamp the timeout parameter at
  1180.  * 2*info->timeout.
  1181.  */
  1182. if (!timeout || timeout > 2 * info->timeout)
  1183. timeout = 2 * info->timeout;
  1185. expire = jiffies + timeout;
  1186. #ifdef DEBUG
  1187. printk("uart_wait_until_sent(%d), jiff=%lu, expire=%lu...n",
  1188.        MINOR(tty->device) - tty->driver.minor_start, jiffies,
  1189.        expire);
  1190. #endif
  1191. while (!info->ops->tx_empty(info->port)) {
  1192. set_current_state(TASK_INTERRUPTIBLE);
  1193. schedule_timeout(char_time);
  1194. if (signal_pending(current))
  1195. break;
  1196. if (timeout && time_after(jiffies, expire))
  1197. break;
  1198. }
  1199. set_current_state(TASK_RUNNING); /* might not be needed */
  1200. }
  1202. /*
  1203.  * This is called with the BKL in effect
  1204.  *  linux/drivers/char/tty_io.c:do_tty_hangup()
  1205.  */
  1206. static void uart_hangup(struct tty_struct *tty)
  1207. {
  1208. struct uart_info *info = tty->driver_data;
  1209. struct uart_state *state = info->state;
  1211. uart_flush_buffer(tty);
  1212. if (info->flags & ASYNC_CLOSING)
  1213. return;
  1214. uart_shutdown(info);
  1215. info->event = 0;
  1216. state->count = 0;
  1217. info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  1218. info->tty = NULL;
  1219. wake_up_interruptible(&info->open_wait);
  1220. }
  1222. static int uart_block_til_ready(struct tty_struct *tty, struct file *filp,
  1223. struct uart_info *info)
  1224. {
  1225. DECLARE_WAITQUEUE(wait, current);
  1226. struct uart_state *state = info->state;
  1227. unsigned long flags;
  1228. int do_clocal = 0, extra_count = 0, retval;
  1230. /*
  1231.  * If the device is in the middle of being closed, then block
  1232.  * until it's done, and then try again.
  1233.  */
  1234. if (tty_hung_up_p(filp) ||
  1235.     (info->flags & ASYNC_CLOSING)) {
  1236. if (info->flags & ASYNC_CLOSING)
  1237. interruptible_sleep_on(&info->close_wait);
  1238. return (info->flags & ASYNC_HUP_NOTIFY) ?
  1239. -EAGAIN : -ERESTARTSYS;
  1240. }
  1242. /*
  1243.  * If this is a callout device, then just make sure the normal
  1244.  * device isn't being used.
  1245.  */
  1246. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1247. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1248. return -EBUSY;
  1249. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1250.     (info->flags & ASYNC_SESSION_LOCKOUT) &&
  1251.     (info->session != current->session))
  1252. return -EBUSY;
  1253. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1254.     (info->flags & ASYNC_PGRP_LOCKOUT) &&
  1255.     (info->pgrp != current->pgrp))
  1256. return -EBUSY;
  1257. info->flags |= ASYNC_CALLOUT_ACTIVE;
  1258. return 0;
  1259. }
  1261. /*
  1262.  * If non-blocking mode is set, or the port is not enabled,
  1263.  * then make the check up front and then exit.  Note that
  1264.  * we have set TTY_IO_ERROR for a non-enabled port.
  1265.  */
  1266. if ((filp->f_flags & O_NONBLOCK) ||
  1267.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1268. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1269. return -EBUSY;
  1270. info->flags |= ASYNC_NORMAL_ACTIVE;
  1271. return 0;
  1272. }
  1274. if (info->flags & ASYNC_CALLOUT_ACTIVE) {
  1275. if (state->normal_termios.c_cflag & CLOCAL)
  1276. do_clocal = 1;
  1277. } else {
  1278. if (tty->termios->c_cflag & CLOCAL)
  1279. do_clocal = 1;
  1280. }
  1282. /*
  1283.  * Block waiting for the carrier detect and the line to become
  1284.  * free (i.e., not in use by the callout).  While we are in
  1285.  * this loop, state->count is dropped by one, so that
  1286.  * rs_close() knows when to free things.  We restore it upon
  1287.  * exit, either normal or abnormal.
  1288.  */
  1289. retval = 0;
  1290. add_wait_queue(&info->open_wait, &wait);
  1291. down(&state->count_sem);
  1292. spin_lock_irqsave(&info->lock, flags);
  1293. if (!tty_hung_up_p(filp)) {
  1294. extra_count = 1;
  1295. state->count--;
  1296. }
  1297. spin_unlock_irqrestore(&info->lock, flags);
  1298. info->blocked_open++;
  1299. up(&state->count_sem);
  1300. while (1) {
  1301. spin_lock_irqsave(&info->lock, flags);
  1302. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1303.     (tty->termios->c_cflag & CBAUD)) {
  1304. info->mctrl |= TIOCM_DTR | TIOCM_RTS;
  1305. info->ops->set_mctrl(info->port, info->mctrl);
  1306. }
  1307. spin_unlock_irqrestore(&info->lock, flags);
  1308. set_current_state(TASK_INTERRUPTIBLE);
  1309. if (tty_hung_up_p(filp) ||
  1310.     !(info->flags & ASYNC_INITIALIZED)) {
  1311. if (info->flags & ASYNC_HUP_NOTIFY)
  1312. retval = -EAGAIN;
  1313. else
  1314. retval = -ERESTARTSYS;
  1315. break;
  1316. }
  1317. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1318.     !(info->flags & ASYNC_CLOSING) &&
  1319.     (do_clocal ||
  1320.      (info->ops->get_mctrl(info->port) & TIOCM_CAR)))
  1321. break;
  1322. if (signal_pending(current)) {
  1323. retval = -ERESTARTSYS;
  1324. break;
  1325. }
  1326. schedule();
  1327. }
  1328. set_current_state(TASK_RUNNING);
  1329. remove_wait_queue(&info->open_wait, &wait);
  1330. down(&state->count_sem);
  1331. if (extra_count)
  1332. state->count++;
  1333. info->blocked_open--;
  1334. up(&state->count_sem);
  1335. if (retval)
  1336. return retval;
  1337. info->flags |= ASYNC_NORMAL_ACTIVE;
  1338. return 0;
  1339. }
  1341. static struct uart_info *uart_get(struct uart_driver *drv, int line)
  1342. {
  1343. struct uart_state *state = drv->state + line;
  1344. struct uart_info *info;
  1346. down(&state->count_sem);
  1347. state->count++;
  1348. if (state->info)
  1349. goto out;
  1351. info = kmalloc(sizeof(struct uart_info), GFP_KERNEL);
  1352. if (info) {
  1353. memset(info, 0, sizeof(struct uart_info));
  1354. init_waitqueue_head(&info->open_wait);
  1355. init_waitqueue_head(&info->close_wait);
  1356. init_waitqueue_head(&info->delta_msr_wait);
  1357. info->port  = state->port;
  1358. info->flags = info->port->flags;
  1359. info->ops   = info->port->ops;
  1360. info->state = state;
  1361. tasklet_init(&info->tlet, uart_tasklet_action,
  1362.      (unsigned long)info);
  1363. }
  1364. if (state->info)
  1365. kfree(info);
  1366. else
  1367. state->info = info;
  1368. out:
  1369. up(&state->count_sem);
  1370. return state->info;
  1371. }
  1373. /*
  1374.  * Make sure we have the temporary buffer allocated.  Note
  1375.  * that we set retval appropriately above, and we rely on
  1376.  * this.
  1377.  */
  1378. static inline int uart_alloc_tmpbuf(void)
  1379. {
  1380. if (!tmp_buf) {
  1381. unsigned long buf = get_zeroed_page(GFP_KERNEL);
  1382. if (!tmp_buf) {
  1383. if (buf)
  1384. tmp_buf = (u_char *)buf;
  1385. else
  1386. return -ENOMEM;
  1387. } else
  1388. free_page(buf);
  1389. }
  1390. return 0;
  1391. }
  1393. /*
  1394.  * In 2.4.5, calls to uart_open are serialised by the BKL in
  1395.  *   linux/fs/devices.c:chrdev_open()
  1396.  * Note that if this fails, then uart_close() _will_ be called.
  1397.  */
  1398. static int uart_open(struct tty_struct *tty, struct file *filp)
  1399. {
  1400. struct uart_driver *drv = (struct uart_driver *)tty->driver.driver_state;
  1401. struct uart_info *info;
  1402. int retval, line = MINOR(tty->device) - tty->driver.minor_start;
  1404. #ifdef DEBUG
  1405. printk("uart_open(%d) calledn", line);
  1406. #endif
  1408. retval = -ENODEV;
  1409. if (line >= tty->driver.num)
  1410. goto fail;
  1412. if (!try_inc_mod_count(drv->owner))
  1413. goto fail;
  1415. info = uart_get(drv, line);
  1416. retval = -ENOMEM;
  1417. if (!info)
  1418. goto out;
  1420. /*
  1421.  * Set the tty driver_data.  If we fail from this point on,
  1422.  * the generic tty layer will cause uart_close(), which will
  1423.  * decrement the module use count.
  1424.  */
  1425. tty->driver_data = info;
  1426. info->tty = tty;
  1427. info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
  1429. if (uart_alloc_tmpbuf())
  1430. goto fail;
  1432. /*
  1433.  * If the port is in the middle of closing, bail out now.
  1434.  */
  1435. if (tty_hung_up_p(filp) ||
  1436.     (info->flags & ASYNC_CLOSING)) {
  1437. if (info->flags & ASYNC_CLOSING)
  1438. interruptible_sleep_on(&info->close_wait);
  1439. retval = (info->flags & ASYNC_HUP_NOTIFY) ?
  1440. -EAGAIN : -ERESTARTSYS;
  1441. goto fail;
  1442. }
  1444. /*
  1445.  * Make sure the device is in D0 state.
  1446.  */
  1447. if (info->state->count == 1)
  1448. #ifdef CONFIG_PM
  1449. pm_send(info->state->pm, PM_RESUME, (void *)0);
  1450. #else
  1451. if (info->ops->pm)
  1452. info->ops->pm(info->port, 0, 3);
  1453. #endif
  1455. /*
  1456.  * Start up the serial port
  1457.  */
  1458. retval = uart_startup(info);
  1459. if (retval)
  1460. goto fail;
  1462. retval = uart_block_til_ready(tty, filp, info);
  1463. if (retval)
  1464. goto fail;
  1466. if (info->state->count == 1) {
  1467. int changed_termios = 0;
  1469. if (info->flags & ASYNC_SPLIT_TERMIOS) {
  1470. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1471. *tty->termios = info->state->normal_termios;
  1472. else
  1473. *tty->termios = info->state->callout_termios;
  1474. changed_termios = 1;
  1475. }
  1477. #ifdef CONFIG_SERIAL_CORE_CONSOLE
  1478. /*
  1479.  * Copy across the serial console cflag setting
  1480.  */
  1481. {
  1482. struct console *c = drv->cons;
  1483. if (c && c->cflag && c->index == line) {
  1484. tty->termios->c_cflag = c->cflag;
  1485. c->cflag = 0;
  1486. changed_termios = 1;
  1487. }
  1488. }
  1489. #endif
  1490. if (changed_termios)
  1491. uart_change_speed(info, NULL);
  1492. }
  1494. info->session = current->session;
  1495. info->pgrp = current->pgrp;
  1496. return 0;
  1498. out:
  1499. if (drv->owner)
  1500. __MOD_DEC_USE_COUNT(drv->owner);
  1501. fail:
  1502. return retval;
  1503. }
  1505. #ifdef CONFIG_PROC_FS
  1507. static const char *uart_type(struct uart_port *port)
  1508. {
  1509. const char *str = NULL;
  1511. if (port->ops->type)
  1512. str = port->ops->type(port);
  1514. if (!str)
  1515. str = "unknown";
  1517. return str;
  1518. }
  1520. static int uart_line_info(char *buf, struct uart_driver *drv, int i)
  1521. {
  1522. struct uart_state *state = drv->state + i;
  1523. struct uart_port *port = state->port;
  1524. char stat_buf[32];
  1525. u_int status;
  1526. int ret;
  1528. ret = sprintf(buf, "%d: uart:%s port:%08X irq:%d",
  1529. port->line, uart_type(port),
  1530. port->iobase, port->irq);
  1532. if (port->type == PORT_UNKNOWN) {
  1533. strcat(buf, "n");
  1534. return ret + 1;
  1535. }
  1537. status = port->ops->get_mctrl(port);
  1539. ret += sprintf(buf + ret, " tx:%d rx:%d",
  1540. port->icount.tx, port->icount.rx);
  1541. if (port->icount.frame)
  1542. ret += sprintf(buf + ret, " fe:%d",
  1543. port->icount.frame);
  1544. if (port->icount.parity)
  1545. ret += sprintf(buf + ret, " pe:%d",
  1546. port->icount.parity);
  1547. if (port->icount.brk)
  1548. ret += sprintf(buf + ret, " brk:%d",
  1549. port->icount.brk);
  1550. if (port->icount.overrun)
  1551. ret += sprintf(buf + ret, " oe:%d",
  1552. port->icount.overrun);
  1554. #define INFOBIT(bit,str) 
  1555. if (state->info && state->info->mctrl & (bit)) 
  1556. strcat(stat_buf, (str))
  1557. #define STATBIT(bit,str) 
  1558. if (status & (bit)) 
  1559. strcat(stat_buf, (str))
  1561. stat_buf[0] = '';
  1562. stat_buf[1] = '';
  1563. INFOBIT(TIOCM_RTS, "|RTS");
  1564. STATBIT(TIOCM_CTS, "|CTS");
  1565. INFOBIT(TIOCM_DTR, "|DTR");
  1566. STATBIT(TIOCM_DSR, "|DSR");
  1567. STATBIT(TIOCM_CAR, "|CD");
  1568. STATBIT(TIOCM_RNG, "|RI");
  1569. if (stat_buf[0])
  1570. stat_buf[0] = ' ';
  1571. strcat(stat_buf, "n");
  1573. ret += sprintf(buf + ret, stat_buf);
  1574. return ret;
  1575. }
  1577. static int uart_read_proc(char *page, char **start, off_t off,
  1578.   int count, int *eof, void *data)
  1579. {
  1580. struct tty_driver *ttydrv = data;
  1581. struct uart_driver *drv = ttydrv->driver_state;
  1582. int i, len = 0, l;
  1583. off_t begin = 0;
  1585. len += sprintf(page, "serinfo:1.0 driver%s%s revision:%sn",
  1586. "", "", "");
  1587. for (i = 0; i < drv->nr && len < PAGE_SIZE - 96; i++) {
  1588. l = uart_line_info(page + len, drv, i);
  1589. len += l;
  1590. if (len + begin > off + count)
  1591. goto done;
  1592. if (len + begin < off) {
  1593. begin += len;
  1594. len = 0;
  1595. }
  1596. }
  1597. *eof = 1;
  1598. done:
  1599. if (off >= len + begin)
  1600. return 0;
  1601. *start = page + (off - begin);
  1602. return (count < begin + len - off) ? count : (begin + len - off);
  1603. }
  1604. #endif
  1606. #ifdef CONFIG_SERIAL_CORE_CONSOLE
  1607. /*
  1608.  * Check whether an invalid uart number has been specified, and
  1609.  * if so, search for the first available port that does have
  1610.  * console support.
  1611.  */
  1612. struct uart_port * __init
  1613. uart_get_console(struct uart_port *ports, int nr, struct console *co)
  1614. {
  1615. int idx = co->index;
  1617. if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
  1618.      ports[idx].membase == NULL))
  1619. for (idx = 0; idx < nr; idx++)
  1620. if (ports[idx].iobase != 0 ||
  1621.     ports[idx].membase != NULL)
  1622. break;
  1624. co->index = idx;
  1626. return ports + idx;
  1627. }
  1629. /**
  1630.  * uart_parse_options - Parse serial port baud/parity/bits/flow contro.
  1631.  * @options: pointer to option string
  1632.  * @baud: pointer to an 'int' variable for the baud rate.
  1633.  * @parity: pointer to an 'int' variable for the parity.
  1634.  * @bits: pointer to an 'int' variable for the number of data bits.
  1635.  * @flow: pointer to an 'int' variable for the flow control character.
  1636.  *
  1637.  * uart_parse_options decodes a string containing the serial console
  1638.  * options.  The format of the string is <baud><parity><bits><flow>,
  1639.  * eg: 115200n8r
  1640.  */
  1641. void __init
  1642. uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
  1643. {
  1644. char *s = options;
  1646. *baud = simple_strtoul(s, NULL, 10);
  1647. while (*s >= '0' && *s <= '9')
  1648. s++;
  1649. if (*s)
  1650. *parity = *s++;
  1651. if (*s)
  1652. *bits = *s++ - '0';
  1653. if (*s)
  1654. *flow = *s;
  1655. }
  1657. /**
  1658.  * uart_set_options - setup the serial console parameters
  1659.  * @port: pointer to the serial ports uart_port structure
  1660.  * @co: console pointer
  1661.  * @baud: baud rate
  1662.  * @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
  1663.  * @bits: number of data bits
  1664.  * @flow: flow control character - 'r' (rts)
  1665.  */
  1666. int __init
  1667. uart_set_options(struct uart_port *port, struct console *co,
  1668.  int baud, int parity, int bits, int flow)
  1669. {
  1670. u_int cflag = CREAD | HUPCL | CLOCAL;
  1671. u_int quot;
  1673. /*
  1674.  * Construct a cflag setting.
  1675.  */
  1676. switch (baud) {
  1677. case 1200: cflag |= B1200; break;
  1678. case 2400: cflag |= B2400; break;
  1679. case 4800: cflag |= B4800; break;
  1680. case 9600: cflag |= B9600; break;
  1681. case 19200: cflag |= B19200; break;
  1682. default: cflag |= B38400;  baud = 38400; break;
  1683. case 57600: cflag |= B57600; break;
  1684. case 115200: cflag |= B115200; break;
  1685. case 230400: cflag |= B230400; break;
  1686. case 460800: cflag |= B460800; break;
  1687. }
  1689. if (bits == 7)
  1690. cflag |= CS7;
  1691. else
  1692. cflag |= CS8;
  1694. switch (parity) {
  1695. case 'o': case 'O':
  1696. cflag |= PARODD;
  1697. /*fall through*/
  1698. case 'e': case 'E':
  1699. cflag |= PARENB;
  1700. break;
  1701. }
  1703. co->cflag = cflag;
  1704. quot = (port->uartclk / (16 * baud));
  1705. port->ops->change_speed(port, cflag, 0, quot);
  1707. return 0;
  1708. }
  1710. extern void ambauart_console_init(void);
  1711. extern void anakin_console_init(void);
  1712. extern void clps711xuart_console_init(void);
  1713. extern void rs285_console_init(void);
  1714. extern void sa1100_rs_console_init(void);
  1715. extern void serial8250_console_init(void);
  1716. extern void s3c2400_console_init(void);
  1717. extern void s3c2410_console_init(void);
  1719. /*
  1720.  * Central "initialise all serial consoles" container.  Needs to be killed.
  1721.  */
  1722. void __init uart_console_init(void)
  1723. {
  1724. #ifdef CONFIG_SERIAL_AMBA_CONSOLE
  1725. ambauart_console_init();
  1726. #endif
  1727. #ifdef CONFIG_SERIAL_ANAKIN_CONSOLE
  1728. anakin_console_init();
  1729. #endif
  1730. #ifdef CONFIG_SERIAL_CLPS711X_CONSOLE
  1731. clps711xuart_console_init();
  1732. #endif
  1733. #ifdef CONFIG_SERIAL_21285_CONSOLE
  1734. rs285_console_init();
  1735. #endif
  1736. #ifdef CONFIG_SERIAL_SA1100_CONSOLE
  1737. sa1100_rs_console_init();
  1738. #endif
  1739. #ifdef CONFIG_SERIAL_8250_CONSOLE
  1740. serial8250_console_init();
  1741. #endif
  1742. #ifdef CONFIG_SERIAL_UART00_CONSOLE
  1743. uart00_console_init();
  1744. #endif
  1745. #ifdef CONFIG_SERIAL_S3C2400_CONSOLE
  1746. s3c2400_console_init();
  1747. #endif
  1748. #ifdef CONFIG_SERIAL_S3C2410_CONSOLE
  1749. s3c2410_console_init();
  1750. #endif
  1751. }
  1752. #endif /* CONFIG_SERIAL_CORE_CONSOLE */
  1754. #ifdef CONFIG_PM
  1755. /*
  1756.  *  Serial port power management.
  1757.  *
  1758.  * This is pretty coarse at the moment - either all on or all off.  We
  1759.  * should probably some day do finer power management here some day.
  1760.  *
  1761.  * We don't actually save any state; the serial driver has enough
  1762.  * state held internally to re-setup the port when we come out of D3.
  1763.  */
  1764. static int uart_pm_set_state(struct uart_state *state, int pm_state, int oldstate)
  1765. {
  1766. struct uart_port *port = state->port;
  1767. struct uart_ops *ops = port->ops;
  1768. int running = state->info &&
  1769.       state->info->flags & ASYNC_INITIALIZED;
  1771. if (port->type == PORT_UNKNOWN)
  1772. return 0;
  1774. //printk("pm: %08x: %d -> %d, %srunningn", port->iobase, dev->state, pm_state, running ? "" : "not ");
  1775. if (pm_state == 0) {
  1776. if (ops->pm)
  1777. ops->pm(port, pm_state, oldstate);
  1778. if (running) {
  1779. ops->set_mctrl(port, 0);
  1780. ops->startup(port, state->info);
  1781. uart_change_speed(state->info, NULL);
  1782. ops->set_mctrl(port, state->info->mctrl);
  1783. ops->start_tx(port, 1, 0);
  1784. }
  1786. /*
  1787.  * Re-enable the console device after suspending.
  1788.  */
  1789. if (state->cons && state->cons->index == port->line)
  1790. state->cons->flags |= CON_ENABLED;
  1791. } else if (pm_state == 1) {
  1792. if (ops->pm)
  1793. ops->pm(port, pm_state, oldstate);
  1794. } else {
  1795. /*
  1796.  * Disable the console device before suspending.
  1797.  */
  1798. if (state->cons && state->cons->index == port->line)
  1799. state->cons->flags &= ~CON_ENABLED;
  1801. if (running) {
  1802. ops->stop_tx(port, 0);
  1803. ops->set_mctrl(port, 0);
  1804. ops->stop_rx(port);
  1805. ops->shutdown(port, state->info);
  1806. }
  1807. if (ops->pm)
  1808. ops->pm(port, pm_state, oldstate);
  1809. }
  1810. return 0;
  1811. }
  1813. /*
  1814.  *  Wakeup support.
  1815.  */
  1816. static int uart_pm_set_wakeup(struct uart_state *state, int data)
  1817. {
  1818. int err = 0;
  1820. if (state->port->ops->set_wake)
  1821. err = state->port->ops->set_wake(state->port, data);
  1823. return err;
  1824. }
  1826. static int uart_pm(struct pm_dev *dev, pm_request_t rqst, void *data)
  1827. {
  1828. struct uart_state *state = dev->data;
  1829. int err = 0;
  1831. switch (rqst) {
  1832. case PM_SUSPEND:
  1833. case PM_RESUME:
  1834. err = uart_pm_set_state(state, (int)data, dev->state);
  1835. break;
  1837. case PM_SET_WAKEUP:
  1838. err = uart_pm_set_wakeup(state, (int)data);
  1839. break;
  1840. }
  1841. return err;
  1842. }
  1843. #endif
  1845. static inline void
  1846. uart_report_port(struct uart_driver *drv, struct uart_port *port)
  1847. {
  1848. printk("%s%d at ", drv->normal_name, port->line);
  1849. switch (port->iotype) {
  1850. case SERIAL_IO_PORT:
  1851. printk("I/O 0x%x", port->iobase);
  1852. break;
  1853. case SERIAL_IO_HUB6:
  1854. printk("I/O 0x%x offset 0x%x", port->iobase, port->hub6);
  1855. break;
  1856. case SERIAL_IO_MEM:
  1857. printk("MEM 0x%lx", port->mapbase);
  1858. break;
  1859. }
  1860. printk(" (irq = %d) is a %sn", port->irq, uart_type(port));
  1861. }
  1863. static void
  1864. uart_setup_port(struct uart_driver *drv, struct uart_state *state)
  1865. {
  1866. struct uart_port *port = state->port;
  1867. int flags = UART_CONFIG_TYPE;
  1869. init_MUTEX(&state->count_sem);
  1871. state->close_delay = 5 * HZ / 10;
  1872. state->closing_wait = 30 * HZ;
  1874. port->type = PORT_UNKNOWN;
  1876. #ifdef CONFIG_PM
  1877. state->cons = drv->cons;
  1878. state->pm = pm_register(PM_SYS_DEV, PM_SYS_COM, uart_pm);
  1879. if (state->pm)
  1880. state->pm->data = state;
  1881. #endif
  1883. /*
  1884.  * If there isn't a port here, don't do anything further.
  1885.  */
  1886. if (!port->iobase && !port->mapbase)
  1887. return;
  1889. /*
  1890.  * Now do the auto configuration stuff.  Note that config_port
  1891.  * is expected to claim the resources and map the port for us.
  1892.  */
  1893. if (port->flags & ASYNC_AUTO_IRQ)
  1894. flags |= UART_CONFIG_IRQ;
  1895. if (port->flags & ASYNC_BOOT_AUTOCONF)
  1896. port->ops->config_port(port, flags);
  1898. /*
  1899.  * Only register this port if it is detected.
  1900.  */
  1901. if (port->type != PORT_UNKNOWN) {
  1902. tty_register_devfs(drv->normal_driver, 0, drv->minor +
  1903. state->port->line);
  1904. tty_register_devfs(drv->callout_driver, 0, drv->minor +
  1905. state->port->line);
  1906. uart_report_port(drv, port);
  1907. }
  1909. #ifdef CONFIG_PM
  1910. /*
  1911.  * Power down all ports by default, except the console if we have one.
  1912.  */
  1913. if (state->pm && (!drv->cons || port->line != drv->cons->index))
  1914. pm_send(state->pm, PM_SUSPEND, (void *)3);
  1915. #endif
  1916. }
  1918. /*
  1919.  * Register a set of ports with the core driver.  Note that we don't
  1920.  * printk any information about the ports; that is up to the low level
  1921.  * driver to do if they so wish.
  1922.  */
  1923. int uart_register_driver(struct uart_driver *drv)
  1924. {
  1925. struct tty_driver *normal, *callout;
  1926. int i, retval;
  1928. if (drv->state)
  1929. panic("drv->state already allocatedn");
  1931. /*
  1932.  * Maybe we should be using a slab cache for this, especially if
  1933.  * we have a large number of ports to handle.  Note that we also
  1934.  * allocate space for an integer for reference counting.
  1935.  */
  1936. drv->state = kmalloc(sizeof(struct uart_state) * drv->nr +
  1937.      sizeof(int), GFP_KERNEL);
  1938. retval = -ENOMEM;
  1939. if (!drv->state)
  1940. goto out;
  1942. memset(drv->state, 0, sizeof(struct uart_state) * drv->nr +
  1943. sizeof(int));
  1945. normal  = drv->normal_driver;
  1946. callout = drv->callout_driver;
  1948. normal->magic = TTY_DRIVER_MAGIC;
  1949. normal->driver_name = drv->normal_name;
  1950. normal->name = drv->normal_name;
  1951. normal->major = drv->normal_major;
  1952. normal->minor_start = drv->minor;
  1953. normal->num = drv->nr;
  1954. normal->type = TTY_DRIVER_TYPE_SERIAL;
  1955. normal->subtype = SERIAL_TYPE_NORMAL;
  1956. normal->init_termios = tty_std_termios;
  1957. normal->init_termios.c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
  1958. normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
  1959. normal->refcount = (int *)(drv->state + drv->nr);
  1960. normal->table = drv->table;
  1961. normal->termios = drv->termios;
  1962. normal->termios_locked = drv->termios_locked;
  1963. normal->driver_state    = drv;
  1965. normal->open = uart_open;
  1966. normal->close = uart_close;
  1967. normal->write = uart_write;
  1968. normal->put_char = uart_put_char;
  1969. normal->flush_chars = uart_flush_chars;
  1970. normal->write_room = uart_write_room;
  1971. normal->chars_in_buffer = uart_chars_in_buffer;
  1972. normal->flush_buffer = uart_flush_buffer;
  1973. normal->ioctl = uart_ioctl;
  1974. normal->throttle = uart_throttle;
  1975. normal->unthrottle = uart_unthrottle;
  1976. normal->send_xchar = uart_send_xchar;
  1977. normal->set_termios = uart_set_termios;
  1978. normal->stop = uart_stop;
  1979. normal->start = uart_start;
  1980. normal->hangup = uart_hangup;
  1981. normal->break_ctl = uart_break_ctl;
  1982. normal->wait_until_sent = uart_wait_until_sent;
  1983. #ifdef CONFIG_PROC_FS
  1984. normal->read_proc = uart_read_proc;
  1985. #endif
  1987. /*
  1988.  * The callout device is just like the normal device except for
  1989.  * the major number and the subtype code.
  1990.  */
  1991. *callout = *normal;
  1992. callout->name = drv->callout_name;
  1993. callout->major = drv->callout_major;
  1994. callout->subtype = SERIAL_TYPE_CALLOUT;
  1995. callout->read_proc = NULL;
  1996. callout->proc_entry = NULL;
  1998. for (i = 0; i < drv->nr; i++) {
  1999. struct uart_state *state = drv->state + i;
  2001. state->callout_termios = callout->init_termios;
  2002. state->normal_termios = normal->init_termios;
  2003. state->port = drv->port + i;
  2004. state->port->line = i;
  2006. uart_setup_port(drv, state);
  2007. }
  2009. retval = tty_register_driver(normal);
  2010. if (retval)
  2011. goto out;
  2013. retval = tty_register_driver(callout);
  2014. if (retval)
  2015. tty_unregister_driver(normal);
  2017. out:
  2018. if (retval && drv->state)
  2019. kfree(drv->state);
  2020. return retval;
  2021. }
  2023. void uart_unregister_driver(struct uart_driver *drv)
  2024. {
  2025. int i;
  2027. for (i = 0; i < drv->nr; i++) {
  2028. struct uart_state *state = drv->state + i;
  2030. if (state->info && state->info->tty)
  2031. tty_hangup(state->info->tty);
  2033. pm_unregister(state->pm);
  2035. if (state->port->type != PORT_UNKNOWN)
  2036. state->port->ops->release_port(state->port);
  2037. if (state->info) {
  2038. tasklet_kill(&state->info->tlet);
  2039. kfree(state->info);
  2040. }
  2041. }
  2043. tty_unregister_driver(drv->normal_driver);
  2044. tty_unregister_driver(drv->callout_driver);
  2046. kfree(drv->state);
  2047. }
  2049. static int uart_match_port(struct uart_port *port1, struct uart_port *port2)
  2050. {
  2051. if (port1->iotype != port2->iotype)
  2052. return 0;
  2053. switch (port1->iotype) {
  2054. case SERIAL_IO_PORT: return (port1->iobase == port2->iobase);
  2055. case SERIAL_IO_MEM: return (port1->membase == port2->membase);
  2056. }
  2057. return 0;
  2058. }
  2060. /**
  2061.  * uart_register_port: register a port with the generic uart driver
  2062.  * @reg: pointer to the uart low level driver structure for this port
  2063.  * @port: uart port structure describing the port
  2064.  *
  2065.  * Register a UART with the specified low level driver.  Detect the
  2066.  * type of the port if ASYNC_BOOT_AUTOCONF is set, and detect the IRQ
  2067.  * if ASYNC_AUTO_IRQ is set.
  2068.  *
  2069.  * Returns negative error, or positive line number.
  2070.  */
  2071. int uart_register_port(struct uart_driver *drv, struct uart_port *port)
  2072. {
  2073. struct uart_state *state = NULL;
  2074. int i, flags = UART_CONFIG_TYPE;
  2076. /*
  2077.  * First, find a port entry which matches.  Note: if we do
  2078.  * find a matching entry, and it has a non-zero use count,
  2079.  * then we can't register the port.
  2080.  */
  2081. down(&port_sem);
  2082. for (i = 0; i < drv->nr; i++) {
  2083. if (uart_match_port(drv->state[i].port, port)) {
  2084. down(&drv->state[i].count_sem);
  2085. state = &drv->state[i];
  2086. break;
  2087. }
  2088. }
  2090. /*
  2091.  * If we didn't find a matching entry, look for the first
  2092.  * free entry.  We look for one which hasn't been previously
  2093.  * used (indicated by zero iobase).
  2094.  */
  2095. if (!state) {
  2096. for (i = 0; i < drv->nr; i++) {
  2097. if (drv->state[i].port->type == PORT_UNKNOWN &&
  2098.     drv->state[i].port->iobase == 0) {
  2099. down(&drv->state[i].count_sem);
  2100. if (drv->state[i].count == 0) {
  2101. state = &drv->state[i];
  2102. break;
  2103. }
  2104. }
  2105. }
  2106. }
  2108. /*
  2109.  * Ok, that also failed.  Find the first unused entry, which
  2110.  * may be previously in use.
  2111.  */
  2112. if (!state) {
  2113. for (i = 0; i < drv->nr; i++) {
  2114. if (drv->state[i].port->type == PORT_UNKNOWN) {
  2115. down(&drv->state[i].count_sem);
  2116. if (drv->state[i].count == 0) {
  2117. state = &drv->state[i];
  2118. break;
  2119. }
  2120. }
  2121. }
  2122. }
  2124. up(&port_sem);
  2126. if (!state)
  2127. return -ENOSPC;
  2129. /*
  2130.  * If we find a port that matches this one, and it appears to
  2131.  * be in-use (even if it doesn't have a type) we shouldn't alter
  2132.  * it underneath itself - the port may be open and trying to do
  2133.  * useful work.
  2134.  */
  2135. if (state->count != 0 ||
  2136.     (state->info && state->info->blocked_open != 0)) {
  2137. up(&state->count_sem);
  2138. return -EBUSY;
  2139. }
  2141. /*
  2142.  * We're holding the lock for this port.  Copy the relevant data
  2143.  * into the port structure.
  2144.  */
  2145. state->port->iobase   = port->iobase;
  2146. state->port->membase  = port->membase;
  2147. state->port->irq      = port->irq;
  2148. state->port->uartclk  = port->uartclk;
  2149. state->port->fifosize = port->fifosize;
  2150. state->port->regshift = port->regshift;
  2151. state->port->iotype   = port->iotype;
  2152. state->port->flags    = port->flags;
  2154. #if 0 //def CONFIG_PM
  2155. /* we have already registered the power management handlers */
  2156. state->pm = pm_register(PM_SYS_DEV, PM_SYS_COM, uart_pm);
  2157. if (state->pm) {
  2158. state->pm->data = state;
  2160. /*
  2161.  * Power down all ports by default, except
  2162.  * the console if we have one.
  2163.  */
  2164. if (!drv->cons || state->port->line != drv->cons->index)
  2165. pm_send(state->pm, PM_SUSPEND, (void *)3);
  2166. }
  2167. #endif
  2169. if (state->port->flags & ASYNC_AUTO_IRQ)
  2170. flags |= UART_CONFIG_IRQ;
  2171. if (state->port->flags & ASYNC_BOOT_AUTOCONF)
  2172. state->port->ops->config_port(state->port, flags);
  2174. tty_register_devfs(drv->normal_driver, 0, drv->minor +
  2175. state->port->line);
  2176. tty_register_devfs(drv->callout_driver, 0, drv->minor +
  2177. state->port->line);
  2179. uart_report_port(drv, state->port);
  2181. up(&state->count_sem);
  2182. return i;
  2183. }
  2185. /*
  2186.  * Unregister the specified port index on the specified driver.
  2187.  */
  2188. void uart_unregister_port(struct uart_driver *drv, int line)
  2189. {
  2190. struct uart_state *state;
  2192. if (line < 0 || line >= drv->nr) {
  2193. printk(KERN_ERR "Attempt to unregister %s%dn",
  2194. drv->normal_name, line);
  2195. return;
  2196. }
  2198. state = drv->state + line;
  2200. down(&state->count_sem);
  2201. /*
  2202.  * The port has already gone.  We have to hang up the line
  2203.  * to kill all usage of this port.
  2204.  */
  2205. if (state->info && state->info->tty)
  2206. tty_hangup(state->info->tty);
  2208. /*
  2209.  * Free the ports resources, if any.
  2210.  */
  2211. state->port->ops->release_port(state->port);
  2213. /*
  2214.  * Indicate that there isn't a port here anymore.
  2215.  */
  2216. state->port->type = PORT_UNKNOWN;
  2218. #if 0 // not yet
  2219. /*
  2220.  * No point in doing power management for hardware that
  2221.  * isn't present.
  2222.  */
  2223. pm_unregister(state->pm);
  2224. #endif
  2226. /*
  2227.  * Remove the devices from devfs
  2228.  */
  2229. tty_unregister_devfs(drv->normal_driver, drv->minor + line);
  2230. tty_unregister_devfs(drv->callout_driver, drv->minor + line);
  2231. up(&state->count_sem);
  2232. }
  2234. EXPORT_SYMBOL(uart_event);
  2235. EXPORT_SYMBOL(uart_register_driver);
  2236. EXPORT_SYMBOL(uart_unregister_driver);
  2237. EXPORT_SYMBOL(uart_register_port);
  2238. EXPORT_SYMBOL(uart_unregister_port);
  2240. static int __init uart_init(void)
  2241. {
  2242. return 0;
  2243. }
  2245. static void __exit uart_exit(void)
  2246. {
  2247. free_page((unsigned long)tmp_buf);
  2248. tmp_buf = NULL;
  2249. }
  2251. module_init(uart_init);
  2252. module_exit(uart_exit);
  2254. MODULE_DESCRIPTION("Serial driver core");
  2255. MODULE_LICENSE("GPL");