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

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

嵌入式Linux

开发平台：

Unix_Linux

uart.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.uart.c 1.23 12/29/01 14:50:03 trini
  3.  */
  4. /*
  5.  *  UART driver for MPC860 CPM SCC or SMC
  6.  *  Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
  7.  *
  8.  * I used the serial.c driver as the framework for this driver.
  9.  * Give credit to those guys.
  10.  * The original code was written for the MBX860 board.  I tried to make
  11.  * it generic, but there may be some assumptions in the structures that
  12.  * have to be fixed later.
  13.  * To save porting time, I did not bother to change any object names
  14.  * that are not accessed outside of this file.
  15.  * It still needs lots of work........When it was easy, I included code
  16.  * to support the SCCs, but this has never been tested, nor is it complete.
  17.  * Only the SCCs support modem control, so that is not complete either.
  18.  *
  19.  * This module exports the following rs232 io functions:
  20.  *
  21.  * int rs_8xx_init(void);
  22.  */
  24. #include <linux/config.h>
  25. #include <linux/module.h>
  26. #include <linux/errno.h>
  27. #include <linux/signal.h>
  28. #include <linux/sched.h>
  29. #include <linux/timer.h>
  30. #include <linux/interrupt.h>
  31. #include <linux/tty.h>
  32. #include <linux/tty_flip.h>
  33. #include <linux/serial.h>
  34. #include <linux/serialP.h>
  35. #include <linux/major.h>
  36. #include <linux/string.h>
  37. #include <linux/fcntl.h>
  38. #include <linux/ptrace.h>
  39. #include <linux/mm.h>
  40. #include <linux/slab.h>
  41. #include <linux/init.h>
  42. #include <linux/delay.h>
  43. #include <asm/uaccess.h>
  44. #include <asm/8xx_immap.h>
  45. #include <asm/mpc8xx.h>
  46. #include <asm/commproc.h>
  47. #ifdef CONFIG_MAGIC_SYSRQ
  48. #include <linux/sysrq.h>
  49. #endif
  51. #ifdef CONFIG_KGDB
  52. extern void breakpoint(void);
  53. extern void set_debug_traps(void);
  54. extern int  kgdb_output_string (const char* s, unsigned int count);
  55. #endif
  57. #ifdef CONFIG_SERIAL_CONSOLE
  58. #include <linux/console.h>
  60. /* this defines the index into rs_table for the port to use
  61. */
  62. # ifndef CONFIG_SERIAL_CONSOLE_PORT
  63. #  ifdef CONFIG_SCC3_ENET
  64. #   ifdef CONFIG_CONS_SMC2
  65. #    define CONFIG_SERIAL_CONSOLE_PORT 0 /* Console on SMC2 is 1st port */
  66. #   else
  67. #    error "Can't use SMC1 for console with Ethernet on SCC3"
  68. #   endif
  69. #  else /* ! CONFIG_SCC3_ENET */
  70. #   ifdef CONFIG_CONS_SMC2 /* Console on SMC2 */
  71. #    define CONFIG_SERIAL_CONSOLE_PORT 1
  72. #   else /* Console on SMC1 */
  73. #    define CONFIG_SERIAL_CONSOLE_PORT 0
  74. #   endif /* CONFIG_CONS_SMC2 */
  75. #  endif  /* CONFIG_SCC3_ENET */
  76. # endif   /* CONFIG_SERIAL_CONSOLE_PORT */
  77. #endif   /* CONFIG_SERIAL_CONSOLE */
  79. #if 0
  80. /* SCC2 for console
  81. */
  82. #undef CONFIG_SERIAL_CONSOLE_PORT
  83. #define CONFIG_SERIAL_CONSOLE_PORT 2
  84. #endif
  86. #define TX_WAKEUP ASYNC_SHARE_IRQ
  88. static char *serial_name = "CPM UART driver";
  89. static char *serial_version = "0.03";
  91. static DECLARE_TASK_QUEUE(tq_serial);
  93. static struct tty_driver serial_driver, callout_driver;
  94. static int serial_refcount;
  95. static int serial_console_setup(struct console *co, char *options);
  97. static void serial_console_write(struct console *c, const char *s,
  98. unsigned count);
  99. static kdev_t serial_console_device(struct console *c);
  100. static int serial_console_wait_key(struct console *co);
  102. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  103. static unsigned long break_pressed; /* break, really ... */
  104. #endif
  106. /*
  107.  * Serial driver configuration section.  Here are the various options:
  108.  */
  109. #define SERIAL_PARANOIA_CHECK
  110. #define CONFIG_SERIAL_NOPAUSE_IO
  111. #define SERIAL_DO_RESTART
  113. /* Set of debugging defines */
  115. #undef SERIAL_DEBUG_INTR
  116. #undef SERIAL_DEBUG_OPEN
  117. #undef SERIAL_DEBUG_FLOW
  118. #undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  120. #define _INLINE_ inline
  121.   
  122. #define DBG_CNT(s)
  124. /* We overload some of the items in the data structure to meet our
  125.  * needs.  For example, the port address is the CPM parameter ram
  126.  * offset for the SCC or SMC.  The maximum number of ports is 4 SCCs and
  127.  * 2 SMCs.  The "hub6" field is used to indicate the channel number, with
  128.  * a flag indicating SCC or SMC, and the number is used as an index into
  129.  * the CPM parameter area for this device.
  130.  * The "type" field is currently set to 0, for PORT_UNKNOWN.  It is
  131.  * not currently used.  I should probably use it to indicate the port
  132.  * type of SMC or SCC.
  133.  * The SMCs do not support any modem control signals.
  134.  */
  135. #define smc_scc_num hub6
  136. #define NUM_IS_SCC ((int)0x00010000)
  137. #define PORT_NUM(P) ((P) & 0x0000ffff)
  139. /* Processors other than the 860 only get SMCs configured by default.
  140.  * Either they don't have SCCs or they are allocated somewhere else.
  141.  * Of course, there are now 860s without some SCCs, so we will need to
  142.  * address that someday.
  143.  * The Embedded Planet Multimedia I/O cards use TDM interfaces to the
  144.  * stereo codec parts, and we use SMC2 to help support that.
  145.  */
  146. static struct serial_state rs_table[] = {
  147. /* UART CLK   PORT          IRQ      FLAGS  NUM   */
  148. #ifndef CONFIG_SCC3_ENET /* SMC1 not usable with Ethernet on SCC3 */
  149.    { 0,     0, PROFF_SMC1, CPMVEC_SMC1,   0,    0 },    /* SMC1 ttyS0 */
  150. #endif
  151. #if !defined(CONFIG_USB_MPC8xx) && !defined(CONFIG_USB_CLIENT_MPC8xx)
  152. # ifdef CONFIG_SMC2_UART
  153.    { 0,     0, PROFF_SMC2, CPMVEC_SMC2,   0,    1 },    /* SMC2 ttyS1 */
  154. # endif
  155. # ifdef CONFIG_USE_SCC_IO
  156.    { 0,     0, PROFF_SCC2, CPMVEC_SCC2,   0,    (NUM_IS_SCC | 1) },    /* SCC2 ttyS2 */
  157.    { 0,     0, PROFF_SCC3, CPMVEC_SCC3,   0,    (NUM_IS_SCC | 2) },    /* SCC3 ttyS3 */
  158. # endif
  159.   #else /* CONFIG_USB_xxx */
  160. # ifdef CONFIG_USE_SCC_IO
  161.    { 0,     0, PROFF_SCC3, CPMVEC_SCC3,   0,    (NUM_IS_SCC | 2) },    /* SCC3 ttyS3 */
  162. # endif
  163. #endif /* CONFIG_USB_xxx */
  164. };
  166. #define NR_PORTS (sizeof(rs_table)/sizeof(struct serial_state))
  168. static struct tty_struct *serial_table[NR_PORTS];
  169. static struct termios *serial_termios[NR_PORTS];
  170. static struct termios *serial_termios_locked[NR_PORTS];
  172. /* The number of buffer descriptors and their sizes.
  173. */
  174. #define RX_NUM_FIFO 4
  175. #define RX_BUF_SIZE 32
  176. #define TX_NUM_FIFO 4
  177. #define TX_BUF_SIZE 32
  179. #ifndef MIN
  180. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  181. #endif
  183. /* The async_struct in serial.h does not really give us what we
  184.  * need, so define our own here.
  185.  */
  186. typedef struct serial_info {
  187. int magic;
  188. int flags;
  189. struct serial_state *state;
  190. struct tty_struct  *tty;
  191. int read_status_mask;
  192. int ignore_status_mask;
  193. int timeout;
  194. int line;
  195. int x_char; /* xon/xoff character */
  196. int close_delay;
  197. unsigned short closing_wait;
  198. unsigned short closing_wait2;
  199. unsigned long event;
  200. unsigned long last_active;
  201. int blocked_open; /* # of blocked opens */
  202. long session; /* Session of opening process */
  203. long pgrp; /* pgrp of opening process */
  204. struct tq_struct tqueue;
  205. struct tq_struct tqueue_hangup;
  206. wait_queue_head_t open_wait;
  207. wait_queue_head_t close_wait;
  209. /* CPM Buffer Descriptor pointers.
  210. */
  211. cbd_t *rx_bd_base;
  212. cbd_t *rx_cur;
  213. cbd_t *tx_bd_base;
  214. cbd_t *tx_cur;
  215. } ser_info_t;
  217. static struct console sercons = {
  218. name: "ttyS",
  219. write: serial_console_write,
  220. device: serial_console_device,
  221. wait_key: serial_console_wait_key,
  222. setup: serial_console_setup,
  223. flags: CON_PRINTBUFFER,
  224. index: CONFIG_SERIAL_CONSOLE_PORT,
  225. };
  227. static void change_speed(ser_info_t *info);
  228. static void rs_8xx_wait_until_sent(struct tty_struct *tty, int timeout);
  230. static inline int serial_paranoia_check(ser_info_t *info,
  231. kdev_t device, const char *routine)
  232. {
  233. #ifdef SERIAL_PARANOIA_CHECK
  234. static const char *badmagic =
  235. "Warning: bad magic number for serial struct (%s) in %sn";
  236. static const char *badinfo =
  237. "Warning: null async_struct for (%s) in %sn";
  239. if (!info) {
  240. printk(badinfo, kdevname(device), routine);
  241. return 1;
  242. }
  243. if (info->magic != SERIAL_MAGIC) {
  244. printk(badmagic, kdevname(device), routine);
  245. return 1;
  246. }
  247. #endif
  248. return 0;
  249. }
  251. /*
  252.  * This is used to figure out the divisor speeds and the timeouts,
  253.  * indexed by the termio value.  The generic CPM functions are responsible
  254.  * for setting and assigning baud rate generators for us.
  255.  */
  256. static int baud_table[] = {
  257. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  258. 9600, 19200, 38400, 57600, 115200, 230400, 460800, 0 };
  261. /*
  262.  * ------------------------------------------------------------
  263.  * rs_stop() and rs_start()
  264.  *
  265.  * This routines are called before setting or resetting tty->stopped.
  266.  * They enable or disable transmitter interrupts, as necessary.
  267.  * ------------------------------------------------------------
  268.  */
  269. static void rs_8xx_stop(struct tty_struct *tty)
  270. {
  271. ser_info_t *info = (ser_info_t *)tty->driver_data;
  272. int idx;
  273. unsigned long flags;
  274. volatile scc_t *sccp;
  275. volatile smc_t *smcp;
  277. if (serial_paranoia_check(info, tty->device, "rs_stop"))
  278. return;
  280. save_flags(flags); cli();
  281. idx = PORT_NUM(info->state->smc_scc_num);
  282. if (info->state->smc_scc_num & NUM_IS_SCC) {
  283. sccp = &cpmp->cp_scc[idx];
  284. sccp->scc_sccm &= ~UART_SCCM_TX;
  285. }
  286. else {
  287. smcp = &cpmp->cp_smc[idx];
  288. smcp->smc_smcm &= ~SMCM_TX;
  289. }
  290. restore_flags(flags);
  291. }
  293. static void rs_8xx_start(struct tty_struct *tty)
  294. {
  295. ser_info_t *info = (ser_info_t *)tty->driver_data;
  296. int idx;
  297. unsigned long flags;
  298. volatile scc_t *sccp;
  299. volatile smc_t *smcp;
  301. if (serial_paranoia_check(info, tty->device, "rs_stop"))
  302. return;
  304. idx = PORT_NUM(info->state->smc_scc_num);
  305. save_flags(flags); cli();
  306. if (info->state->smc_scc_num & NUM_IS_SCC) {
  307. sccp = &cpmp->cp_scc[idx];
  308. sccp->scc_sccm |= UART_SCCM_TX;
  309. }
  310. else {
  311. smcp = &cpmp->cp_smc[idx];
  312. smcp->smc_smcm |= SMCM_TX;
  313. }
  314. restore_flags(flags);
  315. }
  317. /*
  318.  * ----------------------------------------------------------------------
  319.  *
  320.  * Here starts the interrupt handling routines.  All of the following
  321.  * subroutines are declared as inline and are folded into
  322.  * rs_interrupt().  They were separated out for readability's sake.
  323.  *
  324.  * Note: rs_interrupt() is a "fast" interrupt, which means that it
  325.  * runs with interrupts turned off.  People who may want to modify
  326.  * rs_interrupt() should try to keep the interrupt handler as fast as
  327.  * possible.  After you are done making modifications, it is not a bad
  328.  * idea to do:
  329.  * 
  330.  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  331.  *
  332.  * and look at the resulting assemble code in serial.s.
  333.  *
  334.  *  - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  335.  * -----------------------------------------------------------------------
  336.  */
  338. /*
  339.  * This routine is used by the interrupt handler to schedule
  340.  * processing in the software interrupt portion of the driver.
  341.  */
  342. static _INLINE_ void rs_sched_event(ser_info_t *info,
  343.   int event)
  344. {
  345. info->event |= 1 << event;
  346. queue_task(&info->tqueue, &tq_serial);
  347. mark_bh(SERIAL_BH);
  348. }
  350. static _INLINE_ void receive_chars(ser_info_t *info, struct pt_regs *regs)
  351. {
  352. struct tty_struct *tty = info->tty;
  353. unsigned char ch, *cp;
  354. /*int ignored = 0;*/
  355. int i;
  356. ushort status;
  357. struct async_icount *icount;
  358. volatile cbd_t *bdp;
  360. icount = &info->state->icount;
  362. /* Just loop through the closed BDs and copy the characters into
  363.  * the buffer.
  364.  */
  365. bdp = info->rx_cur;
  366. for (;;) {
  367. if (bdp->cbd_sc & BD_SC_EMPTY) /* If this one is empty */
  368. break; /*   we are all done */
  370. /* The read status mask tell us what we should do with
  371.  * incoming characters, especially if errors occur.
  372.  * One special case is the use of BD_SC_EMPTY.  If
  373.  * this is not set, we are supposed to be ignoring
  374.  * inputs.  In this case, just mark the buffer empty and
  375.  * continue.
  376. if (!(info->read_status_mask & BD_SC_EMPTY)) {
  377. bdp->cbd_sc |= BD_SC_EMPTY;
  378. bdp->cbd_sc &=
  379. ~(BD_SC_BR | BD_SC_FR | BD_SC_PR | BD_SC_OV);
  381. if (bdp->cbd_sc & BD_SC_WRAP)
  382. bdp = info->rx_bd_base;
  383. else
  384. bdp++;
  385. continue;
  386. }
  387.  */
  389. /* Get the number of characters and the buffer pointer.
  390. */
  391. i = bdp->cbd_datlen;
  392. cp = (unsigned char *)__va(bdp->cbd_bufaddr);
  393. status = bdp->cbd_sc;
  395. /* Check to see if there is room in the tty buffer for
  396.  * the characters in our BD buffer.  If not, we exit
  397.  * now, leaving the BD with the characters.  We'll pick
  398.  * them up again on the next receive interrupt (which could
  399.  * be a timeout).
  400.  */
  401. if ((tty->flip.count + i) >= TTY_FLIPBUF_SIZE)
  402. break;
  404. while (i-- > 0) {
  405. ch = *cp++;
  406. *tty->flip.char_buf_ptr = ch;
  407. icount->rx++;
  409. #ifdef SERIAL_DEBUG_INTR
  410. printk("DR%02x:%02x...", ch, status);
  411. #endif
  412. *tty->flip.flag_buf_ptr = 0;
  413. if (status & (BD_SC_BR | BD_SC_FR |
  414.        BD_SC_PR | BD_SC_OV)) {
  415. /*
  416.  * For statistics only
  417.  */
  418. if (status & BD_SC_BR)
  419. icount->brk++;
  420. else if (status & BD_SC_PR)
  421. icount->parity++;
  422. else if (status & BD_SC_FR)
  423. icount->frame++;
  424. if (status & BD_SC_OV)
  425. icount->overrun++;
  427. /*
  428.  * Now check to see if character should be
  429.  * ignored, and mask off conditions which
  430.  * should be ignored.
  431. if (status & info->ignore_status_mask) {
  432. if (++ignored > 100)
  433. break;
  434. continue;
  435. }
  436.  */
  437. status &= info->read_status_mask;
  439. if (status & (BD_SC_BR)) {
  440. #ifdef SERIAL_DEBUG_INTR
  441. printk("handling break....");
  442. #endif
  443. *tty->flip.flag_buf_ptr = TTY_BREAK;
  444. if (info->flags & ASYNC_SAK)
  445. do_SAK(tty);
  446. } else if (status & BD_SC_PR)
  447. *tty->flip.flag_buf_ptr = TTY_PARITY;
  448. else if (status & BD_SC_FR)
  449. *tty->flip.flag_buf_ptr = TTY_FRAME;
  450. if (status & BD_SC_OV) {
  451. /*
  452.  * Overrun is special, since it's
  453.  * reported immediately, and doesn't
  454.  * affect the current character
  455.  */
  456. if (tty->flip.count < TTY_FLIPBUF_SIZE) {
  457. tty->flip.count++;
  458. tty->flip.flag_buf_ptr++;
  459. tty->flip.char_buf_ptr++;
  460. *tty->flip.flag_buf_ptr =
  461. TTY_OVERRUN;
  462. }
  463. }
  464. }
  465. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  466. if (break_pressed && info->line == sercons.index) {
  467. if (ch != 0 && time_before(jiffies, 
  468. break_pressed + HZ*5)) {
  469. handle_sysrq(ch, regs, NULL, NULL);
  470. break_pressed = 0;
  471. goto ignore_char;
  472. } else
  473. break_pressed = 0;
  474. }
  475. #endif
  476. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  477. break;
  479. tty->flip.flag_buf_ptr++;
  480. tty->flip.char_buf_ptr++;
  481. tty->flip.count++;
  482. }
  484. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  485. ignore_char:
  486. #endif
  487. /* This BD is ready to be used again.  Clear status.
  488.  * Get next BD.
  489.  */
  490. bdp->cbd_sc |= BD_SC_EMPTY;
  491. bdp->cbd_sc &= ~(BD_SC_BR | BD_SC_FR | BD_SC_PR | BD_SC_OV);
  493. if (bdp->cbd_sc & BD_SC_WRAP)
  494. bdp = info->rx_bd_base;
  495. else
  496. bdp++;
  497. }
  498. info->rx_cur = (cbd_t *)bdp;
  500. queue_task(&tty->flip.tqueue, &tq_timer);
  501. }
  503. static _INLINE_ void receive_break(ser_info_t *info, struct pt_regs *regs)
  504. {
  505. struct tty_struct *tty = info->tty;
  507. info->state->icount.brk++;
  509. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  510. if (info->line == sercons.index) {
  511. if (!break_pressed) {
  512. break_pressed = jiffies;
  513. return;
  514. } else
  515. break_pressed = 0;
  516. }
  517. #endif
  519. /* Check to see if there is room in the tty buffer for
  520.  * the break.  If not, we exit now, losing the break.  FIXME
  521.  */
  522. if ((tty->flip.count + 1) >= TTY_FLIPBUF_SIZE)
  523. return;
  524. *(tty->flip.flag_buf_ptr++) = TTY_BREAK;
  525. *(tty->flip.char_buf_ptr++) = 0;
  526. tty->flip.count++;
  528. queue_task(&tty->flip.tqueue, &tq_timer);
  529. }
  531. static _INLINE_ void transmit_chars(ser_info_t *info, struct pt_regs *regs)
  532. {
  534. if ((info->flags & TX_WAKEUP) ||
  535.     (info->tty->flags & (1 << TTY_DO_WRITE_WAKEUP))) {
  536. rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  537. }
  539. #ifdef SERIAL_DEBUG_INTR
  540. printk("THRE...");
  541. #endif
  542. }
  544. #ifdef notdef
  545. /* I need to do this for the SCCs, so it is left as a reminder.
  546. */
  547. static _INLINE_ void check_modem_status(struct async_struct *info)
  548. {
  549. int status;
  550. struct async_icount *icount;
  552. status = serial_in(info, UART_MSR);
  554. if (status & UART_MSR_ANY_DELTA) {
  555. icount = &info->state->icount;
  556. /* update input line counters */
  557. if (status & UART_MSR_TERI)
  558. icount->rng++;
  559. if (status & UART_MSR_DDSR)
  560. icount->dsr++;
  561. if (status & UART_MSR_DDCD) {
  562. icount->dcd++;
  563. #ifdef CONFIG_HARD_PPS
  564. if ((info->flags & ASYNC_HARDPPS_CD) &&
  565.     (status & UART_MSR_DCD))
  566. hardpps();
  567. #endif
  568. }
  569. if (status & UART_MSR_DCTS)
  570. icount->cts++;
  571. wake_up_interruptible(&info->delta_msr_wait);
  572. }
  574. if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
  575. #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
  576. printk("ttys%d CD now %s...", info->line,
  577.        (status & UART_MSR_DCD) ? "on" : "off");
  578. #endif
  579. if (status & UART_MSR_DCD)
  580. wake_up_interruptible(&info->open_wait);
  581. else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  582.    (info->flags & ASYNC_CALLOUT_NOHUP))) {
  583. #ifdef SERIAL_DEBUG_OPEN
  584. printk("scheduling hangup...");
  585. #endif
  586. MOD_INC_USE_COUNT;
  587. if (schedule_task(&info->tqueue_hangup) == 0)
  588. MOD_DEC_USE_COUNT;
  589. }
  590. }
  591. if (info->flags & ASYNC_CTS_FLOW) {
  592. if (info->tty->hw_stopped) {
  593. if (status & UART_MSR_CTS) {
  594. #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  595. printk("CTS tx start...");
  596. #endif
  597. info->tty->hw_stopped = 0;
  598. info->IER |= UART_IER_THRI;
  599. serial_out(info, UART_IER, info->IER);
  600. rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  601. return;
  602. }
  603. } else {
  604. if (!(status & UART_MSR_CTS)) {
  605. #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  606. printk("CTS tx stop...");
  607. #endif
  608. info->tty->hw_stopped = 1;
  609. info->IER &= ~UART_IER_THRI;
  610. serial_out(info, UART_IER, info->IER);
  611. }
  612. }
  613. }
  614. }
  615. #endif
  617. /*
  618.  * This is the serial driver's interrupt routine for a single port
  619.  */
  620. static void rs_8xx_interrupt(void *dev_id, struct pt_regs *regs)
  621. {
  622. u_char events;
  623. int idx;
  624. ser_info_t *info;
  625. volatile smc_t *smcp;
  626. volatile scc_t *sccp;
  628. info = (ser_info_t *)dev_id;
  630. idx = PORT_NUM(info->state->smc_scc_num);
  631. if (info->state->smc_scc_num & NUM_IS_SCC) {
  632. sccp = &cpmp->cp_scc[idx];
  633. events = sccp->scc_scce;
  634. if (events & SMCM_BRKE)
  635. receive_break(info, regs);
  636. if (events & SCCM_RX)
  637. receive_chars(info, regs);
  638. if (events & SCCM_TX)
  639. transmit_chars(info, regs);
  640. sccp->scc_scce = events;
  641. }
  642. else {
  643. smcp = &cpmp->cp_smc[idx];
  644. events = smcp->smc_smce;
  645. if (events & SMCM_BRKE)
  646. receive_break(info, regs);
  647. if (events & SMCM_RX)
  648. receive_chars(info, regs);
  649. if (events & SMCM_TX)
  650. transmit_chars(info, regs);
  651. smcp->smc_smce = events;
  652. }
  654. #ifdef SERIAL_DEBUG_INTR
  655. printk("rs_interrupt_single(%d, %x)...",
  656. info->state->smc_scc_num, events);
  657. #endif
  658. #ifdef modem_control
  659. check_modem_status(info);
  660. #endif
  661. info->last_active = jiffies;
  662. #ifdef SERIAL_DEBUG_INTR
  663. printk("end.n");
  664. #endif
  665. }
  668. /*
  669.  * -------------------------------------------------------------------
  670.  * Here ends the serial interrupt routines.
  671.  * -------------------------------------------------------------------
  672.  */
  674. /*
  675.  * This routine is used to handle the "bottom half" processing for the
  676.  * serial driver, known also the "software interrupt" processing.
  677.  * This processing is done at the kernel interrupt level, after the
  678.  * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  679.  * is where time-consuming activities which can not be done in the
  680.  * interrupt driver proper are done; the interrupt driver schedules
  681.  * them using rs_sched_event(), and they get done here.
  682.  */
  683. static void do_serial_bh(void)
  684. {
  685. run_task_queue(&tq_serial);
  686. }
  688. static void do_softint(void *private_)
  689. {
  690. ser_info_t *info = (ser_info_t *) private_;
  691. struct tty_struct *tty;
  693. tty = info->tty;
  694. if (!tty)
  695. return;
  697. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  698. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  699.     tty->ldisc.write_wakeup)
  700. (tty->ldisc.write_wakeup)(tty);
  701. wake_up_interruptible(&tty->write_wait);
  702. }
  703. }
  705. /*
  706.  * This routine is called from the scheduler tqueue when the interrupt
  707.  * routine has signalled that a hangup has occurred.  The path of
  708.  * hangup processing is:
  709.  *
  710.  *  serial interrupt routine -> (scheduler tqueue) ->
  711.  *  do_serial_hangup() -> tty->hangup() -> rs_hangup()
  712.  * 
  713.  */
  714. static void do_serial_hangup(void *private_)
  715. {
  716. struct async_struct *info = (struct async_struct *) private_;
  717. struct tty_struct *tty;
  719. tty = info->tty;
  720. if (tty)
  721. tty_hangup(tty);
  722. MOD_DEC_USE_COUNT;
  723. }
  725. /*static void rs_8xx_timer(void)
  726. {
  727. printk("rs_8xx_timern");
  728. }*/
  731. static int startup(ser_info_t *info)
  732. {
  733. unsigned long flags;
  734. int retval=0;
  735. int idx;
  736. struct serial_state *state= info->state;
  737. volatile smc_t *smcp;
  738. volatile scc_t *sccp;
  739. volatile smc_uart_t *up;
  740. volatile scc_uart_t *scup;
  743. save_flags(flags); cli();
  745. if (info->flags & ASYNC_INITIALIZED) {
  746. goto errout;
  747. }
  749. #ifdef maybe
  750. if (!state->port || !state->type) {
  751. if (info->tty)
  752. set_bit(TTY_IO_ERROR, &info->tty->flags);
  753. goto errout;
  754. }
  755. #endif
  757. #ifdef SERIAL_DEBUG_OPEN
  758. printk("starting up ttys%d (irq %d)...", info->line, state->irq);
  759. #endif
  762. #ifdef modem_control
  763. info->MCR = 0;
  764. if (info->tty->termios->c_cflag & CBAUD)
  765. info->MCR = UART_MCR_DTR | UART_MCR_RTS;
  766. #endif
  768. if (info->tty)
  769. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  771. /*
  772.  * and set the speed of the serial port
  773.  */
  774. change_speed(info);
  776. idx = PORT_NUM(info->state->smc_scc_num);
  777. if (info->state->smc_scc_num & NUM_IS_SCC) {
  778. sccp = &cpmp->cp_scc[idx];
  779. scup = (scc_uart_t *)&cpmp->cp_dparam[state->port];
  780. scup->scc_genscc.scc_mrblr = RX_BUF_SIZE;
  781. scup->scc_maxidl = RX_BUF_SIZE;
  782. sccp->scc_sccm |= (UART_SCCM_TX | UART_SCCM_RX);
  783. sccp->scc_gsmrl |= (SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  784. }
  785. else {
  786. smcp = &cpmp->cp_smc[idx];
  788. /* Enable interrupts and I/O.
  789. */
  790. smcp->smc_smcm |= (SMCM_RX | SMCM_TX);
  791. smcp->smc_smcmr |= (SMCMR_REN | SMCMR_TEN);
  793. /* We can tune the buffer length and idle characters
  794.  * to take advantage of the entire incoming buffer size.
  795.  * If mrblr is something other than 1, maxidl has to be
  796.  * non-zero or we never get an interrupt.  The maxidl
  797.  * is the number of character times we wait after reception
  798.  * of the last character before we decide no more characters
  799.  * are coming.
  800.  */
  801. up = (smc_uart_t *)&cpmp->cp_dparam[state->port];
  802. up->smc_mrblr = RX_BUF_SIZE;
  803. up->smc_maxidl = RX_BUF_SIZE;
  804. up->smc_brkcr = 1; /* number of break chars */
  805. }
  807. info->flags |= ASYNC_INITIALIZED;
  808. restore_flags(flags);
  809. return 0;
  811. errout:
  812. restore_flags(flags);
  813. return retval;
  814. }
  816. /*
  817.  * This routine will shutdown a serial port; interrupts are disabled, and
  818.  * DTR is dropped if the hangup on close termio flag is on.
  819.  */
  820. static void shutdown(ser_info_t * info)
  821. {
  822. unsigned long flags;
  823. struct serial_state *state;
  824. int idx;
  825. volatile smc_t *smcp;
  826. volatile scc_t *sccp;
  828. if (!(info->flags & ASYNC_INITIALIZED))
  829. return;
  831. state = info->state;
  833. #ifdef SERIAL_DEBUG_OPEN
  834. printk("Shutting down serial port %d (irq %d)....", info->line,
  835.        state->irq);
  836. #endif
  838. save_flags(flags); cli(); /* Disable interrupts */
  840. idx = PORT_NUM(state->smc_scc_num);
  841. if (state->smc_scc_num & NUM_IS_SCC) {
  842. sccp = &cpmp->cp_scc[idx];
  843. sccp->scc_gsmrl &= ~(SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  844. #ifdef CONFIG_SERIAL_CONSOLE
  845. /* We can't disable the transmitter if this is the
  846.  * system console.
  847.  */
  848. if ((state - rs_table) != CONFIG_SERIAL_CONSOLE_PORT)
  849. #endif
  850. sccp->scc_sccm &= ~(UART_SCCM_TX | UART_SCCM_RX);
  851. }
  852. else {
  853. smcp = &cpmp->cp_smc[idx];
  855. /* Disable interrupts and I/O.
  856. */
  857. smcp->smc_smcm &= ~(SMCM_RX | SMCM_TX);
  858. #ifdef CONFIG_SERIAL_CONSOLE
  859. /* We can't disable the transmitter if this is the
  860.  * system console.
  861.  */
  862. if ((state - rs_table) != CONFIG_SERIAL_CONSOLE_PORT)
  863. #endif
  864. smcp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
  865. }
  867. if (info->tty)
  868. set_bit(TTY_IO_ERROR, &info->tty->flags);
  870. info->flags &= ~ASYNC_INITIALIZED;
  871. restore_flags(flags);
  872. }
  874. /*
  875.  * This routine is called to set the UART divisor registers to match
  876.  * the specified baud rate for a serial port.
  877.  */
  878. static void change_speed(ser_info_t *info)
  879. {
  880. int baud_rate;
  881. unsigned cflag, cval, scval, prev_mode, new_mode;
  882. int i, bits, sbits, idx;
  883. unsigned long flags;
  884. struct serial_state *state;
  885. volatile smc_t *smcp;
  886. volatile scc_t *sccp;
  888. if (!info->tty || !info->tty->termios)
  889. return;
  890. cflag = info->tty->termios->c_cflag;
  892. state = info->state;
  894. /* Character length programmed into the mode register is the
  895.  * sum of: 1 start bit, number of data bits, 0 or 1 parity bit,
  896.  * 1 or 2 stop bits, minus 1.
  897.  * The value 'bits' counts this for us.
  898.  */
  899. cval = 0;
  900. scval = 0;
  902. /* byte size and parity */
  903. switch (cflag & CSIZE) {
  904.       case CS5: bits = 5; break;
  905.       case CS6: bits = 6; break;
  906.       case CS7: bits = 7; break;
  907.       case CS8: bits = 8; break;
  908.       /* Never happens, but GCC is too dumb to figure it out */
  909.       default:  bits = 8; break;
  910. }
  911. sbits = bits - 5;
  913. if (cflag & CSTOPB) {
  914. cval |= SMCMR_SL; /* Two stops */
  915. scval |= SCU_PMSR_SL;
  916. bits++;
  917. }
  918. if (cflag & PARENB) {
  919. cval |= SMCMR_PEN;
  920. scval |= SCU_PMSR_PEN;
  921. bits++;
  922. if (!(cflag & PARODD)) {
  923. cval |= SMCMR_PM_EVEN;
  924. scval |= (SCU_PMSR_REVP | SCU_PMSR_TEVP);
  925. }
  926. }
  928. /* Determine divisor based on baud rate */
  929. i = cflag & CBAUD;
  930. if (i >= (sizeof(baud_table)/sizeof(int)))
  931. baud_rate = 9600;
  932. else
  933. baud_rate = baud_table[i];
  935. info->timeout = (TX_BUF_SIZE*HZ*bits);
  936. info->timeout += HZ/50; /* Add .02 seconds of slop */
  938. #ifdef modem_control
  939. /* CTS flow control flag and modem status interrupts */
  940. info->IER &= ~UART_IER_MSI;
  941. if (info->flags & ASYNC_HARDPPS_CD)
  942. info->IER |= UART_IER_MSI;
  943. if (cflag & CRTSCTS) {
  944. info->flags |= ASYNC_CTS_FLOW;
  945. info->IER |= UART_IER_MSI;
  946. } else
  947. info->flags &= ~ASYNC_CTS_FLOW;
  948. if (cflag & CLOCAL)
  949. info->flags &= ~ASYNC_CHECK_CD;
  950. else {
  951. info->flags |= ASYNC_CHECK_CD;
  952. info->IER |= UART_IER_MSI;
  953. }
  954. serial_out(info, UART_IER, info->IER);
  955. #endif
  957. /*
  958.  * Set up parity check flag
  959.  */
  960. #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  962. info->read_status_mask = (BD_SC_EMPTY | BD_SC_OV);
  963. if (I_INPCK(info->tty))
  964. info->read_status_mask |= BD_SC_FR | BD_SC_PR;
  965. if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
  966. info->read_status_mask |= BD_SC_BR;
  968. /*
  969.  * Characters to ignore
  970.  */
  971. info->ignore_status_mask = 0;
  972. if (I_IGNPAR(info->tty))
  973. info->ignore_status_mask |= BD_SC_PR | BD_SC_FR;
  974. if (I_IGNBRK(info->tty)) {
  975. info->ignore_status_mask |= BD_SC_BR;
  976. /*
  977.  * If we're ignore parity and break indicators, ignore 
  978.  * overruns too.  (For real raw support).
  979.  */
  980. if (I_IGNPAR(info->tty))
  981. info->ignore_status_mask |= BD_SC_OV;
  982. }
  983. /*
  984.  * !!! ignore all characters if CREAD is not set
  985.  */
  986. if ((cflag & CREAD) == 0)
  987. info->read_status_mask &= ~BD_SC_EMPTY;
  988. save_flags(flags); cli();
  990. /* Start bit has not been added (so don't, because we would just
  991.  * subtract it later), and we need to add one for the number of
  992.  * stops bits (there is always at least one).
  993.  */
  994. bits++;
  995. idx = PORT_NUM(state->smc_scc_num);
  996. if (state->smc_scc_num & NUM_IS_SCC) {
  997. sccp = &cpmp->cp_scc[idx];
  998. new_mode = (sbits << 12) | scval;
  999. prev_mode = sccp->scc_pmsr;
  1000. if (!(prev_mode & SCU_PMSR_PEN)) 
  1001. /* If parity is disabled, mask out even/odd */
  1002. prev_mode &= ~(SCU_PMSR_TPM|SCU_PMSR_RPM);
  1003. if (prev_mode != new_mode)
  1004. sccp->scc_pmsr = new_mode;
  1005. }
  1006. else {
  1007. smcp = &cpmp->cp_smc[idx];
  1009. /* Set the mode register.  We want to keep a copy of the
  1010.  * enables, because we want to put them back if they were
  1011.  * present.
  1012.  */
  1013. prev_mode = smcp->smc_smcmr;
  1014. new_mode = smcr_mk_clen(bits) | cval |  SMCMR_SM_UART;
  1015. new_mode |= (prev_mode & (SMCMR_REN | SMCMR_TEN));
  1016. if (!(prev_mode & SMCMR_PEN))
  1017. /* If parity is disabled, mask out even/odd */
  1018. prev_mode &= ~SMCMR_PM_EVEN;
  1019. if (prev_mode != new_mode)
  1020. smcp->smc_smcmr = new_mode;
  1021. }
  1023. m8xx_cpm_setbrg((state - rs_table), baud_rate);
  1025. restore_flags(flags);
  1026. }
  1028. static void rs_8xx_put_char(struct tty_struct *tty, unsigned char ch)
  1029. {
  1030. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1031. volatile cbd_t *bdp;
  1033. if (serial_paranoia_check(info, tty->device, "rs_put_char"))
  1034. return;
  1036. if (!tty)
  1037. return;
  1039. bdp = info->tx_cur;
  1040. while (bdp->cbd_sc & BD_SC_READY);
  1042. *((char *)__va(bdp->cbd_bufaddr)) = ch;
  1043. bdp->cbd_datlen = 1;
  1044. bdp->cbd_sc |= BD_SC_READY;
  1046. /* Get next BD.
  1047. */
  1048. if (bdp->cbd_sc & BD_SC_WRAP)
  1049. bdp = info->tx_bd_base;
  1050. else
  1051. bdp++;
  1053. info->tx_cur = (cbd_t *)bdp;
  1055. }
  1057. static int rs_8xx_write(struct tty_struct * tty, int from_user,
  1058.     const unsigned char *buf, int count)
  1059. {
  1060. int c, ret = 0;
  1061. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1062. volatile cbd_t *bdp;
  1064. #ifdef CONFIG_KGDB
  1065.         /* Try to let stub handle output. Returns true if it did. */ 
  1066.         if (kgdb_output_string(buf, count))
  1067.             return ret;
  1068. #endif
  1070. if (serial_paranoia_check(info, tty->device, "rs_write"))
  1071. return 0;
  1073. if (!tty) 
  1074. return 0;
  1076. bdp = info->tx_cur;
  1078. while (1) {
  1079. c = MIN(count, TX_BUF_SIZE);
  1081. if (c <= 0)
  1082. break;
  1084. if (bdp->cbd_sc & BD_SC_READY) {
  1085. info->flags |= TX_WAKEUP;
  1086. break;
  1087. }
  1089. if (from_user) {
  1090. if (copy_from_user(__va(bdp->cbd_bufaddr), buf, c)) {
  1091. if (!ret)
  1092. ret = -EFAULT;
  1093. break;
  1094. }
  1095. } else {
  1096. memcpy(__va(bdp->cbd_bufaddr), buf, c);
  1097. }
  1099. bdp->cbd_datlen = c;
  1100. bdp->cbd_sc |= BD_SC_READY;
  1102. buf += c;
  1103. count -= c;
  1104. ret += c;
  1106. /* Get next BD.
  1107. */
  1108. if (bdp->cbd_sc & BD_SC_WRAP)
  1109. bdp = info->tx_bd_base;
  1110. else
  1111. bdp++;
  1112. info->tx_cur = (cbd_t *)bdp;
  1113. }
  1114. return ret;
  1115. }
  1117. static int rs_8xx_write_room(struct tty_struct *tty)
  1118. {
  1119. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1120. int ret;
  1122. if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  1123. return 0;
  1125. if ((info->tx_cur->cbd_sc & BD_SC_READY) == 0) {
  1126. info->flags &= ~TX_WAKEUP;
  1127. ret = TX_BUF_SIZE;
  1128. }
  1129. else {
  1130. info->flags |= TX_WAKEUP;
  1131. ret = 0;
  1132. }
  1133. return ret;
  1134. }
  1136. /* I could track this with transmit counters....maybe later.
  1137. */
  1138. static int rs_8xx_chars_in_buffer(struct tty_struct *tty)
  1139. {
  1140. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1142. if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  1143. return 0;
  1144. return 0;
  1145. }
  1147. static void rs_8xx_flush_buffer(struct tty_struct *tty)
  1148. {
  1149. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1151. if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  1152. return;
  1154. /* There is nothing to "flush", whatever we gave the CPM
  1155.  * is on its way out.
  1156.  */
  1157. wake_up_interruptible(&tty->write_wait);
  1158. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1159.     tty->ldisc.write_wakeup)
  1160. (tty->ldisc.write_wakeup)(tty);
  1161. info->flags &= ~TX_WAKEUP;
  1162. }
  1164. /*
  1165.  * This function is used to send a high-priority XON/XOFF character to
  1166.  * the device
  1167.  */
  1168. static void rs_8xx_send_xchar(struct tty_struct *tty, char ch)
  1169. {
  1170. volatile cbd_t *bdp;
  1172. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1174. if (serial_paranoia_check(info, tty->device, "rs_send_char"))
  1175. return;
  1177. bdp = info->tx_cur;
  1178. while (bdp->cbd_sc & BD_SC_READY);
  1180. *((char *)__va(bdp->cbd_bufaddr)) = ch;
  1181. bdp->cbd_datlen = 1;
  1182. bdp->cbd_sc |= BD_SC_READY;
  1184. /* Get next BD.
  1185. */
  1186. if (bdp->cbd_sc & BD_SC_WRAP)
  1187. bdp = info->tx_bd_base;
  1188. else
  1189. bdp++;
  1191. info->tx_cur = (cbd_t *)bdp;
  1192. }
  1194. /*
  1195.  * ------------------------------------------------------------
  1196.  * rs_throttle()
  1197.  * 
  1198.  * This routine is called by the upper-layer tty layer to signal that
  1199.  * incoming characters should be throttled.
  1200.  * ------------------------------------------------------------
  1201.  */
  1202. static void rs_8xx_throttle(struct tty_struct * tty)
  1203. {
  1204. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1205. #ifdef SERIAL_DEBUG_THROTTLE
  1206. char buf[64];
  1208. printk("throttle %s: %d....n", _tty_name(tty, buf),
  1209.        tty->ldisc.chars_in_buffer(tty));
  1210. #endif
  1212. if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  1213. return;
  1215. if (I_IXOFF(tty))
  1216. rs_8xx_send_xchar(tty, STOP_CHAR(tty));
  1218. #ifdef modem_control
  1219. if (tty->termios->c_cflag & CRTSCTS)
  1220. info->MCR &= ~UART_MCR_RTS;
  1222. cli();
  1223. serial_out(info, UART_MCR, info->MCR);
  1224. sti();
  1225. #endif
  1226. }
  1228. static void rs_8xx_unthrottle(struct tty_struct * tty)
  1229. {
  1230. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1231. #ifdef SERIAL_DEBUG_THROTTLE
  1232. char buf[64];
  1234. printk("unthrottle %s: %d....n", _tty_name(tty, buf),
  1235.        tty->ldisc.chars_in_buffer(tty));
  1236. #endif
  1238. if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  1239. return;
  1241. if (I_IXOFF(tty)) {
  1242. if (info->x_char)
  1243. info->x_char = 0;
  1244. else
  1245. rs_8xx_send_xchar(tty, START_CHAR(tty));
  1246. }
  1247. #ifdef modem_control
  1248. if (tty->termios->c_cflag & CRTSCTS)
  1249. info->MCR |= UART_MCR_RTS;
  1250. cli();
  1251. serial_out(info, UART_MCR, info->MCR);
  1252. sti();
  1253. #endif
  1254. }
  1256. /*
  1257.  * ------------------------------------------------------------
  1258.  * rs_ioctl() and friends
  1259.  * ------------------------------------------------------------
  1260.  */
  1262. #ifdef maybe
  1263. /*
  1264.  * get_lsr_info - get line status register info
  1265.  *
  1266.  * Purpose: Let user call ioctl() to get info when the UART physically
  1267.  *      is emptied.  On bus types like RS485, the transmitter must
  1268.  *      release the bus after transmitting. This must be done when
  1269.  *      the transmit shift register is empty, not be done when the
  1270.  *      transmit holding register is empty.  This functionality
  1271.  *      allows an RS485 driver to be written in user space. 
  1272.  */
  1273. static int get_lsr_info(struct async_struct * info, unsigned int *value)
  1274. {
  1275. unsigned char status;
  1276. unsigned int result;
  1278. cli();
  1279. status = serial_in(info, UART_LSR);
  1280. sti();
  1281. result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
  1282. return put_user(result,value);
  1283. }
  1284. #endif
  1286. static int get_modem_info(ser_info_t *info, unsigned int *value)
  1287. {
  1288. unsigned int result = 0;
  1289. #ifdef modem_control
  1290. unsigned char control, status;
  1292. control = info->MCR;
  1293. cli();
  1294. status = serial_in(info, UART_MSR);
  1295. sti();
  1296. result =  ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
  1297. | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
  1298. #ifdef TIOCM_OUT1
  1299. | ((control & UART_MCR_OUT1) ? TIOCM_OUT1 : 0)
  1300. | ((control & UART_MCR_OUT2) ? TIOCM_OUT2 : 0)
  1301. #endif
  1302. | ((status  & UART_MSR_DCD) ? TIOCM_CAR : 0)
  1303. | ((status  & UART_MSR_RI) ? TIOCM_RNG : 0)
  1304. | ((status  & UART_MSR_DSR) ? TIOCM_DSR : 0)
  1305. | ((status  & UART_MSR_CTS) ? TIOCM_CTS : 0);
  1306. #endif
  1307. return put_user(result,value);
  1308. }
  1310. static int set_modem_info(ser_info_t *info, unsigned int cmd,
  1311.   unsigned int *value)
  1312. {
  1313. int error;
  1314. unsigned int arg;
  1316. error = get_user(arg, value);
  1317. if (error)
  1318. return error;
  1319. #ifdef modem_control
  1320. switch (cmd) {
  1321. case TIOCMBIS: 
  1322. if (arg & TIOCM_RTS)
  1323. info->MCR |= UART_MCR_RTS;
  1324. if (arg & TIOCM_DTR)
  1325. info->MCR |= UART_MCR_DTR;
  1326. #ifdef TIOCM_OUT1
  1327. if (arg & TIOCM_OUT1)
  1328. info->MCR |= UART_MCR_OUT1;
  1329. if (arg & TIOCM_OUT2)
  1330. info->MCR |= UART_MCR_OUT2;
  1331. #endif
  1332. break;
  1333. case TIOCMBIC:
  1334. if (arg & TIOCM_RTS)
  1335. info->MCR &= ~UART_MCR_RTS;
  1336. if (arg & TIOCM_DTR)
  1337. info->MCR &= ~UART_MCR_DTR;
  1338. #ifdef TIOCM_OUT1
  1339. if (arg & TIOCM_OUT1)
  1340. info->MCR &= ~UART_MCR_OUT1;
  1341. if (arg & TIOCM_OUT2)
  1342. info->MCR &= ~UART_MCR_OUT2;
  1343. #endif
  1344. break;
  1345. case TIOCMSET:
  1346. info->MCR = ((info->MCR & ~(UART_MCR_RTS |
  1347. #ifdef TIOCM_OUT1
  1348.     UART_MCR_OUT1 |
  1349.     UART_MCR_OUT2 |
  1350. #endif
  1351.     UART_MCR_DTR))
  1352.      | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  1353. #ifdef TIOCM_OUT1
  1354.      | ((arg & TIOCM_OUT1) ? UART_MCR_OUT1 : 0)
  1355.      | ((arg & TIOCM_OUT2) ? UART_MCR_OUT2 : 0)
  1356. #endif
  1357.      | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  1358. break;
  1359. default:
  1360. return -EINVAL;
  1361. }
  1362. cli();
  1363. serial_out(info, UART_MCR, info->MCR);
  1364. sti();
  1365. #endif
  1366. return 0;
  1367. }
  1369. /* Sending a break is a two step process on the SMC/SCC.  It is accomplished
  1370.  * by sending a STOP TRANSMIT command followed by a RESTART TRANSMIT
  1371.  * command.  We take advantage of the begin/end functions to make this
  1372.  * happen.
  1373.  */
  1374. static ushort smc_chan_map[] = {
  1375. CPM_CR_CH_SMC1,
  1376. CPM_CR_CH_SMC2
  1377. };
  1379. static ushort scc_chan_map[] = {
  1380. CPM_CR_CH_SCC1,
  1381. CPM_CR_CH_SCC2,
  1382. CPM_CR_CH_SCC3,
  1383. CPM_CR_CH_SCC4
  1384. };
  1386. static void begin_break(ser_info_t *info)
  1387. {
  1388. volatile cpm8xx_t *cp;
  1389. ushort chan;
  1390. int idx;
  1392. cp = cpmp;
  1394. idx = PORT_NUM(info->state->smc_scc_num);
  1395. if (info->state->smc_scc_num & NUM_IS_SCC)
  1396. chan = scc_chan_map[idx];
  1397. else
  1398. chan = smc_chan_map[idx];
  1399. cp->cp_cpcr = mk_cr_cmd(chan, CPM_CR_STOP_TX) | CPM_CR_FLG;
  1400. while (cp->cp_cpcr & CPM_CR_FLG);
  1401. }
  1403. static void end_break(ser_info_t *info)
  1404. {
  1405. volatile cpm8xx_t *cp;
  1406. ushort chan;
  1407. int idx;
  1409. cp = cpmp;
  1411. idx = PORT_NUM(info->state->smc_scc_num);
  1412. if (info->state->smc_scc_num & NUM_IS_SCC)
  1413. chan = scc_chan_map[idx];
  1414. else
  1415. chan = smc_chan_map[idx];
  1416. cp->cp_cpcr = mk_cr_cmd(chan, CPM_CR_RESTART_TX) | CPM_CR_FLG;
  1417. while (cp->cp_cpcr & CPM_CR_FLG);
  1418. }
  1420. /*
  1421.  * This routine sends a break character out the serial port.
  1422.  */
  1423. static void send_break(ser_info_t *info, int duration)
  1424. {
  1425. current->state = TASK_INTERRUPTIBLE;
  1426. #ifdef SERIAL_DEBUG_SEND_BREAK
  1427. printk("rs_send_break(%d) jiff=%lu...", duration, jiffies);
  1428. #endif
  1429. begin_break(info);
  1430. schedule_timeout(duration);
  1431. end_break(info);
  1432. #ifdef SERIAL_DEBUG_SEND_BREAK
  1433. printk("done jiffies=%lun", jiffies);
  1434. #endif
  1435. }
  1438. static int rs_8xx_ioctl(struct tty_struct *tty, struct file * file,
  1439.     unsigned int cmd, unsigned long arg)
  1440. {
  1441. int error;
  1442. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1443. int retval;
  1444. struct async_icount cnow; /* kernel counter temps */
  1445. struct serial_icounter_struct *p_cuser; /* user space */
  1447. if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  1448. return -ENODEV;
  1450. if ((cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
  1451. if (tty->flags & (1 << TTY_IO_ERROR))
  1452.     return -EIO;
  1453. }
  1455. switch (cmd) {
  1456. case TCSBRK: /* SVID version: non-zero arg --> no break */
  1457. retval = tty_check_change(tty);
  1458. if (retval)
  1459. return retval;
  1460. tty_wait_until_sent(tty, 0);
  1461. if (signal_pending(current))
  1462. return -EINTR;
  1463. if (!arg) {
  1464. send_break(info, HZ/4); /* 1/4 second */
  1465. if (signal_pending(current))
  1466. return -EINTR;
  1467. }
  1468. return 0;
  1469. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1470. retval = tty_check_change(tty);
  1471. if (retval)
  1472. return retval;
  1473. tty_wait_until_sent(tty, 0);
  1474. if (signal_pending(current))
  1475. return -EINTR;
  1476. send_break(info, arg ? arg*(HZ/10) : HZ/4);
  1477. if (signal_pending(current))
  1478. return -EINTR;
  1479. return 0;
  1480. case TIOCSBRK:
  1481. retval = tty_check_change(tty);
  1482. if (retval)
  1483. return retval;
  1484. tty_wait_until_sent(tty, 0);
  1485. begin_break(info);
  1486. return 0;
  1487. case TIOCCBRK:
  1488. retval = tty_check_change(tty);
  1489. if (retval)
  1490. return retval;
  1491. end_break(info);
  1492. return 0;
  1493. case TIOCGSOFTCAR:
  1494. return put_user(C_CLOCAL(tty) ? 1 : 0, (int *) arg);
  1495. case TIOCSSOFTCAR:
  1496. error = get_user(arg, (unsigned int *) arg);
  1497. if (error)
  1498. return error;
  1499. tty->termios->c_cflag =
  1500. ((tty->termios->c_cflag & ~CLOCAL) |
  1501.  (arg ? CLOCAL : 0));
  1502. return 0;
  1503. case TIOCMGET:
  1504. return get_modem_info(info, (unsigned int *) arg);
  1505. case TIOCMBIS:
  1506. case TIOCMBIC:
  1507. case TIOCMSET:
  1508. return set_modem_info(info, cmd, (unsigned int *) arg);
  1509. #ifdef maybe
  1510. case TIOCSERGETLSR: /* Get line status register */
  1511. return get_lsr_info(info, (unsigned int *) arg);
  1512. #endif
  1513. /*
  1514.  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
  1515.  * - mask passed in arg for lines of interest
  1516.    *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  1517.  * Caller should use TIOCGICOUNT to see which one it was
  1518.  */
  1519.  case TIOCMIWAIT:
  1520. #ifdef modem_control
  1521. cli();
  1522. /* note the counters on entry */
  1523. cprev = info->state->icount;
  1524. sti();
  1525. while (1) {
  1526. interruptible_sleep_on(&info->delta_msr_wait);
  1527. /* see if a signal did it */
  1528. if (signal_pending(current))
  1529. return -ERESTARTSYS;
  1530. cli();
  1531. cnow = info->state->icount; /* atomic copy */
  1532. sti();
  1533. if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
  1534.     cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
  1535. return -EIO; /* no change => error */
  1536. if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  1537.      ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  1538.      ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
  1539.      ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
  1540. return 0;
  1541. }
  1542. cprev = cnow;
  1543. }
  1544. /* NOTREACHED */
  1545. #else
  1546. return 0;
  1547. #endif
  1549. /* 
  1550.  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
  1551.  * Return: write counters to the user passed counter struct
  1552.  * NB: both 1->0 and 0->1 transitions are counted except for
  1553.  *     RI where only 0->1 is counted.
  1554.  */
  1555. case TIOCGICOUNT:
  1556. cli();
  1557. cnow = info->state->icount;
  1558. sti();
  1559. p_cuser = (struct serial_icounter_struct *) arg;
  1560. error = put_user(cnow.cts, &p_cuser->cts);
  1561. if (error) return error;
  1562. error = put_user(cnow.dsr, &p_cuser->dsr);
  1563. if (error) return error;
  1564. error = put_user(cnow.rng, &p_cuser->rng);
  1565. if (error) return error;
  1566. error = put_user(cnow.dcd, &p_cuser->dcd);
  1567. if (error) return error;
  1568. return 0;
  1570. default:
  1571. return -ENOIOCTLCMD;
  1572. }
  1573. return 0;
  1574. }
  1576. /* FIX UP modem control here someday......
  1577. */
  1578. static void rs_8xx_set_termios(struct tty_struct *tty, struct termios *old_termios)
  1579. {
  1580. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1582. if (   (tty->termios->c_cflag == old_termios->c_cflag)
  1583.     && (   RELEVANT_IFLAG(tty->termios->c_iflag) 
  1584. == RELEVANT_IFLAG(old_termios->c_iflag)))
  1585.   return;
  1587. change_speed(info);
  1589. #ifdef modem_control
  1590. /* Handle transition to B0 status */
  1591. if ((old_termios->c_cflag & CBAUD) &&
  1592.     !(tty->termios->c_cflag & CBAUD)) {
  1593. info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS);
  1594. cli();
  1595. serial_out(info, UART_MCR, info->MCR);
  1596. sti();
  1597. }
  1599. /* Handle transition away from B0 status */
  1600. if (!(old_termios->c_cflag & CBAUD) &&
  1601.     (tty->termios->c_cflag & CBAUD)) {
  1602. info->MCR |= UART_MCR_DTR;
  1603. if (!tty->hw_stopped ||
  1604.     !(tty->termios->c_cflag & CRTSCTS)) {
  1605. info->MCR |= UART_MCR_RTS;
  1606. }
  1607. cli();
  1608. serial_out(info, UART_MCR, info->MCR);
  1609. sti();
  1610. }
  1612. /* Handle turning off CRTSCTS */
  1613. if ((old_termios->c_cflag & CRTSCTS) &&
  1614.     !(tty->termios->c_cflag & CRTSCTS)) {
  1615. tty->hw_stopped = 0;
  1616. rs_8xx_start(tty);
  1617. }
  1618. #endif
  1620. #if 0
  1621. /*
  1622.  * No need to wake up processes in open wait, since they
  1623.  * sample the CLOCAL flag once, and don't recheck it.
  1624.  * XXX  It's not clear whether the current behavior is correct
  1625.  * or not.  Hence, this may change.....
  1626.  */
  1627. if (!(old_termios->c_cflag & CLOCAL) &&
  1628.     (tty->termios->c_cflag & CLOCAL))
  1629. wake_up_interruptible(&info->open_wait);
  1630. #endif
  1631. }
  1633. /*
  1634.  * ------------------------------------------------------------
  1635.  * rs_close()
  1636.  * 
  1637.  * This routine is called when the serial port gets closed.  First, we
  1638.  * wait for the last remaining data to be sent.  Then, we unlink its
  1639.  * async structure from the interrupt chain if necessary, and we free
  1640.  * that IRQ if nothing is left in the chain.
  1641.  * ------------------------------------------------------------
  1642.  */
  1643. static void rs_8xx_close(struct tty_struct *tty, struct file * filp)
  1644. {
  1645. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1646. struct serial_state *state;
  1647. unsigned long flags;
  1648. int idx;
  1649. volatile smc_t *smcp;
  1650. volatile scc_t *sccp;
  1652. if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  1653. return;
  1655. state = info->state;
  1657. save_flags(flags); cli();
  1659. if (tty_hung_up_p(filp)) {
  1660. DBG_CNT("before DEC-hung");
  1661. MOD_DEC_USE_COUNT;
  1662. restore_flags(flags);
  1663. return;
  1664. }
  1666. #ifdef SERIAL_DEBUG_OPEN
  1667. printk("rs_close ttys%d, count = %dn", info->line, state->count);
  1668. #endif
  1669. if ((tty->count == 1) && (state->count != 1)) {
  1670. /*
  1671.  * Uh, oh.  tty->count is 1, which means that the tty
  1672.  * structure will be freed.  state->count should always
  1673.  * be one in these conditions.  If it's greater than
  1674.  * one, we've got real problems, since it means the
  1675.  * serial port won't be shutdown.
  1676.  */
  1677. printk("rs_close: bad serial port count; tty->count is 1, "
  1678.        "state->count is %dn", state->count);
  1679. state->count = 1;
  1680. }
  1681. if (--state->count < 0) {
  1682. printk("rs_close: bad serial port count for ttys%d: %dn",
  1683.        info->line, state->count);
  1684. state->count = 0;
  1685. }
  1686. if (state->count) {
  1687. DBG_CNT("before DEC-2");
  1688. MOD_DEC_USE_COUNT;
  1689. restore_flags(flags);
  1690. return;
  1691. }
  1692. info->flags |= ASYNC_CLOSING;
  1693. /*
  1694.  * Save the termios structure, since this port may have
  1695.  * separate termios for callout and dialin.
  1696.  */
  1697. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1698. info->state->normal_termios = *tty->termios;
  1699. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1700. info->state->callout_termios = *tty->termios;
  1701. /*
  1702.  * Now we wait for the transmit buffer to clear; and we notify 
  1703.  * the line discipline to only process XON/XOFF characters.
  1704.  */
  1705. tty->closing = 1;
  1706. if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  1707. tty_wait_until_sent(tty, info->closing_wait);
  1708. /*
  1709.  * At this point we stop accepting input.  To do this, we
  1710.  * disable the receive line status interrupts, and tell the
  1711.  * interrupt driver to stop checking the data ready bit in the
  1712.  * line status register.
  1713.  */
  1714. info->read_status_mask &= ~BD_SC_EMPTY;
  1715. if (info->flags & ASYNC_INITIALIZED) {
  1716. idx = PORT_NUM(info->state->smc_scc_num);
  1717. if (info->state->smc_scc_num & NUM_IS_SCC) {
  1718. sccp = &cpmp->cp_scc[idx];
  1719. sccp->scc_sccm &= ~UART_SCCM_RX;
  1720. sccp->scc_gsmrl &= ~SCC_GSMRL_ENR;
  1721. }
  1722. else {
  1723. smcp = &cpmp->cp_smc[idx];
  1724. smcp->smc_smcm &= ~SMCM_RX;
  1725. smcp->smc_smcmr &= ~SMCMR_REN;
  1726. }
  1727. /*
  1728.  * Before we drop DTR, make sure the UART transmitter
  1729.  * has completely drained; this is especially
  1730.  * important if there is a transmit FIFO!
  1731.  */
  1732. rs_8xx_wait_until_sent(tty, info->timeout);
  1733. }
  1734. shutdown(info);
  1735. if (tty->driver.flush_buffer)
  1736. tty->driver.flush_buffer(tty);
  1737. if (tty->ldisc.flush_buffer)
  1738. tty->ldisc.flush_buffer(tty);
  1739. tty->closing = 0;
  1740. info->event = 0;
  1741. info->tty = 0;
  1742. if (info->blocked_open) {
  1743. if (info->close_delay) {
  1744. current->state = TASK_INTERRUPTIBLE;
  1745. schedule_timeout(info->close_delay);
  1746. }
  1747. wake_up_interruptible(&info->open_wait);
  1748. }
  1749. info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  1750.  ASYNC_CLOSING);
  1751. wake_up_interruptible(&info->close_wait);
  1752. MOD_DEC_USE_COUNT;
  1753. restore_flags(flags);
  1754. }
  1756. /*
  1757.  * rs_wait_until_sent() --- wait until the transmitter is empty
  1758.  */
  1759. static void rs_8xx_wait_until_sent(struct tty_struct *tty, int timeout)
  1760. {
  1761. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1762. unsigned long orig_jiffies, char_time;
  1763. /*int lsr;*/
  1764. volatile cbd_t *bdp;
  1766. if (serial_paranoia_check(info, tty->device, "rs_wait_until_sent"))
  1767. return;
  1769. #ifdef maybe
  1770. if (info->state->type == PORT_UNKNOWN)
  1771. return;
  1772. #endif
  1774. orig_jiffies = jiffies;
  1775. /*
  1776.  * Set the check interval to be 1/5 of the estimated time to
  1777.  * send a single character, and make it at least 1.  The check
  1778.  * interval should also be less than the timeout.
  1779.  * 
  1780.  * Note: we have to use pretty tight timings here to satisfy
  1781.  * the NIST-PCTS.
  1782.  */
  1783. char_time = 1;
  1784. if (timeout)
  1785. char_time = MIN(char_time, timeout);
  1786. #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  1787. printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
  1788. printk("jiff=%lu...", jiffies);
  1789. #endif
  1791. /* We go through the loop at least once because we can't tell
  1792.  * exactly when the last character exits the shifter.  There can
  1793.  * be at least two characters waiting to be sent after the buffers
  1794.  * are empty.
  1795.  */
  1796. do {
  1797. #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  1798. printk("lsr = %d (jiff=%lu)...", lsr, jiffies);
  1799. #endif
  1800. current->state = TASK_INTERRUPTIBLE;
  1801. /* current->counter = 0;  make us low-priority */
  1802. schedule_timeout(char_time);
  1803. if (signal_pending(current))
  1804. break;
  1805. if (timeout && time_after(jiffies, orig_jiffies + timeout))
  1806. break;
  1808. /* The 'tx_cur' is really the next buffer to send.  We
  1809.  * have to back up to the previous BD and wait for it
  1810.  * to go.  This isn't perfect, because all this indicates
  1811.  * is the buffer is available.  There are still characters
  1812.  * in the CPM FIFO.
  1813.  */
  1814. bdp = info->tx_cur;
  1815. if (bdp == info->tx_bd_base)
  1816. bdp += (TX_NUM_FIFO-1);
  1817. else
  1818. bdp--;
  1819. } while (bdp->cbd_sc & BD_SC_READY);
  1820. current->state = TASK_RUNNING;
  1821. #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  1822. printk("lsr = %d (jiff=%lu)...donen", lsr, jiffies);
  1823. #endif
  1824. }
  1826. /*
  1827.  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  1828.  */
  1829. static void rs_8xx_hangup(struct tty_struct *tty)
  1830. {
  1831. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1832. struct serial_state *state = info->state;
  1834. if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  1835. return;
  1837. state = info->state;
  1839. rs_8xx_flush_buffer(tty);
  1840. shutdown(info);
  1841. info->event = 0;
  1842. state->count = 0;
  1843. info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  1844. info->tty = 0;
  1845. wake_up_interruptible(&info->open_wait);
  1846. }
  1848. /*
  1849.  * ------------------------------------------------------------
  1850.  * rs_open() and friends
  1851.  * ------------------------------------------------------------
  1852.  */
  1853. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1854.    ser_info_t *info)
  1855. {
  1856. #ifdef DO_THIS_LATER
  1857. DECLARE_WAITQUEUE(wait, current);
  1858. #endif
  1859. struct serial_state *state = info->state;
  1860. int retval;
  1861. int do_clocal = 0;
  1863. /*
  1864.  * If the device is in the middle of being closed, then block
  1865.  * until it's done, and then try again.
  1866.  */
  1867. if (tty_hung_up_p(filp) ||
  1868.     (info->flags & ASYNC_CLOSING)) {
  1869. if (info->flags & ASYNC_CLOSING)
  1870. interruptible_sleep_on(&info->close_wait);
  1871. #ifdef SERIAL_DO_RESTART
  1872. if (info->flags & ASYNC_HUP_NOTIFY)
  1873. return -EAGAIN;
  1874. else
  1875. return -ERESTARTSYS;
  1876. #else
  1877. return -EAGAIN;
  1878. #endif
  1879. }
  1881. /*
  1882.  * If this is a callout device, then just make sure the normal
  1883.  * device isn't being used.
  1884.  */
  1885. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1886. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1887. return -EBUSY;
  1888. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1889.     (info->flags & ASYNC_SESSION_LOCKOUT) &&
  1890.     (info->session != current->session))
  1891.     return -EBUSY;
  1892. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1893.     (info->flags & ASYNC_PGRP_LOCKOUT) &&
  1894.     (info->pgrp != current->pgrp))
  1895.     return -EBUSY;
  1896. info->flags |= ASYNC_CALLOUT_ACTIVE;
  1897. return 0;
  1898. }
  1900. /*
  1901.  * If non-blocking mode is set, or the port is not enabled,
  1902.  * then make the check up front and then exit.
  1903.  * If this is an SMC port, we don't have modem control to wait
  1904.  * for, so just get out here.
  1905.  */
  1906. if ((filp->f_flags & O_NONBLOCK) ||
  1907.     (tty->flags & (1 << TTY_IO_ERROR)) ||
  1908.     !(info->state->smc_scc_num & NUM_IS_SCC)) {
  1909. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1910. return -EBUSY;
  1911. info->flags |= ASYNC_NORMAL_ACTIVE;
  1912. return 0;
  1913. }
  1915. if (info->flags & ASYNC_CALLOUT_ACTIVE) {
  1916. if (state->normal_termios.c_cflag & CLOCAL)
  1917. do_clocal = 1;
  1918. } else {
  1919. if (tty->termios->c_cflag & CLOCAL)
  1920. do_clocal = 1;
  1921. }
  1923. /*
  1924.  * Block waiting for the carrier detect and the line to become
  1925.  * free (i.e., not in use by the callout).  While we are in
  1926.  * this loop, state->count is dropped by one, so that
  1927.  * rs_close() knows when to free things.  We restore it upon
  1928.  * exit, either normal or abnormal.
  1929.  */
  1930. retval = 0;
  1931. #ifdef DO_THIS_LATER
  1932. add_wait_queue(&info->open_wait, &wait);
  1933. #ifdef SERIAL_DEBUG_OPEN
  1934. printk("block_til_ready before block: ttys%d, count = %dn",
  1935.        state->line, state->count);
  1936. #endif
  1937. cli();
  1938. if (!tty_hung_up_p(filp)) 
  1939. state->count--;
  1940. sti();
  1941. info->blocked_open++;
  1942. while (1) {
  1943. cli();
  1944. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1945.     (tty->termios->c_cflag & CBAUD))
  1946. serial_out(info, UART_MCR,
  1947.    serial_inp(info, UART_MCR) |
  1948.    (UART_MCR_DTR | UART_MCR_RTS));
  1949. sti();
  1950. set_current_state(TASK_INTERRUPTIBLE);
  1951. if (tty_hung_up_p(filp) ||
  1952.     !(info->flags & ASYNC_INITIALIZED)) {
  1953. #ifdef SERIAL_DO_RESTART
  1954. if (info->flags & ASYNC_HUP_NOTIFY)
  1955. retval = -EAGAIN;
  1956. else
  1957. retval = -ERESTARTSYS;
  1958. #else
  1959. retval = -EAGAIN;
  1960. #endif
  1961. break;
  1962. }
  1963. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1964.     !(info->flags & ASYNC_CLOSING) &&
  1965.     (do_clocal || (serial_in(info, UART_MSR) &
  1966.    UART_MSR_DCD)))
  1967. break;
  1968. if (signal_pending(current)) {
  1969. retval = -ERESTARTSYS;
  1970. break;
  1971. }
  1972. #ifdef SERIAL_DEBUG_OPEN
  1973. printk("block_til_ready blocking: ttys%d, count = %dn",
  1974.        info->line, state->count);
  1975. #endif
  1976. schedule();
  1977. }
  1978. current->state = TASK_RUNNING;
  1979. remove_wait_queue(&info->open_wait, &wait);
  1980. if (!tty_hung_up_p(filp))
  1981. state->count++;
  1982. info->blocked_open--;
  1983. #ifdef SERIAL_DEBUG_OPEN
  1984. printk("block_til_ready after blocking: ttys%d, count = %dn",
  1985.        info->line, state->count);
  1986. #endif
  1987. #endif /* DO_THIS_LATER */
  1988. if (retval)
  1989. return retval;
  1990. info->flags |= ASYNC_NORMAL_ACTIVE;
  1991. return 0;
  1992. }
  1994. static int get_async_struct(int line, ser_info_t **ret_info)
  1995. {
  1996. struct serial_state *sstate;
  1998. sstate = rs_table + line;
  1999. if (sstate->info) {
  2000. sstate->count++;
  2001. *ret_info = (ser_info_t *)sstate->info;
  2002. return 0;
  2003. }
  2004. else {
  2005. return -ENOMEM;
  2006. }
  2007. }
  2009. /*
  2010.  * This routine is called whenever a serial port is opened.  It
  2011.  * enables interrupts for a serial port, linking in its async structure into
  2012.  * the IRQ chain.   It also performs the serial-specific
  2013.  * initialization for the tty structure.
  2014.  */
  2015. static int rs_8xx_open(struct tty_struct *tty, struct file * filp)
  2016. {
  2017. ser_info_t *info;
  2018. int  retval, line;
  2020. line = MINOR(tty->device) - tty->driver.minor_start;
  2021. if ((line < 0) || (line >= NR_PORTS))
  2022. return -ENODEV;
  2023. retval = get_async_struct(line, &info);
  2024. if (retval)
  2025. return retval;
  2026. if (serial_paranoia_check(info, tty->device, "rs_open"))
  2027. return -ENODEV;
  2029. #ifdef SERIAL_DEBUG_OPEN
  2030. printk("rs_open %s%d, count = %dn", tty->driver.name, info->line,
  2031.        info->state->count);
  2032. #endif
  2033. tty->driver_data = info;
  2034. info->tty = tty;
  2036. /*
  2037.  * Start up serial port
  2038.  */
  2039. retval = startup(info);
  2040. if (retval)
  2041. return retval;
  2043. MOD_INC_USE_COUNT;
  2044. retval = block_til_ready(tty, filp, info);
  2045. if (retval) {
  2046. #ifdef SERIAL_DEBUG_OPEN
  2047. printk("rs_open returning after block_til_ready with %dn",
  2048.        retval);
  2049. #endif
  2050. MOD_DEC_USE_COUNT;
  2051. return retval;
  2052. }
  2054. if ((info->state->count == 1) &&
  2055.     (info->flags & ASYNC_SPLIT_TERMIOS)) {
  2056. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  2057. *tty->termios = info->state->normal_termios;
  2058. else 
  2059. *tty->termios = info->state->callout_termios;
  2060. change_speed(info);
  2061. }
  2063. info->session = current->session;
  2064. info->pgrp = current->pgrp;
  2066. #ifdef SERIAL_DEBUG_OPEN
  2067. printk("rs_open ttys%d successful...", info->line);
  2068. #endif
  2069. return 0;
  2070. }
  2072. /*
  2073.  * /proc fs routines....
  2074.  */
  2076. static int inline line_info(char *buf, struct serial_state *state)
  2077. {
  2078. #ifdef notdef
  2079. struct async_struct *info = state->info, scr_info;
  2080. char stat_buf[30], control, status;
  2081. #endif
  2082. int ret;
  2084. ret = sprintf(buf, "%d: uart:%s port:%X irq:%d",
  2085.       state->line,
  2086.       (state->smc_scc_num & NUM_IS_SCC) ? "SCC" : "SMC",
  2087.       (unsigned int)(state->port), state->irq);
  2089. if (!state->port || (state->type == PORT_UNKNOWN)) {
  2090. ret += sprintf(buf+ret, "n");
  2091. return ret;
  2092. }
  2094. #ifdef notdef
  2095. /*
  2096.  * Figure out the current RS-232 lines
  2097.  */
  2098. if (!info) {
  2099. info = &scr_info; /* This is just for serial_{in,out} */
  2101. info->magic = SERIAL_MAGIC;
  2102. info->port = state->port;
  2103. info->flags = state->flags;
  2104. info->quot = 0;
  2105. info->tty = 0;
  2106. }
  2107. cli();
  2108. status = serial_in(info, UART_MSR);
  2109. control = info ? info->MCR : serial_in(info, UART_MCR);
  2110. sti();
  2112. stat_buf[0] = 0;
  2113. stat_buf[1] = 0;
  2114. if (control & UART_MCR_RTS)
  2115. strcat(stat_buf, "|RTS");
  2116. if (status & UART_MSR_CTS)
  2117. strcat(stat_buf, "|CTS");
  2118. if (control & UART_MCR_DTR)
  2119. strcat(stat_buf, "|DTR");
  2120. if (status & UART_MSR_DSR)
  2121. strcat(stat_buf, "|DSR");
  2122. if (status & UART_MSR_DCD)
  2123. strcat(stat_buf, "|CD");
  2124. if (status & UART_MSR_RI)
  2125. strcat(stat_buf, "|RI");
  2127. if (info->quot) {
  2128. ret += sprintf(buf+ret, " baud:%d",
  2129.        state->baud_base / info->quot);
  2130. }
  2132. ret += sprintf(buf+ret, " tx:%d rx:%d",
  2133.       state->icount.tx, state->icount.rx);
  2135. if (state->icount.frame)
  2136. ret += sprintf(buf+ret, " fe:%d", state->icount.frame);
  2138. if (state->icount.parity)
  2139. ret += sprintf(buf+ret, " pe:%d", state->icount.parity);
  2141. if (state->icount.brk)
  2142. ret += sprintf(buf+ret, " brk:%d", state->icount.brk);
  2144. if (state->icount.overrun)
  2145. ret += sprintf(buf+ret, " oe:%d", state->icount.overrun);
  2147. /*
  2148.  * Last thing is the RS-232 status lines
  2149.  */
  2150. ret += sprintf(buf+ret, " %sn", stat_buf+1);
  2151. #endif
  2152. return ret;
  2153. }
  2155. int rs_8xx_read_proc(char *page, char **start, off_t off, int count,
  2156.  int *eof, void *data)
  2157. {
  2158. int i, len = 0;
  2159. off_t begin = 0;
  2161. len += sprintf(page, "serinfo:1.0 driver:%sn", serial_version);
  2162. for (i = 0; i < NR_PORTS && len < 4000; i++) {
  2163. len += line_info(page + len, &rs_table[i]);
  2164. if (len+begin > off+count)
  2165. goto done;
  2166. if (len+begin < off) {
  2167. begin += len;
  2168. len = 0;
  2169. }
  2170. }
  2171. *eof = 1;
  2172. done:
  2173. if (off >= len+begin)
  2174. return 0;
  2175. *start = page + (begin-off);
  2176. return ((count < begin+len-off) ? count : begin+len-off);
  2177. }
  2179. /*
  2180.  * ---------------------------------------------------------------------
  2181.  * rs_init() and friends
  2182.  *
  2183.  * rs_init() is called at boot-time to initialize the serial driver.
  2184.  * ---------------------------------------------------------------------
  2185.  */
  2187. /*
  2188.  * This routine prints out the appropriate serial driver version
  2189.  * number, and identifies which options were configured into this
  2190.  * driver.
  2191.  */
  2192. static _INLINE_ void show_serial_version(void)
  2193. {
  2194.   printk(KERN_INFO "%s version %sn", serial_name, serial_version);
  2195. }
  2198. /*
  2199.  * The serial console driver used during boot.  Note that these names
  2200.  * clash with those found in "serial.c", so we currently can't support
  2201.  * the 16xxx uarts and these at the same time.  I will fix this to become
  2202.  * an indirect function call from tty_io.c (or something).
  2203.  */
  2205. #ifdef CONFIG_SERIAL_CONSOLE
  2207. /*
  2208.  * Print a string to the serial port trying not to disturb any possible
  2209.  * real use of the port...
  2210.  */
  2211. static void my_console_write(int idx, const char *s,
  2212. unsigned count)
  2213. {
  2214. struct serial_state *ser;
  2215. ser_info_t *info;
  2216. unsigned i;
  2217. volatile cbd_t *bdp, *bdbase;
  2218. volatile smc_uart_t *up;
  2219. volatile u_char *cp;
  2221. ser = rs_table + idx;
  2223. /* If the port has been initialized for general use, we have
  2224.  * to use the buffer descriptors allocated there.  Otherwise,
  2225.  * we simply use the single buffer allocated.
  2226.  */
  2227. if ((info = (ser_info_t *)ser->info) != NULL) {
  2228. bdp = info->tx_cur;
  2229. bdbase = info->tx_bd_base;
  2230. }
  2231. else {
  2232. /* Pointer to UART in parameter ram.
  2233. */
  2234. up = (smc_uart_t *)&cpmp->cp_dparam[ser->port];
  2236. /* Get the address of the host memory buffer.
  2237.  */
  2238. bdp = bdbase = (cbd_t *)&cpmp->cp_dpmem[up->smc_tbase];
  2239. }
  2241. /*
  2242.  * We need to gracefully shut down the transmitter, disable
  2243.  * interrupts, then send our bytes out.
  2244.  */
  2246. /*
  2247.  * Now, do each character.  This is not as bad as it looks
  2248.  * since this is a holding FIFO and not a transmitting FIFO.
  2249.  * We could add the complexity of filling the entire transmit
  2250.  * buffer, but we would just wait longer between accesses......
  2251.  */
  2252. for (i = 0; i < count; i++, s++) {
  2253. /* Wait for transmitter fifo to empty.
  2254.  * Ready indicates output is ready, and xmt is doing
  2255.  * that, not that it is ready for us to send.
  2256.  */
  2257. while (bdp->cbd_sc & BD_SC_READY);
  2259. /* Send the character out.
  2260.  * If the buffer address is in the CPM DPRAM, don't
  2261.  * convert it.
  2262.  */
  2263. if ((uint)(bdp->cbd_bufaddr) > (uint)IMAP_ADDR)
  2264. cp = (u_char *)(bdp->cbd_bufaddr);
  2265. else
  2266. cp = __va(bdp->cbd_bufaddr);
  2267. *cp = *s;
  2269. bdp->cbd_datlen = 1;
  2270. bdp->cbd_sc |= BD_SC_READY;
  2272. if (bdp->cbd_sc & BD_SC_WRAP)
  2273. bdp = bdbase;
  2274. else
  2275. bdp++;
  2277. /* if a LF, also do CR... */
  2278. if (*s == 10) {
  2279. while (bdp->cbd_sc & BD_SC_READY);
  2280. cp = __va(bdp->cbd_bufaddr);
  2281. *cp = 13;
  2282. bdp->cbd_datlen = 1;
  2283. bdp->cbd_sc |= BD_SC_READY;
  2285. if (bdp->cbd_sc & BD_SC_WRAP) {
  2286. bdp = bdbase;
  2287. }
  2288. else {
  2289. bdp++;
  2290. }
  2291. }
  2292. }
  2294. /*
  2295.  * Finally, Wait for transmitter & holding register to empty
  2296.  *  and restore the IER
  2297.  */
  2298. while (bdp->cbd_sc & BD_SC_READY);
  2300. if (info)
  2301. info->tx_cur = (cbd_t *)bdp;
  2302. }
  2304. static void serial_console_write(struct console *c, const char *s,
  2305. unsigned count)
  2306. {
  2307. #ifdef CONFIG_KGDB
  2308. /* Try to let stub handle output. Returns true if it did. */ 
  2309. if (kgdb_output_string(s, count))
  2310. return;
  2311. #endif
  2312. my_console_write(c->index, s, count);
  2313. }
  2315. #ifdef CONFIG_XMON
  2316. int
  2317. xmon_8xx_write(const char *s, unsigned count)
  2318. {
  2319. my_console_write(0, s, count);
  2320. return(count);
  2321. }
  2322. #endif
  2324. #ifdef CONFIG_KGDB
  2325. void
  2326. putDebugChar(char ch)
  2327. {
  2328. my_console_write(0, &ch, 1);
  2329. }
  2330. #endif
  2332. /*
  2333.  * Receive character from the serial port.  This only works well
  2334.  * before the port is initialized for real use.
  2335.  */
  2336. static int my_console_wait_key(int idx, int xmon, char *obuf)
  2337. {
  2338. struct serial_state *ser;
  2339. u_char c, *cp;
  2340. ser_info_t *info;
  2341. volatile cbd_t *bdp;
  2342. volatile smc_uart_t *up;
  2343. int i;
  2345. ser = rs_table + idx;
  2347. /* Pointer to UART in parameter ram.
  2348. */
  2349. up = (smc_uart_t *)&cpmp->cp_dparam[ser->port];
  2351. /* Get the address of the host memory buffer.
  2352.  * If the port has been initialized for general use, we must
  2353.  * use information from the port structure.
  2354.  */
  2355. if ((info = (ser_info_t *)ser->info))
  2356. bdp = info->rx_cur;
  2357. else
  2358. bdp = (cbd_t *)&cpmp->cp_dpmem[up->smc_rbase];
  2360. /*
  2361.  * We need to gracefully shut down the receiver, disable
  2362.  * interrupts, then read the input.
  2363.  * XMON just wants a poll.  If no character, return -1, else
  2364.  * return the character.
  2365.  */
  2366. if (!xmon) {
  2367. while (bdp->cbd_sc & BD_SC_EMPTY);
  2368. }
  2369. else {
  2370. if (bdp->cbd_sc & BD_SC_EMPTY)
  2371. return -1;
  2372. }
  2374. /* If the buffer address is in the CPM DPRAM, don't
  2375.  * convert it.
  2376.  */
  2377. if ((uint)(bdp->cbd_bufaddr) > (uint)IMAP_ADDR)
  2378. cp = (u_char *)(bdp->cbd_bufaddr);
  2379. else
  2380. cp = __va(bdp->cbd_bufaddr);
  2382. if (obuf) {
  2383. i = c = bdp->cbd_datlen;
  2384. while (i-- > 0)
  2385. *obuf++ = *cp++;
  2386. }
  2387. else {
  2388. c = *cp;
  2389. }
  2390. bdp->cbd_sc |= BD_SC_EMPTY;
  2392. if (info) {
  2393. if (bdp->cbd_sc & BD_SC_WRAP) {
  2394. bdp = info->rx_bd_base;
  2395. }
  2396. else {
  2397. bdp++;
  2398. }
  2399. info->rx_cur = (cbd_t *)bdp;
  2400. }
  2402. return((int)c);
  2403. }
  2405. static int serial_console_wait_key(struct console *co)
  2406. {
  2407. return(my_console_wait_key(co->index, 0, NULL));
  2408. }
  2410. #ifdef CONFIG_XMON
  2411. int
  2412. xmon_8xx_read_poll(void)
  2413. {
  2414. return(my_console_wait_key(0, 1, NULL));
  2415. }
  2417. int
  2418. xmon_8xx_read_char(void)
  2419. {
  2420. return(my_console_wait_key(0, 0, NULL));
  2421. }
  2422. #endif
  2424. #ifdef CONFIG_KGDB
  2425. static char kgdb_buf[RX_BUF_SIZE], *kgdp;
  2426. static int kgdb_chars;
  2428. unsigned char
  2429. getDebugChar(void)
  2430. {
  2431. if (kgdb_chars <= 0) {
  2432. kgdb_chars = my_console_wait_key(0, 0, kgdb_buf);
  2433. kgdp = kgdb_buf;
  2434. }
  2435. kgdb_chars--;
  2437. return(*kgdp++);
  2438. }
  2440. void kgdb_interruptible(int state)
  2441. {
  2442. }
  2443. void kgdb_map_scc(void)
  2444. {
  2445. struct serial_state *ser;
  2446. uint mem_addr;
  2447. volatile cbd_t *bdp;
  2448. volatile smc_uart_t *up;
  2450. cpmp = (cpm8xx_t *)&(((immap_t *)IMAP_ADDR)->im_cpm);
  2452. /* To avoid data cache CPM DMA coherency problems, allocate a
  2453.  * buffer in the CPM DPRAM.  This will work until the CPM and
  2454.  * serial ports are initialized.  At that time a memory buffer
  2455.  * will be allocated.
  2456.  * The port is already initialized from the boot procedure, all
  2457.  * we do here is give it a different buffer and make it a FIFO.
  2458.  */
  2460. ser = rs_table;
  2462. /* Right now, assume we are using SMCs.
  2463. */
  2464. up = (smc_uart_t *)&cpmp->cp_dparam[ser->port];
  2466. /* Allocate space for an input FIFO, plus a few bytes for output.
  2467.  * Allocate bytes to maintain word alignment.
  2468.  */
  2469. mem_addr = (uint)(&cpmp->cp_dpmem[0x1000]);
  2471. /* Set the physical address of the host memory buffers in
  2472.  * the buffer descriptors.
  2473.  */
  2474. bdp = (cbd_t *)&cpmp->cp_dpmem[up->smc_rbase];
  2475. bdp->cbd_bufaddr = mem_addr;
  2477. bdp = (cbd_t *)&cpmp->cp_dpmem[up->smc_tbase];
  2478. bdp->cbd_bufaddr = mem_addr+RX_BUF_SIZE;
  2480. up->smc_mrblr = RX_BUF_SIZE; /* receive buffer length */
  2481. up->smc_maxidl = RX_BUF_SIZE;
  2482. }
  2483. #endif
  2485. static kdev_t serial_console_device(struct console *c)
  2486. {
  2487. return MKDEV(TTY_MAJOR, 64 + c->index);
  2488. }
  2490. /*
  2491.  * Register console.
  2492.  */
  2493. long __init console_8xx_init(long kmem_start, long kmem_end)
  2494. {
  2495. register_console(&sercons);
  2496. return kmem_start;
  2497. }
  2499. #endif
  2501. /* Index in baud rate table of the default console baud rate.
  2502. */
  2503. static int baud_idx;
  2505. /*
  2506.  * The serial driver boot-time initialization code!
  2507.  */
  2508. int __init rs_8xx_init(void)
  2509. {
  2510. struct serial_state * state;
  2511. ser_info_t *info;
  2512. uint mem_addr, dp_addr, iobits;
  2513. int i, j, idx;
  2514. ushort chan;
  2515. volatile cbd_t *bdp;
  2516. volatile cpm8xx_t *cp;
  2517. volatile smc_t *sp;
  2518. volatile smc_uart_t *up;
  2519. volatile scc_t *scp;
  2520. volatile scc_uart_t *sup;
  2521. volatile immap_t *immap;
  2523. init_bh(SERIAL_BH, do_serial_bh);
  2525. show_serial_version();
  2527. /* Initialize the tty_driver structure */
  2529. __clear_user(&serial_driver,sizeof(struct tty_driver));
  2530. serial_driver.magic = TTY_DRIVER_MAGIC;
  2531. serial_driver.driver_name = "serial";
  2532. #ifdef CONFIG_DEVFS_FS
  2533. serial_driver.name = "tts/%d";
  2534. #else
  2535. serial_driver.name = "ttyS";
  2536. #endif
  2537. serial_driver.major = TTY_MAJOR;
  2538. serial_driver.minor_start = 64;
  2539. serial_driver.num = NR_PORTS;
  2540. serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  2541. serial_driver.subtype = SERIAL_TYPE_NORMAL;
  2542. serial_driver.init_termios = tty_std_termios;
  2543. serial_driver.init_termios.c_cflag =
  2544. baud_idx | CS8 | CREAD | HUPCL | CLOCAL;
  2545. serial_driver.flags = TTY_DRIVER_REAL_RAW;
  2546. serial_driver.refcount = &serial_refcount;
  2547. serial_driver.table = serial_table;
  2548. serial_driver.termios = serial_termios;
  2549. serial_driver.termios_locked = serial_termios_locked;
  2551. serial_driver.open = rs_8xx_open;
  2552. serial_driver.close = rs_8xx_close;
  2553. serial_driver.write = rs_8xx_write;
  2554. serial_driver.put_char = rs_8xx_put_char;
  2555. serial_driver.write_room = rs_8xx_write_room;
  2556. serial_driver.chars_in_buffer = rs_8xx_chars_in_buffer;
  2557. serial_driver.flush_buffer = rs_8xx_flush_buffer;
  2558. serial_driver.ioctl = rs_8xx_ioctl;
  2559. serial_driver.throttle = rs_8xx_throttle;
  2560. serial_driver.unthrottle = rs_8xx_unthrottle;
  2561. serial_driver.send_xchar = rs_8xx_send_xchar;
  2562. serial_driver.set_termios = rs_8xx_set_termios;
  2563. serial_driver.stop = rs_8xx_stop;
  2564. serial_driver.start = rs_8xx_start;
  2565. serial_driver.hangup = rs_8xx_hangup;
  2566. serial_driver.wait_until_sent = rs_8xx_wait_until_sent;
  2567. serial_driver.read_proc = rs_8xx_read_proc;
  2569. /*
  2570.  * The callout device is just like normal device except for
  2571.  * major number and the subtype code.
  2572.  */
  2573. callout_driver = serial_driver;
  2574. #ifdef CONFIG_DEVFS_FS
  2575. callout_driver.name = "cua/%d";
  2576. #else
  2577. callout_driver.name = "cua";
  2578. #endif
  2579. callout_driver.major = TTYAUX_MAJOR;
  2580. callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  2581. callout_driver.read_proc = 0;
  2582. callout_driver.proc_entry = 0;
  2584. if (tty_register_driver(&serial_driver))
  2585. panic("Couldn't register serial drivern");
  2586. if (tty_register_driver(&callout_driver))
  2587. panic("Couldn't register callout drivern");
  2589. cp = cpmp; /* Get pointer to Communication Processor */
  2590. immap = (immap_t *)IMAP_ADDR; /* and to internal registers */
  2593. /* Configure SCC2, SCC3, and SCC4 instead of port A parallel I/O.
  2594.  */
  2595. #ifdef CONFIG_USE_SCC_IO
  2596. #ifndef CONFIG_MBX
  2597. /* The "standard" configuration through the 860.
  2598. */
  2599. immap->im_ioport.iop_papar |= 0x00fc;
  2600. immap->im_ioport.iop_padir &= ~0x00fc;
  2601. immap->im_ioport.iop_paodr &= ~0x00fc;
  2602. #else
  2603. /* On the MBX, SCC3 is through Port D.
  2604. */
  2605. immap->im_ioport.iop_papar |= 0x000c; /* SCC2 on port A */
  2606. immap->im_ioport.iop_padir &= ~0x000c;
  2607. immap->im_ioport.iop_paodr &= ~0x000c;
  2609. immap->im_ioport.iop_pdpar |= 0x0030; /* SCC3 on port D */
  2610. #endif
  2612. /* Since we don't yet do modem control, connect the port C pins
  2613.  * as general purpose I/O.  This will assert CTS and CD for the
  2614.  * SCC ports.
  2615.  */
  2616. immap->im_ioport.iop_pcdir |= 0x03c6;
  2617. immap->im_ioport.iop_pcpar &= ~0x03c6;
  2619. /* Connect SCC2 and SCC3 to NMSI.  Connect BRG3 to SCC2 and
  2620.  * BRG4 to SCC3.
  2621.  */
  2622. cp->cp_sicr &= ~0x00ffff00;
  2623. cp->cp_sicr |= 0x001b1200;
  2625. #ifdef CONFIG_PP04
  2626. /* Frequentis PP04 forced to RS-232 until we know better.
  2627.  * Port C 12 and 13 low enables RS-232 on SCC3 and SCC4.
  2628.  */
  2629. immap->im_ioport.iop_pcdir |= 0x000c;
  2630. immap->im_ioport.iop_pcpar &= ~0x000c;
  2631. immap->im_ioport.iop_pcdat &= ~0x000c;
  2633. /* This enables the TX driver.
  2634. */
  2635. cp->cp_pbpar &= ~0x6000;
  2636. cp->cp_pbdat &= ~0x6000;
  2637. #endif
  2638. #endif
  2640. for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) {
  2641. state->magic = SSTATE_MAGIC;
  2642. state->line = i;
  2643. state->type = PORT_UNKNOWN;
  2644. state->custom_divisor = 0;
  2645. state->close_delay = 5*HZ/10;
  2646. state->closing_wait = 30*HZ;
  2647. state->callout_termios = callout_driver.init_termios;
  2648. state->normal_termios = serial_driver.init_termios;
  2649. state->icount.cts = state->icount.dsr = 
  2650. state->icount.rng = state->icount.dcd = 0;
  2651. state->icount.rx = state->icount.tx = 0;
  2652. state->icount.frame = state->icount.parity = 0;
  2653. state->icount.overrun = state->icount.brk = 0;
  2654. printk(KERN_INFO "ttyS%02d at 0x%04x is a %sn",
  2655.        i, (unsigned int)(state->port),
  2656.        (state->smc_scc_num & NUM_IS_SCC) ? "SCC" : "SMC");
  2657. #ifdef CONFIG_SERIAL_CONSOLE
  2658. /* If we just printed the message on the console port, and
  2659.  * we are about to initialize it for general use, we have
  2660.  * to wait a couple of character times for the CR/NL to
  2661.  * make it out of the transmit buffer.
  2662.  */
  2663. if (i == CONFIG_SERIAL_CONSOLE_PORT)
  2664. mdelay(2);
  2665. #endif
  2666. info = kmalloc(sizeof(ser_info_t), GFP_KERNEL);
  2667. if (info) {
  2668. __clear_user(info,sizeof(ser_info_t));
  2669. init_waitqueue_head(&info->open_wait);
  2670. init_waitqueue_head(&info->close_wait);
  2671. info->magic = SERIAL_MAGIC;
  2672. info->flags = state->flags;
  2673. info->tqueue.routine = do_softint;
  2674. info->tqueue.data = info;
  2675. info->tqueue_hangup.routine = do_serial_hangup;
  2676. info->tqueue_hangup.data = info;
  2677. info->line = i;
  2678. info->state = state;
  2679. state->info = (struct async_struct *)info;
  2681. /* We need to allocate a transmit and receive buffer
  2682.  * descriptors from dual port ram, and a character
  2683.  * buffer area from host mem.
  2684.  */
  2685. dp_addr = m8xx_cpm_dpalloc(sizeof(cbd_t) * RX_NUM_FIFO);
  2687. /* Allocate space for FIFOs in the host memory.
  2688. */
  2689. mem_addr = m8xx_cpm_hostalloc(RX_NUM_FIFO * RX_BUF_SIZE);
  2691. /* Set the physical address of the host memory
  2692.  * buffers in the buffer descriptors, and the
  2693.  * virtual address for us to work with.
  2694.  */
  2695. bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
  2696. info->rx_cur = info->rx_bd_base = (cbd_t *)bdp;
  2698. for (j=0; j<(RX_NUM_FIFO-1); j++) {
  2699. bdp->cbd_bufaddr = __pa(mem_addr);
  2700. bdp->cbd_sc = BD_SC_EMPTY | BD_SC_INTRPT;
  2701. mem_addr += RX_BUF_SIZE;
  2702. bdp++;
  2703. }
  2704. bdp->cbd_bufaddr = __pa(mem_addr);
  2705. bdp->cbd_sc = BD_SC_WRAP | BD_SC_EMPTY | BD_SC_INTRPT;
  2707. idx = PORT_NUM(info->state->smc_scc_num);
  2708. if (info->state->smc_scc_num & NUM_IS_SCC) {
  2709. scp = &cp->cp_scc[idx];
  2710. sup = (scc_uart_t *)&cp->cp_dparam[state->port];
  2711. sup->scc_genscc.scc_rbase = dp_addr;
  2712. }
  2713. else {
  2714. sp = &cp->cp_smc[idx];
  2715. up = (smc_uart_t *)&cp->cp_dparam[state->port];
  2716. up->smc_rbase = dp_addr;
  2717. }
  2719. dp_addr = m8xx_cpm_dpalloc(sizeof(cbd_t) * TX_NUM_FIFO);
  2721. /* Allocate space for FIFOs in the host memory.
  2722. */
  2723. mem_addr = m8xx_cpm_hostalloc(TX_NUM_FIFO * TX_BUF_SIZE);
  2725. /* Set the physical address of the host memory
  2726.  * buffers in the buffer descriptors, and the
  2727.  * virtual address for us to work with.
  2728.  */
  2729. bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
  2730. info->tx_cur = info->tx_bd_base = (cbd_t *)bdp;
  2732. for (j=0; j<(TX_NUM_FIFO-1); j++) {
  2733. bdp->cbd_bufaddr = __pa(mem_addr);
  2734. bdp->cbd_sc = BD_SC_INTRPT;
  2735. mem_addr += TX_BUF_SIZE;
  2736. bdp++;
  2737. }
  2738. bdp->cbd_bufaddr = __pa(mem_addr);
  2739. bdp->cbd_sc = (BD_SC_WRAP | BD_SC_INTRPT);
  2741. if (info->state->smc_scc_num & NUM_IS_SCC) {
  2742. sup->scc_genscc.scc_tbase = dp_addr;
  2744. /* Set up the uart parameters in the
  2745.  * parameter ram.
  2746.  */
  2747. sup->scc_genscc.scc_rfcr = SMC_EB;
  2748. sup->scc_genscc.scc_tfcr = SMC_EB;
  2750. /* Set this to 1 for now, so we get single
  2751.  * character interrupts.  Using idle charater
  2752.  * time requires some additional tuning.
  2753.  */
  2754. sup->scc_genscc.scc_mrblr = 1;
  2755. sup->scc_maxidl = 0;
  2756. sup->scc_brkcr = 1;
  2757. sup->scc_parec = 0;
  2758. sup->scc_frmec = 0;
  2759. sup->scc_nosec = 0;
  2760. sup->scc_brkec = 0;
  2761. sup->scc_uaddr1 = 0;
  2762. sup->scc_uaddr2 = 0;
  2763. sup->scc_toseq = 0;
  2764. sup->scc_char1 = 0x8000;
  2765. sup->scc_char2 = 0x8000;
  2766. sup->scc_char3 = 0x8000;
  2767. sup->scc_char4 = 0x8000;
  2768. sup->scc_char5 = 0x8000;
  2769. sup->scc_char6 = 0x8000;
  2770. sup->scc_char7 = 0x8000;
  2771. sup->scc_char8 = 0x8000;
  2772. sup->scc_rccm = 0xc0ff;
  2774. /* Send the CPM an initialize command.
  2775. */
  2776. chan = scc_chan_map[idx];
  2778. cp->cp_cpcr = mk_cr_cmd(chan,
  2779. CPM_CR_INIT_TRX) | CPM_CR_FLG;
  2780. while (cp->cp_cpcr & CPM_CR_FLG);
  2782. /* Set UART mode, 8 bit, no parity, one stop.
  2783.  * Enable receive and transmit.
  2784.  */
  2785. scp->scc_gsmrh = 0;
  2786. scp->scc_gsmrl = 
  2787. (SCC_GSMRL_MODE_UART | SCC_GSMRL_TDCR_16 | SCC_GSMRL_RDCR_16);
  2789. /* Disable all interrupts and clear all pending
  2790.  * events.
  2791.  */
  2792. scp->scc_sccm = 0;
  2793. scp->scc_scce = 0xffff;
  2794. scp->scc_dsr = 0x7e7e;
  2795. scp->scc_pmsr = 0x3000;
  2797. /* If the port is the console, enable Rx and Tx.
  2798. */
  2799. #ifdef CONFIG_SERIAL_CONSOLE
  2800. if (i == CONFIG_SERIAL_CONSOLE_PORT)
  2801. scp->scc_gsmrl |= (SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  2802. #endif
  2803. }
  2804. else {
  2805. /* Configure SMCs Tx/Rx instead of port B
  2806.  * parallel I/O.  On 823/850 these are on
  2807.  * port A for SMC2.
  2808.  */
  2809. #ifndef CONFIG_ALTSMC2
  2810. iobits = 0xc0 << (idx * 4);
  2811. cp->cp_pbpar |= iobits;
  2812. cp->cp_pbdir &= ~iobits;
  2813. cp->cp_pbodr &= ~iobits;
  2814. #else
  2815. iobits = 0xc0;
  2816. if (idx == 0) {
  2817. /* SMC1 on Port B, like all 8xx.
  2818. */
  2819. cp->cp_pbpar |= iobits;
  2820. cp->cp_pbdir &= ~iobits;
  2821. cp->cp_pbodr &= ~iobits;
  2822. }
  2823. else {
  2824. /* SMC2 is on Port A.
  2825. */
  2826. immap->im_ioport.iop_papar |= iobits;
  2827. immap->im_ioport.iop_padir &= ~iobits;
  2828. immap->im_ioport.iop_paodr &= ~iobits;
  2829. }
  2830. #endif /* CONFIG_ALTSMC2 */
  2832. /* Connect the baud rate generator to the
  2833.  * SMC based upon index in rs_table.  Also
  2834.  * make sure it is connected to NMSI.
  2835.  */
  2836. cp->cp_simode &= ~(0xffff << (idx * 16));
  2837. cp->cp_simode |= (i << ((idx * 16) + 12));
  2839. up->smc_tbase = dp_addr;
  2841. /* Set up the uart parameters in the
  2842.  * parameter ram.
  2843.  */
  2844. up->smc_rfcr = SMC_EB;
  2845. up->smc_tfcr = SMC_EB;
  2847. /* Set this to 1 for now, so we get single
  2848.  * character interrupts.  Using idle charater
  2849.  * time requires some additional tuning.
  2850.  */
  2851. up->smc_mrblr = 1;
  2852. up->smc_maxidl = 0;
  2853. up->smc_brkcr = 1;
  2855. /* Send the CPM an initialize command.
  2856. */
  2857. chan = smc_chan_map[idx];
  2859. cp->cp_cpcr = mk_cr_cmd(chan,
  2860. CPM_CR_INIT_TRX) | CPM_CR_FLG;
  2861. while (cp->cp_cpcr & CPM_CR_FLG);
  2863. /* Set UART mode, 8 bit, no parity, one stop.
  2864.  * Enable receive and transmit.
  2865.  */
  2866. sp->smc_smcmr = smcr_mk_clen(9) | SMCMR_SM_UART;
  2868. /* Disable all interrupts and clear all pending
  2869.  * events.
  2870.  */
  2871. sp->smc_smcm = 0;
  2872. sp->smc_smce = 0xff;
  2874. /* If the port is the console, enable Rx and Tx.
  2875. */
  2876. #ifdef CONFIG_SERIAL_CONSOLE
  2877. if (i == CONFIG_SERIAL_CONSOLE_PORT)
  2878. sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
  2879. #endif
  2880. }
  2882. /* Install interrupt handler.
  2883. */
  2884. cpm_install_handler(state->irq, rs_8xx_interrupt, info);
  2886. /* Set up the baud rate generator.
  2887. */
  2888. m8xx_cpm_setbrg(i, baud_table[baud_idx]);
  2890. }
  2891. }
  2893. return 0;
  2894. }
  2896. /* This must always be called before the rs_8xx_init() function, otherwise
  2897.  * it blows away the port control information.
  2898. */
  2899. static int __init serial_console_setup(struct console *co, char *options)
  2900. {
  2901. struct serial_state *ser;
  2902. uint mem_addr, dp_addr, bidx, idx;
  2903. ushort chan;
  2904. volatile cbd_t *bdp;
  2905. volatile cpm8xx_t *cp;
  2906. volatile smc_t *sp;
  2907. volatile scc_t *scp;
  2908. volatile smc_uart_t *up;
  2909. volatile scc_uart_t *sup;
  2910. bd_t *bd;
  2912. bd = (bd_t *)__res;
  2914. for (bidx = 0; bidx < (sizeof(baud_table) / sizeof(int)); bidx++)
  2915. if (bd->bi_baudrate == baud_table[bidx])
  2916. break;
  2917. /* make sure we have a useful value */
  2918. if (bidx == (sizeof(baud_table) / sizeof(int)))
  2919. bidx = 13; /* B9600 */
  2921. co->cflag = CREAD|CLOCAL|bidx|CS8;
  2922. baud_idx = bidx;
  2924. ser = rs_table + co->index;
  2926. cp = cpmp; /* Get pointer to Communication Processor */
  2928. idx = PORT_NUM(ser->smc_scc_num);
  2929. if (ser->smc_scc_num & NUM_IS_SCC) {
  2930. scp = &cp->cp_scc[idx];
  2931. sup = (scc_uart_t *)&cp->cp_dparam[ser->port];
  2932. }
  2933. else {
  2934. sp = &cp->cp_smc[idx];
  2935. up = (smc_uart_t *)&cpmp->cp_dparam[ser->port];
  2936. }
  2938. /* When we get here, the CPM has been reset, so we need
  2939.  * to configure the port.
  2940.  * We need to allocate a transmit and receive buffer descriptor
  2941.  * from dual port ram, and a character buffer area from host mem.
  2942.  */
  2944. /* Allocate space for two buffer descriptors in the DP ram.
  2945. */
  2946. dp_addr = m8xx_cpm_dpalloc(sizeof(cbd_t) * 2);
  2948. /* Allocate space for two 2 byte FIFOs in the host memory.
  2949. */
  2950. mem_addr = m8xx_cpm_hostalloc(8);
  2952. /* Set the physical address of the host memory buffers in
  2953.  * the buffer descriptors.
  2954.  */
  2955. bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
  2956. bdp->cbd_bufaddr = __pa(mem_addr);
  2957. (bdp+1)->cbd_bufaddr = __pa(mem_addr+4);
  2959. /* For the receive, set empty and wrap.
  2960.  * For transmit, set wrap.
  2961.  */
  2962. bdp->cbd_sc = BD_SC_EMPTY | BD_SC_WRAP;
  2963. (bdp+1)->cbd_sc = BD_SC_WRAP;
  2965. /* Set up the uart parameters in the parameter ram.
  2966. */
  2967. if (ser->smc_scc_num & NUM_IS_SCC) {
  2969. sup->scc_genscc.scc_rbase = dp_addr;
  2970. sup->scc_genscc.scc_tbase = dp_addr + sizeof(cbd_t);
  2972. /* Set up the uart parameters in the
  2973.  * parameter ram.
  2974.  */
  2975. sup->scc_genscc.scc_rfcr = SMC_EB;
  2976. sup->scc_genscc.scc_tfcr = SMC_EB;
  2978. /* Set this to 1 for now, so we get single
  2979.  * character interrupts.  Using idle charater
  2980.  * time requires some additional tuning.
  2981.  */
  2982. sup->scc_genscc.scc_mrblr = 1;
  2983. sup->scc_maxidl = 0;
  2984. sup->scc_brkcr = 1;
  2985. sup->scc_parec = 0;
  2986. sup->scc_frmec = 0;
  2987. sup->scc_nosec = 0;
  2988. sup->scc_brkec = 0;
  2989. sup->scc_uaddr1 = 0;
  2990. sup->scc_uaddr2 = 0;
  2991. sup->scc_toseq = 0;
  2992. sup->scc_char1 = 0x8000;
  2993. sup->scc_char2 = 0x8000;
  2994. sup->scc_char3 = 0x8000;
  2995. sup->scc_char4 = 0x8000;
  2996. sup->scc_char5 = 0x8000;
  2997. sup->scc_char6 = 0x8000;
  2998. sup->scc_char7 = 0x8000;
  2999. sup->scc_char8 = 0x8000;
  3000. sup->scc_rccm = 0xc0ff;
  3002. /* Send the CPM an initialize command.
  3003. */
  3004. chan = scc_chan_map[idx];
  3006. cp->cp_cpcr = mk_cr_cmd(chan, CPM_CR_INIT_TRX) | CPM_CR_FLG;
  3007. while (cp->cp_cpcr & CPM_CR_FLG);
  3009. /* Set UART mode, 8 bit, no parity, one stop.
  3010.  * Enable receive and transmit.
  3011.  */
  3012. scp->scc_gsmrh = 0;
  3013. scp->scc_gsmrl = 
  3014. (SCC_GSMRL_MODE_UART | SCC_GSMRL_TDCR_16 | SCC_GSMRL_RDCR_16);
  3016. /* Disable all interrupts and clear all pending
  3017.  * events.
  3018.  */
  3019. scp->scc_sccm = 0;
  3020. scp->scc_scce = 0xffff;
  3021. scp->scc_dsr = 0x7e7e;
  3022. scp->scc_pmsr = 0x3000;
  3024. scp->scc_gsmrl |= (SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  3026. }
  3027. else {
  3028. up->smc_rbase = dp_addr; /* Base of receive buffer desc. */
  3029. up->smc_tbase = dp_addr+sizeof(cbd_t); /* Base of xmt buffer desc. */
  3030. up->smc_rfcr = SMC_EB;
  3031. up->smc_tfcr = SMC_EB;
  3033. /* Set this to 1 for now, so we get single character interrupts.
  3034. */
  3035. up->smc_mrblr = 1; /* receive buffer length */
  3036. up->smc_maxidl = 0; /* wait forever for next char */
  3038. /* Send the CPM an initialize command.
  3039. */
  3040. chan = smc_chan_map[idx];
  3041. cp->cp_cpcr = mk_cr_cmd(chan, CPM_CR_INIT_TRX) | CPM_CR_FLG;
  3042. printk("%s", "");
  3043. while (cp->cp_cpcr & CPM_CR_FLG);
  3045. /* Set UART mode, 8 bit, no parity, one stop.
  3046.  * Enable receive and transmit.
  3047.  */
  3048. sp->smc_smcmr = smcr_mk_clen(9) |  SMCMR_SM_UART;
  3050. /* And finally, enable Rx and Tx.
  3051. */
  3052. sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
  3053. }
  3055. /* Set up the baud rate generator.
  3056. */
  3057. m8xx_cpm_setbrg((ser - rs_table), bd->bi_baudrate);
  3059. return 0;
  3060. }