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

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

嵌入式Linux

开发平台：

Unix_Linux

zs.c：源码内容
  1. /*
  2.  * decserial.c: Serial port driver for IOASIC DECstations.
  3.  *
  4.  * Derived from drivers/sbus/char/sunserial.c by Paul Mackerras.
  5.  * Derived from drivers/macintosh/macserial.c by Harald Koerfgen.
  6.  *
  7.  * DECstation changes
  8.  * Copyright (C) 1998-2000 Harald Koerfgen
  9.  * Copyright (C) 2000,2001 Maciej W. Rozycki <macro@ds2.pg.gda.pl>
  10.  *
  11.  * For the rest of the code the original Copyright applies:
  12.  * Copyright (C) 1996 Paul Mackerras (Paul.Mackerras@cs.anu.edu.au)
  13.  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  14.  *
  15.  *
  16.  * Note: for IOASIC systems the wiring is as follows:
  17.  *
  18.  * mouse/keyboard:
  19.  * DIN-7 MJ-4  signal        SCC
  20.  * 2     1     TxD       <-  A.TxD
  21.  * 3     4     RxD       ->  A.RxD
  22.  *
  23.  * EIA-232/EIA-423:
  24.  * DB-25 MMJ-6 signal        SCC
  25.  * 2     2     TxD       <-  B.TxD
  26.  * 3     5     RxD       ->  B.RxD
  27.  * 4           RTS       <- ~A.RTS
  28.  * 5           CTS       -> ~B.CTS
  29.  * 6     6     DSR       -> ~A.SYNC
  30.  * 8           CD        -> ~B.DCD
  31.  * 12          DSRS(DCE) -> ~A.CTS  (*)
  32.  * 15          TxC       ->  B.TxC
  33.  * 17          RxC       ->  B.RxC
  34.  * 20    1     DTR       <- ~A.DTR
  35.  * 22          RI        -> ~A.DCD
  36.  * 23          DSRS(DTE) <- ~B.RTS
  37.  *
  38.  * (*) EIA-232 defines the signal at this pin to be SCD, while DSRS(DCE)
  39.  *     is shared with DSRS(DTE) at pin 23.
  40.  */
  42. #include <linux/config.h>
  43. #include <linux/version.h>
  44. #include <linux/errno.h>
  45. #include <linux/signal.h>
  46. #include <linux/sched.h>
  47. #include <linux/timer.h>
  48. #include <linux/interrupt.h>
  49. #include <linux/tty.h>
  50. #include <linux/tty_flip.h>
  51. #include <linux/major.h>
  52. #include <linux/string.h>
  53. #include <linux/fcntl.h>
  54. #include <linux/mm.h>
  55. #include <linux/kernel.h>
  56. #include <linux/delay.h>
  57. #include <linux/init.h>
  58. #include <linux/ioport.h>
  59. #ifdef CONFIG_SERIAL_CONSOLE
  60. #include <linux/console.h>
  61. #endif
  63. #include <asm/io.h>
  64. #include <asm/pgtable.h>
  65. #include <asm/irq.h>
  66. #include <asm/system.h>
  67. #include <asm/segment.h>
  68. #include <asm/bitops.h>
  69. #include <asm/uaccess.h>
  70. #include <asm/wbflush.h>
  71. #include <asm/bootinfo.h>
  72. #ifdef CONFIG_DECSTATION
  73. #include <asm/dec/interrupts.h>
  74. #include <asm/dec/machtype.h>
  75. #include <asm/dec/tc.h>
  76. #include <asm/dec/ioasic_addrs.h>
  77. #endif
  78. #ifdef CONFIG_BAGET_MIPS
  79. #include <asm/baget/baget.h>
  80. unsigned long system_base;
  81. #endif
  82. #ifdef CONFIG_KGDB
  83. #include <asm/kgdb.h>
  84. #endif
  85. #ifdef CONFIG_MAGIC_SYSRQ
  86. #include <linux/sysrq.h>
  87. #endif
  89. #include "zs.h"
  91. /*
  92.  * It would be nice to dynamically allocate everything that
  93.  * depends on NUM_SERIAL, so we could support any number of
  94.  * Z8530s, but for now...
  95.  */
  96. #define NUM_SERIAL 2 /* Max number of ZS chips supported */
  97. #define NUM_CHANNELS (NUM_SERIAL * 2) /* 2 channels per chip */
  98. #define CHANNEL_A_NR  (zs_parms->channel_a_offset > zs_parms->channel_b_offset)
  99.                                         /* Number of channel A in the chip */ 
  100. #define ZS_CHAN_IO_SIZE 8
  101. #define ZS_CLOCK        7372800  /* Z8530 RTxC input clock rate */
  103. #define RECOVERY_DELAY  udelay(2)
  105. struct zs_parms {
  106. unsigned long scc0;
  107. unsigned long scc1;
  108. int channel_a_offset;
  109. int channel_b_offset;
  110. int irq;
  111. int clock;
  112. };
  114. static struct zs_parms *zs_parms;
  116. #ifdef CONFIG_DECSTATION
  117. static struct zs_parms ds_parms = {
  118. scc0 : SCC0,
  119. scc1 : SCC1,
  120. channel_a_offset : 1,
  121. channel_b_offset : 9,
  122. irq : SERIAL,
  123. clock : ZS_CLOCK
  124. };
  125. #endif
  126. #ifdef CONFIG_BAGET_MIPS
  127. static struct zs_parms baget_parms = {
  128. scc0 : UNI_SCC0,
  129. scc1 : UNI_SCC1,
  130. channel_a_offset : 9,
  131. channel_b_offset : 1,
  132. irq : BAGET_SCC_IRQ,
  133. clock : 14745000
  134. };
  135. #endif
  137. #ifdef CONFIG_DECSTATION
  138. #define DS_BUS_PRESENT (IOASIC)
  139. #else
  140. #define DS_BUS_PRESENT 0
  141. #endif
  143. #ifdef CONFIG_BAGET_MIPS
  144. #define BAGET_BUS_PRESENT (mips_machtype == MACH_BAGET202)
  145. #else
  146. #define BAGET_BUS_PRESENT 0
  147. #endif
  149. #define BUS_PRESENT (DS_BUS_PRESENT || BAGET_BUS_PRESENT)
  151. struct dec_zschannel zs_channels[NUM_CHANNELS];
  152. struct dec_serial zs_soft[NUM_CHANNELS];
  153. int zs_channels_found;
  154. struct dec_serial *zs_chain; /* list of all channels */
  156. struct tty_struct zs_ttys[NUM_CHANNELS];
  158. #ifdef CONFIG_SERIAL_CONSOLE
  159. static struct console sercons;
  160. #endif
  161. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 
  162.     && !defined(MODULE)
  163. static unsigned long break_pressed; /* break, really ... */
  164. #endif
  166. static unsigned char zs_init_regs[16] __initdata = {
  167. 0,                           /* write 0 */
  168. 0,      /* write 1 */
  169. 0xf0,                        /* write 2 */
  170. (Rx8),                       /* write 3 */
  171. (X16CLK | SB1),              /* write 4 */
  172. (Tx8),                       /* write 5 */
  173. 0, 0, 0,                     /* write 6, 7, 8 */
  174. (VIS),                       /* write 9 */
  175. (NRZ),                       /* write 10 */
  176. (TCBR | RCBR),               /* write 11 */
  177. 0, 0,                        /* BRG time constant, write 12 + 13 */
  178. (BRSRC | BRENABL),           /* write 14 */
  179. 0       /* write 15 */
  180. };
  182. DECLARE_TASK_QUEUE(tq_zs_serial);
  184. struct tty_driver serial_driver, callout_driver;
  185. static int serial_refcount;
  187. /* serial subtype definitions */
  188. #define SERIAL_TYPE_NORMAL 1
  189. #define SERIAL_TYPE_CALLOUT 2
  191. /* number of characters left in xmit buffer before we ask for more */
  192. #define WAKEUP_CHARS 256
  194. /*
  195.  * Debugging.
  196.  */
  197. #undef SERIAL_DEBUG_INTR
  198. #undef SERIAL_DEBUG_OPEN
  199. #undef SERIAL_DEBUG_FLOW
  200. #undef SERIAL_DEBUG_THROTTLE
  201. #undef SERIAL_PARANOIA_CHECK
  203. #undef ZS_DEBUG_REGS
  205. #ifdef SERIAL_DEBUG_THROTTLE
  206. #define _tty_name(tty,buf) tty_name(tty,buf)
  207. #endif
  209. #define RS_STROBE_TIME 10
  210. #define RS_ISR_PASS_LIMIT 256
  212. #define _INLINE_ inline
  214. static void probe_sccs(void);
  215. static void change_speed(struct dec_serial *info);
  216. static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
  218. static struct tty_struct *serial_table[NUM_CHANNELS];
  219. static struct termios *serial_termios[NUM_CHANNELS];
  220. static struct termios *serial_termios_locked[NUM_CHANNELS];
  222. #ifndef MIN
  223. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  224. #endif
  226. /*
  227.  * tmp_buf is used as a temporary buffer by serial_write.  We need to
  228.  * lock it in case the copy_from_user blocks while swapping in a page,
  229.  * and some other program tries to do a serial write at the same time.
  230.  * Since the lock will only come under contention when the system is
  231.  * swapping and available memory is low, it makes sense to share one
  232.  * buffer across all the serial ports, since it significantly saves
  233.  * memory if large numbers of serial ports are open.
  234.  */
  235. static unsigned char tmp_buf[4096]; /* This is cheating */
  236. static DECLARE_MUTEX(tmp_buf_sem);
  238. static inline int serial_paranoia_check(struct dec_serial *info,
  239. dev_t device, const char *routine)
  240. {
  241. #ifdef SERIAL_PARANOIA_CHECK
  242. static const char *badmagic =
  243. "Warning: bad magic number for serial struct (%d, %d) in %sn";
  244. static const char *badinfo =
  245. "Warning: null mac_serial for (%d, %d) in %sn";
  247. if (!info) {
  248. printk(badinfo, MAJOR(device), MINOR(device), routine);
  249. return 1;
  250. }
  251. if (info->magic != SERIAL_MAGIC) {
  252. printk(badmagic, MAJOR(device), MINOR(device), routine);
  253. return 1;
  254. }
  255. #endif
  256. return 0;
  257. }
  259. /*
  260.  * This is used to figure out the divisor speeds and the timeouts
  261.  */
  262. static int baud_table[] = {
  263. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  264. 9600, 19200, 38400, 57600, 115200, 0 };
  266. /* 
  267.  * Reading and writing Z8530 registers.
  268.  */
  269. static inline unsigned char read_zsreg(struct dec_zschannel *channel,
  270.        unsigned char reg)
  271. {
  272. unsigned char retval;
  274. if (reg != 0) {
  275. *channel->control = reg & 0xf;
  276. wbflush(); RECOVERY_DELAY;
  277. }
  278. retval = *channel->control;
  279. RECOVERY_DELAY;
  280. return retval;
  281. }
  283. static inline void write_zsreg(struct dec_zschannel *channel,
  284.        unsigned char reg, unsigned char value)
  285. {
  286. if (reg != 0) {
  287. *channel->control = reg & 0xf;
  288. wbflush(); RECOVERY_DELAY;
  289. }
  290. *channel->control = value;
  291. wbflush(); RECOVERY_DELAY;
  292. return;
  293. }
  295. static inline unsigned char read_zsdata(struct dec_zschannel *channel)
  296. {
  297. unsigned char retval;
  299. retval = *channel->data;
  300. RECOVERY_DELAY;
  301. return retval;
  302. }
  304. static inline void write_zsdata(struct dec_zschannel *channel,
  305. unsigned char value)
  306. {
  307. *channel->data = value;
  308. wbflush(); RECOVERY_DELAY;
  309. return;
  310. }
  312. static inline void load_zsregs(struct dec_zschannel *channel,
  313.        unsigned char *regs)
  314. {
  315. /* ZS_CLEARERR(channel);
  316. ZS_CLEARFIFO(channel); */
  317. /* Load 'em up */
  318. write_zsreg(channel, R4, regs[R4]);
  319. write_zsreg(channel, R3, regs[R3] & ~RxENABLE);
  320. write_zsreg(channel, R5, regs[R5] & ~TxENAB);
  321. write_zsreg(channel, R9, regs[R9]);
  322. write_zsreg(channel, R1, regs[R1]);
  323. write_zsreg(channel, R2, regs[R2]);
  324. write_zsreg(channel, R10, regs[R10]);
  325. write_zsreg(channel, R11, regs[R11]);
  326. write_zsreg(channel, R12, regs[R12]);
  327. write_zsreg(channel, R13, regs[R13]);
  328. write_zsreg(channel, R14, regs[R14]);
  329. write_zsreg(channel, R15, regs[R15]);
  330. write_zsreg(channel, R3, regs[R3]);
  331. write_zsreg(channel, R5, regs[R5]);
  332. return;
  333. }
  335. /* Sets or clears DTR/RTS on the requested line */
  336. static inline void zs_rtsdtr(struct dec_serial *info, int which, int set)
  337. {
  338.         unsigned long flags;
  341. save_flags(flags); cli();
  342. if (info->zs_channel != info->zs_chan_a) {
  343. if (set) {
  344. info->zs_chan_a->curregs[5] |= (which & (RTS | DTR));
  345. } else {
  346. info->zs_chan_a->curregs[5] &= ~(which & (RTS | DTR));
  347. }
  348. write_zsreg(info->zs_chan_a, 5, info->zs_chan_a->curregs[5]);
  349. }
  350. restore_flags(flags);
  351. }
  353. /* Utility routines for the Zilog */
  354. static inline int get_zsbaud(struct dec_serial *ss)
  355. {
  356. struct dec_zschannel *channel = ss->zs_channel;
  357. int brg;
  359. /* The baud rate is split up between two 8-bit registers in
  360.  * what is termed 'BRG time constant' format in my docs for
  361.  * the chip, it is a function of the clk rate the chip is
  362.  * receiving which happens to be constant.
  363.  */
  364. brg = (read_zsreg(channel, 13) << 8);
  365. brg |= read_zsreg(channel, 12);
  366. return BRG_TO_BPS(brg, (zs_parms->clock/(ss->clk_divisor)));
  367. }
  369. /* On receive, this clears errors and the receiver interrupts */
  370. static inline void rs_recv_clear(struct dec_zschannel *zsc)
  371. {
  372. write_zsreg(zsc, 0, ERR_RES);
  373. write_zsreg(zsc, 0, RES_H_IUS); /* XXX this is unnecessary */
  374. }
  376. /*
  377.  * ----------------------------------------------------------------------
  378.  *
  379.  * Here starts the interrupt handling routines.  All of the following
  380.  * subroutines are declared as inline and are folded into
  381.  * rs_interrupt().  They were separated out for readability's sake.
  382.  *
  383.  *  - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  384.  * -----------------------------------------------------------------------
  385.  */
  387. static int tty_break; /* Set whenever BREAK condition is detected.  */
  389. /*
  390.  * This routine is used by the interrupt handler to schedule
  391.  * processing in the software interrupt portion of the driver.
  392.  */
  393. static _INLINE_ void rs_sched_event(struct dec_serial *info,
  394.   int event)
  395. {
  396. info->event |= 1 << event;
  397. queue_task(&info->tqueue, &tq_zs_serial);
  398. mark_bh(SERIAL_BH);
  399. }
  401. static _INLINE_ void receive_chars(struct dec_serial *info,
  402.    struct pt_regs *regs)
  403. {
  404. struct tty_struct *tty = info->tty;
  405. unsigned char ch, stat, flag;
  407. while ((read_zsreg(info->zs_channel, R0) & Rx_CH_AV) != 0) {
  409. stat = read_zsreg(info->zs_channel, R1);
  410. ch = read_zsdata(info->zs_channel);
  412. if (!tty && !info->hook && !info->hook->rx_char)
  413. continue;
  415. if (tty_break) {
  416. tty_break = 0;
  417. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) && !defined(MODULE)
  418. if (info->line == sercons.index) {
  419. if (!break_pressed) {
  420. break_pressed = jiffies;
  421. goto ignore_char;
  422. }
  423. break_pressed = 0;
  424. }
  425. #endif
  426. flag = TTY_BREAK;
  427. if (info->flags & ZILOG_SAK)
  428. do_SAK(tty);
  429. } else {
  430. if (stat & Rx_OVR) {
  431. flag = TTY_OVERRUN;
  432. } else if (stat & FRM_ERR) {
  433. flag = TTY_FRAME;
  434. } else if (stat & PAR_ERR) {
  435. flag = TTY_PARITY;
  436. } else
  437. flag = 0;
  438. if (flag)
  439. /* reset the error indication */
  440. write_zsreg(info->zs_channel, R0, ERR_RES);
  441. }
  443. #if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) && !defined(MODULE)
  444. if (break_pressed && info->line == sercons.index) {
  445. if (ch != 0 &&
  446.     time_before(jiffies, break_pressed + HZ*5)) {
  447. handle_sysrq(ch, regs, NULL, NULL);
  448. break_pressed = 0;
  449. goto ignore_char;
  450. }
  451. break_pressed = 0;
  452. }
  453. #endif
  455. if (info->hook && info->hook->rx_char) {
  456. (*info->hook->rx_char)(ch, flag);
  457. return;
  458.    }
  460. if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  461. static int flip_buf_ovf;
  462. ++flip_buf_ovf;
  463. continue;
  464. }
  465. tty->flip.count++;
  466. {
  467. static int flip_max_cnt;
  468. if (flip_max_cnt < tty->flip.count)
  469. flip_max_cnt = tty->flip.count;
  470. }
  472. *tty->flip.flag_buf_ptr++ = flag;
  473. *tty->flip.char_buf_ptr++ = ch;
  474. ignore_char:
  475. }
  476. if (tty)
  477. tty_flip_buffer_push(tty);
  478. }
  480. static void transmit_chars(struct dec_serial *info)
  481. {
  482. if ((read_zsreg(info->zs_channel, R0) & Tx_BUF_EMP) == 0)
  483. return;
  484. info->tx_active = 0;
  486. if (info->x_char) {
  487. /* Send next char */
  488. write_zsdata(info->zs_channel, info->x_char);
  489. info->x_char = 0;
  490. info->tx_active = 1;
  491. return;
  492. }
  494. if ((info->xmit_cnt <= 0) || (info->tty && info->tty->stopped)
  495.     || info->tx_stopped) {
  496. write_zsreg(info->zs_channel, R0, RES_Tx_P);
  497. return;
  498. }
  499. /* Send char */
  500. write_zsdata(info->zs_channel, info->xmit_buf[info->xmit_tail++]);
  501. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  502. info->xmit_cnt--;
  503. info->tx_active = 1;
  505. if (info->xmit_cnt < WAKEUP_CHARS)
  506. rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  507. }
  509. static _INLINE_ void status_handle(struct dec_serial *info)
  510. {
  511. unsigned char stat;
  513. /* Get status from Read Register 0 */
  514. stat = read_zsreg(info->zs_channel, R0);
  516. if (stat & BRK_ABRT) {
  517. #ifdef SERIAL_DEBUG_INTR
  518. printk("handling break....");
  519. #endif
  520. tty_break = 1;
  521. }
  523. if (info->zs_channel != info->zs_chan_a) {
  525. /* FIXEM: Check for DCD transitions */
  526. if (((stat ^ info->read_reg_zero) & DCD) != 0
  527.     && info->tty && !C_CLOCAL(info->tty)) {
  528. if (stat & DCD) {
  529. wake_up_interruptible(&info->open_wait);
  530. } else if (!(info->flags & ZILOG_CALLOUT_ACTIVE)) {
  531. tty_hangup(info->tty);
  532. }
  533. }
  535. /* Check for CTS transitions */
  536. if (info->tty && C_CRTSCTS(info->tty)) {
  537. if ((stat & CTS) != 0) {
  538. if (info->tx_stopped) {
  539. info->tx_stopped = 0;
  540. if (!info->tx_active)
  541. transmit_chars(info);
  542. }
  543. } else {
  544. info->tx_stopped = 1;
  545. }
  546. }
  548. }
  550. /* Clear status condition... */
  551. write_zsreg(info->zs_channel, R0, RES_EXT_INT);
  552. info->read_reg_zero = stat;
  553. }
  555. /*
  556.  * This is the serial driver's generic interrupt routine
  557.  */
  558. void rs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  559. {
  560. struct dec_serial *info = (struct dec_serial *) dev_id;
  561. unsigned char zs_intreg;
  562. int shift;
  564. /* NOTE: The read register 3, which holds the irq status,
  565.  *       does so for both channels on each chip.  Although
  566.  *       the status value itself must be read from the A
  567.  *       channel and is only valid when read from channel A.
  568.  *       Yes... broken hardware...
  569.  */
  570. #define CHAN_IRQMASK (CHBRxIP | CHBTxIP | CHBEXT)
  572. if (info->zs_chan_a == info->zs_channel)
  573. shift = 3; /* Channel A */
  574. else
  575. shift = 0; /* Channel B */
  577. for (;;) {
  578. zs_intreg = read_zsreg(info->zs_chan_a, R3) >> shift; 
  579. if ((zs_intreg & CHAN_IRQMASK) == 0)
  580. break;
  582. if (zs_intreg & CHBRxIP) {
  583. receive_chars(info, regs);
  584. }
  585. if (zs_intreg & CHBTxIP) {
  586. transmit_chars(info);
  587. }
  588. if (zs_intreg & CHBEXT) {
  589. status_handle(info);
  590. }
  591. }
  593. /* Why do we need this ? */
  594. write_zsreg(info->zs_channel, 0, RES_H_IUS);
  595. }
  597. #ifdef ZS_DEBUG_REGS
  598. void zs_dump (void) {
  599. int i, j;
  600. for (i = 0; i < zs_channels_found; i++) {
  601. struct dec_zschannel *ch = &zs_channels[i]; 
  602. if ((long)ch->control == UNI_IO_BASE+UNI_SCC1A_CTRL) {
  603. for (j = 0; j < 15; j++) {
  604. printk("W%d = 0x%xt", 
  605.        j, (int)ch->curregs[j]);
  606. }
  607. for (j = 0; j < 15; j++) {
  608. printk("R%d = 0x%xt", 
  609.        j, (int)read_zsreg(ch,j));
  610. }
  611. printk("nn");
  612. }
  613. }
  614. }
  615. #endif
  617. /*
  618.  * -------------------------------------------------------------------
  619.  * Here ends the serial interrupt routines.
  620.  * -------------------------------------------------------------------
  621.  */
  623. /*
  624.  * ------------------------------------------------------------
  625.  * rs_stop() and rs_start()
  626.  *
  627.  * This routines are called before setting or resetting tty->stopped.
  628.  * ------------------------------------------------------------
  629.  */
  630. static void rs_stop(struct tty_struct *tty)
  631. {
  632. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  633. unsigned long flags;
  635. if (serial_paranoia_check(info, tty->device, "rs_stop"))
  636. return;
  638. #if 1
  639. save_flags(flags); cli();
  640. if (info->zs_channel->curregs[5] & TxENAB) {
  641. info->zs_channel->curregs[5] &= ~TxENAB;
  642. write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]);
  643. }
  644. restore_flags(flags);
  645. #endif
  646. }
  648. static void rs_start(struct tty_struct *tty)
  649. {
  650. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  651. unsigned long flags;
  653. if (serial_paranoia_check(info, tty->device, "rs_start"))
  654. return;
  656. save_flags(flags); cli();
  657. #if 1
  658. if (info->xmit_cnt && info->xmit_buf && !(info->zs_channel->curregs[5] & TxENAB)) {
  659. info->zs_channel->curregs[5] |= TxENAB;
  660. write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]);
  661. }
  662. #else
  663. if (info->xmit_cnt && info->xmit_buf && !info->tx_active) {
  664. transmit_chars(info);
  665. }
  666. #endif
  667. restore_flags(flags);
  668. }
  670. /*
  671.  * This routine is used to handle the "bottom half" processing for the
  672.  * serial driver, known also the "software interrupt" processing.
  673.  * This processing is done at the kernel interrupt level, after the
  674.  * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  675.  * is where time-consuming activities which can not be done in the
  676.  * interrupt driver proper are done; the interrupt driver schedules
  677.  * them using rs_sched_event(), and they get done here.
  678.  */
  679. static void do_serial_bh(void)
  680. {
  681. run_task_queue(&tq_zs_serial);
  682. }
  684. static void do_softint(void *private_)
  685. {
  686. struct dec_serial *info = (struct dec_serial *) private_;
  687. struct tty_struct *tty;
  689. tty = info->tty;
  690. if (!tty)
  691. return;
  693. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  694. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  695.     tty->ldisc.write_wakeup)
  696. (tty->ldisc.write_wakeup)(tty);
  697. wake_up_interruptible(&tty->write_wait);
  698. }
  699. }
  701. int zs_startup(struct dec_serial * info)
  702. {
  703. unsigned long flags;
  705. if (info->flags & ZILOG_INITIALIZED)
  706. return 0;
  708. if (!info->xmit_buf) {
  709. info->xmit_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  710. if (!info->xmit_buf)
  711. return -ENOMEM;
  712. }
  714. save_flags(flags); cli();
  716. #ifdef SERIAL_DEBUG_OPEN
  717. printk("starting up ttyS%02d (irq %d)...", info->line, info->irq);
  718. #endif
  720. /*
  721.  * Clear the receive FIFO.
  722.  */
  723. ZS_CLEARFIFO(info->zs_channel);
  724. info->xmit_fifo_size = 1;
  726. /*
  727.  * Clear the interrupt registers.
  728.  */
  729. write_zsreg(info->zs_channel, 0, ERR_RES);
  730. write_zsreg(info->zs_channel, 0, RES_H_IUS);
  732. /*
  733.  * Turn on RTS and DTR.
  734.  */
  735. zs_rtsdtr(info, RTS | DTR, 1);
  737. /*
  738.  * Finally, enable sequencing and interrupts
  739.  */
  740. info->zs_channel->curregs[1] = (info->zs_channel->curregs[1] & ~0x18) | (EXT_INT_ENAB | INT_ALL_Rx | TxINT_ENAB);
  741. info->zs_channel->curregs[3] |= (RxENABLE | Rx8);
  742. info->zs_channel->curregs[5] |= (TxENAB | Tx8);
  743. info->zs_channel->curregs[15] |= (DCDIE | CTSIE | TxUIE | BRKIE);
  744. info->zs_channel->curregs[9] |= (VIS | MIE);
  745. write_zsreg(info->zs_channel, 1, info->zs_channel->curregs[1]);
  746. write_zsreg(info->zs_channel, 3, info->zs_channel->curregs[3]);
  747. write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]);
  748. write_zsreg(info->zs_channel, 15, info->zs_channel->curregs[15]);
  749. write_zsreg(info->zs_channel, 9, info->zs_channel->curregs[9]);
  751. /*
  752.  * And clear the interrupt registers again for luck.
  753.  */
  754. write_zsreg(info->zs_channel, 0, ERR_RES);
  755. write_zsreg(info->zs_channel, 0, RES_H_IUS);
  757. if (info->tty)
  758. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  759. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  761. /*
  762.  * Set the speed of the serial port
  763.  */
  764. change_speed(info);
  766. /* Save the current value of RR0 */
  767. info->read_reg_zero = read_zsreg(info->zs_channel, 0);
  769. info->flags |= ZILOG_INITIALIZED;
  770. restore_flags(flags);
  771. return 0;
  772. }
  774. /*
  775.  * This routine will shutdown a serial port; interrupts are disabled, and
  776.  * DTR is dropped if the hangup on close termio flag is on.
  777.  */
  778. static void shutdown(struct dec_serial * info)
  779. {
  780. unsigned long flags;
  782. if (!(info->flags & ZILOG_INITIALIZED))
  783. return;
  785. #ifdef SERIAL_DEBUG_OPEN
  786. printk("Shutting down serial port %d (irq %d)....", info->line,
  787.        info->irq);
  788. #endif
  790. save_flags(flags); cli(); /* Disable interrupts */
  792. if (info->xmit_buf) {
  793. free_page((unsigned long) info->xmit_buf);
  794. info->xmit_buf = 0;
  795. }
  797. info->zs_channel->curregs[1] = 0;
  798. write_zsreg(info->zs_channel, 1, info->zs_channel->curregs[1]); /* no interrupts */
  800. info->zs_channel->curregs[3] &= ~RxENABLE;
  801. write_zsreg(info->zs_channel, 3, info->zs_channel->curregs[3]);
  803. info->zs_channel->curregs[5] &= ~TxENAB;
  804. write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]);
  805. if (!info->tty || C_HUPCL(info->tty)) {
  806. zs_rtsdtr(info, RTS | DTR, 0);
  807. }
  809. if (info->tty)
  810. set_bit(TTY_IO_ERROR, &info->tty->flags);
  812. info->flags &= ~ZILOG_INITIALIZED;
  813. restore_flags(flags);
  814. }
  816. /*
  817.  * This routine is called to set the UART divisor registers to match
  818.  * the specified baud rate for a serial port.
  819.  */
  820. static void change_speed(struct dec_serial *info)
  821. {
  822. unsigned cflag;
  823. int i;
  824. int brg, bits;
  825. unsigned long flags;
  827. if (!info->hook) {
  828. if (!info->tty || !info->tty->termios)
  829. return;
  830. cflag = info->tty->termios->c_cflag;
  831. if (!info->port)
  832. return;
  833. } else {
  834. cflag = info->hook->cflags;
  835. }
  837. i = cflag & CBAUD;
  838. if (i & CBAUDEX) {
  839. i &= ~CBAUDEX;
  840. if (i < 1 || i > 2) {
  841. if (!info->hook)
  842. info->tty->termios->c_cflag &= ~CBAUDEX;
  843. else
  844. info->hook->cflags &= ~CBAUDEX;
  845. } else
  846. i += 15;
  847. }
  849. save_flags(flags); cli();
  850. info->zs_baud = baud_table[i];
  851. info->clk_divisor = 16;
  852. if (info->zs_baud) {
  853. info->zs_channel->curregs[4] = X16CLK;
  854. brg = BPS_TO_BRG(info->zs_baud, zs_parms->clock/info->clk_divisor);
  855. info->zs_channel->curregs[12] = (brg & 255);
  856. info->zs_channel->curregs[13] = ((brg >> 8) & 255);
  857. zs_rtsdtr(info, DTR, 1); 
  858. } else {
  859. zs_rtsdtr(info, RTS | DTR, 0);
  860. return;
  861. }
  863. /* byte size and parity */
  864. info->zs_channel->curregs[3] &= ~RxNBITS_MASK;
  865. info->zs_channel->curregs[5] &= ~TxNBITS_MASK;
  866. switch (cflag & CSIZE) {
  867. case CS5:
  868. bits = 7;
  869. info->zs_channel->curregs[3] |= Rx5;
  870. info->zs_channel->curregs[5] |= Tx5;
  871. break;
  872. case CS6:
  873. bits = 8;
  874. info->zs_channel->curregs[3] |= Rx6;
  875. info->zs_channel->curregs[5] |= Tx6;
  876. break;
  877. case CS7:
  878. bits = 9;
  879. info->zs_channel->curregs[3] |= Rx7;
  880. info->zs_channel->curregs[5] |= Tx7;
  881. break;
  882. case CS8:
  883. default: /* defaults to 8 bits */
  884. bits = 10;
  885. info->zs_channel->curregs[3] |= Rx8;
  886. info->zs_channel->curregs[5] |= Tx8;
  887. break;
  888. }
  890. info->timeout = ((info->xmit_fifo_size*HZ*bits) / info->zs_baud);
  891.         info->timeout += HZ/50;         /* Add .02 seconds of slop */
  893. info->zs_channel->curregs[4] &= ~(SB_MASK | PAR_ENA | PAR_EVEN);
  894. if (cflag & CSTOPB) {
  895. info->zs_channel->curregs[4] |= SB2;
  896. } else {
  897. info->zs_channel->curregs[4] |= SB1;
  898. }
  899. if (cflag & PARENB) {
  900. info->zs_channel->curregs[4] |= PAR_ENA;
  901. }
  902. if (!(cflag & PARODD)) {
  903. info->zs_channel->curregs[4] |= PAR_EVEN;
  904. }
  906. if (!(cflag & CLOCAL)) {
  907. if (!(info->zs_channel->curregs[15] & DCDIE))
  908. info->read_reg_zero = read_zsreg(info->zs_channel, 0);
  909. info->zs_channel->curregs[15] |= DCDIE;
  910. } else
  911. info->zs_channel->curregs[15] &= ~DCDIE;
  912. if (cflag & CRTSCTS) {
  913. info->zs_channel->curregs[15] |= CTSIE;
  914. if ((read_zsreg(info->zs_channel, 0) & CTS) == 0)
  915. info->tx_stopped = 1;
  916. } else {
  917. info->zs_channel->curregs[15] &= ~CTSIE;
  918. info->tx_stopped = 0;
  919. }
  921. /* Load up the new values */
  922. load_zsregs(info->zs_channel, info->zs_channel->curregs);
  924. restore_flags(flags);
  925. }
  927. static void rs_flush_chars(struct tty_struct *tty)
  928. {
  929. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  930. unsigned long flags;
  932. if (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
  933. return;
  935. if (info->xmit_cnt <= 0 || tty->stopped || info->tx_stopped ||
  936.     !info->xmit_buf)
  937. return;
  939. /* Enable transmitter */
  940. save_flags(flags); cli();
  941. transmit_chars(info);
  942. restore_flags(flags);
  943. }
  945. static int rs_write(struct tty_struct * tty, int from_user,
  946.     const unsigned char *buf, int count)
  947. {
  948. int c, total = 0;
  949. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  950. unsigned long flags;
  952. if (serial_paranoia_check(info, tty->device, "rs_write"))
  953. return 0;
  955. if (!tty || !info->xmit_buf)
  956. return 0;
  958. save_flags(flags);
  959. while (1) {
  960. cli();
  961. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  962.    SERIAL_XMIT_SIZE - info->xmit_head));
  963. if (c <= 0)
  964. break;
  966. if (from_user) {
  967. down(&tmp_buf_sem);
  968. copy_from_user(tmp_buf, buf, c);
  969. c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  970.        SERIAL_XMIT_SIZE - info->xmit_head));
  971. memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  972. up(&tmp_buf_sem);
  973. } else
  974. memcpy(info->xmit_buf + info->xmit_head, buf, c);
  975. info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  976. info->xmit_cnt += c;
  977. restore_flags(flags);
  978. buf += c;
  979. count -= c;
  980. total += c;
  981. }
  983. if (info->xmit_cnt && !tty->stopped && !info->tx_stopped
  984.     && !info->tx_active)
  985. transmit_chars(info);
  986. restore_flags(flags);
  987. return total;
  988. }
  990. static int rs_write_room(struct tty_struct *tty)
  991. {
  992. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  993. int ret;
  995. if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  996. return 0;
  997. ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  998. if (ret < 0)
  999. ret = 0;
  1000. return ret;
  1001. }
  1003. static int rs_chars_in_buffer(struct tty_struct *tty)
  1004. {
  1005. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  1007. if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  1008. return 0;
  1009. return info->xmit_cnt;
  1010. }
  1012. static void rs_flush_buffer(struct tty_struct *tty)
  1013. {
  1014. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  1016. if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  1017. return;
  1018. cli();
  1019. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  1020. sti();
  1021. wake_up_interruptible(&tty->write_wait);
  1022. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1023.     tty->ldisc.write_wakeup)
  1024. (tty->ldisc.write_wakeup)(tty);
  1025. }
  1027. /*
  1028.  * ------------------------------------------------------------
  1029.  * rs_throttle()
  1030.  * 
  1031.  * This routine is called by the upper-layer tty layer to signal that
  1032.  * incoming characters should be throttled.
  1033.  * ------------------------------------------------------------
  1034.  */
  1035. static void rs_throttle(struct tty_struct * tty)
  1036. {
  1037. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  1038. unsigned long flags;
  1040. #ifdef SERIAL_DEBUG_THROTTLE
  1041. char buf[64];
  1043. printk("throttle %s: %d....n", _tty_name(tty, buf),
  1044.        tty->ldisc.chars_in_buffer(tty));
  1045. #endif
  1047. if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  1048. return;
  1050. if (I_IXOFF(tty)) {
  1051. save_flags(flags); cli();
  1052. info->x_char = STOP_CHAR(tty);
  1053. if (!info->tx_active)
  1054. transmit_chars(info);
  1055. restore_flags(flags);
  1056. }
  1058. if (C_CRTSCTS(tty)) {
  1059. zs_rtsdtr(info, RTS, 0);
  1060. }
  1061. }
  1063. static void rs_unthrottle(struct tty_struct * tty)
  1064. {
  1065. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  1066. unsigned long flags;
  1068. #ifdef SERIAL_DEBUG_THROTTLE
  1069. char buf[64];
  1071. printk("unthrottle %s: %d....n", _tty_name(tty, buf),
  1072.        tty->ldisc.chars_in_buffer(tty));
  1073. #endif
  1075. if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  1076. return;
  1078. if (I_IXOFF(tty)) {
  1079. save_flags(flags); cli();
  1080. if (info->x_char)
  1081. info->x_char = 0;
  1082. else {
  1083. info->x_char = START_CHAR(tty);
  1084. if (!info->tx_active)
  1085. transmit_chars(info);
  1086. }
  1087. restore_flags(flags);
  1088. }
  1090. if (C_CRTSCTS(tty)) {
  1091. zs_rtsdtr(info, RTS, 1);
  1092. }
  1093. }
  1095. /*
  1096.  * ------------------------------------------------------------
  1097.  * rs_ioctl() and friends
  1098.  * ------------------------------------------------------------
  1099.  */
  1101. static int get_serial_info(struct dec_serial * info,
  1102.    struct serial_struct * retinfo)
  1103. {
  1104. struct serial_struct tmp;
  1106. if (!retinfo)
  1107. return -EFAULT;
  1108. memset(&tmp, 0, sizeof(tmp));
  1109. tmp.type = info->type;
  1110. tmp.line = info->line;
  1111. tmp.port = info->port;
  1112. tmp.irq = info->irq;
  1113. tmp.flags = info->flags;
  1114. tmp.baud_base = info->baud_base;
  1115. tmp.close_delay = info->close_delay;
  1116. tmp.closing_wait = info->closing_wait;
  1117. tmp.custom_divisor = info->custom_divisor;
  1118. return copy_to_user(retinfo,&tmp,sizeof(*retinfo));
  1119. }
  1121. static int set_serial_info(struct dec_serial * info,
  1122.    struct serial_struct * new_info)
  1123. {
  1124. struct serial_struct new_serial;
  1125. struct dec_serial old_info;
  1126. int  retval = 0;
  1128. if (!new_info)
  1129. return -EFAULT;
  1130. copy_from_user(&new_serial,new_info,sizeof(new_serial));
  1131. old_info = *info;
  1133. if (!capable(CAP_SYS_ADMIN)) {
  1134. if ((new_serial.baud_base != info->baud_base) ||
  1135.     (new_serial.type != info->type) ||
  1136.     (new_serial.close_delay != info->close_delay) ||
  1137.     ((new_serial.flags & ~ZILOG_USR_MASK) !=
  1138.      (info->flags & ~ZILOG_USR_MASK)))
  1139. return -EPERM;
  1140. info->flags = ((info->flags & ~ZILOG_USR_MASK) |
  1141.        (new_serial.flags & ZILOG_USR_MASK));
  1142. info->custom_divisor = new_serial.custom_divisor;
  1143. goto check_and_exit;
  1144. }
  1146. if (info->count > 1)
  1147. return -EBUSY;
  1149. /*
  1150.  * OK, past this point, all the error checking has been done.
  1151.  * At this point, we start making changes.....
  1152.  */
  1154. info->baud_base = new_serial.baud_base;
  1155. info->flags = ((info->flags & ~ZILOG_FLAGS) |
  1156. (new_serial.flags & ZILOG_FLAGS));
  1157. info->type = new_serial.type;
  1158. info->close_delay = new_serial.close_delay;
  1159. info->closing_wait = new_serial.closing_wait;
  1161. check_and_exit:
  1162. retval = zs_startup(info);
  1163. return retval;
  1164. }
  1166. /*
  1167.  * get_lsr_info - get line status register info
  1168.  *
  1169.  * Purpose: Let user call ioctl() to get info when the UART physically
  1170.  *      is emptied.  On bus types like RS485, the transmitter must
  1171.  *      release the bus after transmitting. This must be done when
  1172.  *      the transmit shift register is empty, not be done when the
  1173.  *      transmit holding register is empty.  This functionality
  1174.  *      allows an RS485 driver to be written in user space. 
  1175.  */
  1176. static int get_lsr_info(struct dec_serial * info, unsigned int *value)
  1177. {
  1178. unsigned char status;
  1180. cli();
  1181. status = read_zsreg(info->zs_channel, 0);
  1182. sti();
  1183. put_user(status,value);
  1184. return 0;
  1185. }
  1187. static int get_modem_info(struct dec_serial *info, unsigned int *value)
  1188. {
  1189. unsigned char control, status_a, status_b;
  1190. unsigned int result;
  1192. if (info->zs_channel == info->zs_chan_a)
  1193. result = 0;
  1194. else {
  1195. cli();
  1196. control = info->zs_chan_a->curregs[5];
  1197. status_a = read_zsreg(info->zs_chan_a, 0);
  1198. status_b = read_zsreg(info->zs_channel, 0);
  1199. sti();
  1200. result =  ((control  & RTS) ? TIOCM_RTS: 0)
  1201. | ((control  & DTR) ? TIOCM_DTR: 0)
  1202. | ((status_b & DCD) ? TIOCM_CAR: 0)
  1203. | ((status_a & DCD) ? TIOCM_RNG: 0)
  1204. | ((status_a & SYNC_HUNT) ? TIOCM_DSR: 0)
  1205. | ((status_b & CTS) ? TIOCM_CTS: 0);
  1206. }
  1207. put_user(result, value);
  1208. return 0;
  1209. }
  1211. static int set_modem_info(struct dec_serial *info, unsigned int cmd,
  1212.   unsigned int *value)
  1213. {
  1214. int error;
  1215. unsigned int arg, bits;
  1217. error = verify_area(VERIFY_READ, value, sizeof(int));
  1218. if (error)
  1219. return error;
  1221. if (info->zs_channel == info->zs_chan_a)
  1222. return 0;
  1224. get_user(arg, value);
  1225. bits = (arg & TIOCM_RTS? RTS: 0) + (arg & TIOCM_DTR? DTR: 0);
  1226. cli();
  1227. switch (cmd) {
  1228. case TIOCMBIS:
  1229. info->zs_chan_a->curregs[5] |= bits;
  1230. break;
  1231. case TIOCMBIC:
  1232. info->zs_chan_a->curregs[5] &= ~bits;
  1233. break;
  1234. case TIOCMSET:
  1235. info->zs_chan_a->curregs[5] = 
  1236. (info->zs_chan_a->curregs[5] & ~(DTR | RTS)) | bits;
  1237. break;
  1238. default:
  1239. sti();
  1240. return -EINVAL;
  1241. }
  1242. write_zsreg(info->zs_chan_a, 5, info->zs_chan_a->curregs[5]);
  1243. sti();
  1244. return 0;
  1245. }
  1247. /*
  1248.  * rs_break - turn transmit break condition on/off
  1249.  */
  1250. static void rs_break(struct tty_struct *tty, int break_state)
  1251. {
  1252. struct dec_serial *info = (struct dec_serial *) tty->driver_data;
  1253. unsigned long flags;
  1255. if (serial_paranoia_check(info, tty->device, "rs_break"))
  1256. return;
  1257. if (!info->port)
  1258. return;
  1260. save_flags(flags); cli();
  1261. if (break_state == -1)
  1262. info->zs_channel->curregs[5] |= SND_BRK;
  1263. else
  1264. info->zs_channel->curregs[5] &= ~SND_BRK;
  1265. write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]);
  1266. restore_flags(flags);
  1267. }
  1269. static int rs_ioctl(struct tty_struct *tty, struct file * file,
  1270.     unsigned int cmd, unsigned long arg)
  1271. {
  1272. int error;
  1273. struct dec_serial * info = (struct dec_serial *)tty->driver_data;
  1275. if (info->hook)
  1276. return -ENODEV;
  1278. if (serial_paranoia_check(info, tty->device, "rs_ioctl"))
  1279. return -ENODEV;
  1281. if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  1282.     (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
  1283.     (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
  1284. if (tty->flags & (1 << TTY_IO_ERROR))
  1285.     return -EIO;
  1286. }
  1288. switch (cmd) {
  1289. case TIOCMGET:
  1290. error = verify_area(VERIFY_WRITE, (void *) arg,
  1291. sizeof(unsigned int));
  1292. if (error)
  1293. return error;
  1294. return get_modem_info(info, (unsigned int *) arg);
  1295. case TIOCMBIS:
  1296. case TIOCMBIC:
  1297. case TIOCMSET:
  1298. return set_modem_info(info, cmd, (unsigned int *) arg);
  1299. case TIOCGSERIAL:
  1300. error = verify_area(VERIFY_WRITE, (void *) arg,
  1301. sizeof(struct serial_struct));
  1302. if (error)
  1303. return error;
  1304. return get_serial_info(info,
  1305.        (struct serial_struct *) arg);
  1306. case TIOCSSERIAL:
  1307. return set_serial_info(info,
  1308.        (struct serial_struct *) arg);
  1309. case TIOCSERGETLSR: /* Get line status register */
  1310. error = verify_area(VERIFY_WRITE, (void *) arg,
  1311. sizeof(unsigned int));
  1312. if (error)
  1313. return error;
  1314. else
  1315.     return get_lsr_info(info, (unsigned int *) arg);
  1317. case TIOCSERGSTRUCT:
  1318. error = verify_area(VERIFY_WRITE, (void *) arg,
  1319. sizeof(struct dec_serial));
  1320. if (error)
  1321. return error;
  1322. copy_from_user((struct dec_serial *) arg,
  1323.        info, sizeof(struct dec_serial));
  1324. return 0;
  1326. default:
  1327. return -ENOIOCTLCMD;
  1328. }
  1329. return 0;
  1330. }
  1332. static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  1333. {
  1334. struct dec_serial *info = (struct dec_serial *)tty->driver_data;
  1335. int was_stopped;
  1337. if (tty->termios->c_cflag == old_termios->c_cflag)
  1338. return;
  1339. was_stopped = info->tx_stopped;
  1341. change_speed(info);
  1343. if (was_stopped && !info->tx_stopped)
  1344. rs_start(tty);
  1345. }
  1347. /*
  1348.  * ------------------------------------------------------------
  1349.  * rs_close()
  1350.  * 
  1351.  * This routine is called when the serial port gets closed.
  1352.  * Wait for the last remaining data to be sent.
  1353.  * ------------------------------------------------------------
  1354.  */
  1355. static void rs_close(struct tty_struct *tty, struct file * filp)
  1356. {
  1357. struct dec_serial * info = (struct dec_serial *)tty->driver_data;
  1358. unsigned long flags;
  1360. if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  1361. return;
  1363. save_flags(flags); cli();
  1365. if (tty_hung_up_p(filp)) {
  1366. restore_flags(flags);
  1367. return;
  1368. }
  1370. #ifdef SERIAL_DEBUG_OPEN
  1371. printk("rs_close ttyS%02d, count = %dn", info->line, info->count);
  1372. #endif
  1373. if ((tty->count == 1) && (info->count != 1)) {
  1374. /*
  1375.  * Uh, oh.  tty->count is 1, which means that the tty
  1376.  * structure will be freed.  Info->count should always
  1377.  * be one in these conditions.  If it's greater than
  1378.  * one, we've got real problems, since it means the
  1379.  * serial port won't be shutdown.
  1380.  */
  1381. printk("rs_close: bad serial port count; tty->count is 1, "
  1382.        "info->count is %dn", info->count);
  1383. info->count = 1;
  1384. }
  1385. if (--info->count < 0) {
  1386. printk("rs_close: bad serial port count for ttyS%02d: %dn",
  1387.        info->line, info->count);
  1388. info->count = 0;
  1389. }
  1390. if (info->count) {
  1391. restore_flags(flags);
  1392. return;
  1393. }
  1394. info->flags |= ZILOG_CLOSING;
  1395. /*
  1396.  * Save the termios structure, since this port may have
  1397.  * separate termios for callout and dialin.
  1398.  */
  1399. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1400. info->normal_termios = *tty->termios;
  1401. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1402. info->callout_termios = *tty->termios;
  1403. /*
  1404.  * Now we wait for the transmit buffer to clear; and we notify 
  1405.  * the line discipline to only process XON/XOFF characters.
  1406.  */
  1407. tty->closing = 1;
  1408. if (info->closing_wait != ZILOG_CLOSING_WAIT_NONE)
  1409. tty_wait_until_sent(tty, info->closing_wait);
  1410. /*
  1411.  * At this point we stop accepting input.  To do this, we
  1412.  * disable the receiver and receive interrupts.
  1413.  */
  1414. info->zs_channel->curregs[3] &= ~RxENABLE;
  1415. write_zsreg(info->zs_channel, 3, info->zs_channel->curregs[3]);
  1416. info->zs_channel->curregs[1] = 0; /* disable any rx ints */
  1417. write_zsreg(info->zs_channel, 1, info->zs_channel->curregs[1]);
  1418. ZS_CLEARFIFO(info->zs_channel);
  1419. if (info->flags & ZILOG_INITIALIZED) {
  1420. /*
  1421.  * Before we drop DTR, make sure the SCC transmitter
  1422.  * has completely drained.
  1423.  */
  1424. rs_wait_until_sent(tty, info->timeout);
  1425. }
  1427. shutdown(info);
  1428. if (tty->driver.flush_buffer)
  1429. tty->driver.flush_buffer(tty);
  1430. if (tty->ldisc.flush_buffer)
  1431. tty->ldisc.flush_buffer(tty);
  1432. tty->closing = 0;
  1433. info->event = 0;
  1434. info->tty = 0;
  1435. if (info->blocked_open) {
  1436. if (info->close_delay) {
  1437. current->state = TASK_INTERRUPTIBLE;
  1438. schedule_timeout(info->close_delay);
  1439. }
  1440. wake_up_interruptible(&info->open_wait);
  1441. }
  1442. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE|
  1443.  ZILOG_CLOSING);
  1444. wake_up_interruptible(&info->close_wait);
  1445. restore_flags(flags);
  1446. }
  1448. /*
  1449.  * rs_wait_until_sent() --- wait until the transmitter is empty
  1450.  */
  1451. static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
  1452. {
  1453. struct dec_serial *info = (struct dec_serial *) tty->driver_data;
  1454. unsigned long orig_jiffies, char_time;
  1456. if (serial_paranoia_check(info, tty->device, "rs_wait_until_sent"))
  1457. return;
  1459. orig_jiffies = jiffies;
  1460. /*
  1461.  * Set the check interval to be 1/5 of the estimated time to
  1462.  * send a single character, and make it at least 1.  The check
  1463.  * interval should also be less than the timeout.
  1464.  */
  1465. char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
  1466. char_time = char_time / 5;
  1467. if (char_time == 0)
  1468. char_time = 1;
  1469. if (timeout)
  1470. char_time = MIN(char_time, timeout);
  1471. while ((read_zsreg(info->zs_channel, 1) & Tx_BUF_EMP) == 0) {
  1472. current->state = TASK_INTERRUPTIBLE;
  1473. schedule_timeout(char_time);
  1474. if (signal_pending(current))
  1475. break;
  1476. if (timeout && ((orig_jiffies + timeout) < jiffies))
  1477. break;
  1478. }
  1479. current->state = TASK_RUNNING;
  1480. }
  1482. /*
  1483.  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  1484.  */
  1485. void rs_hangup(struct tty_struct *tty)
  1486. {
  1487. struct dec_serial * info = (struct dec_serial *)tty->driver_data;
  1489. if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  1490. return;
  1492. rs_flush_buffer(tty);
  1493. shutdown(info);
  1494. info->event = 0;
  1495. info->count = 0;
  1496. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE);
  1497. info->tty = 0;
  1498. wake_up_interruptible(&info->open_wait);
  1499. }
  1501. /*
  1502.  * ------------------------------------------------------------
  1503.  * rs_open() and friends
  1504.  * ------------------------------------------------------------
  1505.  */
  1506. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1507.    struct dec_serial *info)
  1508. {
  1509. DECLARE_WAITQUEUE(wait, current);
  1510. int retval;
  1511. int do_clocal = 0;
  1513. /*
  1514.  * If the device is in the middle of being closed, then block
  1515.  * until it's done, and then try again.
  1516.  */
  1517. if (info->flags & ZILOG_CLOSING) {
  1518. interruptible_sleep_on(&info->close_wait);
  1519. #ifdef SERIAL_DO_RESTART
  1520. return ((info->flags & ZILOG_HUP_NOTIFY) ?
  1521. -EAGAIN : -ERESTARTSYS);
  1522. #else
  1523. return -EAGAIN;
  1524. #endif
  1525. }
  1527. /*
  1528.  * If this is a callout device, then just make sure the normal
  1529.  * device isn't being used.
  1530.  */
  1531. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1532. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1533. return -EBUSY;
  1534. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1535.     (info->flags & ZILOG_SESSION_LOCKOUT) &&
  1536.     (info->session != current->session))
  1537.     return -EBUSY;
  1538. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1539.     (info->flags & ZILOG_PGRP_LOCKOUT) &&
  1540.     (info->pgrp != current->pgrp))
  1541.     return -EBUSY;
  1542. info->flags |= ZILOG_CALLOUT_ACTIVE;
  1543. return 0;
  1544. }
  1546. /*
  1547.  * If non-blocking mode is set, or the port is not enabled,
  1548.  * then make the check up front and then exit.
  1549.  */
  1550. if ((filp->f_flags & O_NONBLOCK) ||
  1551.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1552. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1553. return -EBUSY;
  1554. info->flags |= ZILOG_NORMAL_ACTIVE;
  1555. return 0;
  1556. }
  1558. if (info->flags & ZILOG_CALLOUT_ACTIVE) {
  1559. if (info->normal_termios.c_cflag & CLOCAL)
  1560. do_clocal = 1;
  1561. } else {
  1562. if (tty->termios->c_cflag & CLOCAL)
  1563. do_clocal = 1;
  1564. }
  1566. /*
  1567.  * Block waiting for the carrier detect and the line to become
  1568.  * free (i.e., not in use by the callout).  While we are in
  1569.  * this loop, info->count is dropped by one, so that
  1570.  * rs_close() knows when to free things.  We restore it upon
  1571.  * exit, either normal or abnormal.
  1572.  */
  1573. retval = 0;
  1574. add_wait_queue(&info->open_wait, &wait);
  1575. #ifdef SERIAL_DEBUG_OPEN
  1576. printk("block_til_ready before block: ttyS%02d, count = %dn",
  1577.        info->line, info->count);
  1578. #endif
  1579. cli();
  1580. if (!tty_hung_up_p(filp)) 
  1581. info->count--;
  1582. sti();
  1583. info->blocked_open++;
  1584. while (1) {
  1585. cli();
  1586. if (!(info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1587.     (tty->termios->c_cflag & CBAUD))
  1588. zs_rtsdtr(info, RTS | DTR, 1);
  1589. sti();
  1590. set_current_state(TASK_INTERRUPTIBLE);
  1591. if (tty_hung_up_p(filp) ||
  1592.     !(info->flags & ZILOG_INITIALIZED)) {
  1593. #ifdef SERIAL_DO_RESTART
  1594. if (info->flags & ZILOG_HUP_NOTIFY)
  1595. retval = -EAGAIN;
  1596. else
  1597. retval = -ERESTARTSYS;
  1598. #else
  1599. retval = -EAGAIN;
  1600. #endif
  1601. break;
  1602. }
  1603. if (!(info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1604.     !(info->flags & ZILOG_CLOSING) &&
  1605.     (do_clocal || (read_zsreg(info->zs_channel, 0) & DCD)))
  1606. break;
  1607. if (signal_pending(current)) {
  1608. retval = -ERESTARTSYS;
  1609. break;
  1610. }
  1611. #ifdef SERIAL_DEBUG_OPEN
  1612. printk("block_til_ready blocking: ttyS%02d, count = %dn",
  1613.        info->line, info->count);
  1614. #endif
  1615. schedule();
  1616. }
  1617. current->state = TASK_RUNNING;
  1618. remove_wait_queue(&info->open_wait, &wait);
  1619. if (!tty_hung_up_p(filp))
  1620. info->count++;
  1621. info->blocked_open--;
  1622. #ifdef SERIAL_DEBUG_OPEN
  1623. printk("block_til_ready after blocking: ttyS%02d, count = %dn",
  1624.        info->line, info->count);
  1625. #endif
  1626. if (retval)
  1627. return retval;
  1628. info->flags |= ZILOG_NORMAL_ACTIVE;
  1629. return 0;
  1630. }
  1632. /*
  1633.  * This routine is called whenever a serial port is opened.  It
  1634.  * enables interrupts for a serial port, linking in its ZILOG structure into
  1635.  * the IRQ chain.   It also performs the serial-specific
  1636.  * initialization for the tty structure.
  1637.  */
  1638. int rs_open(struct tty_struct *tty, struct file * filp)
  1639. {
  1640. struct dec_serial *info;
  1641. int  retval, line;
  1643. line = MINOR(tty->device) - tty->driver.minor_start;
  1644. if ((line < 0) || (line >= zs_channels_found))
  1645. return -ENODEV;
  1646. info = zs_soft + line;
  1648. if (info->hook)
  1649. return -ENODEV;
  1651. if (serial_paranoia_check(info, tty->device, "rs_open"))
  1652. return -ENODEV;
  1653. #ifdef SERIAL_DEBUG_OPEN
  1654. printk("rs_open %s%d, count = %dn", tty->driver.name, info->line,
  1655.        info->count);
  1656. #endif
  1658. info->count++;
  1659. tty->driver_data = info;
  1660. info->tty = tty;
  1662. /*
  1663.  * If the port is the middle of closing, bail out now
  1664.  */
  1665. if (tty_hung_up_p(filp) ||
  1666.     (info->flags & ZILOG_CLOSING)) {
  1667. if (info->flags & ZILOG_CLOSING)
  1668. interruptible_sleep_on(&info->close_wait);
  1669. #ifdef SERIAL_DO_RESTART
  1670. return ((info->flags & ZILOG_HUP_NOTIFY) ?
  1671. -EAGAIN : -ERESTARTSYS);
  1672. #else
  1673. return -EAGAIN;
  1674. #endif
  1675. }
  1677. /*
  1678.  * Start up serial port
  1679.  */
  1680. retval = zs_startup(info);
  1681. if (retval)
  1682. return retval;
  1684. retval = block_til_ready(tty, filp, info);
  1685. if (retval) {
  1686. #ifdef SERIAL_DEBUG_OPEN
  1687. printk("rs_open returning after block_til_ready with %dn",
  1688.        retval);
  1689. #endif
  1690. return retval;
  1691. }
  1693. if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
  1694. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1695. *tty->termios = info->normal_termios;
  1696. else 
  1697. *tty->termios = info->callout_termios;
  1698. change_speed(info);
  1699. }
  1700. #ifdef CONFIG_SERIAL_CONSOLE
  1701. if (sercons.cflag && sercons.index == line) {
  1702. tty->termios->c_cflag = sercons.cflag;
  1703. sercons.cflag = 0;
  1704. change_speed(info);
  1705. }
  1706. #endif
  1708. info->session = current->session;
  1709. info->pgrp = current->pgrp;
  1711. #ifdef SERIAL_DEBUG_OPEN
  1712. printk("rs_open ttyS%02d successful...", info->line);
  1713. #endif
  1714. /* tty->low_latency = 1; */
  1715. return 0;
  1716. }
  1718. /* Finally, routines used to initialize the serial driver. */
  1720. static void __init show_serial_version(void)
  1721. {
  1722. printk("DECstation Z8530 serial driver version 0.05n");
  1723. }
  1725. /*  Initialize Z8530s zs_channels
  1726.  */
  1728. static void __init probe_sccs(void)
  1729. {
  1730. struct dec_serial **pp;
  1731. int i, n, n_chips = 0, n_channels, chip, channel;
  1733. /*
  1734.  * did we get here by accident?
  1735.  */
  1736. if(!BUS_PRESENT) {
  1737. printk("Not on JUNKIO machine, skipping probe_sccsn");
  1738. return;
  1739. }
  1741. /*
  1742.  * When serial console is activated, tc_init has not been called yet
  1743.  * and system_base is undefined. Unfortunately we have to hardcode
  1744.  * system_base for this case :-(. HK
  1745.  */
  1746. switch(mips_machtype) {
  1747. #ifdef CONFIG_DECSTATION
  1748. case MACH_DS5000_2X0:
  1749. system_base = 0xbf800000;
  1750. n_chips = 2;
  1751. zs_parms = &ds_parms;
  1752. break;
  1753. case MACH_DS5000_1XX:
  1754. system_base = 0xbc000000;
  1755. n_chips = 2;
  1756. zs_parms = &ds_parms;
  1757. break;
  1758. case MACH_DS5000_XX:
  1759. system_base = 0xbc000000;
  1760. n_chips = 1;
  1761. zs_parms = &ds_parms;
  1762. break;
  1763. #endif
  1764. #ifdef CONFIG_BAGET_MIPS
  1765. case MACH_BAGET202:
  1766. system_base = UNI_IO_BASE;
  1767. n_chips = 2;
  1768. zs_parms = &baget_parms;
  1769. zs_init_regs[2] = 0x8;
  1770. break;
  1771. #endif
  1772. default:
  1773. panic("zs: unsupported bus");
  1774. }
  1775. if (!zs_parms)
  1776. panic("zs: uninitialized parms");
  1778. pp = &zs_chain;
  1780. n_channels = 0;
  1782. for (chip = 0; chip < n_chips; chip++) {
  1783. for (channel = 0; channel <= 1; channel++) {
  1784. /*
  1785.  * The sccs reside on the high byte of the 16 bit IOBUS
  1786.  */
  1787. zs_channels[n_channels].control = 
  1788. (volatile unsigned char *)system_base + 
  1789.   (0 == chip ? zs_parms->scc0 : zs_parms->scc1) + 
  1790.   (0 == channel ? zs_parms->channel_a_offset : 
  1791.                   zs_parms->channel_b_offset);
  1792. zs_channels[n_channels].data = 
  1793. zs_channels[n_channels].control + 4;
  1795. #ifndef CONFIG_SERIAL_CONSOLE
  1796. /*
  1797.  * We're called early and memory managment isn't up, yet.
  1798.  * Thus check_region would fail.
  1799.  */
  1800. if (check_region((unsigned long)
  1801.  zs_channels[n_channels].control,
  1802.  ZS_CHAN_IO_SIZE) < 0) {
  1803. panic("SCC I/O region is not free");
  1804. }
  1805. request_region((unsigned long)
  1806.        zs_channels[n_channels].control,
  1807.        ZS_CHAN_IO_SIZE, "SCC");
  1808. #endif
  1809. zs_soft[n_channels].zs_channel = &zs_channels[n_channels];
  1810. zs_soft[n_channels].irq = zs_parms->irq;
  1812. /* 
  1813.  *  Identification of channel A. Location of channel A
  1814.                          *  inside chip depends on mapping of internal address
  1815.  *  the chip decodes channels by.
  1816.  *  CHANNEL_A_NR returns either 0 (in case of 
  1817.  *  DECstations) or 1 (in case of Baget).
  1818.  */
  1819. if (CHANNEL_A_NR == channel)
  1820. zs_soft[n_channels].zs_chan_a = 
  1821.     &zs_channels[n_channels+1-2*CHANNEL_A_NR];
  1822. else
  1823. zs_soft[n_channels].zs_chan_a = 
  1824.     &zs_channels[n_channels];
  1826. *pp = &zs_soft[n_channels];
  1827. pp = &zs_soft[n_channels].zs_next;
  1828. n_channels++;
  1829. }
  1830. }
  1832. *pp = 0;
  1833. zs_channels_found = n_channels;
  1835. for (n = 0; n < zs_channels_found; n++) {
  1836. for (i = 0; i < 16; i++) {
  1837. zs_soft[n].zs_channel->curregs[i] = zs_init_regs[i];
  1838. }
  1839. }
  1841. /* save_and_cli(flags);
  1842. for (n = 0; n < zs_channels_found; n++) {
  1843. if (((int)zs_channels[n].control & 0xf) == 1) {
  1844. write_zsreg(zs_soft[n].zs_chan_a, R9, FHWRES);
  1845. mdelay(10);
  1846. write_zsreg(zs_soft[n].zs_chan_a, R9, 0);
  1847. }
  1848. load_zsregs(zs_soft[n].zs_channel, zs_soft[n].zs_channel->curregs);
  1849. } 
  1850. restore_flags(flags); */
  1851. }
  1853. /* zs_init inits the driver */
  1854. int __init zs_init(void)
  1855. {
  1856. int channel, i;
  1857. unsigned long flags;
  1858. struct dec_serial *info;
  1860. if(!BUS_PRESENT)
  1861. return -ENODEV;
  1863. /* Setup base handler, and timer table. */
  1864. init_bh(SERIAL_BH, do_serial_bh);
  1866. /* Find out how many Z8530 SCCs we have */
  1867. if (zs_chain == 0)
  1868. probe_sccs();
  1870. show_serial_version();
  1872. /* Initialize the tty_driver structure */
  1873. /* Not all of this is exactly right for us. */
  1875. memset(&serial_driver, 0, sizeof(struct tty_driver));
  1876. serial_driver.magic = TTY_DRIVER_MAGIC;
  1877. #if (LINUX_VERSION_CODE > 0x2032D && defined(CONFIG_DEVFS_FS))
  1878. serial_driver.name = "tts/%d";
  1879. #else
  1880. serial_driver.name = "ttyS";
  1881. #endif
  1882. serial_driver.major = TTY_MAJOR;
  1883. serial_driver.minor_start = 64;
  1884. serial_driver.num = zs_channels_found;
  1885. serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  1886. serial_driver.subtype = SERIAL_TYPE_NORMAL;
  1887. serial_driver.init_termios = tty_std_termios;
  1889. serial_driver.init_termios.c_cflag =
  1890. B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  1891. serial_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
  1892. serial_driver.refcount = &serial_refcount;
  1893. serial_driver.table = serial_table;
  1894. serial_driver.termios = serial_termios;
  1895. serial_driver.termios_locked = serial_termios_locked;
  1897. serial_driver.open = rs_open;
  1898. serial_driver.close = rs_close;
  1899. serial_driver.write = rs_write;
  1900. serial_driver.flush_chars = rs_flush_chars;
  1901. serial_driver.write_room = rs_write_room;
  1902. serial_driver.chars_in_buffer = rs_chars_in_buffer;
  1903. serial_driver.flush_buffer = rs_flush_buffer;
  1904. serial_driver.ioctl = rs_ioctl;
  1905. serial_driver.throttle = rs_throttle;
  1906. serial_driver.unthrottle = rs_unthrottle;
  1907. serial_driver.set_termios = rs_set_termios;
  1908. serial_driver.stop = rs_stop;
  1909. serial_driver.start = rs_start;
  1910. serial_driver.hangup = rs_hangup;
  1911. serial_driver.break_ctl = rs_break;
  1912. serial_driver.wait_until_sent = rs_wait_until_sent;
  1914. /*
  1915.  * The callout device is just like normal device except for
  1916.  * major number and the subtype code.
  1917.  */
  1918. callout_driver = serial_driver;
  1919. #if (LINUX_VERSION_CODE > 0x2032D && defined(CONFIG_DEVFS_FS))
  1920. callout_driver.name = "cua/%d";
  1921. #else
  1922. callout_driver.name = "cua";
  1923. #endif
  1924. callout_driver.major = TTYAUX_MAJOR;
  1925. callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  1927. if (tty_register_driver(&serial_driver))
  1928. panic("Couldn't register serial drivern");
  1929. if (tty_register_driver(&callout_driver))
  1930. panic("Couldn't register callout drivern");
  1932. save_flags(flags); cli();
  1934. for (channel = 0; channel < zs_channels_found; ++channel) {
  1935. if (zs_soft[channel].hook &&
  1936.     zs_soft[channel].hook->init_channel)
  1937. (*zs_soft[channel].hook->init_channel)
  1938. (&zs_soft[channel]);
  1940. zs_soft[channel].clk_divisor = 16;
  1941. zs_soft[channel].zs_baud = get_zsbaud(&zs_soft[channel]);
  1943. if (request_irq(zs_parms->irq, rs_interrupt, SA_SHIRQ,
  1944. "SCC", &zs_soft[channel]))
  1945. printk(KERN_ERR "decserial: can't get irq %dn",
  1946.        zs_parms->irq);
  1947. }
  1949. for (info = zs_chain, i = 0; info; info = info->zs_next, i++)
  1950. {
  1951. if (info->hook && info->hook->init_info) {
  1952. (*info->hook->init_info)(info);
  1953. continue;
  1954. }
  1955. info->magic = SERIAL_MAGIC;
  1956. info->port = (int) info->zs_channel->control;
  1957. info->line = i;
  1958. info->tty = 0;
  1959. info->custom_divisor = 16;
  1960. info->close_delay = 50;
  1961. info->closing_wait = 3000;
  1962. info->x_char = 0;
  1963. info->event = 0;
  1964. info->count = 0;
  1965. info->blocked_open = 0;
  1966. info->tqueue.routine = do_softint;
  1967. info->tqueue.data = info;
  1968. info->callout_termios = callout_driver.init_termios;
  1969. info->normal_termios = serial_driver.init_termios;
  1970. init_waitqueue_head(&info->open_wait);
  1971. init_waitqueue_head(&info->close_wait);
  1972. printk("ttyS%02d at 0x%08x (irq = %d)", info->line, 
  1973.        info->port, info->irq);
  1974. printk(" is a Z85C30 SCCn");
  1975. tty_register_devfs(&serial_driver, 0,
  1976.    serial_driver.minor_start + info->line);
  1977. tty_register_devfs(&callout_driver, 0,
  1978.    callout_driver.minor_start + info->line);
  1980. }
  1982. restore_flags(flags);
  1984. return 0;
  1985. }
  1987. /*
  1988.  * register_serial and unregister_serial allows for serial ports to be
  1989.  * configured at run-time, to support PCMCIA modems.
  1990.  */
  1991. /* PowerMac: Unused at this time, just here to make things link. */
  1992. int register_serial(struct serial_struct *req)
  1993. {
  1994. return -1;
  1995. }
  1997. void unregister_serial(int line)
  1998. {
  1999. return;
  2000. }
  2002. /*
  2003.  * polling I/O routines
  2004.  */
  2005. static int
  2006. zs_poll_tx_char(struct dec_serial *info, unsigned char ch)
  2007. {
  2008. struct dec_zschannel *chan = info->zs_channel;
  2009. int    ret;
  2011. if(chan) {
  2012. int loops = 10000;
  2013. // int nine = read_zsreg(chan, R9);
  2015. RECOVERY_DELAY;
  2016. //         write_zsreg(chan, R9, nine & ~MIE);
  2017.                 wbflush();
  2018. RECOVERY_DELAY;
  2020.          while (!(*(chan->control) & Tx_BUF_EMP) && --loops)
  2021.          RECOVERY_DELAY;
  2023.                 if (loops) {
  2024.                         ret = 0;
  2025.                  *(chan->data) = ch;
  2026.                  wbflush();
  2027. RECOVERY_DELAY;
  2028.                 } else
  2029.                         ret = -EAGAIN;
  2031. //         write_zsreg(chan, R9, nine);
  2032.                 wbflush();
  2033. RECOVERY_DELAY;
  2035.                 return ret;
  2036.         }
  2038. return -ENODEV;
  2039. }
  2041. static int
  2042. zs_poll_rx_char(struct dec_serial *info)
  2043. {
  2044.         struct dec_zschannel *chan = info->zs_channel;
  2045.         int    ret;
  2047. if(chan) {
  2048.                 int loops = 10000;
  2050.                 while((read_zsreg(chan, 0) & Rx_CH_AV) == 0)
  2051.         loops--;
  2053.                 if (loops)
  2054.                         ret = read_zsdata(chan);
  2055.                 else
  2056.                         ret = -EAGAIN;
  2058.                 return ret;
  2059.         } else
  2060.                 return -ENODEV;
  2061. }
  2063. unsigned int register_zs_hook(unsigned int channel, struct zs_hook *hook)
  2064. {
  2065. struct dec_serial *info = &zs_soft[channel];
  2067. if (info->hook) {
  2068. printk(__FUNCTION__": line %d has already a hook registeredn", channel);
  2070. return 0;
  2071. } else {
  2072. info->hook = hook;
  2074. if (zs_chain == 0)
  2075. probe_sccs();
  2077. if (!(info->flags & ZILOG_INITIALIZED))
  2078. zs_startup(info);
  2080. hook->poll_rx_char = zs_poll_rx_char;
  2081. hook->poll_tx_char = zs_poll_tx_char;
  2083. return 1;
  2084. }
  2085. }
  2087. unsigned int unregister_zs_hook(unsigned int channel)
  2088. {
  2089. struct dec_serial *info = &zs_soft[channel];
  2091.         if (info->hook) {
  2092.                 info->hook = NULL;
  2093.                 return 1;
  2094.         } else {
  2095.                 printk(__FUNCTION__": trying to unregister hook on line %d,"
  2096.                        " but none is registeredn", channel);
  2097.                 return 0;
  2098.         }
  2099. }
  2101. /*
  2102.  * ------------------------------------------------------------
  2103.  * Serial console driver
  2104.  * ------------------------------------------------------------
  2105.  */
  2106. #ifdef CONFIG_SERIAL_CONSOLE
  2109. /*
  2110.  * Print a string to the serial port trying not to disturb
  2111.  * any possible real use of the port...
  2112.  */
  2113. static void serial_console_write(struct console *co, const char *s,
  2114.  unsigned count)
  2115. {
  2116. struct dec_serial *info;
  2117. int i;
  2119. info = zs_soft + co->index;
  2121. for (i = 0; i < count; i++, s++) {
  2122. if(*s == 'n')
  2123. zs_poll_tx_char(info, 'r');
  2124. zs_poll_tx_char(info, *s);
  2125. }
  2126. }
  2128. /*
  2129.  * Receive character from the serial port
  2130.  */
  2131. static int serial_console_wait_key(struct console *co)
  2132. {
  2133. struct dec_serial *info;
  2135.         info = zs_soft + co->index;
  2137.         return zs_poll_rx_char(info);
  2138. }
  2140. static kdev_t serial_console_device(struct console *c)
  2141. {
  2142. return MKDEV(TTY_MAJOR, 64 + c->index);
  2143. }
  2145. /*
  2146.  * Setup initial baud/bits/parity. We do two things here:
  2147.  * - construct a cflag setting for the first rs_open()
  2148.  * - initialize the serial port
  2149.  * Return non-zero if we didn't find a serial port.
  2150.  */
  2151. static int __init serial_console_setup(struct console *co, char *options)
  2152. {
  2153. struct dec_serial *info;
  2154. int baud = 9600;
  2155. int bits = 8;
  2156. int parity = 'n';
  2157. int cflag = CREAD | HUPCL | CLOCAL;
  2158. char *s;
  2159. unsigned long flags;
  2161. if(!BUS_PRESENT)
  2162. return -ENODEV;
  2164. info = zs_soft + co->index;
  2166. if (zs_chain == 0)
  2167. probe_sccs();
  2169. info->is_cons = 1;
  2171. if (options) {
  2172. baud = simple_strtoul(options, NULL, 10);
  2173. s = options;
  2174. while(*s >= '0' && *s <= '9')
  2175. s++;
  2176. if (*s)
  2177. parity = *s++;
  2178. if (*s)
  2179. bits   = *s - '0';
  2180. }
  2182. /*
  2183.  * Now construct a cflag setting.
  2184.  */
  2185. switch(baud) {
  2186. case 1200:
  2187. cflag |= B1200;
  2188. break;
  2189. case 2400:
  2190. cflag |= B2400;
  2191. break;
  2192. case 4800:
  2193. cflag |= B4800;
  2194. break;
  2195. case 19200:
  2196. cflag |= B19200;
  2197. break;
  2198. case 38400:
  2199. cflag |= B38400;
  2200. break;
  2201. case 57600:
  2202. cflag |= B57600;
  2203. break;
  2204. case 115200:
  2205. cflag |= B115200;
  2206. break;
  2207. case 9600:
  2208. default:
  2209. cflag |= B9600;
  2210. break;
  2211. }
  2212. switch(bits) {
  2213. case 7:
  2214. cflag |= CS7;
  2215. break;
  2216. default:
  2217. case 8:
  2218. cflag |= CS8;
  2219. break;
  2220. }
  2221. switch(parity) {
  2222. case 'o': case 'O':
  2223. cflag |= PARODD;
  2224. break;
  2225. case 'e': case 'E':
  2226. cflag |= PARENB;
  2227. break;
  2228. }
  2229. co->cflag = cflag;
  2230. #if 1 
  2231. save_and_cli(flags);
  2233. /*
  2234.  * Turn on RTS and DTR.
  2235.  */
  2236. zs_rtsdtr(info, RTS | DTR, 1);
  2238. /*
  2239.  * Finally, enable sequencing
  2240.  */
  2241. info->zs_channel->curregs[3] |= (RxENABLE | Rx8);
  2242. info->zs_channel->curregs[5] |= (TxENAB | Tx8);
  2243. info->zs_channel->curregs[9] |= (VIS);
  2244. write_zsreg(info->zs_channel, 3, info->zs_channel->curregs[3]);
  2245. write_zsreg(info->zs_channel, 5, info->zs_channel->curregs[5]);
  2246. write_zsreg(info->zs_channel, 9, info->zs_channel->curregs[9]);
  2248. /*
  2249.  * Clear the interrupt registers.
  2250.  */
  2251. write_zsreg(info->zs_channel, 0, ERR_RES);
  2252. write_zsreg(info->zs_channel, 0, RES_H_IUS);
  2254. /*
  2255.  * Set the speed of the serial port
  2256.  */
  2257. change_speed(info);
  2259. /* Save the current value of RR0 */
  2260. info->read_reg_zero = read_zsreg(info->zs_channel, 0);
  2262. zs_soft[co->index].clk_divisor = 16;
  2263. zs_soft[co->index].zs_baud = get_zsbaud(&zs_soft[co->index]);
  2265. restore_flags(flags);
  2266. #endif
  2267. return 0;
  2268. }
  2270. static struct console sercons = {
  2271. name: "ttyS",
  2272. write: serial_console_write,
  2273. device: serial_console_device,
  2274. wait_key: serial_console_wait_key,
  2275. setup: serial_console_setup,
  2276. flags: CON_PRINTBUFFER,
  2277. index: -1,
  2278. };
  2280. /*
  2281.  * Register console.
  2282.  */
  2283. void __init zs_serial_console_init(void)
  2284. {
  2285. register_console(&sercons);
  2286. }
  2287. #endif /* ifdef CONFIG_SERIAL_CONSOLE */
  2289. #ifdef CONFIG_KGDB
  2290. struct dec_zschannel *zs_kgdbchan;
  2291. static unsigned char scc_inittab[] = {
  2292. 9,  0x80, /* reset A side (CHRA) */
  2293. 13, 0, /* set baud rate divisor */
  2294. 12, 1,
  2295. 14, 1, /* baud rate gen enable, src=rtxc (BRENABL) */
  2296. 11, 0x50, /* clocks = br gen (RCBR | TCBR) */
  2297. 5,  0x6a, /* tx 8 bits, assert RTS (Tx8 | TxENAB | RTS) */
  2298. 4,  0x44, /* x16 clock, 1 stop (SB1 | X16CLK)*/
  2299. 3,  0xc1, /* rx enable, 8 bits (RxENABLE | Rx8)*/
  2300. };
  2302. /* These are for receiving and sending characters under the kgdb
  2303.  * source level kernel debugger.
  2304.  */
  2305. void putDebugChar(char kgdb_char)
  2306. {
  2307. struct dec_zschannel *chan = zs_kgdbchan;
  2308. while ((read_zsreg(chan, 0) & Tx_BUF_EMP) == 0)
  2309. RECOVERY_DELAY;
  2310. write_zsdata(chan, kgdb_char);
  2311. }
  2312. char getDebugChar(void)
  2313. {
  2314. struct dec_zschannel *chan = zs_kgdbchan;
  2315. while((read_zsreg(chan, 0) & Rx_CH_AV) == 0)
  2316. eieio(); /*barrier();*/
  2317. return read_zsdata(chan);
  2318. }
  2319. void kgdb_interruptible(int yes)
  2320. {
  2321. struct dec_zschannel *chan = zs_kgdbchan;
  2322. int one, nine;
  2323. nine = read_zsreg(chan, 9);
  2324. if (yes == 1) {
  2325. one = EXT_INT_ENAB|INT_ALL_Rx;
  2326. nine |= MIE;
  2327. printk("turning serial ints onn");
  2328. } else {
  2329. one = RxINT_DISAB;
  2330. nine &= ~MIE;
  2331. printk("turning serial ints offn");
  2332. }
  2333. write_zsreg(chan, 1, one);
  2334. write_zsreg(chan, 9, nine);
  2335. }
  2337. static int kgdbhook_init_channel(struct dec_serial* info) 
  2338. {
  2339. return 0;
  2340. }
  2342. static void kgdbhook_init_info(struct dec_serial* info)
  2343. {
  2344. }
  2346. static void kgdbhook_rx_char(struct dec_serial* info, 
  2347.      unsigned char ch, unsigned char stat)
  2348. {
  2349. if (ch == 0x03 || ch == '$')
  2350. breakpoint();
  2351. if (stat & (Rx_OVR|FRM_ERR|PAR_ERR))
  2352. write_zsreg(info->zs_channel, 0, ERR_RES);
  2353. }
  2355. /* This sets up the serial port we're using, and turns on
  2356.  * interrupts for that channel, so kgdb is usable once we're done.
  2357.  */
  2358. static inline void kgdb_chaninit(struct dec_zschannel *ms, int intson, int bps)
  2359. {
  2360. int brg;
  2361. int i, x;
  2362. volatile char *sccc = ms->control;
  2363. brg = BPS_TO_BRG(bps, zs_parms->clock/16);
  2364. printk("setting bps on kgdb line to %d [brg=%x]n", bps, brg);
  2365. for (i = 20000; i != 0; --i) {
  2366. x = *sccc; eieio();
  2367. }
  2368. for (i = 0; i < sizeof(scc_inittab); ++i) {
  2369. write_zsreg(ms, scc_inittab[i], scc_inittab[i+1]);
  2370. i++;
  2371. }
  2372. }
  2373. /* This is called at boot time to prime the kgdb serial debugging
  2374.  * serial line.  The 'tty_num' argument is 0 for /dev/ttya and 1
  2375.  * for /dev/ttyb which is determined in setup_arch() from the
  2376.  * boot command line flags.
  2377.  */
  2378. struct zs_hook zs_kgdbhook = {
  2379. init_channel : kgdbhook_init_channel,
  2380. init_info    : kgdbhook_init_info,
  2381. cflags       : B38400|CS8|CLOCAL,
  2382. rx_char      : kgdbhook_rx_char,
  2383. }
  2385. void __init zs_kgdb_hook(int tty_num)
  2386. {
  2387. /* Find out how many Z8530 SCCs we have */
  2388. if (zs_chain == 0)
  2389. probe_sccs();
  2390. zs_soft[tty_num].zs_channel = &zs_channels[tty_num];
  2391. zs_kgdbchan = zs_soft[tty_num].zs_channel;
  2392. zs_soft[tty_num].change_needed = 0;
  2393. zs_soft[tty_num].clk_divisor = 16;
  2394. zs_soft[tty_num].zs_baud = 38400;
  2395.   zs_soft[tty_num].hook = &zs_kgdbhook; /* This runs kgdb */
  2396. /* Turn on transmitter/receiver at 8-bits/char */
  2397.         kgdb_chaninit(zs_soft[tty_num].zs_channel, 1, 38400);
  2398. printk("KGDB: on channel %d initializedn", tty_num);
  2399. set_debug_traps(); /* init stub */
  2400. }
  2401. #endif /* ifdef CONFIG_KGDB */