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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
uart.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：69k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

uart.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.uart.c 1.13 12/29/01 14:50:03 trini
  3.  */
  4. /*
  5.  *  UART driver for MPC8260 CPM SCC or SMC
  6.  *  Copyright (c) 1999 Dan Malek (dmalek@jlc.net)
  7.  *  Copyright (c) 2000 MontaVista Software, Inc. (source@mvista.com)
  8.  * 2.3.99 updates
  9.  *
  10.  * I used the 8xx uart.c driver as the framework for this driver.
  11.  * The original code was written for the EST8260 board.  I tried to make
  12.  * it generic, but there may be some assumptions in the structures that
  13.  * have to be fixed later.
  14.  *
  15.  * The 8xx and 8260 are similar, but not identical.  Over time we
  16.  * could probably merge these two drivers.
  17.  * To save porting time, I did not bother to change any object names
  18.  * that are not accessed outside of this file.
  19.  * It still needs lots of work........When it was easy, I included code
  20.  * to support the SCCs.
  21.  * Only the SCCs support modem control, so that is not complete either.
  22.  *
  23.  * This module exports the following rs232 io functions:
  24.  *
  25.  * int rs_8xx_init(void);
  26.  */
  28. #include <linux/config.h>
  29. #include <linux/module.h>
  30. #include <linux/errno.h>
  31. #include <linux/signal.h>
  32. #include <linux/sched.h>
  33. #include <linux/timer.h>
  34. #include <linux/interrupt.h>
  35. #include <linux/tty.h>
  36. #include <linux/tty_flip.h>
  37. #include <linux/serial.h>
  38. #include <linux/serialP.h>
  39. #include <linux/major.h>
  40. #include <linux/string.h>
  41. #include <linux/fcntl.h>
  42. #include <linux/ptrace.h>
  43. #include <linux/mm.h>
  44. #include <linux/slab.h>
  45. #include <linux/init.h>
  46. #include <linux/delay.h>
  47. #include <asm/uaccess.h>
  48. #include <asm/immap_8260.h>
  49. #include <asm/mpc8260.h>
  50. #include <asm/cpm_8260.h>
  51. #include <asm/irq.h>
  53. #ifdef CONFIG_SERIAL_CONSOLE
  54. #include <linux/console.h>
  56. /* this defines the index into rs_table for the port to use
  57. */
  58. #ifndef CONFIG_SERIAL_CONSOLE_PORT
  59. #define CONFIG_SERIAL_CONSOLE_PORT 0
  60. #endif
  61. #endif
  63. #define TX_WAKEUP ASYNC_SHARE_IRQ
  65. static char *serial_name = "CPM UART driver";
  66. static char *serial_version = "0.01";
  68. static DECLARE_TASK_QUEUE(tq_serial);
  70. static struct tty_driver serial_driver, callout_driver;
  71. static int serial_refcount;
  72. static int serial_console_setup(struct console *co, char *options);
  74. /*
  75.  * Serial driver configuration section.  Here are the various options:
  76.  */
  77. #define SERIAL_PARANOIA_CHECK
  78. #define CONFIG_SERIAL_NOPAUSE_IO
  79. #define SERIAL_DO_RESTART
  81. /* Set of debugging defines */
  83. #undef SERIAL_DEBUG_INTR
  84. #undef SERIAL_DEBUG_OPEN
  85. #undef SERIAL_DEBUG_FLOW
  86. #undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  88. #define _INLINE_ inline
  89.   
  90. #define DBG_CNT(s)
  92. /* We overload some of the items in the data structure to meet our
  93.  * needs.  For example, the port address is the CPM parameter ram
  94.  * offset for the SCC or SMC.  The maximum number of ports is 4 SCCs and
  95.  * 2 SMCs.  The "hub6" field is used to indicate the channel number, with
  96.  * 0 and 1 indicating the SMCs and 2, 3, 4, and 5 are the SCCs.
  97.  * Since these ports are so versatile, I don't yet have a strategy for
  98.  * their management.  For example, SCC1 is used for Ethernet.  Right
  99.  * now, just don't put them in the table.  Of course, right now I just
  100.  * want the SMC to work as a uart :-)..
  101.  * The "type" field is currently set to 0, for PORT_UNKNOWN.  It is
  102.  * not currently used.  I should probably use it to indicate the port
  103.  * type of CMS or SCC.
  104.  * The SMCs do not support any modem control signals.
  105.  */
  106. #define smc_scc_num hub6
  108. /* SMC2 is sometimes used for low performance TDM interfaces.  Define
  109.  * this as 1 if you want SMC2 as a serial port UART managed by this driver.
  110.  * Define this as 0 if you wish to use SMC2 for something else.
  111.  */
  112. #define USE_SMC2 1
  114. /* Define SCC to ttySx mapping.
  115. */
  116. #define SCC_NUM_BASE (USE_SMC2 + 1) /* SCC base tty "number" */
  118. /* Define which SCC is the first one to use for a serial port.  These
  119.  * are 0-based numbers, i.e. this assumes the first SCC (SCC1) is used
  120.  * for Ethernet, and the first available SCC for serial UART is SCC2.
  121.  * NOTE:  IF YOU CHANGE THIS, you have to change the PROFF_xxx and
  122.  * interrupt vectors in the table below to match.
  123.  */
  124. #define SCC_IDX_BASE 1 /* table index */
  126. static struct serial_state rs_table[] = {
  127. /* UART CLK   PORT          IRQ      FLAGS  NUM   */
  128. { 0,     0, PROFF_SMC1, SIU_INT_SMC1,   0,    0 },    /* SMC1 ttyS0 */
  129. #if USE_SMC2
  130. { 0,     0, PROFF_SMC2, SIU_INT_SMC2,   0,    1 },    /* SMC2 ttyS1 */
  131. #endif
  132. { 0,     0, PROFF_SCC2, SIU_INT_SCC2,   0, SCC_NUM_BASE},    /* SCC2 ttyS2 */
  133. { 0,     0, PROFF_SCC3, SIU_INT_SCC3,   0, SCC_NUM_BASE + 1},    /* SCC3 ttyS3 */
  134. };
  136. #define NR_PORTS (sizeof(rs_table)/sizeof(struct serial_state))
  138. static struct tty_struct *serial_table[NR_PORTS];
  139. static struct termios *serial_termios[NR_PORTS];
  140. static struct termios *serial_termios_locked[NR_PORTS];
  142. /* The number of buffer descriptors and their sizes.
  143. */
  144. #define RX_NUM_FIFO 4
  145. #define RX_BUF_SIZE 32
  146. #define TX_NUM_FIFO 4
  147. #define TX_BUF_SIZE 32
  149. #ifndef MIN
  150. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  151. #endif
  153. /* The async_struct in serial.h does not really give us what we
  154.  * need, so define our own here.
  155.  */
  156. typedef struct serial_info {
  157. int magic;
  158. int flags;
  159. struct serial_state *state;
  160. struct tty_struct  *tty;
  161. int read_status_mask;
  162. int ignore_status_mask;
  163. int timeout;
  164. int line;
  165. int x_char; /* xon/xoff character */
  166. int close_delay;
  167. unsigned short closing_wait;
  168. unsigned short closing_wait2;
  169. unsigned long event;
  170. unsigned long last_active;
  171. int blocked_open; /* # of blocked opens */
  172. long session; /* Session of opening process */
  173. long pgrp; /* pgrp of opening process */
  174. struct tq_struct tqueue;
  175. struct tq_struct tqueue_hangup;
  176. wait_queue_head_t open_wait;
  177. wait_queue_head_t close_wait;
  179. /* CPM Buffer Descriptor pointers.
  180. */
  181. cbd_t *rx_bd_base;
  182. cbd_t *rx_cur;
  183. cbd_t *tx_bd_base;
  184. cbd_t *tx_cur;
  185. } ser_info_t;
  187. static void change_speed(ser_info_t *info);
  188. static void rs_8xx_wait_until_sent(struct tty_struct *tty, int timeout);
  190. static inline int serial_paranoia_check(ser_info_t *info,
  191. kdev_t device, const char *routine)
  192. {
  193. #ifdef SERIAL_PARANOIA_CHECK
  194. static const char *badmagic =
  195. "Warning: bad magic number for serial struct (%s) in %sn";
  196. static const char *badinfo =
  197. "Warning: null async_struct for (%s) in %sn";
  199. if (!info) {
  200. printk(badinfo, kdevname(device), routine);
  201. return 1;
  202. }
  203. if (info->magic != SERIAL_MAGIC) {
  204. printk(badmagic, kdevname(device), routine);
  205. return 1;
  206. }
  207. #endif
  208. return 0;
  209. }
  211. /*
  212.  * This is used to figure out the divisor speeds and the timeouts,
  213.  * indexed by the termio value.  The generic CPM functions are responsible
  214.  * for setting and assigning baud rate generators for us.
  215.  */
  216. static int baud_table[] = {
  217. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  218. 9600, 19200, 38400, 57600, 115200, 230400, 460800, 0 };
  221. /*
  222.  * ------------------------------------------------------------
  223.  * rs_stop() and rs_start()
  224.  *
  225.  * This routines are called before setting or resetting tty->stopped.
  226.  * They enable or disable transmitter interrupts, as necessary.
  227.  * ------------------------------------------------------------
  228.  */
  229. static void rs_8xx_stop(struct tty_struct *tty)
  230. {
  231. ser_info_t *info = (ser_info_t *)tty->driver_data;
  232. int idx;
  233. unsigned long flags;
  234. volatile scc_t *sccp;
  235. volatile smc_t *smcp;
  237. if (serial_paranoia_check(info, tty->device, "rs_stop"))
  238. return;
  240. save_flags(flags); cli();
  241. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  242. smcp = &immr->im_smc[idx];
  243. smcp->smc_smcm &= ~SMCM_TX;
  244. }
  245. else {
  246. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  247. sccp->scc_sccm &= ~UART_SCCM_TX;
  248. }
  249. restore_flags(flags);
  250. }
  252. static void rs_8xx_start(struct tty_struct *tty)
  253. {
  254. ser_info_t *info = (ser_info_t *)tty->driver_data;
  255. int idx;
  256. unsigned long flags;
  257. volatile scc_t *sccp;
  258. volatile smc_t *smcp;
  260. if (serial_paranoia_check(info, tty->device, "rs_stop"))
  261. return;
  263. save_flags(flags); cli();
  264. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  265. smcp = &immr->im_smc[idx];
  266. smcp->smc_smcm |= SMCM_TX;
  267. }
  268. else {
  269. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  270. sccp->scc_sccm |= UART_SCCM_TX;
  271. }
  272. restore_flags(flags);
  273. }
  275. /*
  276.  * ----------------------------------------------------------------------
  277.  *
  278.  * Here starts the interrupt handling routines.  All of the following
  279.  * subroutines are declared as inline and are folded into
  280.  * rs_interrupt().  They were separated out for readability's sake.
  281.  *
  282.  * Note: rs_interrupt() is a "fast" interrupt, which means that it
  283.  * runs with interrupts turned off.  People who may want to modify
  284.  * rs_interrupt() should try to keep the interrupt handler as fast as
  285.  * possible.  After you are done making modifications, it is not a bad
  286.  * idea to do:
  287.  * 
  288.  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  289.  *
  290.  * and look at the resulting assemble code in serial.s.
  291.  *
  292.  *  - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  293.  * -----------------------------------------------------------------------
  294.  */
  296. /*
  297.  * This routine is used by the interrupt handler to schedule
  298.  * processing in the software interrupt portion of the driver.
  299.  */
  300. static _INLINE_ void rs_sched_event(ser_info_t *info,
  301.   int event)
  302. {
  303. info->event |= 1 << event;
  304. queue_task(&info->tqueue, &tq_serial);
  305. mark_bh(SERIAL_BH);
  306. }
  308. static _INLINE_ void receive_chars(ser_info_t *info)
  309. {
  310. struct tty_struct *tty = info->tty;
  311. unsigned char ch, *cp;
  312. /*int ignored = 0;*/
  313. int i;
  314. ushort status;
  315. struct async_icount *icount;
  316. volatile cbd_t *bdp;
  318. icount = &info->state->icount;
  320. /* Just loop through the closed BDs and copy the characters into
  321.  * the buffer.
  322.  */
  323. bdp = info->rx_cur;
  324. for (;;) {
  325. if (bdp->cbd_sc & BD_SC_EMPTY) /* If this one is empty */
  326. break; /*   we are all done */
  328. /* The read status mask tell us what we should do with
  329.  * incoming characters, especially if errors occur.
  330.  * One special case is the use of BD_SC_EMPTY.  If
  331.  * this is not set, we are supposed to be ignoring
  332.  * inputs.  In this case, just mark the buffer empty and
  333.  * continue.
  334. if (!(info->read_status_mask & BD_SC_EMPTY)) {
  335. bdp->cbd_sc |= BD_SC_EMPTY;
  336. bdp->cbd_sc &=
  337. ~(BD_SC_BR | BD_SC_FR | BD_SC_PR | BD_SC_OV);
  339. if (bdp->cbd_sc & BD_SC_WRAP)
  340. bdp = info->rx_bd_base;
  341. else
  342. bdp++;
  343. continue;
  344. }
  345.  */
  347. /* Get the number of characters and the buffer pointer.
  348. */
  349. i = bdp->cbd_datlen;
  350. cp = (unsigned char *)__va(bdp->cbd_bufaddr);
  351. status = bdp->cbd_sc;
  353. /* Check to see if there is room in the tty buffer for
  354.  * the characters in our BD buffer.  If not, we exit
  355.  * now, leaving the BD with the characters.  We'll pick
  356.  * them up again on the next receive interrupt (which could
  357.  * be a timeout).
  358.  */
  359. if ((tty->flip.count + i) >= TTY_FLIPBUF_SIZE)
  360. break;
  362. while (i-- > 0) {
  363. ch = *cp++;
  364. *tty->flip.char_buf_ptr = ch;
  365. icount->rx++;
  367. #ifdef SERIAL_DEBUG_INTR
  368. printk("DR%02x:%02x...", ch, *status);
  369. #endif
  370. *tty->flip.flag_buf_ptr = 0;
  371. if (status & (BD_SC_BR | BD_SC_FR |
  372.        BD_SC_PR | BD_SC_OV)) {
  373. /*
  374.  * For statistics only
  375.  */
  376. if (status & BD_SC_BR)
  377. icount->brk++;
  378. else if (status & BD_SC_PR)
  379. icount->parity++;
  380. else if (status & BD_SC_FR)
  381. icount->frame++;
  382. if (status & BD_SC_OV)
  383. icount->overrun++;
  385. /*
  386.  * Now check to see if character should be
  387.  * ignored, and mask off conditions which
  388.  * should be ignored.
  389. if (status & info->ignore_status_mask) {
  390. if (++ignored > 100)
  391. break;
  392. continue;
  393. }
  394.  */
  395. status &= info->read_status_mask;
  397. if (status & (BD_SC_BR)) {
  398. #ifdef SERIAL_DEBUG_INTR
  399. printk("handling break....");
  400. #endif
  401. *tty->flip.flag_buf_ptr = TTY_BREAK;
  402. if (info->flags & ASYNC_SAK)
  403. do_SAK(tty);
  404. } else if (status & BD_SC_PR)
  405. *tty->flip.flag_buf_ptr = TTY_PARITY;
  406. else if (status & BD_SC_FR)
  407. *tty->flip.flag_buf_ptr = TTY_FRAME;
  408. if (status & BD_SC_OV) {
  409. /*
  410.  * Overrun is special, since it's
  411.  * reported immediately, and doesn't
  412.  * affect the current character
  413.  */
  414. if (tty->flip.count < TTY_FLIPBUF_SIZE) {
  415. tty->flip.count++;
  416. tty->flip.flag_buf_ptr++;
  417. tty->flip.char_buf_ptr++;
  418. *tty->flip.flag_buf_ptr =
  419. TTY_OVERRUN;
  420. }
  421. }
  422. }
  423. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  424. break;
  426. tty->flip.flag_buf_ptr++;
  427. tty->flip.char_buf_ptr++;
  428. tty->flip.count++;
  429. }
  431. /* This BD is ready to be used again.  Clear status.
  432.  * Get next BD.
  433.  */
  434. bdp->cbd_sc |= BD_SC_EMPTY;
  435. bdp->cbd_sc &= ~(BD_SC_BR | BD_SC_FR | BD_SC_PR | BD_SC_OV);
  437. if (bdp->cbd_sc & BD_SC_WRAP)
  438. bdp = info->rx_bd_base;
  439. else
  440. bdp++;
  441. }
  443. info->rx_cur = (cbd_t *)bdp;
  445. queue_task(&tty->flip.tqueue, &tq_timer);
  446. }
  448. static _INLINE_ void transmit_chars(ser_info_t *info)
  449. {
  451. if (info->flags & TX_WAKEUP) {
  452. rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  453. }
  455. #ifdef SERIAL_DEBUG_INTR
  456. printk("THRE...");
  457. #endif
  458. }
  460. #ifdef notdef
  461. /* I need to do this for the SCCs, so it is left as a reminder.
  462. */
  463. static _INLINE_ void check_modem_status(struct async_struct *info)
  464. {
  465. int status;
  466. struct async_icount *icount;
  468. status = serial_in(info, UART_MSR);
  470. if (status & UART_MSR_ANY_DELTA) {
  471. icount = &info->state->icount;
  472. /* update input line counters */
  473. if (status & UART_MSR_TERI)
  474. icount->rng++;
  475. if (status & UART_MSR_DDSR)
  476. icount->dsr++;
  477. if (status & UART_MSR_DDCD) {
  478. icount->dcd++;
  479. #ifdef CONFIG_HARD_PPS
  480. if ((info->flags & ASYNC_HARDPPS_CD) &&
  481.     (status & UART_MSR_DCD))
  482. hardpps();
  483. #endif
  484. }
  485. if (status & UART_MSR_DCTS)
  486. icount->cts++;
  487. wake_up_interruptible(&info->delta_msr_wait);
  488. }
  490. if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
  491. #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
  492. printk("ttys%d CD now %s...", info->line,
  493.        (status & UART_MSR_DCD) ? "on" : "off");
  494. #endif
  495. if (status & UART_MSR_DCD)
  496. wake_up_interruptible(&info->open_wait);
  497. else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  498.    (info->flags & ASYNC_CALLOUT_NOHUP))) {
  499. #ifdef SERIAL_DEBUG_OPEN
  500. printk("scheduling hangup...");
  501. #endif
  502. MOD_INC_USE_COUNT;
  503. if (schedule_task(&info->tqueue_hangup) == 0)
  504. MOD_DEC_USE_COUNT;
  505. }
  506. }
  507. if (info->flags & ASYNC_CTS_FLOW) {
  508. if (info->tty->hw_stopped) {
  509. if (status & UART_MSR_CTS) {
  510. #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  511. printk("CTS tx start...");
  512. #endif
  513. info->tty->hw_stopped = 0;
  514. info->IER |= UART_IER_THRI;
  515. serial_out(info, UART_IER, info->IER);
  516. rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  517. return;
  518. }
  519. } else {
  520. if (!(status & UART_MSR_CTS)) {
  521. #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
  522. printk("CTS tx stop...");
  523. #endif
  524. info->tty->hw_stopped = 1;
  525. info->IER &= ~UART_IER_THRI;
  526. serial_out(info, UART_IER, info->IER);
  527. }
  528. }
  529. }
  530. }
  531. #endif
  533. /*
  534.  * This is the serial driver's interrupt routine for a single port
  535.  */
  536. static void rs_8xx_interrupt(int irq, void * dev_id, struct pt_regs * regs)
  537. {
  538. u_char events;
  539. int idx;
  540. ser_info_t *info;
  541. volatile smc_t *smcp;
  542. volatile scc_t *sccp;
  544. info = (ser_info_t *)dev_id;
  546. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  547. smcp = &immr->im_smc[idx];
  548. events = smcp->smc_smce;
  549. if (events & SMCM_RX)
  550. receive_chars(info);
  551. if (events & SMCM_TX)
  552. transmit_chars(info);
  553. smcp->smc_smce = events;
  554. }
  555. else {
  556. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  557. events = sccp->scc_scce;
  558. if (events & SCCM_RX)
  559. receive_chars(info);
  560. if (events & SCCM_TX)
  561. transmit_chars(info);
  562. sccp->scc_scce = events;
  563. }
  565. #ifdef SERIAL_DEBUG_INTR
  566. printk("rs_interrupt_single(%d, %x)...",
  567. info->state->smc_scc_num, events);
  568. #endif
  569. #ifdef modem_control
  570. check_modem_status(info);
  571. #endif
  572. info->last_active = jiffies;
  573. #ifdef SERIAL_DEBUG_INTR
  574. printk("end.n");
  575. #endif
  576. }
  579. /*
  580.  * -------------------------------------------------------------------
  581.  * Here ends the serial interrupt routines.
  582.  * -------------------------------------------------------------------
  583.  */
  585. /*
  586.  * This routine is used to handle the "bottom half" processing for the
  587.  * serial driver, known also the "software interrupt" processing.
  588.  * This processing is done at the kernel interrupt level, after the
  589.  * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  590.  * is where time-consuming activities which can not be done in the
  591.  * interrupt driver proper are done; the interrupt driver schedules
  592.  * them using rs_sched_event(), and they get done here.
  593.  */
  594. static void do_serial_bh(void)
  595. {
  596. run_task_queue(&tq_serial);
  597. }
  599. static void do_softint(void *private_)
  600. {
  601. ser_info_t *info = (ser_info_t *) private_;
  602. struct tty_struct *tty;
  604. tty = info->tty;
  605. if (!tty)
  606. return;
  608. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  609. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  610.     tty->ldisc.write_wakeup)
  611. (tty->ldisc.write_wakeup)(tty);
  612. wake_up_interruptible(&tty->write_wait);
  613. }
  614. }
  616. /*
  617.  * This routine is called from the scheduler tqueue when the interrupt
  618.  * routine has signalled that a hangup has occurred.  The path of
  619.  * hangup processing is:
  620.  *
  621.  *  serial interrupt routine -> (scheduler tqueue) ->
  622.  *  do_serial_hangup() -> tty->hangup() -> rs_hangup()
  623.  * 
  624.  */
  625. static void do_serial_hangup(void *private_)
  626. {
  627. struct async_struct *info = (struct async_struct *) private_;
  628. struct tty_struct *tty;
  630. tty = info->tty;
  631. if (tty)
  632. tty_hangup(tty);
  633. MOD_DEC_USE_COUNT;
  634. }
  636. /*static void rs_8xx_timer(void)
  637. {
  638. printk("rs_8xx_timern");
  639. }*/
  642. static int startup(ser_info_t *info)
  643. {
  644. unsigned long flags;
  645. int retval=0;
  646. int idx;
  647. struct serial_state *state= info->state;
  648. volatile smc_t *smcp;
  649. volatile scc_t *sccp;
  650. volatile smc_uart_t *up;
  651. volatile scc_uart_t *scup;
  654. save_flags(flags); cli();
  656. if (info->flags & ASYNC_INITIALIZED) {
  657. goto errout;
  658. }
  660. #ifdef maybe
  661. if (!state->port || !state->type) {
  662. if (info->tty)
  663. set_bit(TTY_IO_ERROR, &info->tty->flags);
  664. goto errout;
  665. }
  666. #endif
  668. #ifdef SERIAL_DEBUG_OPEN
  669. printk("starting up ttys%d (irq %d)...", info->line, state->irq);
  670. #endif
  673. #ifdef modem_control
  674. info->MCR = 0;
  675. if (info->tty->termios->c_cflag & CBAUD)
  676. info->MCR = UART_MCR_DTR | UART_MCR_RTS;
  677. #endif
  679. if (info->tty)
  680. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  682. /*
  683.  * and set the speed of the serial port
  684.  */
  685. change_speed(info);
  687. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  688. smcp = &immr->im_smc[idx];
  690. /* Enable interrupts and I/O.
  691. */
  692. smcp->smc_smcm |= (SMCM_RX | SMCM_TX);
  693. smcp->smc_smcmr |= (SMCMR_REN | SMCMR_TEN);
  695. /* We can tune the buffer length and idle characters
  696.  * to take advantage of the entire incoming buffer size.
  697.  * If mrblr is something other than 1, maxidl has to be
  698.  * non-zero or we never get an interrupt.  The maxidl
  699.  * is the number of character times we wait after reception
  700.  * of the last character before we decide no more characters
  701.  * are coming.
  702.  */
  703. up = (smc_uart_t *)&immr->im_dprambase[state->port];
  704. #if 0
  705. up->smc_mrblr = 1; /* receive buffer length */
  706. up->smc_maxidl = 0; /* wait forever for next char */
  707. #else
  708. up->smc_mrblr = RX_BUF_SIZE;
  709. up->smc_maxidl = RX_BUF_SIZE;
  710. #endif
  711. up->smc_brkcr = 1; /* number of break chars */
  712. }
  713. else {
  714. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  715. scup = (scc_uart_t *)&immr->im_dprambase[state->port];
  716. #if 0
  717. scup->scc_genscc.scc_mrblr = 1; /* receive buffer length */
  718. scup->scc_maxidl = 0; /* wait forever for next char */
  719. #else
  720. scup->scc_genscc.scc_mrblr = RX_BUF_SIZE;
  721. scup->scc_maxidl = RX_BUF_SIZE;
  722. #endif
  724. sccp->scc_sccm |= (UART_SCCM_TX | UART_SCCM_RX);
  725. sccp->scc_gsmrl |= (SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  726. }
  728. info->flags |= ASYNC_INITIALIZED;
  729. restore_flags(flags);
  730. return 0;
  732. errout:
  733. restore_flags(flags);
  734. return retval;
  735. }
  737. /*
  738.  * This routine will shutdown a serial port; interrupts are disabled, and
  739.  * DTR is dropped if the hangup on close termio flag is on.
  740.  */
  741. static void shutdown(ser_info_t * info)
  742. {
  743. unsigned long flags;
  744. struct serial_state *state;
  745. int idx;
  746. volatile smc_t *smcp;
  747. volatile scc_t *sccp;
  749. if (!(info->flags & ASYNC_INITIALIZED))
  750. return;
  752. state = info->state;
  754. #ifdef SERIAL_DEBUG_OPEN
  755. printk("Shutting down serial port %d (irq %d)....", info->line,
  756.        state->irq);
  757. #endif
  759. save_flags(flags); cli(); /* Disable interrupts */
  761. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  762. smcp = &immr->im_smc[idx];
  764. /* Disable interrupts and I/O.
  765. */
  766. smcp->smc_smcm &= ~(SMCM_RX | SMCM_TX);
  767. #ifdef CONFIG_SERIAL_CONSOLE
  768. /* We can't disable the transmitter if this is the
  769.  * system console.
  770.  */
  771. if (idx != CONFIG_SERIAL_CONSOLE_PORT)
  772. #endif
  773. smcp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
  774. }
  775. else {
  776. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  777. sccp->scc_sccm &= ~(UART_SCCM_TX | UART_SCCM_RX);
  778. sccp->scc_gsmrl &= ~(SCC_GSMRL_ENR | SCC_GSMRL_ENT);
  779. }
  781. if (info->tty)
  782. set_bit(TTY_IO_ERROR, &info->tty->flags);
  784. info->flags &= ~ASYNC_INITIALIZED;
  785. restore_flags(flags);
  786. }
  788. /*
  789.  * This routine is called to set the UART divisor registers to match
  790.  * the specified baud rate for a serial port.
  791.  */
  792. static void change_speed(ser_info_t *info)
  793. {
  794. int baud_rate;
  795. unsigned cflag, cval, scval, prev_mode;
  796. int i, bits, sbits, idx;
  797. unsigned long flags;
  798. volatile smc_t *smcp;
  799. volatile scc_t *sccp;
  801. if (!info->tty || !info->tty->termios)
  802. return;
  803. cflag = info->tty->termios->c_cflag;
  805. /* Character length programmed into the mode register is the
  806.  * sum of: 1 start bit, number of data bits, 0 or 1 parity bit,
  807.  * 1 or 2 stop bits, minus 1.
  808.  * The value 'bits' counts this for us.
  809.  */
  810. cval = 0;
  811. scval = 0;
  813. /* byte size and parity */
  814. switch (cflag & CSIZE) {
  815.       case CS5: bits = 5; break;
  816.       case CS6: bits = 6; break;
  817.       case CS7: bits = 7; break;
  818.       case CS8: bits = 8; break;
  819.       /* Never happens, but GCC is too dumb to figure it out */
  820.       default:  bits = 8; break;
  821. }
  822. sbits = bits - 5;
  824. if (cflag & CSTOPB) {
  825. cval |= SMCMR_SL; /* Two stops */
  826. scval |= SCU_PMSR_SL;
  827. bits++;
  828. }
  829. if (cflag & PARENB) {
  830. cval |= SMCMR_PEN;
  831. scval |= SCU_PMSR_PEN;
  832. bits++;
  833. }
  834. if (!(cflag & PARODD)) {
  835. cval |= SMCMR_PM_EVEN;
  836. scval |= (SCU_PMSR_REVP | SCU_PMSR_TEVP);
  837. }
  839. /* Determine divisor based on baud rate */
  840. i = cflag & CBAUD;
  841. if (i >= (sizeof(baud_table)/sizeof(int)))
  842. baud_rate = 9600;
  843. else
  844. baud_rate = baud_table[i];
  846. info->timeout = (TX_BUF_SIZE*HZ*bits);
  847. info->timeout += HZ/50; /* Add .02 seconds of slop */
  849. #ifdef modem_control
  850. /* CTS flow control flag and modem status interrupts */
  851. info->IER &= ~UART_IER_MSI;
  852. if (info->flags & ASYNC_HARDPPS_CD)
  853. info->IER |= UART_IER_MSI;
  854. if (cflag & CRTSCTS) {
  855. info->flags |= ASYNC_CTS_FLOW;
  856. info->IER |= UART_IER_MSI;
  857. } else
  858. info->flags &= ~ASYNC_CTS_FLOW;
  859. if (cflag & CLOCAL)
  860. info->flags &= ~ASYNC_CHECK_CD;
  861. else {
  862. info->flags |= ASYNC_CHECK_CD;
  863. info->IER |= UART_IER_MSI;
  864. }
  865. serial_out(info, UART_IER, info->IER);
  866. #endif
  868. /*
  869.  * Set up parity check flag
  870.  */
  871. #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  873. info->read_status_mask = (BD_SC_EMPTY | BD_SC_OV);
  874. if (I_INPCK(info->tty))
  875. info->read_status_mask |= BD_SC_FR | BD_SC_PR;
  876. if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
  877. info->read_status_mask |= BD_SC_BR;
  879. /*
  880.  * Characters to ignore
  881.  */
  882. info->ignore_status_mask = 0;
  883. if (I_IGNPAR(info->tty))
  884. info->ignore_status_mask |= BD_SC_PR | BD_SC_FR;
  885. if (I_IGNBRK(info->tty)) {
  886. info->ignore_status_mask |= BD_SC_BR;
  887. /*
  888.  * If we're ignore parity and break indicators, ignore 
  889.  * overruns too.  (For real raw support).
  890.  */
  891. if (I_IGNPAR(info->tty))
  892. info->ignore_status_mask |= BD_SC_OV;
  893. }
  894. /*
  895.  * !!! ignore all characters if CREAD is not set
  896.  */
  897. if ((cflag & CREAD) == 0)
  898. info->read_status_mask &= ~BD_SC_EMPTY;
  899. save_flags(flags); cli();
  901. /* Start bit has not been added (so don't, because we would just
  902.  * subtract it later), and we need to add one for the number of
  903.  * stops bits (there is always at least one).
  904.  */
  905. bits++;
  906. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  907. smcp = &immr->im_smc[idx];
  909. /* Set the mode register.  We want to keep a copy of the
  910.  * enables, because we want to put them back if they were
  911.  * present.
  912.  */
  913. prev_mode = smcp->smc_smcmr;
  914. smcp->smc_smcmr = smcr_mk_clen(bits) | cval |  SMCMR_SM_UART;
  915. smcp->smc_smcmr |= (prev_mode & (SMCMR_REN | SMCMR_TEN));
  916. }
  917. else {
  918. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  919. sccp->scc_pmsr = (sbits << 12) | scval;
  920. }
  922. m8260_cpm_setbrg(info->state->smc_scc_num, baud_rate);
  924. restore_flags(flags);
  925. }
  927. static void rs_8xx_put_char(struct tty_struct *tty, unsigned char ch)
  928. {
  929. ser_info_t *info = (ser_info_t *)tty->driver_data;
  930. volatile cbd_t *bdp;
  932. if (serial_paranoia_check(info, tty->device, "rs_put_char"))
  933. return;
  935. if (!tty)
  936. return;
  938. bdp = info->tx_cur;
  939. while (bdp->cbd_sc & BD_SC_READY);
  941. *((char *)__va(bdp->cbd_bufaddr)) = ch;
  942. bdp->cbd_datlen = 1;
  943. bdp->cbd_sc |= BD_SC_READY;
  945. /* Get next BD.
  946. */
  947. if (bdp->cbd_sc & BD_SC_WRAP)
  948. bdp = info->tx_bd_base;
  949. else
  950. bdp++;
  952. info->tx_cur = (cbd_t *)bdp;
  954. }
  956. static int rs_8xx_write(struct tty_struct * tty, int from_user,
  957.     const unsigned char *buf, int count)
  958. {
  959. int c, ret = 0;
  960. ser_info_t *info = (ser_info_t *)tty->driver_data;
  961. volatile cbd_t *bdp;
  963. if (serial_paranoia_check(info, tty->device, "rs_write"))
  964. return 0;
  966. if (!tty) 
  967. return 0;
  969. bdp = info->tx_cur;
  971. while (1) {
  972. c = MIN(count, TX_BUF_SIZE);
  974. if (c <= 0)
  975. break;
  977. if (bdp->cbd_sc & BD_SC_READY) {
  978. info->flags |= TX_WAKEUP;
  979. break;
  980. }
  982. if (from_user) {
  983. if (copy_from_user(__va(bdp->cbd_bufaddr), buf, c)) {
  984. if (!ret)
  985. ret = -EFAULT;
  986. break;
  987. }
  988. } else {
  989. memcpy(__va(bdp->cbd_bufaddr), buf, c);
  990. }
  992. bdp->cbd_datlen = c;
  993. bdp->cbd_sc |= BD_SC_READY;
  995. buf += c;
  996. count -= c;
  997. ret += c;
  999. /* Get next BD.
  1000. */
  1001. if (bdp->cbd_sc & BD_SC_WRAP)
  1002. bdp = info->tx_bd_base;
  1003. else
  1004. bdp++;
  1005. info->tx_cur = (cbd_t *)bdp;
  1006. }
  1007. return ret;
  1008. }
  1010. static int rs_8xx_write_room(struct tty_struct *tty)
  1011. {
  1012. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1013. int ret;
  1015. if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  1016. return 0;
  1018. if ((info->tx_cur->cbd_sc & BD_SC_READY) == 0) {
  1019. info->flags &= ~TX_WAKEUP;
  1020. ret = TX_BUF_SIZE;
  1021. }
  1022. else {
  1023. info->flags |= TX_WAKEUP;
  1024. ret = 0;
  1025. }
  1026. return ret;
  1027. }
  1029. /* I could track this with transmit counters....maybe later.
  1030. */
  1031. static int rs_8xx_chars_in_buffer(struct tty_struct *tty)
  1032. {
  1033. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1035. if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  1036. return 0;
  1037. return 0;
  1038. }
  1040. static void rs_8xx_flush_buffer(struct tty_struct *tty)
  1041. {
  1042. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1044. if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  1045. return;
  1047. /* There is nothing to "flush", whatever we gave the CPM
  1048.  * is on its way out.
  1049.  */
  1050. wake_up_interruptible(&tty->write_wait);
  1051. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1052.     tty->ldisc.write_wakeup)
  1053. (tty->ldisc.write_wakeup)(tty);
  1054. info->flags &= ~TX_WAKEUP;
  1055. }
  1057. /*
  1058.  * This function is used to send a high-priority XON/XOFF character to
  1059.  * the device
  1060.  */
  1061. static void rs_8xx_send_xchar(struct tty_struct *tty, char ch)
  1062. {
  1063. volatile cbd_t *bdp;
  1065. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1067. if (serial_paranoia_check(info, tty->device, "rs_send_char"))
  1068. return;
  1070. bdp = info->tx_cur;
  1071. while (bdp->cbd_sc & BD_SC_READY);
  1073. *((char *)__va(bdp->cbd_bufaddr)) = ch;
  1074. bdp->cbd_datlen = 1;
  1075. bdp->cbd_sc |= BD_SC_READY;
  1077. /* Get next BD.
  1078. */
  1079. if (bdp->cbd_sc & BD_SC_WRAP)
  1080. bdp = info->tx_bd_base;
  1081. else
  1082. bdp++;
  1084. info->tx_cur = (cbd_t *)bdp;
  1085. }
  1087. /*
  1088.  * ------------------------------------------------------------
  1089.  * rs_throttle()
  1090.  * 
  1091.  * This routine is called by the upper-layer tty layer to signal that
  1092.  * incoming characters should be throttled.
  1093.  * ------------------------------------------------------------
  1094.  */
  1095. static void rs_8xx_throttle(struct tty_struct * tty)
  1096. {
  1097. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1098. #ifdef SERIAL_DEBUG_THROTTLE
  1099. char buf[64];
  1101. printk("throttle %s: %d....n", _tty_name(tty, buf),
  1102.        tty->ldisc.chars_in_buffer(tty));
  1103. #endif
  1105. if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  1106. return;
  1108. if (I_IXOFF(tty))
  1109. rs_8xx_send_xchar(tty, STOP_CHAR(tty));
  1111. #ifdef modem_control
  1112. if (tty->termios->c_cflag & CRTSCTS)
  1113. info->MCR &= ~UART_MCR_RTS;
  1115. cli();
  1116. serial_out(info, UART_MCR, info->MCR);
  1117. sti();
  1118. #endif
  1119. }
  1121. static void rs_8xx_unthrottle(struct tty_struct * tty)
  1122. {
  1123. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1124. #ifdef SERIAL_DEBUG_THROTTLE
  1125. char buf[64];
  1127. printk("unthrottle %s: %d....n", _tty_name(tty, buf),
  1128.        tty->ldisc.chars_in_buffer(tty));
  1129. #endif
  1131. if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  1132. return;
  1134. if (I_IXOFF(tty)) {
  1135. if (info->x_char)
  1136. info->x_char = 0;
  1137. else
  1138. rs_8xx_send_xchar(tty, START_CHAR(tty));
  1139. }
  1140. #ifdef modem_control
  1141. if (tty->termios->c_cflag & CRTSCTS)
  1142. info->MCR |= UART_MCR_RTS;
  1143. cli();
  1144. serial_out(info, UART_MCR, info->MCR);
  1145. sti();
  1146. #endif
  1147. }
  1149. /*
  1150.  * ------------------------------------------------------------
  1151.  * rs_ioctl() and friends
  1152.  * ------------------------------------------------------------
  1153.  */
  1155. #ifdef maybe
  1156. /*
  1157.  * get_lsr_info - get line status register info
  1158.  *
  1159.  * Purpose: Let user call ioctl() to get info when the UART physically
  1160.  *      is emptied.  On bus types like RS485, the transmitter must
  1161.  *      release the bus after transmitting. This must be done when
  1162.  *      the transmit shift register is empty, not be done when the
  1163.  *      transmit holding register is empty.  This functionality
  1164.  *      allows an RS485 driver to be written in user space. 
  1165.  */
  1166. static int get_lsr_info(struct async_struct * info, unsigned int *value)
  1167. {
  1168. unsigned char status;
  1169. unsigned int result;
  1171. cli();
  1172. status = serial_in(info, UART_LSR);
  1173. sti();
  1174. result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
  1175. return put_user(result,value);
  1176. }
  1177. #endif
  1179. static int get_modem_info(ser_info_t *info, unsigned int *value)
  1180. {
  1181. unsigned int result = 0;
  1182. #ifdef modem_control
  1183. unsigned char control, status;
  1185. control = info->MCR;
  1186. cli();
  1187. status = serial_in(info, UART_MSR);
  1188. sti();
  1189. result =  ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
  1190. | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
  1191. #ifdef TIOCM_OUT1
  1192. | ((control & UART_MCR_OUT1) ? TIOCM_OUT1 : 0)
  1193. | ((control & UART_MCR_OUT2) ? TIOCM_OUT2 : 0)
  1194. #endif
  1195. | ((status  & UART_MSR_DCD) ? TIOCM_CAR : 0)
  1196. | ((status  & UART_MSR_RI) ? TIOCM_RNG : 0)
  1197. | ((status  & UART_MSR_DSR) ? TIOCM_DSR : 0)
  1198. | ((status  & UART_MSR_CTS) ? TIOCM_CTS : 0);
  1199. #endif
  1200. return put_user(result,value);
  1201. }
  1203. static int set_modem_info(ser_info_t *info, unsigned int cmd,
  1204.   unsigned int *value)
  1205. {
  1206. int error;
  1207. unsigned int arg;
  1209. error = get_user(arg, value);
  1210. if (error)
  1211. return error;
  1212. #ifdef modem_control
  1213. switch (cmd) {
  1214. case TIOCMBIS: 
  1215. if (arg & TIOCM_RTS)
  1216. info->MCR |= UART_MCR_RTS;
  1217. if (arg & TIOCM_DTR)
  1218. info->MCR |= UART_MCR_DTR;
  1219. #ifdef TIOCM_OUT1
  1220. if (arg & TIOCM_OUT1)
  1221. info->MCR |= UART_MCR_OUT1;
  1222. if (arg & TIOCM_OUT2)
  1223. info->MCR |= UART_MCR_OUT2;
  1224. #endif
  1225. break;
  1226. case TIOCMBIC:
  1227. if (arg & TIOCM_RTS)
  1228. info->MCR &= ~UART_MCR_RTS;
  1229. if (arg & TIOCM_DTR)
  1230. info->MCR &= ~UART_MCR_DTR;
  1231. #ifdef TIOCM_OUT1
  1232. if (arg & TIOCM_OUT1)
  1233. info->MCR &= ~UART_MCR_OUT1;
  1234. if (arg & TIOCM_OUT2)
  1235. info->MCR &= ~UART_MCR_OUT2;
  1236. #endif
  1237. break;
  1238. case TIOCMSET:
  1239. info->MCR = ((info->MCR & ~(UART_MCR_RTS |
  1240. #ifdef TIOCM_OUT1
  1241.     UART_MCR_OUT1 |
  1242.     UART_MCR_OUT2 |
  1243. #endif
  1244.     UART_MCR_DTR))
  1245.      | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
  1246. #ifdef TIOCM_OUT1
  1247.      | ((arg & TIOCM_OUT1) ? UART_MCR_OUT1 : 0)
  1248.      | ((arg & TIOCM_OUT2) ? UART_MCR_OUT2 : 0)
  1249. #endif
  1250.      | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0));
  1251. break;
  1252. default:
  1253. return -EINVAL;
  1254. }
  1255. cli();
  1256. serial_out(info, UART_MCR, info->MCR);
  1257. sti();
  1258. #endif
  1259. return 0;
  1260. }
  1262. /* Sending a break is a two step process on the SMC/SCC.  It is accomplished
  1263.  * by sending a STOP TRANSMIT command followed by a RESTART TRANSMIT
  1264.  * command.  We take advantage of the begin/end functions to make this
  1265.  * happen.
  1266.  */
  1267. static void begin_break(ser_info_t *info)
  1268. {
  1269. volatile cpm8260_t *cp;
  1270. uint page, sblock;
  1271. ushort num;
  1273. cp = cpmp;
  1275. if ((num = info->state->smc_scc_num) < SCC_NUM_BASE) {
  1276. if (num == 0) {
  1277. page = CPM_CR_SMC1_PAGE;
  1278. sblock = CPM_CR_SMC1_SBLOCK;
  1279. }
  1280. else {
  1281. page = CPM_CR_SMC2_PAGE;
  1282. sblock = CPM_CR_SMC2_SBLOCK;
  1283. }
  1284. }
  1285. else {
  1286. num -= SCC_NUM_BASE;
  1287. switch (num) {
  1288. case 0:
  1289. page = CPM_CR_SCC1_PAGE;
  1290. sblock = CPM_CR_SCC1_SBLOCK;
  1291. break;
  1292. case 1:
  1293. page = CPM_CR_SCC2_PAGE;
  1294. sblock = CPM_CR_SCC2_SBLOCK;
  1295. break;
  1296. case 2:
  1297. page = CPM_CR_SCC3_PAGE;
  1298. sblock = CPM_CR_SCC3_SBLOCK;
  1299. break;
  1300. case 3:
  1301. page = CPM_CR_SCC4_PAGE;
  1302. sblock = CPM_CR_SCC4_SBLOCK;
  1303. break;
  1304. default: return;
  1305. }
  1306. }
  1307. cp->cp_cpcr = mk_cr_cmd(page, sblock, 0, CPM_CR_STOP_TX) | CPM_CR_FLG;
  1308. while (cp->cp_cpcr & CPM_CR_FLG);
  1309. }
  1311. static void end_break(ser_info_t *info)
  1312. {
  1313. volatile cpm8260_t *cp;
  1314. uint page, sblock;
  1315. ushort num;
  1317. cp = cpmp;
  1319. if ((num = info->state->smc_scc_num) < SCC_NUM_BASE) {
  1320. if (num == 0) {
  1321. page = CPM_CR_SMC1_PAGE;
  1322. sblock = CPM_CR_SMC1_SBLOCK;
  1323. }
  1324. else {
  1325. page = CPM_CR_SMC2_PAGE;
  1326. sblock = CPM_CR_SMC2_SBLOCK;
  1327. }
  1328. }
  1329. else {
  1330. num -= SCC_NUM_BASE;
  1331. switch (num) {
  1332. case 0:
  1333. page = CPM_CR_SCC1_PAGE;
  1334. sblock = CPM_CR_SCC1_SBLOCK;
  1335. break;
  1336. case 1:
  1337. page = CPM_CR_SCC2_PAGE;
  1338. sblock = CPM_CR_SCC2_SBLOCK;
  1339. break;
  1340. case 2:
  1341. page = CPM_CR_SCC3_PAGE;
  1342. sblock = CPM_CR_SCC3_SBLOCK;
  1343. break;
  1344. case 3:
  1345. page = CPM_CR_SCC4_PAGE;
  1346. sblock = CPM_CR_SCC4_SBLOCK;
  1347. break;
  1348. default: return;
  1349. }
  1350. }
  1351. cp->cp_cpcr = mk_cr_cmd(page, sblock, 0, CPM_CR_RESTART_TX) | CPM_CR_FLG;
  1352. while (cp->cp_cpcr & CPM_CR_FLG);
  1353. }
  1355. /*
  1356.  * This routine sends a break character out the serial port.
  1357.  */
  1358. static void send_break(ser_info_t *info, int duration)
  1359. {
  1360. current->state = TASK_INTERRUPTIBLE;
  1361. #ifdef SERIAL_DEBUG_SEND_BREAK
  1362. printk("rs_send_break(%d) jiff=%lu...", duration, jiffies);
  1363. #endif
  1364. begin_break(info);
  1365. schedule_timeout(duration);
  1366. end_break(info);
  1367. #ifdef SERIAL_DEBUG_SEND_BREAK
  1368. printk("done jiffies=%lun", jiffies);
  1369. #endif
  1370. }
  1373. static int rs_8xx_ioctl(struct tty_struct *tty, struct file * file,
  1374.     unsigned int cmd, unsigned long arg)
  1375. {
  1376. int error;
  1377. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1378. int retval;
  1379. struct async_icount cnow; /* kernel counter temps */
  1380. struct serial_icounter_struct *p_cuser; /* user space */
  1382. if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  1383. return -ENODEV;
  1385. if ((cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
  1386. if (tty->flags & (1 << TTY_IO_ERROR))
  1387.     return -EIO;
  1388. }
  1390. switch (cmd) {
  1391. case TCSBRK: /* SVID version: non-zero arg --> no break */
  1392. retval = tty_check_change(tty);
  1393. if (retval)
  1394. return retval;
  1395. tty_wait_until_sent(tty, 0);
  1396. if (signal_pending(current))
  1397. return -EINTR;
  1398. if (!arg) {
  1399. send_break(info, HZ/4); /* 1/4 second */
  1400. if (signal_pending(current))
  1401. return -EINTR;
  1402. }
  1403. return 0;
  1404. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1405. retval = tty_check_change(tty);
  1406. if (retval)
  1407. return retval;
  1408. tty_wait_until_sent(tty, 0);
  1409. if (signal_pending(current))
  1410. return -EINTR;
  1411. send_break(info, arg ? arg*(HZ/10) : HZ/4);
  1412. if (signal_pending(current))
  1413. return -EINTR;
  1414. return 0;
  1415. case TIOCSBRK:
  1416. retval = tty_check_change(tty);
  1417. if (retval)
  1418. return retval;
  1419. tty_wait_until_sent(tty, 0);
  1420. begin_break(info);
  1421. return 0;
  1422. case TIOCCBRK:
  1423. retval = tty_check_change(tty);
  1424. if (retval)
  1425. return retval;
  1426. end_break(info);
  1427. return 0;
  1428. case TIOCGSOFTCAR:
  1429. return put_user(C_CLOCAL(tty) ? 1 : 0, (int *) arg);
  1430. case TIOCSSOFTCAR:
  1431. error = get_user(arg, (unsigned int *) arg);
  1432. if (error)
  1433. return error;
  1434. tty->termios->c_cflag =
  1435. ((tty->termios->c_cflag & ~CLOCAL) |
  1436.  (arg ? CLOCAL : 0));
  1437. return 0;
  1438. case TIOCMGET:
  1439. return get_modem_info(info, (unsigned int *) arg);
  1440. case TIOCMBIS:
  1441. case TIOCMBIC:
  1442. case TIOCMSET:
  1443. return set_modem_info(info, cmd, (unsigned int *) arg);
  1444. #ifdef maybe
  1445. case TIOCSERGETLSR: /* Get line status register */
  1446. return get_lsr_info(info, (unsigned int *) arg);
  1447. #endif
  1448. /*
  1449.  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
  1450.  * - mask passed in arg for lines of interest
  1451.    *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  1452.  * Caller should use TIOCGICOUNT to see which one it was
  1453.  */
  1454.  case TIOCMIWAIT:
  1455. #ifdef modem_control
  1456. cli();
  1457. /* note the counters on entry */
  1458. cprev = info->state->icount;
  1459. sti();
  1460. while (1) {
  1461. interruptible_sleep_on(&info->delta_msr_wait);
  1462. /* see if a signal did it */
  1463. if (signal_pending(current))
  1464. return -ERESTARTSYS;
  1465. cli();
  1466. cnow = info->state->icount; /* atomic copy */
  1467. sti();
  1468. if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
  1469.     cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
  1470. return -EIO; /* no change => error */
  1471. if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
  1472.      ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
  1473.      ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
  1474.      ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
  1475. return 0;
  1476. }
  1477. cprev = cnow;
  1478. }
  1479. /* NOTREACHED */
  1480. #else
  1481. return 0;
  1482. #endif
  1484. /* 
  1485.  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
  1486.  * Return: write counters to the user passed counter struct
  1487.  * NB: both 1->0 and 0->1 transitions are counted except for
  1488.  *     RI where only 0->1 is counted.
  1489.  */
  1490. case TIOCGICOUNT:
  1491. cli();
  1492. cnow = info->state->icount;
  1493. sti();
  1494. p_cuser = (struct serial_icounter_struct *) arg;
  1495. error = put_user(cnow.cts, &p_cuser->cts);
  1496. if (error) return error;
  1497. error = put_user(cnow.dsr, &p_cuser->dsr);
  1498. if (error) return error;
  1499. error = put_user(cnow.rng, &p_cuser->rng);
  1500. if (error) return error;
  1501. error = put_user(cnow.dcd, &p_cuser->dcd);
  1502. if (error) return error;
  1503. return 0;
  1505. default:
  1506. return -ENOIOCTLCMD;
  1507. }
  1508. return 0;
  1509. }
  1511. /* FIX UP modem control here someday......
  1512. */
  1513. static void rs_8xx_set_termios(struct tty_struct *tty, struct termios *old_termios)
  1514. {
  1515. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1517. if (   (tty->termios->c_cflag == old_termios->c_cflag)
  1518.     && (   RELEVANT_IFLAG(tty->termios->c_iflag) 
  1519. == RELEVANT_IFLAG(old_termios->c_iflag)))
  1520.   return;
  1522. change_speed(info);
  1524. #ifdef modem_control
  1525. /* Handle transition to B0 status */
  1526. if ((old_termios->c_cflag & CBAUD) &&
  1527.     !(tty->termios->c_cflag & CBAUD)) {
  1528. info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS);
  1529. cli();
  1530. serial_out(info, UART_MCR, info->MCR);
  1531. sti();
  1532. }
  1534. /* Handle transition away from B0 status */
  1535. if (!(old_termios->c_cflag & CBAUD) &&
  1536.     (tty->termios->c_cflag & CBAUD)) {
  1537. info->MCR |= UART_MCR_DTR;
  1538. if (!tty->hw_stopped ||
  1539.     !(tty->termios->c_cflag & CRTSCTS)) {
  1540. info->MCR |= UART_MCR_RTS;
  1541. }
  1542. cli();
  1543. serial_out(info, UART_MCR, info->MCR);
  1544. sti();
  1545. }
  1547. /* Handle turning off CRTSCTS */
  1548. if ((old_termios->c_cflag & CRTSCTS) &&
  1549.     !(tty->termios->c_cflag & CRTSCTS)) {
  1550. tty->hw_stopped = 0;
  1551. rs_8xx_start(tty);
  1552. }
  1553. #endif
  1555. #if 0
  1556. /*
  1557.  * No need to wake up processes in open wait, since they
  1558.  * sample the CLOCAL flag once, and don't recheck it.
  1559.  * XXX  It's not clear whether the current behavior is correct
  1560.  * or not.  Hence, this may change.....
  1561.  */
  1562. if (!(old_termios->c_cflag & CLOCAL) &&
  1563.     (tty->termios->c_cflag & CLOCAL))
  1564. wake_up_interruptible(&info->open_wait);
  1565. #endif
  1566. }
  1568. /*
  1569.  * ------------------------------------------------------------
  1570.  * rs_close()
  1571.  * 
  1572.  * This routine is called when the serial port gets closed.  First, we
  1573.  * wait for the last remaining data to be sent.  Then, we unlink its
  1574.  * async structure from the interrupt chain if necessary, and we free
  1575.  * that IRQ if nothing is left in the chain.
  1576.  * ------------------------------------------------------------
  1577.  */
  1578. static void rs_8xx_close(struct tty_struct *tty, struct file * filp)
  1579. {
  1580. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1581. struct serial_state *state;
  1582. unsigned long flags;
  1583. int idx;
  1584. volatile smc_t *smcp;
  1585. volatile scc_t *sccp;
  1587. if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  1588. return;
  1590. state = info->state;
  1592. save_flags(flags); cli();
  1594. if (tty_hung_up_p(filp)) {
  1595. DBG_CNT("before DEC-hung");
  1596. MOD_DEC_USE_COUNT;
  1597. restore_flags(flags);
  1598. return;
  1599. }
  1601. #ifdef SERIAL_DEBUG_OPEN
  1602. printk("rs_close ttys%d, count = %dn", info->line, state->count);
  1603. #endif
  1604. if ((tty->count == 1) && (state->count != 1)) {
  1605. /*
  1606.  * Uh, oh.  tty->count is 1, which means that the tty
  1607.  * structure will be freed.  state->count should always
  1608.  * be one in these conditions.  If it's greater than
  1609.  * one, we've got real problems, since it means the
  1610.  * serial port won't be shutdown.
  1611.  */
  1612. printk("rs_close: bad serial port count; tty->count is 1, "
  1613.        "state->count is %dn", state->count);
  1614. state->count = 1;
  1615. }
  1616. if (--state->count < 0) {
  1617. printk("rs_close: bad serial port count for ttys%d: %dn",
  1618.        info->line, state->count);
  1619. state->count = 0;
  1620. }
  1621. if (state->count) {
  1622. DBG_CNT("before DEC-2");
  1623. MOD_DEC_USE_COUNT;
  1624. restore_flags(flags);
  1625. return;
  1626. }
  1627. info->flags |= ASYNC_CLOSING;
  1628. /*
  1629.  * Save the termios structure, since this port may have
  1630.  * separate termios for callout and dialin.
  1631.  */
  1632. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1633. info->state->normal_termios = *tty->termios;
  1634. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1635. info->state->callout_termios = *tty->termios;
  1636. /*
  1637.  * Now we wait for the transmit buffer to clear; and we notify 
  1638.  * the line discipline to only process XON/XOFF characters.
  1639.  */
  1640. tty->closing = 1;
  1641. if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  1642. tty_wait_until_sent(tty, info->closing_wait);
  1643. /*
  1644.  * At this point we stop accepting input.  To do this, we
  1645.  * disable the receive line status interrupts, and tell the
  1646.  * interrupt driver to stop checking the data ready bit in the
  1647.  * line status register.
  1648.  */
  1649. info->read_status_mask &= ~BD_SC_EMPTY;
  1650. if (info->flags & ASYNC_INITIALIZED) {
  1651. if ((idx = info->state->smc_scc_num) < SCC_NUM_BASE) {
  1652. smcp = &immr->im_smc[idx];
  1653. smcp->smc_smcm &= ~SMCM_RX;
  1654. smcp->smc_smcmr &= ~SMCMR_REN;
  1655. }
  1656. else {
  1657. sccp = &immr->im_scc[idx - SCC_IDX_BASE];
  1658. sccp->scc_sccm &= ~UART_SCCM_RX;
  1659. sccp->scc_gsmrl &= ~SCC_GSMRL_ENR;
  1660. }
  1661. /*
  1662.  * Before we drop DTR, make sure the UART transmitter
  1663.  * has completely drained; this is especially
  1664.  * important if there is a transmit FIFO!
  1665.  */
  1666. rs_8xx_wait_until_sent(tty, info->timeout);
  1667. }
  1668. shutdown(info);
  1669. if (tty->driver.flush_buffer)
  1670. tty->driver.flush_buffer(tty);
  1671. if (tty->ldisc.flush_buffer)
  1672. tty->ldisc.flush_buffer(tty);
  1673. tty->closing = 0;
  1674. info->event = 0;
  1675. info->tty = 0;
  1676. if (info->blocked_open) {
  1677. if (info->close_delay) {
  1678. current->state = TASK_INTERRUPTIBLE;
  1679. schedule_timeout(info->close_delay);
  1680. }
  1681. wake_up_interruptible(&info->open_wait);
  1682. }
  1683. info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  1684.  ASYNC_CLOSING);
  1685. wake_up_interruptible(&info->close_wait);
  1686. MOD_DEC_USE_COUNT;
  1687. restore_flags(flags);
  1688. }
  1690. /*
  1691.  * rs_wait_until_sent() --- wait until the transmitter is empty
  1692.  */
  1693. static void rs_8xx_wait_until_sent(struct tty_struct *tty, int timeout)
  1694. {
  1695. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1696. unsigned long orig_jiffies, char_time;
  1697. /*int lsr;*/
  1698. volatile cbd_t *bdp;
  1700. if (serial_paranoia_check(info, tty->device, "rs_wait_until_sent"))
  1701. return;
  1703. #ifdef maybe
  1704. if (info->state->type == PORT_UNKNOWN)
  1705. return;
  1706. #endif
  1708. orig_jiffies = jiffies;
  1709. /*
  1710.  * Set the check interval to be 1/5 of the estimated time to
  1711.  * send a single character, and make it at least 1.  The check
  1712.  * interval should also be less than the timeout.
  1713.  * 
  1714.  * Note: we have to use pretty tight timings here to satisfy
  1715.  * the NIST-PCTS.
  1716.  */
  1717. char_time = 1;
  1718. if (timeout)
  1719. char_time = MIN(char_time, timeout);
  1720. #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  1721. printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
  1722. printk("jiff=%lu...", jiffies);
  1723. #endif
  1725. /* We go through the loop at least once because we can't tell
  1726.  * exactly when the last character exits the shifter.  There can
  1727.  * be at least two characters waiting to be sent after the buffers
  1728.  * are empty.
  1729.  */
  1730. do {
  1731. #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  1732. printk("lsr = %d (jiff=%lu)...", lsr, jiffies);
  1733. #endif
  1734. current->state = TASK_INTERRUPTIBLE;
  1735. /* current->counter = 0;  make us low-priority */
  1736. schedule_timeout(char_time);
  1737. if (signal_pending(current))
  1738. break;
  1739. if (timeout && time_after(jiffies, orig_jiffies + timeout))
  1740. break;
  1741. bdp = info->tx_cur;
  1742. } while (bdp->cbd_sc & BD_SC_READY);
  1743. current->state = TASK_RUNNING;
  1744. #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  1745. printk("lsr = %d (jiff=%lu)...donen", lsr, jiffies);
  1746. #endif
  1747. }
  1749. /*
  1750.  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  1751.  */
  1752. static void rs_8xx_hangup(struct tty_struct *tty)
  1753. {
  1754. ser_info_t *info = (ser_info_t *)tty->driver_data;
  1755. struct serial_state *state = info->state;
  1757. if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  1758. return;
  1760. state = info->state;
  1762. rs_8xx_flush_buffer(tty);
  1763. shutdown(info);
  1764. info->event = 0;
  1765. state->count = 0;
  1766. info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  1767. info->tty = 0;
  1768. wake_up_interruptible(&info->open_wait);
  1769. }
  1771. /*
  1772.  * ------------------------------------------------------------
  1773.  * rs_open() and friends
  1774.  * ------------------------------------------------------------
  1775.  */
  1776. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1777.    ser_info_t *info)
  1778. {
  1779. #ifdef DO_THIS_LATER
  1780. DECLARE_WAITQUEUE(wait, current);
  1781. #endif
  1782. struct serial_state *state = info->state;
  1783. int retval;
  1784. int do_clocal = 0;
  1786. /*
  1787.  * If the device is in the middle of being closed, then block
  1788.  * until it's done, and then try again.
  1789.  */
  1790. if (tty_hung_up_p(filp) ||
  1791.     (info->flags & ASYNC_CLOSING)) {
  1792. if (info->flags & ASYNC_CLOSING)
  1793. interruptible_sleep_on(&info->close_wait);
  1794. #ifdef SERIAL_DO_RESTART
  1795. if (info->flags & ASYNC_HUP_NOTIFY)
  1796. return -EAGAIN;
  1797. else
  1798. return -ERESTARTSYS;
  1799. #else
  1800. return -EAGAIN;
  1801. #endif
  1802. }
  1804. /*
  1805.  * If this is a callout device, then just make sure the normal
  1806.  * device isn't being used.
  1807.  */
  1808. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1809. if (info->flags & ASYNC_NORMAL_ACTIVE)
  1810. return -EBUSY;
  1811. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1812.     (info->flags & ASYNC_SESSION_LOCKOUT) &&
  1813.     (info->session != current->session))
  1814.     return -EBUSY;
  1815. if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1816.     (info->flags & ASYNC_PGRP_LOCKOUT) &&
  1817.     (info->pgrp != current->pgrp))
  1818.     return -EBUSY;
  1819. info->flags |= ASYNC_CALLOUT_ACTIVE;
  1820. return 0;
  1821. }
  1823. /*
  1824.  * If non-blocking mode is set, or the port is not enabled,
  1825.  * then make the check up front and then exit.
  1826.  * If this is an SMC port, we don't have modem control to wait
  1827.  * for, so just get out here.
  1828.  */
  1829. if ((filp->f_flags & O_NONBLOCK) ||
  1830.     (tty->flags & (1 << TTY_IO_ERROR)) ||
  1831.     (info->state->smc_scc_num < SCC_NUM_BASE)) {
  1832. if (info->flags & ASYNC_CALLOUT_ACTIVE)
  1833. return -EBUSY;
  1834. info->flags |= ASYNC_NORMAL_ACTIVE;
  1835. return 0;
  1836. }
  1838. if (info->flags & ASYNC_CALLOUT_ACTIVE) {
  1839. if (state->normal_termios.c_cflag & CLOCAL)
  1840. do_clocal = 1;
  1841. } else {
  1842. if (tty->termios->c_cflag & CLOCAL)
  1843. do_clocal = 1;
  1844. }
  1846. /*
  1847.  * Block waiting for the carrier detect and the line to become
  1848.  * free (i.e., not in use by the callout).  While we are in
  1849.  * this loop, state->count is dropped by one, so that
  1850.  * rs_close() knows when to free things.  We restore it upon
  1851.  * exit, either normal or abnormal.
  1852.  */
  1853. retval = 0;
  1854. #ifdef DO_THIS_LATER
  1855. add_wait_queue(&info->open_wait, &wait);
  1856. #ifdef SERIAL_DEBUG_OPEN
  1857. printk("block_til_ready before block: ttys%d, count = %dn",
  1858.        state->line, state->count);
  1859. #endif
  1860. cli();
  1861. if (!tty_hung_up_p(filp)) 
  1862. state->count--;
  1863. sti();
  1864. info->blocked_open++;
  1865. while (1) {
  1866. cli();
  1867. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1868.     (tty->termios->c_cflag & CBAUD))
  1869. serial_out(info, UART_MCR,
  1870.    serial_inp(info, UART_MCR) |
  1871.    (UART_MCR_DTR | UART_MCR_RTS));
  1872. sti();
  1873. set_current_state(TASK_INTERRUPTIBLE);
  1874. if (tty_hung_up_p(filp) ||
  1875.     !(info->flags & ASYNC_INITIALIZED)) {
  1876. #ifdef SERIAL_DO_RESTART
  1877. if (info->flags & ASYNC_HUP_NOTIFY)
  1878. retval = -EAGAIN;
  1879. else
  1880. retval = -ERESTARTSYS;
  1881. #else
  1882. retval = -EAGAIN;
  1883. #endif
  1884. break;
  1885. }
  1886. if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
  1887.     !(info->flags & ASYNC_CLOSING) &&
  1888.     (do_clocal || (serial_in(info, UART_MSR) &
  1889.    UART_MSR_DCD)))
  1890. break;
  1891. if (signal_pending(current)) {
  1892. retval = -ERESTARTSYS;
  1893. break;
  1894. }
  1895. #ifdef SERIAL_DEBUG_OPEN
  1896. printk("block_til_ready blocking: ttys%d, count = %dn",
  1897.        info->line, state->count);
  1898. #endif
  1899. schedule();
  1900. }
  1901. current->state = TASK_RUNNING;
  1902. remove_wait_queue(&info->open_wait, &wait);
  1903. if (!tty_hung_up_p(filp))
  1904. state->count++;
  1905. info->blocked_open--;
  1906. #ifdef SERIAL_DEBUG_OPEN
  1907. printk("block_til_ready after blocking: ttys%d, count = %dn",
  1908.        info->line, state->count);
  1909. #endif
  1910. #endif /* DO_THIS_LATER */
  1911. if (retval)
  1912. return retval;
  1913. info->flags |= ASYNC_NORMAL_ACTIVE;
  1914. return 0;
  1915. }
  1917. static int get_async_struct(int line, ser_info_t **ret_info)
  1918. {
  1919. struct serial_state *sstate;
  1921. sstate = rs_table + line;
  1922. if (sstate->info) {
  1923. sstate->count++;
  1924. *ret_info = (ser_info_t *)sstate->info;
  1925. return 0;
  1926. }
  1927. else {
  1928. return -ENOMEM;
  1929. }
  1930. }
  1932. /*
  1933.  * This routine is called whenever a serial port is opened.  It
  1934.  * enables interrupts for a serial port, linking in its async structure into
  1935.  * the IRQ chain.   It also performs the serial-specific
  1936.  * initialization for the tty structure.
  1937.  */
  1938. static int rs_8xx_open(struct tty_struct *tty, struct file * filp)
  1939. {
  1940. ser_info_t *info;
  1941. int  retval, line;
  1943. line = MINOR(tty->device) - tty->driver.minor_start;
  1944. if ((line < 0) || (line >= NR_PORTS))
  1945. return -ENODEV;
  1946. retval = get_async_struct(line, &info);
  1947. if (retval)
  1948. return retval;
  1949. if (serial_paranoia_check(info, tty->device, "rs_open"))
  1950. return -ENODEV;
  1952. #ifdef SERIAL_DEBUG_OPEN
  1953. printk("rs_open %s%d, count = %dn", tty->driver.name, info->line,
  1954.        info->state->count);
  1955. #endif
  1956. tty->driver_data = info;
  1957. info->tty = tty;
  1959. /*
  1960.  * Start up serial port
  1961.  */
  1962. retval = startup(info);
  1963. if (retval)
  1964. return retval;
  1966. MOD_INC_USE_COUNT;
  1967. retval = block_til_ready(tty, filp, info);
  1968. if (retval) {
  1969. #ifdef SERIAL_DEBUG_OPEN
  1970. printk("rs_open returning after block_til_ready with %dn",
  1971.        retval);
  1972. #endif
  1973. return retval;
  1974. }
  1976. if ((info->state->count == 1) &&
  1977.     (info->flags & ASYNC_SPLIT_TERMIOS)) {
  1978. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1979. *tty->termios = info->state->normal_termios;
  1980. else 
  1981. *tty->termios = info->state->callout_termios;
  1982. change_speed(info);
  1983. }
  1985. info->session = current->session;
  1986. info->pgrp = current->pgrp;
  1988. #ifdef SERIAL_DEBUG_OPEN
  1989. printk("rs_open ttys%d successful...", info->line);
  1990. #endif
  1991. return 0;
  1992. }
  1994. /*
  1995.  * /proc fs routines....
  1996.  */
  1998. static int inline line_info(char *buf, struct serial_state *state)
  1999. {
  2000. #ifdef notdef
  2001. struct async_struct *info = state->info, scr_info;
  2002. char stat_buf[30], control, status;
  2003. #endif
  2004. int ret;
  2006. ret = sprintf(buf, "%d: uart:%s port:%X irq:%d",
  2007.       state->line,
  2008.       (state->smc_scc_num < SCC_NUM_BASE) ? "SMC" : "SCC",
  2009.       state->port, state->irq);
  2011. if (!state->port || (state->type == PORT_UNKNOWN)) {
  2012. ret += sprintf(buf+ret, "n");
  2013. return ret;
  2014. }
  2016. #ifdef notdef
  2017. /*
  2018.  * Figure out the current RS-232 lines
  2019.  */
  2020. if (!info) {
  2021. info = &scr_info; /* This is just for serial_{in,out} */
  2023. info->magic = SERIAL_MAGIC;
  2024. info->port = state->port;
  2025. info->flags = state->flags;
  2026. info->quot = 0;
  2027. info->tty = 0;
  2028. }
  2029. cli();
  2030. status = serial_in(info, UART_MSR);
  2031. control = info ? info->MCR : serial_in(info, UART_MCR);
  2032. sti();
  2034. stat_buf[0] = 0;
  2035. stat_buf[1] = 0;
  2036. if (control & UART_MCR_RTS)
  2037. strcat(stat_buf, "|RTS");
  2038. if (status & UART_MSR_CTS)
  2039. strcat(stat_buf, "|CTS");
  2040. if (control & UART_MCR_DTR)
  2041. strcat(stat_buf, "|DTR");
  2042. if (status & UART_MSR_DSR)
  2043. strcat(stat_buf, "|DSR");
  2044. if (status & UART_MSR_DCD)
  2045. strcat(stat_buf, "|CD");
  2046. if (status & UART_MSR_RI)
  2047. strcat(stat_buf, "|RI");
  2049. if (info->quot) {
  2050. ret += sprintf(buf+ret, " baud:%d",
  2051.        state->baud_base / info->quot);
  2052. }
  2054. ret += sprintf(buf+ret, " tx:%d rx:%d",
  2055.       state->icount.tx, state->icount.rx);
  2057. if (state->icount.frame)
  2058. ret += sprintf(buf+ret, " fe:%d", state->icount.frame);
  2060. if (state->icount.parity)
  2061. ret += sprintf(buf+ret, " pe:%d", state->icount.parity);
  2063. if (state->icount.brk)
  2064. ret += sprintf(buf+ret, " brk:%d", state->icount.brk);
  2066. if (state->icount.overrun)
  2067. ret += sprintf(buf+ret, " oe:%d", state->icount.overrun);
  2069. /*
  2070.  * Last thing is the RS-232 status lines
  2071.  */
  2072. ret += sprintf(buf+ret, " %sn", stat_buf+1);
  2073. #endif
  2074. return ret;
  2075. }
  2077. int rs_8xx_read_proc(char *page, char **start, off_t off, int count,
  2078.  int *eof, void *data)
  2079. {
  2080. int i, len = 0;
  2081. off_t begin = 0;
  2083. len += sprintf(page, "serinfo:1.0 driver:%sn", serial_version);
  2084. for (i = 0; i < NR_PORTS && len < 4000; i++) {
  2085. len += line_info(page + len, &rs_table[i]);
  2086. if (len+begin > off+count)
  2087. goto done;
  2088. if (len+begin < off) {
  2089. begin += len;
  2090. len = 0;
  2091. }
  2092. }
  2093. *eof = 1;
  2094. done:
  2095. if (off >= len+begin)
  2096. return 0;
  2097. *start = page + (begin-off);
  2098. return ((count < begin+len-off) ? count : begin+len-off);
  2099. }
  2101. /*
  2102.  * ---------------------------------------------------------------------
  2103.  * rs_init() and friends
  2104.  *
  2105.  * rs_init() is called at boot-time to initialize the serial driver.
  2106.  * ---------------------------------------------------------------------
  2107.  */
  2109. /*
  2110.  * This routine prints out the appropriate serial driver version
  2111.  * number, and identifies which options were configured into this
  2112.  * driver.
  2113.  */
  2114. static _INLINE_ void show_serial_version(void)
  2115. {
  2116.   printk(KERN_INFO "%s version %sn", serial_name, serial_version);
  2117. }
  2120. /*
  2121.  * The serial console driver used during boot.  Note that these names
  2122.  * clash with those found in "serial.c", so we currently can't support
  2123.  * the 16xxx uarts and these at the same time.  I will fix this to become
  2124.  * an indirect function call from tty_io.c (or something).
  2125.  */
  2127. #ifdef CONFIG_SERIAL_CONSOLE
  2129. /*
  2130.  * Print a string to the serial port trying not to disturb any possible
  2131.  * real use of the port...
  2132.  */
  2133. static void serial_console_write(struct console *c, const char *s,
  2134. unsigned count)
  2135. {
  2136. struct serial_state *ser;
  2137. ser_info_t *info;
  2138. unsigned i;
  2139. volatile cbd_t *bdp, *bdbase;
  2140. volatile smc_uart_t *up;
  2141. volatile u_char *cp;
  2143. ser = rs_table + c->index;
  2145. /* If the port has been initialized for general use, we have
  2146.  * to use the buffer descriptors allocated there.  Otherwise,
  2147.  * we simply use the single buffer allocated.
  2148.  */
  2149. if ((info = (ser_info_t *)ser->info) != NULL) {
  2150. bdp = info->tx_cur;
  2151. bdbase = info->tx_bd_base;
  2152. }
  2153. else {
  2154. /* Pointer to UART in parameter ram.
  2155. */
  2156. up = (smc_uart_t *)&immr->im_dprambase[ser->port];
  2158. /* Get the address of the host memory buffer.
  2159.  */
  2160. bdp = bdbase = (cbd_t *)&immr->im_dprambase[up->smc_tbase];
  2161. }
  2163. /*
  2164.  * We need to gracefully shut down the transmitter, disable
  2165.  * interrupts, then send our bytes out.
  2166.  */
  2168. /*
  2169.  * Now, do each character.  This is not as bad as it looks
  2170.  * since this is a holding FIFO and not a transmitting FIFO.
  2171.  * We could add the complexity of filling the entire transmit
  2172.  * buffer, but we would just wait longer between accesses......
  2173.  */
  2174. for (i = 0; i < count; i++, s++) {
  2175. /* Wait for transmitter fifo to empty.
  2176.  * Ready indicates output is ready, and xmt is doing
  2177.  * that, not that it is ready for us to send.
  2178.  */
  2179. while (bdp->cbd_sc & BD_SC_READY);
  2180. /* Send the character out. */
  2181. cp = __va(bdp->cbd_bufaddr);
  2182. *cp = *s;
  2184. bdp->cbd_datlen = 1;
  2185. bdp->cbd_sc |= BD_SC_READY;
  2187. if (bdp->cbd_sc & BD_SC_WRAP)
  2188. bdp = bdbase;
  2189. else
  2190. bdp++;
  2192. /* if a LF, also do CR... */
  2193. if (*s == 10) {
  2194. while (bdp->cbd_sc & BD_SC_READY);
  2195. cp = __va(bdp->cbd_bufaddr);
  2196. *cp = 13;
  2197. bdp->cbd_datlen = 1;
  2198. bdp->cbd_sc |= BD_SC_READY;
  2200. if (bdp->cbd_sc & BD_SC_WRAP) {
  2201. bdp = bdbase;
  2202. }
  2203. else {
  2204. bdp++;
  2205. }
  2206. }
  2207. }
  2209. /*
  2210.  * Finally, Wait for transmitter & holding register to empty
  2211.  *  and restore the IER
  2212.  */
  2213. while (bdp->cbd_sc & BD_SC_READY);
  2215. if (info)
  2216. info->tx_cur = (cbd_t *)bdp;
  2217. }
  2219. static kdev_t serial_console_device(struct console *c)
  2220. {
  2221. return MKDEV(TTYAUX_MAJOR, 64 + c->index);
  2222. }
  2225. static struct console sercons = {
  2226. name: "ttyS",
  2227. write: serial_console_write,
  2228. device: serial_console_device,
  2229. setup: serial_console_setup,
  2230. flags: CON_PRINTBUFFER,
  2231. index: CONFIG_SERIAL_CONSOLE_PORT,
  2232. };
  2234. /*
  2235.  * Register console.
  2236.  */
  2237. long __init console_8xx_init(long kmem_start, long kmem_end)
  2238. {
  2239. register_console(&sercons);
  2240. return kmem_start;
  2241. }
  2243. #endif
  2245. /* Default console baud rate as determined by the board information
  2246.  * structure.
  2247.  */
  2248. static int baud_idx;
  2250. /*
  2251.  * The serial driver boot-time initialization code!
  2252.  */
  2253. int __init rs_8xx_init(void)
  2254. {
  2255. struct serial_state * state;
  2256. ser_info_t *info;
  2257. uint mem_addr, dp_addr;
  2258. int i, j, idx;
  2259. uint page, sblock;
  2260. volatile cbd_t *bdp;
  2261. volatile cpm8260_t *cp;
  2262. volatile smc_t *sp;
  2263. volatile smc_uart_t *up;
  2264. volatile scc_t *scp;
  2265. volatile scc_uart_t *sup;
  2266. volatile immap_t *immap;
  2267. volatile iop8260_t *io;
  2269. init_bh(SERIAL_BH, do_serial_bh);
  2271. show_serial_version();
  2273. /* Initialize the tty_driver structure */
  2275. /*memset(&serial_driver, 0, sizeof(struct tty_driver));*/
  2276. __clear_user(&serial_driver,sizeof(struct tty_driver));
  2277. serial_driver.magic = TTY_DRIVER_MAGIC;
  2278. serial_driver.driver_name = "serial";
  2279. #ifdef CONFIG_DEVFS_FS
  2280. serial_driver.name = "tts/%d";
  2281. #else
  2282. serial_driver.name = "ttyS";
  2283. #endif
  2284. serial_driver.major = TTY_MAJOR;
  2285. serial_driver.minor_start = 64;
  2286. serial_driver.num = NR_PORTS;
  2287. serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  2288. serial_driver.subtype = SERIAL_TYPE_NORMAL;
  2289. serial_driver.init_termios = tty_std_termios;
  2290. serial_driver.init_termios.c_cflag =
  2291. baud_idx | CS8 | CREAD | HUPCL | CLOCAL;
  2292. serial_driver.flags = TTY_DRIVER_REAL_RAW;
  2293. serial_driver.refcount = &serial_refcount;
  2294. serial_driver.table = serial_table;
  2295. serial_driver.termios = serial_termios;
  2296. serial_driver.termios_locked = serial_termios_locked;
  2298. serial_driver.open = rs_8xx_open;
  2299. serial_driver.close = rs_8xx_close;
  2300. serial_driver.write = rs_8xx_write;
  2301. serial_driver.put_char = rs_8xx_put_char;
  2302. serial_driver.write_room = rs_8xx_write_room;
  2303. serial_driver.chars_in_buffer = rs_8xx_chars_in_buffer;
  2304. serial_driver.flush_buffer = rs_8xx_flush_buffer;
  2305. serial_driver.ioctl = rs_8xx_ioctl;
  2306. serial_driver.throttle = rs_8xx_throttle;
  2307. serial_driver.unthrottle = rs_8xx_unthrottle;
  2308. serial_driver.send_xchar = rs_8xx_send_xchar;
  2309. serial_driver.set_termios = rs_8xx_set_termios;
  2310. serial_driver.stop = rs_8xx_stop;
  2311. serial_driver.start = rs_8xx_start;
  2312. serial_driver.hangup = rs_8xx_hangup;
  2313. serial_driver.wait_until_sent = rs_8xx_wait_until_sent;
  2314. serial_driver.read_proc = rs_8xx_read_proc;
  2316. /*
  2317.  * The callout device is just like normal device except for
  2318.  * major number and the subtype code.
  2319.  */
  2320. callout_driver = serial_driver;
  2321. #ifdef CONFIG_DEVFS_FS
  2322. callout_driver.name = "cua/%d";
  2323. #else
  2324. callout_driver.name = "cua";
  2325. #endif
  2326. callout_driver.major = TTYAUX_MAJOR;
  2327. callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  2328. callout_driver.read_proc = 0;
  2329. callout_driver.proc_entry = 0;
  2331. if (tty_register_driver(&serial_driver))
  2332. panic("Couldn't register serial drivern");
  2333. if (tty_register_driver(&callout_driver))
  2334. panic("Couldn't register callout drivern");
  2336. immap = immr;
  2337. cp = &immap->im_cpm;
  2338. io = &immap->im_ioport;
  2340. /* This should have been done long ago by the early boot code,
  2341.  * but do it again to make sure.
  2342.  */
  2343. *(ushort *)(&immap->im_dprambase[PROFF_SMC1_BASE]) = PROFF_SMC1;
  2344. *(ushort *)(&immap->im_dprambase[PROFF_SMC2_BASE]) = PROFF_SMC2;
  2346. /* Geeze, here we go....Picking I/O port bits....Lots of
  2347.  * choices.  If you don't like mine, pick your own.
  2348.  * Configure SMCs Tx/Rx.  SMC1 is only on Port D, SMC2 is
  2349.  * only on Port A.  You either pick 'em, or not.
  2350.  */
  2351. io->iop_ppard |= 0x00c00000;
  2352. io->iop_pdird |= 0x00400000;
  2353. io->iop_pdird &= ~0x00800000;
  2354. io->iop_psord &= ~0x00c00000;
  2355. #if USE_SMC2
  2356. io->iop_ppara |= 0x00c00000;
  2357. io->iop_pdira |= 0x00400000;
  2358. io->iop_pdira &= ~0x00800000;
  2359. io->iop_psora &= ~0x00c00000;
  2360. #endif
  2362. /* Configure SCC2 and SCC3.  Be careful about the fine print.
  2363.  * Secondary options are only available when you take away
  2364.  * the primary option.  Unless the pins are used for something
  2365.  * else, SCC2 and SCC3 are on Port B.
  2366.  * Port B,  8 - SCC3 TxD
  2367.  * Port B, 12 - SCC2 TxD
  2368.  * Port B, 14 - SCC3 RxD
  2369.  * Port B, 15 - SCC2 RxD
  2370.  */
  2371. io->iop_pparb |= 0x008b0000;
  2372. io->iop_pdirb |= 0x00880000;
  2373. io->iop_psorb |= 0x00880000;
  2374. io->iop_pdirb &= ~0x00030000;
  2375. io->iop_psorb &= ~0x00030000;
  2377. /* Wire BRG1 to SMC1 and BRG2 to SMC2.
  2378. */
  2379. immap->im_cpmux.cmx_smr = 0;
  2381. /* Connect SCC2 and SCC3 to NMSI.  Connect BRG3 to SCC2 and
  2382.  * BRG4 to SCC3.
  2383.  */
  2384. immap->im_cpmux.cmx_scr &= ~0x00ffff00;
  2385. immap->im_cpmux.cmx_scr |= 0x00121b00;
  2387. for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) {
  2388. state->magic = SSTATE_MAGIC;
  2389. state->line = i;
  2390. state->type = PORT_UNKNOWN;
  2391. state->custom_divisor = 0;
  2392. state->close_delay = 5*HZ/10;
  2393. state->closing_wait = 30*HZ;
  2394. state->callout_termios = callout_driver.init_termios;
  2395. state->normal_termios = serial_driver.init_termios;
  2396. state->icount.cts = state->icount.dsr = 
  2397. state->icount.rng = state->icount.dcd = 0;
  2398. state->icount.rx = state->icount.tx = 0;
  2399. state->icount.frame = state->icount.parity = 0;
  2400. state->icount.overrun = state->icount.brk = 0;
  2401. printk(KERN_INFO "ttyS%02d at 0x%04x is a %sn",
  2402.        i, state->port,
  2403.        (state->smc_scc_num < SCC_NUM_BASE) ? "SMC" : "SCC");
  2404. #ifdef CONFIG_SERIAL_CONSOLE
  2405. /* If we just printed the message on the console port, and
  2406.  * we are about to initialize it for general use, we have
  2407.  * to wait a couple of character times for the CR/NL to
  2408.  * make it out of the transmit buffer.
  2409.  */
  2410. if (i == CONFIG_SERIAL_CONSOLE_PORT)
  2411. mdelay(2);
  2412. #endif
  2413. info = kmalloc(sizeof(ser_info_t), GFP_KERNEL);
  2414. if (info) {
  2415. /*memset(info, 0, sizeof(ser_info_t));*/
  2416. __clear_user(info,sizeof(ser_info_t));
  2417. init_waitqueue_head(&info->open_wait);
  2418. init_waitqueue_head(&info->close_wait);
  2419. info->magic = SERIAL_MAGIC;
  2420. info->flags = state->flags;
  2421. info->tqueue.routine = do_softint;
  2422. info->tqueue.data = info;
  2423. info->tqueue_hangup.routine = do_serial_hangup;
  2424. info->tqueue_hangup.data = info;
  2425. info->line = i;
  2426. info->state = state;
  2427. state->info = (struct async_struct *)info;
  2429. /* We need to allocate a transmit and receive buffer
  2430.  * descriptors from dual port ram, and a character
  2431.  * buffer area from host mem.
  2432.  */
  2433. dp_addr = m8260_cpm_dpalloc(sizeof(cbd_t) * RX_NUM_FIFO, 8);
  2435. /* Allocate space for FIFOs in the host memory.
  2436. */
  2437. mem_addr = m8260_cpm_hostalloc(RX_NUM_FIFO * RX_BUF_SIZE, 1);
  2439. /* Set the physical address of the host memory
  2440.  * buffers in the buffer descriptors, and the
  2441.  * virtual address for us to work with.
  2442.  */
  2443. bdp = (cbd_t *)&immap->im_dprambase[dp_addr];
  2444. info->rx_cur = info->rx_bd_base = (cbd_t *)bdp;
  2446. for (j=0; j<(RX_NUM_FIFO-1); j++) {
  2447. bdp->cbd_bufaddr = __pa(mem_addr);
  2448. bdp->cbd_sc = BD_SC_EMPTY | BD_SC_INTRPT;
  2449. mem_addr += RX_BUF_SIZE;
  2450. bdp++;
  2451. }
  2452. bdp->cbd_bufaddr = __pa(mem_addr);
  2453. bdp->cbd_sc = BD_SC_WRAP | BD_SC_EMPTY | BD_SC_INTRPT;
  2455. if ((idx = state->smc_scc_num) < SCC_NUM_BASE) {
  2456. sp = &immap->im_smc[idx];
  2457. up = (smc_uart_t *)&immap->im_dprambase[state->port];
  2458. up->smc_rbase = dp_addr;
  2459. }
  2460. else {
  2461. scp = &immap->im_scc[idx - SCC_IDX_BASE];
  2462. sup = (scc_uart_t *)&immap->im_dprambase[state->port];
  2463. sup->scc_genscc.scc_rbase = dp_addr;
  2464. }
  2466. dp_addr = m8260_cpm_dpalloc(sizeof(cbd_t) * TX_NUM_FIFO, 8);
  2468. /* Allocate space for FIFOs in the host memory.
  2469. */
  2470. mem_addr = m8260_cpm_hostalloc(TX_NUM_FIFO * TX_BUF_SIZE, 1);
  2472. /* Set the physical address of the host memory
  2473.  * buffers in the buffer descriptors, and the
  2474.  * virtual address for us to work with.
  2475.  */
  2476. bdp = (cbd_t *)&immap->im_dprambase[dp_addr];
  2477. info->tx_cur = info->tx_bd_base = (cbd_t *)bdp;
  2479. for (j=0; j<(TX_NUM_FIFO-1); j++) {
  2480. bdp->cbd_bufaddr = __pa(mem_addr);
  2481. bdp->cbd_sc = BD_SC_INTRPT;
  2482. mem_addr += TX_BUF_SIZE;
  2483. bdp++;
  2484. }
  2485. bdp->cbd_bufaddr = __pa(mem_addr);
  2486. bdp->cbd_sc = (BD_SC_WRAP | BD_SC_INTRPT);
  2488. if (idx < SCC_NUM_BASE) {
  2489. up->smc_tbase = dp_addr;
  2491. /* Set up the uart parameters in the
  2492.  * parameter ram.
  2493.  */
  2494. up->smc_rfcr = CPMFCR_GBL | CPMFCR_EB;
  2495. up->smc_tfcr = CPMFCR_GBL | CPMFCR_EB;
  2497. /* Set this to 1 for now, so we get single
  2498.  * character interrupts.  Using idle charater
  2499.  * time requires some additional tuning.
  2500.  */
  2501. up->smc_mrblr = 1;
  2502. up->smc_maxidl = 0;
  2503. up->smc_brkcr = 1;
  2505. /* Send the CPM an initialize command.
  2506. */
  2507. if (state->smc_scc_num == 0) {
  2508. page = CPM_CR_SMC1_PAGE;
  2509. sblock = CPM_CR_SMC1_SBLOCK;
  2510. }
  2511. else {
  2512. page = CPM_CR_SMC2_PAGE;
  2513. sblock = CPM_CR_SMC2_SBLOCK;
  2514. }
  2516. cp->cp_cpcr = mk_cr_cmd(page, sblock, 0,
  2517. CPM_CR_INIT_TRX) | CPM_CR_FLG;
  2518. while (cp->cp_cpcr & CPM_CR_FLG);
  2520. /* Set UART mode, 8 bit, no parity, one stop.
  2521.  * Enable receive and transmit.
  2522.  */
  2523. sp->smc_smcmr = smcr_mk_clen(9) | SMCMR_SM_UART;
  2525. /* Disable all interrupts and clear all pending
  2526.  * events.
  2527.  */
  2528. sp->smc_smcm = 0;
  2529. sp->smc_smce = 0xff;
  2530. }
  2531. else {
  2532. sup->scc_genscc.scc_tbase = dp_addr;
  2534. /* Set up the uart parameters in the
  2535.  * parameter ram.
  2536.  */
  2537. sup->scc_genscc.scc_rfcr = CPMFCR_GBL | CPMFCR_EB;
  2538. sup->scc_genscc.scc_tfcr = CPMFCR_GBL | CPMFCR_EB;
  2540. /* Set this to 1 for now, so we get single
  2541.  * character interrupts.  Using idle charater
  2542.  * time requires some additional tuning.
  2543.  */
  2544. sup->scc_genscc.scc_mrblr = 1;
  2545. sup->scc_maxidl = 0;
  2546. sup->scc_brkcr = 1;
  2547. sup->scc_parec = 0;
  2548. sup->scc_frmec = 0;
  2549. sup->scc_nosec = 0;
  2550. sup->scc_brkec = 0;
  2551. sup->scc_uaddr1 = 0;
  2552. sup->scc_uaddr2 = 0;
  2553. sup->scc_toseq = 0;
  2554. sup->scc_char1 = 0x8000;
  2555. sup->scc_char2 = 0x8000;
  2556. sup->scc_char3 = 0x8000;
  2557. sup->scc_char4 = 0x8000;
  2558. sup->scc_char5 = 0x8000;
  2559. sup->scc_char6 = 0x8000;
  2560. sup->scc_char7 = 0x8000;
  2561. sup->scc_char8 = 0x8000;
  2562. sup->scc_rccm = 0xc0ff;
  2564. /* Send the CPM an initialize command.
  2565. */
  2566. if (state->smc_scc_num == 2) {
  2567. page = CPM_CR_SCC2_PAGE;
  2568. sblock = CPM_CR_SCC2_SBLOCK;
  2569. }
  2570. else {
  2571. page = CPM_CR_SCC3_PAGE;
  2572. sblock = CPM_CR_SCC3_SBLOCK;
  2573. }
  2575. cp->cp_cpcr = mk_cr_cmd(page, sblock, 0,
  2576. CPM_CR_INIT_TRX) | CPM_CR_FLG;
  2577. while (cp->cp_cpcr & CPM_CR_FLG);
  2579. /* Set UART mode, 8 bit, no parity, one stop.
  2580.  * Enable receive and transmit.
  2581.  */
  2582. scp->scc_gsmrh = 0;
  2583. scp->scc_gsmrl = 
  2584. (SCC_GSMRL_MODE_UART | SCC_GSMRL_TDCR_16 | SCC_GSMRL_RDCR_16);
  2586. /* Disable all interrupts and clear all pending
  2587.  * events.
  2588.  */
  2589. scp->scc_sccm = 0;
  2590. scp->scc_scce = 0xffff;
  2591. scp->scc_dsr = 0x7e7e;
  2592. scp->scc_pmsr = 0x3000;
  2593. }
  2595. /* Install interrupt handler.
  2596. */
  2597. request_8xxirq(state->irq, rs_8xx_interrupt, 0, "uart", info);
  2599. /* Set up the baud rate generator.
  2600. */
  2601. m8260_cpm_setbrg(state->smc_scc_num,
  2602. baud_table[baud_idx]);
  2604. /* If the port is the console, enable Rx and Tx.
  2605. */
  2606. #ifdef CONFIG_SERIAL_CONSOLE
  2607. if (i == CONFIG_SERIAL_CONSOLE_PORT)
  2608. sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
  2609. #endif
  2610. }
  2611. }
  2612. return 0;
  2613. }
  2615. /* This must always be called before the rs_8xx_init() function, otherwise
  2616.  * it blows away the port control information.
  2617. */
  2618. static int __init serial_console_setup(struct console *co, char *options)
  2619. {
  2620. struct serial_state *ser;
  2621. uint mem_addr, dp_addr, bidx;
  2622. volatile cbd_t *bdp;
  2623. volatile cpm8260_t *cp;
  2624. volatile immap_t *immap;
  2625. volatile smc_t *sp;
  2626. volatile smc_uart_t *up;
  2627. volatile iop8260_t *io;
  2628. bd_t *bd;
  2630. bd = (bd_t *)__res;
  2632. for (bidx = 0; bidx < (sizeof(baud_table) / sizeof(int)); bidx++)
  2633. if (bd->bi_baudrate == baud_table[bidx])
  2634. break;
  2636. co->cflag = CREAD|CLOCAL|bidx|CS8;
  2637. baud_idx = bidx;
  2639. ser = rs_table + co->index;
  2642. immap = immr;
  2643. cp = &immap->im_cpm;
  2644. io = &immap->im_ioport;
  2646. /* This should have been done long ago by the early boot code,
  2647.  * but do it again to make sure.
  2648.  */
  2649. *(ushort *)(&immap->im_dprambase[PROFF_SMC1_BASE]) = PROFF_SMC1;
  2650. *(ushort *)(&immap->im_dprambase[PROFF_SMC2_BASE]) = PROFF_SMC2;
  2652. /* Right now, assume we are using SMCs.
  2653. */
  2654. sp = &immap->im_smc[ser->smc_scc_num];
  2656. /* When we get here, the CPM has been reset, so we need
  2657.  * to configure the port.
  2658.  * We need to allocate a transmit and receive buffer descriptor
  2659.  * from dual port ram, and a character buffer area from host mem.
  2660.  */
  2661. up = (smc_uart_t *)&immap->im_dprambase[ser->port];
  2663. /* Disable transmitter/receiver.
  2664. */
  2665. sp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
  2667. /* Use Port D for SMC1 instead of other functions.
  2668. */
  2669. io->iop_ppard |= 0x00c00000;
  2670. io->iop_pdird |= 0x00400000;
  2671. io->iop_pdird &= ~0x00800000;
  2672. io->iop_psord &= ~0x00c00000;
  2674. /* Allocate space for two buffer descriptors in the DP ram.
  2675. */
  2676. dp_addr = m8260_cpm_dpalloc(sizeof(cbd_t) * 2, 8);
  2678. /* Allocate space for two 2 byte FIFOs in the host memory.
  2679. */
  2680. mem_addr = m8260_cpm_hostalloc(4, 1);
  2682. /* Set the physical address of the host memory buffers in
  2683.  * the buffer descriptors.
  2684.  */
  2685. bdp = (cbd_t *)&immap->im_dprambase[dp_addr];
  2686. bdp->cbd_bufaddr = __pa(mem_addr);
  2687. (bdp+1)->cbd_bufaddr = __pa(mem_addr+2);
  2689. /* For the receive, set empty and wrap.
  2690.  * For transmit, set wrap.
  2691.  */
  2692. bdp->cbd_sc = BD_SC_EMPTY | BD_SC_WRAP;
  2693. (bdp+1)->cbd_sc = BD_SC_WRAP;
  2695. /* Set up the uart parameters in the parameter ram.
  2696. */
  2697. up->smc_rbase = dp_addr; /* Base of receive buffer desc. */
  2698. up->smc_tbase = dp_addr+sizeof(cbd_t); /* Base of xmt buffer desc. */
  2699. up->smc_rfcr = CPMFCR_GBL | CPMFCR_EB;
  2700. up->smc_tfcr = CPMFCR_GBL | CPMFCR_EB;
  2702. /* Set this to 1 for now, so we get single character interrupts.
  2703. */
  2704. up->smc_mrblr = 1; /* receive buffer length */
  2705. up->smc_maxidl = 0; /* wait forever for next char */
  2707. /* Send the CPM an initialize command.
  2708. */
  2709. cp->cp_cpcr = mk_cr_cmd(CPM_CR_SMC1_PAGE, CPM_CR_SMC1_SBLOCK, 0,
  2710. CPM_CR_INIT_TRX) | CPM_CR_FLG;
  2711. while (cp->cp_cpcr & CPM_CR_FLG);
  2713. /* Set UART mode, 8 bit, no parity, one stop.
  2714.  * Enable receive and transmit.
  2715.  */
  2716. sp->smc_smcmr = smcr_mk_clen(9) |  SMCMR_SM_UART;
  2718. /* Set up the baud rate generator.
  2719. */
  2720. m8260_cpm_setbrg(ser->smc_scc_num, bd->bi_baudrate);
  2722. /* And finally, enable Rx and Tx.
  2723. */
  2724. sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
  2726. return 0;
  2727. }