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

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

Linux/Unix编程

开发平台：

Unix_Linux

sgiserial.c：源码内容
  1. /* sgiserial.c: Serial port driver for SGI machines.
  2.  *
  3.  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
  4.  */
  6. /*
  7.  * Note: This driver seems to have been derived from some
  8.  * version of the sbus/char/zs.c driver.  A lot of clean-up
  9.  * and bug fixes seem to have happened to the Sun driver in
  10.  * the intervening time.  As of 21.09.1999, I have merged in
  11.  * ONLY the changes necessary to fix observed functional
  12.  * problems on the Indy.  Someone really ought to do a
  13.  * thorough pass to merge in the rest of the updates.
  14.  * Better still, someone really ought to make it a common
  15.  * code module for both platforms.   kevink@mips.com
  16.  *
  17.  * 20010616 - Klaus Naumann <spock@mgnet.de> : Make serial console work with
  18.  *                                             any speed - not only 9600
  19.  */
  21. #include <linux/config.h> /* for CONFIG_REMOTE_DEBUG */
  22. #include <linux/errno.h>
  23. #include <linux/signal.h>
  24. #include <linux/sched.h>
  25. #include <linux/timer.h>
  26. #include <linux/interrupt.h>
  27. #include <linux/tty.h>
  28. #include <linux/tty_flip.h>
  29. #include <linux/major.h>
  30. #include <linux/string.h>
  31. #include <linux/fcntl.h>
  32. #include <linux/mm.h>
  33. #include <linux/kernel.h>
  34. #include <linux/delay.h>
  35. #include <linux/console.h>
  36. #include <linux/init.h>
  38. #include <asm/io.h>
  39. #include <asm/irq.h>
  40. #include <asm/sgialib.h>
  41. #include <asm/system.h>
  42. #include <asm/bitops.h>
  43. #include <asm/sgi/sgihpc.h>
  44. #include <asm/sgi/sgint23.h>
  45. #include <asm/uaccess.h>
  47. #include "sgiserial.h"
  49. #define NUM_SERIAL 1     /* One chip on board. */
  50. #define NUM_CHANNELS (NUM_SERIAL * 2)
  52. struct sgi_zslayout *zs_chips[NUM_SERIAL] = { 0, };
  53. struct sgi_zschannel *zs_channels[NUM_CHANNELS] = { 0, 0, };
  54. struct sgi_zschannel *zs_conschan;
  55. struct sgi_zschannel *zs_kgdbchan;
  57. struct sgi_serial zs_soft[NUM_CHANNELS];
  58. struct sgi_serial *zs_chain;  /* IRQ servicing chain */
  59. static int zilog_irq = SGI_SERIAL_IRQ;
  61. /* Console hooks... */
  62. static int zs_cons_chanout;
  63. static int zs_cons_chanin;
  64. struct sgi_serial *zs_consinfo;
  66. static unsigned char kgdb_regs[16] = {
  67. 0, 0, 0,                     /* write 0, 1, 2 */
  68. (Rx8 | RxENABLE),            /* write 3 */
  69. (X16CLK | SB1 | PAR_EVEN),   /* write 4 */
  70. (Tx8 | TxENAB),              /* write 5 */
  71. 0, 0, 0,                     /* write 6, 7, 8 */
  72. (NV),                        /* write 9 */
  73. (NRZ),                       /* write 10 */
  74. (TCBR | RCBR),               /* write 11 */
  75. 0, 0,                        /* BRG time constant, write 12 + 13 */
  76. (BRENABL),                   /* write 14 */
  77. (DCDIE)                      /* write 15 */
  78. };
  80. static unsigned char zscons_regs[16] = {
  81. 0,                           /* write 0 */
  82. (EXT_INT_ENAB | INT_ALL_Rx), /* write 1 */
  83. 0,                           /* write 2 */
  84. (Rx8 | RxENABLE),            /* write 3 */
  85. (X16CLK),                    /* write 4 */
  86. (DTR | Tx8 | TxENAB),        /* write 5 */
  87. 0, 0, 0,                     /* write 6, 7, 8 */
  88. (NV | MIE),                  /* write 9 */
  89. (NRZ),                       /* write 10 */
  90. (TCBR | RCBR),               /* write 11 */
  91. 0, 0,                        /* BRG time constant, write 12 + 13 */
  92. (BRENABL),                   /* write 14 */
  93. (DCDIE | CTSIE | TxUIE | BRKIE) /* write 15 */
  94. };
  96. #define ZS_CLOCK         3672000   /* Zilog input clock rate */
  98. DECLARE_TASK_QUEUE(tq_serial);
  100. struct tty_driver serial_driver, callout_driver;
  101. struct console *sgisercon;
  102. static int serial_refcount;
  104. /* serial subtype definitions */
  105. #define SERIAL_TYPE_NORMAL 1
  106. #define SERIAL_TYPE_CALLOUT 2
  108. /* number of characters left in xmit buffer before we ask for more */
  109. #define WAKEUP_CHARS 256
  111. /* Debugging... DEBUG_INTR is bad to use when one of the zs
  112.  * lines is your console ;(
  113.  */
  114. #undef SERIAL_DEBUG_INTR
  115. #undef SERIAL_DEBUG_OPEN
  116. #undef SERIAL_DEBUG_FLOW
  118. #define RS_STROBE_TIME 10
  119. #define RS_ISR_PASS_LIMIT 256
  121. #define _INLINE_ inline
  123. static void change_speed(struct sgi_serial *info);
  125. static struct tty_struct *serial_table[NUM_CHANNELS];
  126. static struct termios *serial_termios[NUM_CHANNELS];
  127. static struct termios *serial_termios_locked[NUM_CHANNELS];
  129. #ifndef MIN
  130. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  131. #endif
  133. /*
  134.  * tmp_buf is used as a temporary buffer by serial_write.  We need to
  135.  * lock it in case the memcpy_fromfs blocks while swapping in a page,
  136.  * and some other program tries to do a serial write at the same time.
  137.  * Since the lock will only come under contention when the system is
  138.  * swapping and available memory is low, it makes sense to share one
  139.  * buffer across all the serial ports, since it significantly saves
  140.  * memory if large numbers of serial ports are open.
  141.  */
  142. static unsigned char tmp_buf[4096]; /* This is cheating */
  143. static DECLARE_MUTEX(tmp_buf_sem);
  145. static inline int serial_paranoia_check(struct sgi_serial *info,
  146. dev_t device, const char *routine)
  147. {
  148. #ifdef SERIAL_PARANOIA_CHECK
  149. static const char *badmagic = KERN_WARNING
  150. "Warning: bad magic number for serial struct (%d, %d) in %sn";
  151. static const char *badinfo = KERN_WARNING
  152. "Warning: null sgi_serial for (%d, %d) in %sn";
  154. if (!info) {
  155. printk(badinfo, MAJOR(device), MINOR(device), routine);
  156. return 1;
  157. }
  158. if (info->magic != SERIAL_MAGIC) {
  159. printk(badmagic, MAJOR(device), MINOR(device), routine);
  160. return 1;
  161. }
  162. #endif
  163. return 0;
  164. }
  166. /*
  167.  * This is used to figure out the divisor speeds and the timeouts
  168.  */
  169. static int baud_table[] = {
  170. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  171. 9600, 19200, 38400, 57600, 115200, 0 };
  173. /*
  174.  * Reading and writing Zilog8530 registers.  The delays are to make this
  175.  * driver work on the Sun4 which needs a settling delay after each chip
  176.  * register access, other machines handle this in hardware via auxiliary
  177.  * flip-flops which implement the settle time we do in software.
  178.  *
  179.  * read_zsreg() and write_zsreg() may get called from rs_kgdb_hook() before
  180.  * interrupts are enabled. Therefore we have to check ioc_iocontrol before we
  181.  * access it.
  182.  */
  183. static inline unsigned char read_zsreg(struct sgi_zschannel *channel,
  184.                                        unsigned char reg)
  185. {
  186. unsigned char retval;
  187. volatile unsigned char junk;
  189. udelay(2);
  190. channel->control = reg;
  191. if (ioc_icontrol)
  192. junk = ioc_icontrol->istat0;
  193. udelay(1);
  194. retval = channel->control;
  195. return retval;
  196. }
  198. static inline void write_zsreg(struct sgi_zschannel *channel,
  199.                                unsigned char reg, unsigned char value)
  200. {
  201. volatile unsigned char junk;
  203. udelay(2);
  204. channel->control = reg;
  205. if (ioc_icontrol)
  206. junk = ioc_icontrol->istat0;
  207. udelay(1);
  208. channel->control = value;
  209. if (ioc_icontrol)
  210. junk = ioc_icontrol->istat0;
  211. return;
  212. }
  214. static inline void load_zsregs(struct sgi_zschannel *channel, unsigned char *regs)
  215. {
  216. ZS_CLEARERR(channel);
  217. ZS_CLEARFIFO(channel);
  218. /* Load 'em up */
  219. write_zsreg(channel, R4, regs[R4]);
  220. write_zsreg(channel, R10, regs[R10]);
  221. write_zsreg(channel, R3, regs[R3] & ~RxENABLE);
  222. write_zsreg(channel, R5, regs[R5] & ~TxENAB);
  223. write_zsreg(channel, R1, regs[R1]);
  224. write_zsreg(channel, R9, regs[R9]);
  225. write_zsreg(channel, R11, regs[R11]);
  226. write_zsreg(channel, R12, regs[R12]);
  227. write_zsreg(channel, R13, regs[R13]);
  228. write_zsreg(channel, R14, regs[R14]);
  229. write_zsreg(channel, R15, regs[R15]);
  230. write_zsreg(channel, R3, regs[R3]);
  231. write_zsreg(channel, R5, regs[R5]);
  232. return;
  233. }
  235. /* Sets or clears DTR/RTS on the requested line */
  236. static inline void zs_rtsdtr(struct sgi_serial *ss, int set)
  237. {
  238. if(set) {
  239. ss->curregs[5] |= (RTS | DTR);
  240. ss->pendregs[5] = ss->curregs[5];
  241. write_zsreg(ss->zs_channel, 5, ss->curregs[5]);
  242. } else {
  243. ss->curregs[5] &= ~(RTS | DTR);
  244. ss->pendregs[5] = ss->curregs[5];
  245. write_zsreg(ss->zs_channel, 5, ss->curregs[5]);
  246. }
  247. return;
  248. }
  250. static inline void kgdb_chaninit(struct sgi_serial *ss, int intson, int bps)
  251. {
  252. int brg;
  254. if(intson) {
  255. kgdb_regs[R1] = INT_ALL_Rx;
  256. kgdb_regs[R9] |= MIE;
  257. } else {
  258. kgdb_regs[R1] = 0;
  259. kgdb_regs[R9] &= ~MIE;
  260. }
  261. brg = BPS_TO_BRG(bps, ZS_CLOCK/ss->clk_divisor);
  262. kgdb_regs[R12] = (brg & 255);
  263. kgdb_regs[R13] = ((brg >> 8) & 255);
  264. load_zsregs(ss->zs_channel, kgdb_regs);
  265. }
  267. /* Utility routines for the Zilog */
  268. static inline int get_zsbaud(struct sgi_serial *ss)
  269. {
  270. struct sgi_zschannel *channel = ss->zs_channel;
  271. int brg;
  273. /* The baud rate is split up between two 8-bit registers in
  274.  * what is termed 'BRG time constant' format in my docs for
  275.  * the chip, it is a function of the clk rate the chip is
  276.  * receiving which happens to be constant.
  277.  */
  278. brg = ((read_zsreg(channel, 13)&0xff) << 8);
  279. brg |= (read_zsreg(channel, 12)&0xff);
  280. return BRG_TO_BPS(brg, (ZS_CLOCK/(ss->clk_divisor)));
  281. }
  283. /*
  284.  * ------------------------------------------------------------
  285.  * rs_stop() and rs_start()
  286.  *
  287.  * This routines are called before setting or resetting tty->stopped.
  288.  * They enable or disable transmitter interrupts, as necessary.
  289.  * ------------------------------------------------------------
  290.  */
  291. static void rs_stop(struct tty_struct *tty)
  292. {
  293. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  294. unsigned long flags;
  296. if (serial_paranoia_check(info, tty->device, "rs_stop"))
  297. return;
  299. save_flags(flags); cli();
  300. if (info->curregs[5] & TxENAB) {
  301. info->curregs[5] &= ~TxENAB;
  302. info->pendregs[5] &= ~TxENAB;
  303. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  304. }
  305. restore_flags(flags);
  306. }
  308. static void rs_start(struct tty_struct *tty)
  309. {
  310. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  311. unsigned long flags;
  313. if (serial_paranoia_check(info, tty->device, "rs_start"))
  314. return;
  316. save_flags(flags); cli();
  317. if (info->xmit_cnt && info->xmit_buf && !(info->curregs[5] & TxENAB)) {
  318. info->curregs[5] |= TxENAB;
  319. info->pendregs[5] = info->curregs[5];
  320. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  321. }
  322. restore_flags(flags);
  323. }
  325. /* Drop into either the boot monitor or kadb upon receiving a break
  326.  * from keyboard/console input.
  327.  */
  328. static void batten_down_hatches(void)
  329. {
  330. ArcEnterInteractiveMode();
  331. #if 0
  332. /* If we are doing kadb, we call the debugger
  333.  * else we just drop into the boot monitor.
  334.  * Note that we must flush the user windows
  335.  * first before giving up control.
  336.  */
  337. printk("n");
  338. if((((unsigned long)linux_dbvec)>=DEBUG_FIRSTVADDR) &&
  339.    (((unsigned long)linux_dbvec)<=DEBUG_LASTVADDR))
  340. sp_enter_debugger();
  341. else
  342. prom_halt();
  344. /* XXX We want to notify the keyboard driver that all
  345.  * XXX keys are in the up state or else weird things
  346.  * XXX happen...
  347.  */
  348. #endif
  349. return;
  350. }
  352. /* On receive, this clears errors and the receiver interrupts */
  353. static inline void rs_recv_clear(struct sgi_zschannel *zsc)
  354. {
  355. volatile unsigned char junk;
  357. udelay(2);
  358. zsc->control = ERR_RES;
  359. junk = ioc_icontrol->istat0;
  360. udelay(2);
  361. zsc->control = RES_H_IUS;
  362. junk = ioc_icontrol->istat0;
  363. }
  365. /*
  366.  * ----------------------------------------------------------------------
  367.  *
  368.  * Here starts the interrupt handling routines.  All of the following
  369.  * subroutines are declared as inline and are folded into
  370.  * rs_interrupt().  They were separated out for readability's sake.
  371.  *
  372.  * Note: rs_interrupt() is a "fast" interrupt, which means that it
  373.  * runs with interrupts turned off.  People who may want to modify
  374.  * rs_interrupt() should try to keep the interrupt handler as fast as
  375.  * possible.  After you are done making modifications, it is not a bad
  376.  * idea to do:
  377.  *
  378.  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  379.  *
  380.  * and look at the resulting assemble code in serial.s.
  381.  *
  382.  *  - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  383.  * -----------------------------------------------------------------------
  384.  */
  386. /*
  387.  * This routine is used by the interrupt handler to schedule
  388.  * processing in the software interrupt portion of the driver.
  389.  */
  390. static _INLINE_ void rs_sched_event(struct sgi_serial *info,
  391.     int event)
  392. {
  393. info->event |= 1 << event;
  394. queue_task(&info->tqueue, &tq_serial);
  395. mark_bh(SERIAL_BH);
  396. }
  398. #ifdef CONFIG_REMOTE_DEBUG
  399. extern void set_async_breakpoint(unsigned int epc);
  400. #endif
  402. static _INLINE_ void receive_chars(struct sgi_serial *info, struct pt_regs *regs)
  403. {
  404. struct tty_struct *tty = info->tty;
  405. volatile unsigned char junk;
  406. unsigned char ch, stat;
  408. udelay(2);
  409. ch = info->zs_channel->data;
  410. junk = ioc_icontrol->istat0;
  411. udelay(2);
  412. stat = read_zsreg(info->zs_channel, R1);
  414. /* If this is the console keyboard, we need to handle
  415.  * L1-A's here.
  416.  */
  417. if(info->is_cons) {
  418. if(ch==0) { /* whee, break received */
  419. batten_down_hatches();
  420. rs_recv_clear(info->zs_channel);
  421. return;
  422. } else if (ch == 1) {
  423. show_state();
  424. return;
  425. } else if (ch == 2) {
  426. show_buffers();
  427. return;
  428. }
  429. }
  430. /* Look for kgdb 'stop' character, consult the gdb documentation
  431.  * for remote target debugging and arch/sparc/kernel/sparc-stub.c
  432.  * to see how all this works.
  433.  */
  434. #ifdef CONFIG_REMOTE_DEBUG
  435. if((info->kgdb_channel) && (ch =='03')) {
  436. set_async_breakpoint(read_32bit_cp0_register(CP0_EPC));
  437. goto clear_and_exit;
  438. }
  439. #endif
  440. if(!tty)
  441. goto clear_and_exit;
  443. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  444. queue_task(&tty->flip.tqueue, &tq_timer);
  445. tty->flip.count++;
  446. if(stat & PAR_ERR)
  447. *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  448. else if(stat & Rx_OVR)
  449. *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  450. else if(stat & CRC_ERR)
  451. *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  452. else
  453. *tty->flip.flag_buf_ptr++ = 0; /* XXX */
  454. *tty->flip.char_buf_ptr++ = ch;
  456. queue_task(&tty->flip.tqueue, &tq_timer);
  458. clear_and_exit:
  459. rs_recv_clear(info->zs_channel);
  460. return;
  461. }
  463. static _INLINE_ void transmit_chars(struct sgi_serial *info)
  464. {
  465. volatile unsigned char junk;
  467. /* P3: In theory we have to test readiness here because a
  468.  * serial console can clog the chip through zs_cons_put_char().
  469.  * David did not do this. I think he relies on 3-chars FIFO in 8530.
  470.  * Let's watch for lost _output_ characters. XXX
  471.  */
  473. /* SGI ADDENDUM: On most SGI machines, the Zilog does possess
  474.  *               a 16 or 17 byte fifo, so no worries. -dm
  475.  */
  477. if (info->x_char) {
  478. /* Send next char */
  479. udelay(2);
  480. info->zs_channel->data = info->x_char;
  481. junk = ioc_icontrol->istat0;
  483. info->x_char = 0;
  484. goto clear_and_return;
  485. }
  487. if((info->xmit_cnt <= 0) || info->tty->stopped) {
  488. /* That's peculiar... */
  489. udelay(2);
  490. info->zs_channel->control = RES_Tx_P;
  491. junk = ioc_icontrol->istat0;
  492. goto clear_and_return;
  493. }
  495. /* Send char */
  496. udelay(2);
  497. info->zs_channel->data = info->xmit_buf[info->xmit_tail++];
  498. junk = ioc_icontrol->istat0;
  500. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  501. info->xmit_cnt--;
  503. if (info->xmit_cnt < WAKEUP_CHARS)
  504. rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  506. if(info->xmit_cnt <= 0) {
  507. udelay(2);
  508. info->zs_channel->control = RES_Tx_P;
  509. junk = ioc_icontrol->istat0;
  510. goto clear_and_return;
  511. }
  513. clear_and_return:
  514. /* Clear interrupt */
  515. udelay(2);
  516. info->zs_channel->control = RES_H_IUS;
  517. junk = ioc_icontrol->istat0;
  518. return;
  519. }
  521. static _INLINE_ void status_handle(struct sgi_serial *info)
  522. {
  523. volatile unsigned char junk;
  524. unsigned char status;
  526. /* Get status from Read Register 0 */
  527. udelay(2);
  528. status = info->zs_channel->control;
  529. junk = ioc_icontrol->istat0;
  530. /* Clear status condition... */
  531. udelay(2);
  532. info->zs_channel->control = RES_EXT_INT;
  533. junk = ioc_icontrol->istat0;
  534. /* Clear the interrupt */
  535. udelay(2);
  536. info->zs_channel->control = RES_H_IUS;
  537. junk = ioc_icontrol->istat0;
  539. #if 0
  540. if(status & DCD) {
  541. if((info->tty->termios->c_cflag & CRTSCTS) &&
  542.    ((info->curregs[3] & AUTO_ENAB)==0)) {
  543. info->curregs[3] |= AUTO_ENAB;
  544. info->pendregs[3] |= AUTO_ENAB;
  545. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  546. }
  547. } else {
  548. if((info->curregs[3] & AUTO_ENAB)) {
  549. info->curregs[3] &= ~AUTO_ENAB;
  550. info->pendregs[3] &= ~AUTO_ENAB;
  551. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  552. }
  553. }
  554. #endif
  555. /* Whee, if this is console input and this is a
  556.  * 'break asserted' status change interrupt, call
  557.  * the boot prom.
  558.  */
  559. if((status & BRK_ABRT) && info->break_abort)
  560. batten_down_hatches();
  562. /* XXX Whee, put in a buffer somewhere, the status information
  563.  * XXX whee whee whee... Where does the information go...
  564.  */
  565. return;
  566. }
  568. /*
  569.  * This is the serial driver's generic interrupt routine
  570.  */
  571. void rs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  572. {
  573. struct sgi_serial * info = (struct sgi_serial *) dev_id;
  574. unsigned char zs_intreg;
  576. zs_intreg = read_zsreg(info->zs_next->zs_channel, 3);
  578. /* NOTE: The read register 3, which holds the irq status,
  579.  *       does so for both channels on each chip.  Although
  580.  *       the status value itself must be read from the A
  581.  *       channel and is only valid when read from channel A.
  582.  *       Yes... broken hardware...
  583.  */
  584. #define CHAN_A_IRQMASK (CHARxIP | CHATxIP | CHAEXT)
  585. #define CHAN_B_IRQMASK (CHBRxIP | CHBTxIP | CHBEXT)
  587. /* *** Chip 1 *** */
  588. /* Channel B -- /dev/ttyb, could be the console */
  589. if(zs_intreg & CHAN_B_IRQMASK) {
  590. if (zs_intreg & CHBRxIP)
  591. receive_chars(info, regs);
  592. if (zs_intreg & CHBTxIP)
  593. transmit_chars(info);
  594. if (zs_intreg & CHBEXT)
  595. status_handle(info);
  596. }
  598. info=info->zs_next;
  600. /* Channel A -- /dev/ttya, could be the console */
  601. if(zs_intreg & CHAN_A_IRQMASK) {
  602. if (zs_intreg & CHARxIP)
  603. receive_chars(info, regs);
  604. if (zs_intreg & CHATxIP)
  605. transmit_chars(info);
  606. if (zs_intreg & CHAEXT)
  607. status_handle(info);
  608. }
  609. }
  611. /*
  612.  * -------------------------------------------------------------------
  613.  * Here ends the serial interrupt routines.
  614.  * -------------------------------------------------------------------
  615.  */
  617. /*
  618.  * This routine is used to handle the "bottom half" processing for the
  619.  * serial driver, known also the "software interrupt" processing.
  620.  * This processing is done at the kernel interrupt level, after the
  621.  * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  622.  * is where time-consuming activities which can not be done in the
  623.  * interrupt driver proper are done; the interrupt driver schedules
  624.  * them using rs_sched_event(), and they get done here.
  625.  */
  626. static void do_serial_bh(void)
  627. {
  628. run_task_queue(&tq_serial);
  629. }
  631. static void do_softint(void *private_)
  632. {
  633. struct sgi_serial *info = (struct sgi_serial *) private_;
  634. struct tty_struct *tty;
  636. tty = info->tty;
  637. if (!tty)
  638. return;
  640. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  641. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  642.     tty->ldisc.write_wakeup)
  643. (tty->ldisc.write_wakeup)(tty);
  644. wake_up_interruptible(&tty->write_wait);
  645. }
  646. }
  648. /*
  649.  * This routine is called from the scheduler tqueue when the interrupt
  650.  * routine has signalled that a hangup has occurred.  The path of
  651.  * hangup processing is:
  652.  *
  653.  *  serial interrupt routine -> (scheduler tqueue) ->
  654.  *  do_serial_hangup() -> tty->hangup() -> rs_hangup()
  655.  *
  656.  */
  657. static void do_serial_hangup(void *private_)
  658. {
  659. struct sgi_serial *info = (struct sgi_serial *) private_;
  660. struct tty_struct *tty;
  662. tty = info->tty;
  663. if (!tty)
  664. return;
  666. tty_hangup(tty);
  667. }
  670. static int startup(struct sgi_serial * info)
  671. {
  672. volatile unsigned char junk;
  673. unsigned long flags;
  675. if (info->flags & ZILOG_INITIALIZED)
  676. return 0;
  678. if (!info->xmit_buf) {
  679. info->xmit_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  680. if (!info->xmit_buf)
  681. return -ENOMEM;
  682. }
  684. save_flags(flags); cli();
  686. #ifdef SERIAL_DEBUG_OPEN
  687. printk("starting up ttys%d (irq %d)...n", info->line, info->irq);
  688. #endif
  690. /*
  691.  * Clear the FIFO buffers and disable them
  692.  * (they will be reenabled in change_speed())
  693.  */
  694. ZS_CLEARFIFO(info->zs_channel);
  695. info->xmit_fifo_size = 1;
  697. /*
  698.  * Clear the interrupt registers.
  699.  */
  700. udelay(2);
  701. info->zs_channel->control = ERR_RES;
  702. junk = ioc_icontrol->istat0;
  703. udelay(2);
  704. info->zs_channel->control = RES_H_IUS;
  705. junk = ioc_icontrol->istat0;
  707. /*
  708.  * Now, initialize the Zilog
  709.  */
  710. zs_rtsdtr(info, 1);
  712. /*
  713.  * Finally, enable sequencing and interrupts
  714.  */
  715. info->curregs[1] |= (info->curregs[1] & ~0x18) | (EXT_INT_ENAB|INT_ALL_Rx);
  716. info->pendregs[1] = info->curregs[1];
  717. info->curregs[3] |= (RxENABLE | Rx8);
  718. info->pendregs[3] = info->curregs[3];
  719. /* We enable Tx interrupts as needed. */
  720. info->curregs[5] |= (TxENAB | Tx8);
  721. info->pendregs[5] = info->curregs[5];
  722. info->curregs[9] |= (NV | MIE);
  723. info->pendregs[9] = info->curregs[9];
  724. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  725. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  726. write_zsreg(info->zs_channel, 9, info->curregs[9]);
  728. /*
  729.  * And clear the interrupt registers again for luck.
  730.  */
  731. udelay(2);
  732. info->zs_channel->control = ERR_RES;
  733. junk = ioc_icontrol->istat0;
  734. udelay(2);
  735. info->zs_channel->control = RES_H_IUS;
  736. junk = ioc_icontrol->istat0;
  738. if (info->tty)
  739. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  740. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  742. /*
  743.  * and set the speed of the serial port
  744.  */
  745. change_speed(info);
  747. info->flags |= ZILOG_INITIALIZED;
  748. restore_flags(flags);
  749. return 0;
  750. }
  752. /*
  753.  * This routine will shutdown a serial port; interrupts are disabled, and
  754.  * DTR is dropped if the hangup on close termio flag is on.
  755.  */
  756. static void shutdown(struct sgi_serial * info)
  757. {
  758. unsigned long flags;
  760. if (!(info->flags & ZILOG_INITIALIZED))
  761. return;
  763. #ifdef SERIAL_DEBUG_OPEN
  764. printk("Shutting down serial port %d (irq %d)....", info->line,
  765.        info->irq);
  766. #endif
  768. save_flags(flags); cli(); /* Disable interrupts */
  770. if (info->xmit_buf) {
  771. free_page((unsigned long) info->xmit_buf);
  772. info->xmit_buf = 0;
  773. }
  775. if (info->tty)
  776. set_bit(TTY_IO_ERROR, &info->tty->flags);
  778. info->flags &= ~ZILOG_INITIALIZED;
  779. restore_flags(flags);
  780. }
  782. /*
  783.  * This routine is called to set the UART divisor registers to match
  784.  * the specified baud rate for a serial port.
  785.  */
  786. static void change_speed(struct sgi_serial *info)
  787. {
  788. unsigned short port;
  789. unsigned cflag;
  790. int i;
  791. int brg;
  793. if (!info->tty || !info->tty->termios)
  794. return;
  795. cflag = info->tty->termios->c_cflag;
  796. if (!(port = info->port))
  797. return;
  798. i = cflag & CBAUD;
  799. if (i & CBAUDEX) {
  800. /* XXX CBAUDEX is not obeyed.
  801.  * It is impossible at a 32bits SPARC.
  802.  * But we have to report this to user ... someday.
  803.  */
  804. i = B9600;
  805. }
  806. if (i == 0) {
  807. /* XXX B0, hangup the line. */
  808. do_serial_hangup(info);
  809. } else if (baud_table[i]) {
  810. info->zs_baud = baud_table[i];
  811. info->clk_divisor = 16;
  813. info->curregs[4] = X16CLK;
  814. info->curregs[11] = TCBR | RCBR;
  815. brg = BPS_TO_BRG(info->zs_baud, ZS_CLOCK/info->clk_divisor);
  816. info->curregs[12] = (brg & 255);
  817. info->curregs[13] = ((brg >> 8) & 255);
  818. info->curregs[14] = BRENABL;
  819. }
  821. /* byte size and parity */
  822. switch (cflag & CSIZE) {
  823. case CS5:
  824. info->curregs[3] &= ~(0xc0);
  825. info->curregs[3] |= Rx5;
  826. info->pendregs[3] = info->curregs[3];
  827. info->curregs[5] &= ~(0xe0);
  828. info->curregs[5] |= Tx5;
  829. info->pendregs[5] = info->curregs[5];
  830. break;
  831. case CS6:
  832. info->curregs[3] &= ~(0xc0);
  833. info->curregs[3] |= Rx6;
  834. info->pendregs[3] = info->curregs[3];
  835. info->curregs[5] &= ~(0xe0);
  836. info->curregs[5] |= Tx6;
  837. info->pendregs[5] = info->curregs[5];
  838. break;
  839. case CS7:
  840. info->curregs[3] &= ~(0xc0);
  841. info->curregs[3] |= Rx7;
  842. info->pendregs[3] = info->curregs[3];
  843. info->curregs[5] &= ~(0xe0);
  844. info->curregs[5] |= Tx7;
  845. info->pendregs[5] = info->curregs[5];
  846. break;
  847. case CS8:
  848. default: /* defaults to 8 bits */
  849. info->curregs[3] &= ~(0xc0);
  850. info->curregs[3] |= Rx8;
  851. info->pendregs[3] = info->curregs[3];
  852. info->curregs[5] &= ~(0xe0);
  853. info->curregs[5] |= Tx8;
  854. info->pendregs[5] = info->curregs[5];
  855. break;
  856. }
  857. info->curregs[4] &= ~(0x0c);
  858. if (cflag & CSTOPB) {
  859. info->curregs[4] |= SB2;
  860. } else {
  861. info->curregs[4] |= SB1;
  862. }
  863. info->pendregs[4] = info->curregs[4];
  864. if (cflag & PARENB) {
  865. info->curregs[4] |= PAR_ENA;
  866. info->pendregs[4] |= PAR_ENA;
  867. } else {
  868. info->curregs[4] &= ~PAR_ENA;
  869. info->pendregs[4] &= ~PAR_ENA;
  870. }
  871. if (!(cflag & PARODD)) {
  872. info->curregs[4] |= PAR_EVEN;
  873. info->pendregs[4] |= PAR_EVEN;
  874. } else {
  875. info->curregs[4] &= ~PAR_EVEN;
  876. info->pendregs[4] &= ~PAR_EVEN;
  877. }
  879. /* Load up the new values */
  880. load_zsregs(info->zs_channel, info->curregs);
  882. return;
  883. }
  885. /* This is for console output over ttya/ttyb */
  886. static void zs_cons_put_char(char ch)
  887. {
  888. struct sgi_zschannel *chan = zs_conschan;
  889. volatile unsigned char junk;
  890. int flags, loops = 0;
  892. save_flags(flags); cli();
  893. while(((junk = chan->control) & Tx_BUF_EMP)==0 && loops < 10000) {
  894. loops++;
  895. udelay(2);
  896. }
  898. udelay(2);
  899. chan->data = ch;
  900. junk = ioc_icontrol->istat0;
  901. restore_flags(flags);
  902. }
  904. /*
  905.  * This is the more generic put_char function for the driver.
  906.  * In earlier versions of this driver, "rs_put_char" was the
  907.  * name of the console-specific fucntion, now called zs_cons_put_char
  908.  */
  910. static void rs_put_char(struct tty_struct *tty, char ch)
  911. {
  912. struct sgi_zschannel *chan =
  913. ((struct sgi_serial *)tty->driver_data)->zs_channel;
  914. volatile unsigned char junk;
  915. int flags, loops = 0;
  917. save_flags(flags); cli();
  918. while(((junk = chan->control) & Tx_BUF_EMP)==0 && loops < 10000) {
  919. loops++;
  920. udelay(2);
  921. }
  923. udelay(2);
  924. chan->data = ch;
  925. junk = ioc_icontrol->istat0;
  926. restore_flags(flags);
  927. }
  929. /* These are for receiving and sending characters under the kgdb
  930.  * source level kernel debugger.
  931.  */
  932. int putDebugChar(char kgdb_char)
  933. {
  934. struct sgi_zschannel *chan = zs_kgdbchan;
  935. volatile unsigned char junk;
  936. unsigned long flags;
  938. save_flags(flags); cli();
  939. udelay(2);
  940. while((chan->control & Tx_BUF_EMP)==0)
  941. udelay(2);
  943. udelay(2);
  944. chan->data = kgdb_char;
  945. junk = ioc_icontrol->istat0;
  946. restore_flags(flags);
  948. return 1;
  949. }
  951. char getDebugChar(void)
  952. {
  953. struct sgi_zschannel *chan = zs_kgdbchan;
  954. unsigned char junk;
  956. while((chan->control & Rx_CH_AV)==0)
  957. udelay(2);
  959. junk = ioc_icontrol->istat0;
  960. udelay(2);
  961. return chan->data;
  962. }
  964. /*
  965.  * Fair output driver allows a process to speak.
  966.  */
  967. static void rs_fair_output(void)
  968. {
  969. int left; /* Output no more than that */
  970. unsigned long flags;
  971. struct sgi_serial *info = zs_consinfo;
  972. volatile unsigned char junk;
  973. char c;
  975. if (info == 0) return;
  976. if (info->xmit_buf == 0) return;
  978. save_flags(flags);  cli();
  979. left = info->xmit_cnt;
  980. while (left != 0) {
  981. c = info->xmit_buf[info->xmit_tail];
  982. info->xmit_tail = (info->xmit_tail+1) & (SERIAL_XMIT_SIZE-1);
  983. info->xmit_cnt--;
  984. restore_flags(flags);
  986. zs_cons_put_char(c);
  988. save_flags(flags);  cli();
  989. left = MIN(info->xmit_cnt, left-1);
  990. }
  992. /* Last character is being transmitted now (hopefully). */
  993. udelay(2);
  994. zs_conschan->control = RES_Tx_P;
  995. junk = ioc_icontrol->istat0;
  997. restore_flags(flags);
  998. return;
  999. }
  1002. static int rs_write(struct tty_struct * tty, int from_user,
  1003.     const unsigned char *buf, int count)
  1004. {
  1005. int c, total = 0;
  1006. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1007. unsigned long flags;
  1009. if (serial_paranoia_check(info, tty->device, "rs_write"))
  1010. return 0;
  1012. if (!tty || !info->xmit_buf)
  1013. return 0;
  1015. save_flags(flags);
  1016. while (1) {
  1017. cli();
  1018. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1019.    SERIAL_XMIT_SIZE - info->xmit_head));
  1020. if (c <= 0)
  1021. break;
  1023. if (from_user) {
  1024. down(&tmp_buf_sem);
  1025. copy_from_user(tmp_buf, buf, c);
  1026. c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1027.        SERIAL_XMIT_SIZE - info->xmit_head));
  1028. memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  1029. up(&tmp_buf_sem);
  1030. } else
  1031. memcpy(info->xmit_buf + info->xmit_head, buf, c);
  1032. info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  1033. info->xmit_cnt += c;
  1034. restore_flags(flags);
  1035. buf += c;
  1036. count -= c;
  1037. total += c;
  1038. }
  1040. if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
  1041. /*
  1042.  * The above test used to include the condition
  1043.    * "&& !(info->curregs[5] & TxENAB)", but there
  1044.  * is reason to suspect that it is never statisfied
  1045.  * when the port is running.  The problem may in fact
  1046.  * have been masked by the fact that, if O_POST is set,
  1047.  * there is always a rs_flush_xx operation following the
  1048.  * rs_write, and the flush ignores that condition when
  1049.  * it kicks off the transmit.
  1050.  */
  1051. /* Enable transmitter */
  1052. info->curregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1053. info->pendregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1054. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1055. info->curregs[5] |= TxENAB;
  1056. info->pendregs[5] |= TxENAB;
  1057. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1059. /*
  1060.  * The following code is imported from the 2.3.6 Sun sbus zs.c
  1061.  * driver, of which an earlier version served as the basis
  1062.  * for sgiserial.c.  Perhaps due to changes over time in
  1063.  * the line discipline code, ns_write()s with from_user
  1064.  * set would not otherwise actually kick-off output in
  1065.  * Linux 2.2.x or later.  Maybe it never really worked.
  1066.  */
  1068. rs_put_char(tty, info->xmit_buf[info->xmit_tail++]);
  1069.                 info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  1070.                 info->xmit_cnt--;
  1071. }
  1073. restore_flags(flags);
  1074. return total;
  1075. }
  1077. static int rs_write_room(struct tty_struct *tty)
  1078. {
  1079. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1080. int ret;
  1082. if (serial_paranoia_check(info, tty->device, "rs_write_room"))
  1083. return 0;
  1084. ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  1085. if (ret < 0)
  1086. ret = 0;
  1087. return ret;
  1088. }
  1090. static int rs_chars_in_buffer(struct tty_struct *tty)
  1091. {
  1092. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1094. if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
  1095. return 0;
  1096. return info->xmit_cnt;
  1097. }
  1099. static void rs_flush_buffer(struct tty_struct *tty)
  1100. {
  1101. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1103. if (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
  1104. return;
  1105. cli();
  1106. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  1107. sti();
  1108. wake_up_interruptible(&tty->write_wait);
  1109. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1110.     tty->ldisc.write_wakeup)
  1111. (tty->ldisc.write_wakeup)(tty);
  1112. }
  1114. static void rs_flush_chars(struct tty_struct *tty)
  1115. {
  1116. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1117. unsigned long flags;
  1119. if (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
  1120. return;
  1122. if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  1123.     !info->xmit_buf)
  1124. return;
  1126. /* Enable transmitter */
  1127. save_flags(flags); cli();
  1128. info->curregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1129. info->pendregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1130. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1131. info->curregs[5] |= TxENAB;
  1132. info->pendregs[5] |= TxENAB;
  1133. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1135. /*
  1136.  * Send a first (bootstrapping) character. A best solution is
  1137.  * to call transmit_chars() here which handles output in a
  1138.  * generic way. Current transmit_chars() not only transmits,
  1139.  * but resets interrupts also what we do not desire here.
  1140.  * XXX Discuss with David.
  1141.  */
  1142. if (info->zs_channel->control & Tx_BUF_EMP) {
  1143. volatile unsigned char junk;
  1145. /* Send char */
  1146. udelay(2);
  1147. info->zs_channel->data = info->xmit_buf[info->xmit_tail++];
  1148. junk = ioc_icontrol->istat0;
  1149. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  1150. info->xmit_cnt--;
  1151. }
  1152. restore_flags(flags);
  1153. }
  1155. /*
  1156.  * ------------------------------------------------------------
  1157.  * rs_throttle()
  1158.  *
  1159.  * This routine is called by the upper-layer tty layer to signal that
  1160.  * incoming characters should be throttled.
  1161.  * ------------------------------------------------------------
  1162.  */
  1163. static void rs_throttle(struct tty_struct * tty)
  1164. {
  1165. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1166. #ifdef SERIAL_DEBUG_THROTTLE
  1167. char buf[64];
  1169. printk("throttle %s: %d....n", _tty_name(tty, buf),
  1170.        tty->ldisc.chars_in_buffer(tty));
  1171. #endif
  1173. if (serial_paranoia_check(info, tty->device, "rs_throttle"))
  1174. return;
  1176. if (I_IXOFF(tty))
  1177. info->x_char = STOP_CHAR(tty);
  1179. /* Turn off RTS line */
  1180. cli();
  1181. info->curregs[5] &= ~RTS;
  1182. info->pendregs[5] &= ~RTS;
  1183. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1184. sti();
  1185. }
  1187. static void rs_unthrottle(struct tty_struct * tty)
  1188. {
  1189. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1190. #ifdef SERIAL_DEBUG_THROTTLE
  1191. char buf[64];
  1193. printk("unthrottle %s: %d....n", _tty_name(tty, buf),
  1194.        tty->ldisc.chars_in_buffer(tty));
  1195. #endif
  1197. if (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
  1198. return;
  1200. if (I_IXOFF(tty)) {
  1201. if (info->x_char)
  1202. info->x_char = 0;
  1203. else
  1204. info->x_char = START_CHAR(tty);
  1205. }
  1207. /* Assert RTS line */
  1208. cli();
  1209. info->curregs[5] |= RTS;
  1210. info->pendregs[5] |= RTS;
  1211. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1212. sti();
  1213. }
  1215. /*
  1216.  * ------------------------------------------------------------
  1217.  * rs_ioctl() and friends
  1218.  * ------------------------------------------------------------
  1219.  */
  1221. static int get_serial_info(struct sgi_serial * info,
  1222.    struct serial_struct * retinfo)
  1223. {
  1224. struct serial_struct tmp;
  1226. if (!retinfo)
  1227. return -EFAULT;
  1228. memset(&tmp, 0, sizeof(tmp));
  1229. tmp.type = info->type;
  1230. tmp.line = info->line;
  1231. tmp.port = info->port;
  1232. tmp.irq = info->irq;
  1233. tmp.flags = info->flags;
  1234. tmp.baud_base = info->baud_base;
  1235. tmp.close_delay = info->close_delay;
  1236. tmp.closing_wait = info->closing_wait;
  1237. tmp.custom_divisor = info->custom_divisor;
  1238. return copy_to_user(retinfo,&tmp,sizeof(*retinfo)) ? -EFAULT : 0;
  1239. }
  1241. static int set_serial_info(struct sgi_serial * info,
  1242.    struct serial_struct * new_info)
  1243. {
  1244. struct serial_struct new_serial;
  1245. struct sgi_serial old_info;
  1246. int  retval = 0;
  1248. if (!new_info)
  1249. return -EFAULT;
  1250. copy_from_user(&new_serial,new_info,sizeof(new_serial));
  1251. old_info = *info;
  1253. if (!capable(CAP_SYS_ADMIN)) {
  1254. if ((new_serial.baud_base != info->baud_base) ||
  1255.     (new_serial.type != info->type) ||
  1256.     (new_serial.close_delay != info->close_delay) ||
  1257.     ((new_serial.flags & ~ZILOG_USR_MASK) !=
  1258.      (info->flags & ~ZILOG_USR_MASK)))
  1259. return -EPERM;
  1260. info->flags = ((info->flags & ~ZILOG_USR_MASK) |
  1261.        (new_serial.flags & ZILOG_USR_MASK));
  1262. info->custom_divisor = new_serial.custom_divisor;
  1263. goto check_and_exit;
  1264. }
  1266. if (info->count > 1)
  1267. return -EBUSY;
  1269. /*
  1270.  * OK, past this point, all the error checking has been done.
  1271.  * At this point, we start making changes.....
  1272.  */
  1274. info->baud_base = new_serial.baud_base;
  1275. info->flags = ((info->flags & ~ZILOG_FLAGS) |
  1276. (new_serial.flags & ZILOG_FLAGS));
  1277. info->type = new_serial.type;
  1278. info->close_delay = new_serial.close_delay;
  1279. info->closing_wait = new_serial.closing_wait;
  1281. check_and_exit:
  1282. retval = startup(info);
  1283. return retval;
  1284. }
  1286. /*
  1287.  * get_lsr_info - get line status register info
  1288.  *
  1289.  * Purpose: Let user call ioctl() to get info when the UART physically
  1290.  *      is emptied.  On bus types like RS485, the transmitter must
  1291.  *      release the bus after transmitting. This must be done when
  1292.  *      the transmit shift register is empty, not be done when the
  1293.  *      transmit holding register is empty.  This functionality
  1294.  *      allows an RS485 driver to be written in user space.
  1295.  */
  1296. static int get_lsr_info(struct sgi_serial * info, unsigned int *value)
  1297. {
  1298. volatile unsigned char junk;
  1299. unsigned char status;
  1301. cli();
  1302. udelay(2);
  1303. status = info->zs_channel->control;
  1304. junk = ioc_icontrol->istat0;
  1305. sti();
  1306. return put_user(status,value);
  1307. }
  1309. static int get_modem_info(struct sgi_serial * info, unsigned int *value)
  1310. {
  1311. unsigned char status;
  1312. unsigned int result;
  1314. cli();
  1315. status = info->zs_channel->control;
  1316. udelay(2);
  1317. sti();
  1318. result =  ((info->curregs[5] & RTS) ? TIOCM_RTS : 0)
  1319. | ((info->curregs[5] & DTR) ? TIOCM_DTR : 0)
  1320. | ((status  & DCD) ? TIOCM_CAR : 0)
  1321. | ((status  & SYNC) ? TIOCM_DSR : 0)
  1322. | ((status  & CTS) ? TIOCM_CTS : 0);
  1323. if (put_user(result, value))
  1324. return -EFAULT;
  1325. return 0;
  1326. }
  1328. static int set_modem_info(struct sgi_serial * info, unsigned int cmd,
  1329.   unsigned int *value)
  1330. {
  1331. unsigned int arg;
  1333. if (get_user(arg, value))
  1334. return -EFAULT;
  1335. switch (cmd) {
  1336. case TIOCMBIS:
  1337. if (arg & TIOCM_RTS)
  1338. info->curregs[5] |= RTS;
  1339. if (arg & TIOCM_DTR)
  1340. info->curregs[5] |= DTR;
  1341. break;
  1342. case TIOCMBIC:
  1343. if (arg & TIOCM_RTS)
  1344. info->curregs[5] &= ~RTS;
  1345. if (arg & TIOCM_DTR)
  1346. info->curregs[5] &= ~DTR;
  1347. break;
  1348. case TIOCMSET:
  1349. info->curregs[5] = ((info->curregs[5] & ~(RTS | DTR))
  1350.      | ((arg & TIOCM_RTS) ? RTS : 0)
  1351.      | ((arg & TIOCM_DTR) ? DTR : 0));
  1352. break;
  1353. default:
  1354. return -EINVAL;
  1355. }
  1356. cli();
  1357. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1358. sti();
  1359. return 0;
  1360. }
  1362. /*
  1363.  * This routine sends a break character out the serial port.
  1364.  */
  1365. static void send_break( struct sgi_serial * info, int duration)
  1366. {
  1367. if (!info->port)
  1368. return;
  1369. current->state = TASK_INTERRUPTIBLE;
  1370. cli();
  1371. write_zsreg(info->zs_channel, 5, (info->curregs[5] | SND_BRK));
  1372. schedule_timeout(duration);
  1373. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1374. sti();
  1375. }
  1377. static int rs_ioctl(struct tty_struct *tty, struct file * file,
  1378.     unsigned int cmd, unsigned long arg)
  1379. {
  1380. struct sgi_serial * info = (struct sgi_serial *) tty->driver_data;
  1381. int retval;
  1383. if (serial_paranoia_check(info, tty->device, "zs_ioctl"))
  1384. return -ENODEV;
  1386. if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  1387.     (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
  1388.     (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
  1389. if (tty->flags & (1 << TTY_IO_ERROR))
  1390.     return -EIO;
  1391. }
  1393. switch (cmd) {
  1394. case TCSBRK: /* SVID version: non-zero arg --> no break */
  1395. retval = tty_check_change(tty);
  1396. if (retval)
  1397. return retval;
  1398. tty_wait_until_sent(tty, 0);
  1399. if (!arg)
  1400. send_break(info, HZ/4); /* 1/4 second */
  1401. return 0;
  1402. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1403. retval = tty_check_change(tty);
  1404. if (retval)
  1405. return retval;
  1406. tty_wait_until_sent(tty, 0);
  1407. send_break(info, arg ? arg*(HZ/10) : HZ/4);
  1408. return 0;
  1409. case TIOCGSOFTCAR:
  1410. if (put_user(C_CLOCAL(tty) ? 1 : 0,
  1411.      (unsigned long *) arg))
  1412. return -EFAULT;
  1413. return 0;
  1414. case TIOCSSOFTCAR:
  1415. if (get_user(arg, (unsigned long *) arg))
  1416. return -EFAULT;
  1417. tty->termios->c_cflag =
  1418. ((tty->termios->c_cflag & ~CLOCAL) |
  1419.  (arg ? CLOCAL : 0));
  1420. return 0;
  1421. case TIOCMGET:
  1422. return get_modem_info(info, (unsigned int *) arg);
  1423. case TIOCMBIS:
  1424. case TIOCMBIC:
  1425. case TIOCMSET:
  1426. return set_modem_info(info, cmd, (unsigned int *) arg);
  1427. case TIOCGSERIAL:
  1428. return get_serial_info(info,
  1429.        (struct serial_struct *) arg);
  1430. case TIOCSSERIAL:
  1431. return set_serial_info(info,
  1432.        (struct serial_struct *) arg);
  1433. case TIOCSERGETLSR: /* Get line status register */
  1434. return get_lsr_info(info, (unsigned int *) arg);
  1436. case TIOCSERGSTRUCT:
  1437. if (copy_to_user((struct sgi_serial *) arg,
  1438.     info, sizeof(struct sgi_serial)))
  1439. return -EFAULT;
  1440. return 0;
  1442. default:
  1443. return -ENOIOCTLCMD;
  1444. }
  1445. return 0;
  1446. }
  1448. static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  1449. {
  1450. struct sgi_serial *info = (struct sgi_serial *)tty->driver_data;
  1452. if (tty->termios->c_cflag == old_termios->c_cflag)
  1453. return;
  1455. change_speed(info);
  1457. if ((old_termios->c_cflag & CRTSCTS) &&
  1458.     !(tty->termios->c_cflag & CRTSCTS)) {
  1459. tty->hw_stopped = 0;
  1460. rs_start(tty);
  1461. }
  1462. }
  1464. /*
  1465.  * ------------------------------------------------------------
  1466.  * rs_close()
  1467.  *
  1468.  * This routine is called when the serial port gets closed.  First, we
  1469.  * wait for the last remaining data to be sent.  Then, we unlink its
  1470.  * ZILOG structure from the interrupt chain if necessary, and we free
  1471.  * that IRQ if nothing is left in the chain.
  1472.  * ------------------------------------------------------------
  1473.  */
  1474. static void rs_close(struct tty_struct *tty, struct file * filp)
  1475. {
  1476. struct sgi_serial * info = (struct sgi_serial *)tty->driver_data;
  1477. unsigned long flags;
  1479. if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  1480. return;
  1482. save_flags(flags); cli();
  1484. if (tty_hung_up_p(filp)) {
  1485. restore_flags(flags);
  1486. return;
  1487. }
  1489. #ifdef SERIAL_DEBUG_OPEN
  1490. printk("rs_close ttys%d, count = %dn", info->line, info->count);
  1491. #endif
  1492. if ((tty->count == 1) && (info->count != 1)) {
  1493. /*
  1494.  * Uh, oh.  tty->count is 1, which means that the tty
  1495.  * structure will be freed.  Info->count should always
  1496.  * be one in these conditions.  If it's greater than
  1497.  * one, we've got real problems, since it means the
  1498.  * serial port won't be shutdown.
  1499.  */
  1500. printk("rs_close: bad serial port count; tty->count is 1, "
  1501.        "info->count is %dn", info->count);
  1502. info->count = 1;
  1503. }
  1504. if (--info->count < 0) {
  1505. printk("rs_close: bad serial port count for ttys%d: %dn",
  1506.        info->line, info->count);
  1507. info->count = 0;
  1508. }
  1509. if (info->count) {
  1510. restore_flags(flags);
  1511. return;
  1512. }
  1513. info->flags |= ZILOG_CLOSING;
  1514. /*
  1515.  * Save the termios structure, since this port may have
  1516.  * separate termios for callout and dialin.
  1517.  */
  1518. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1519. info->normal_termios = *tty->termios;
  1520. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1521. info->callout_termios = *tty->termios;
  1522. /*
  1523.  * Now we wait for the transmit buffer to clear; and we notify
  1524.  * the line discipline to only process XON/XOFF characters.
  1525.  */
  1526. tty->closing = 1;
  1527. if (info->closing_wait != ZILOG_CLOSING_WAIT_NONE)
  1528. tty_wait_until_sent(tty, info->closing_wait);
  1529. /*
  1530.  * At this point we stop accepting input.  To do this, we
  1531.  * disable the receive line status interrupts, and tell the
  1532.  * interrupt driver to stop checking the data ready bit in the
  1533.  * line status register.
  1534.  */
  1535. /** if (!info->iscons) ... **/
  1536. info->curregs[3] &= ~RxENABLE;
  1537. info->pendregs[3] = info->curregs[3];
  1538. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  1539. info->curregs[1] &= ~(0x18);
  1540. info->pendregs[1] = info->curregs[1];
  1541. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1542. ZS_CLEARFIFO(info->zs_channel);
  1544. shutdown(info);
  1545. if (tty->driver.flush_buffer)
  1546. tty->driver.flush_buffer(tty);
  1547. if (tty->ldisc.flush_buffer)
  1548. tty->ldisc.flush_buffer(tty);
  1549. tty->closing = 0;
  1550. info->event = 0;
  1551. info->tty = 0;
  1552. if (tty->ldisc.num != ldiscs[N_TTY].num) {
  1553. if (tty->ldisc.close)
  1554. (tty->ldisc.close)(tty);
  1555. tty->ldisc = ldiscs[N_TTY];
  1556. tty->termios->c_line = N_TTY;
  1557. if (tty->ldisc.open)
  1558. (tty->ldisc.open)(tty);
  1559. }
  1560. if (info->blocked_open) {
  1561. if (info->close_delay) {
  1562. current->state = TASK_INTERRUPTIBLE;
  1563. schedule_timeout(info->close_delay);
  1564. }
  1565. wake_up_interruptible(&info->open_wait);
  1566. }
  1567. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE|
  1568.  ZILOG_CLOSING);
  1569. wake_up_interruptible(&info->close_wait);
  1570. restore_flags(flags);
  1571. }
  1573. /*
  1574.  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
  1575.  */
  1576. void rs_hangup(struct tty_struct *tty)
  1577. {
  1578. struct sgi_serial * info = (struct sgi_serial *)tty->driver_data;
  1580. if (serial_paranoia_check(info, tty->device, "rs_hangup"))
  1581. return;
  1583. rs_flush_buffer(tty);
  1584. shutdown(info);
  1585. info->event = 0;
  1586. info->count = 0;
  1587. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE);
  1588. info->tty = 0;
  1589. wake_up_interruptible(&info->open_wait);
  1590. }
  1592. /*
  1593.  * ------------------------------------------------------------
  1594.  * rs_open() and friends
  1595.  * ------------------------------------------------------------
  1596.  */
  1597. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1598.    struct sgi_serial *info)
  1599. {
  1600. DECLARE_WAITQUEUE(wait, current);
  1601. int retval;
  1602. int do_clocal = 0;
  1604. /*
  1605.  * If the device is in the middle of being closed, then block
  1606.  * until it's done, and then try again.
  1607.  */
  1608. if (info->flags & ZILOG_CLOSING) {
  1609. interruptible_sleep_on(&info->close_wait);
  1610. #ifdef SERIAL_DO_RESTART
  1611. if (info->flags & ZILOG_HUP_NOTIFY)
  1612. return -EAGAIN;
  1613. else
  1614. return -ERESTARTSYS;
  1615. #else
  1616. return -EAGAIN;
  1617. #endif
  1618. }
  1620. /*
  1621.  * If this is a callout device, then just make sure the normal
  1622.  * device isn't being used.
  1623.  */
  1624. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1625. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1626. return -EBUSY;
  1627. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1628.     (info->flags & ZILOG_SESSION_LOCKOUT) &&
  1629.     (info->session != current->session))
  1630.     return -EBUSY;
  1631. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1632.     (info->flags & ZILOG_PGRP_LOCKOUT) &&
  1633.     (info->pgrp != current->pgrp))
  1634.     return -EBUSY;
  1635. info->flags |= ZILOG_CALLOUT_ACTIVE;
  1636. return 0;
  1637. }
  1639. /*
  1640.  * If non-blocking mode is set, or the port is not enabled,
  1641.  * then make the check up front and then exit.
  1642.  */
  1643. if ((filp->f_flags & O_NONBLOCK) ||
  1644.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1645. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1646. return -EBUSY;
  1647. info->flags |= ZILOG_NORMAL_ACTIVE;
  1648. return 0;
  1649. }
  1651. if (info->flags & ZILOG_CALLOUT_ACTIVE) {
  1652. if (info->normal_termios.c_cflag & CLOCAL)
  1653. do_clocal = 1;
  1654. } else {
  1655. if (tty->termios->c_cflag & CLOCAL)
  1656. do_clocal = 1;
  1657. }
  1659. /*
  1660.  * Block waiting for the carrier detect and the line to become
  1661.  * free (i.e., not in use by the callout).  While we are in
  1662.  * this loop, info->count is dropped by one, so that
  1663.  * rs_close() knows when to free things.  We restore it upon
  1664.  * exit, either normal or abnormal.
  1665.  */
  1666. retval = 0;
  1667. add_wait_queue(&info->open_wait, &wait);
  1668. #ifdef SERIAL_DEBUG_OPEN
  1669. printk("block_til_ready before block: ttys%d, count = %dn",
  1670.        info->line, info->count);
  1671. #endif
  1672. info->count--;
  1673. info->blocked_open++;
  1674. while (1) {
  1675. cli();
  1676. if (!(info->flags & ZILOG_CALLOUT_ACTIVE))
  1677. zs_rtsdtr(info, 1);
  1678. sti();
  1679. set_current_state(TASK_INTERRUPTIBLE);
  1680. if (tty_hung_up_p(filp) ||
  1681.     !(info->flags & ZILOG_INITIALIZED)) {
  1682. #ifdef SERIAL_DO_RESTART
  1683. if (info->flags & ZILOG_HUP_NOTIFY)
  1684. retval = -EAGAIN;
  1685. else
  1686. retval = -ERESTARTSYS;
  1687. #else
  1688. retval = -EAGAIN;
  1689. #endif
  1690. break;
  1691. }
  1692. if (!(info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1693.     !(info->flags & ZILOG_CLOSING) && do_clocal)
  1694. break;
  1695. if (signal_pending(current)) {
  1696. retval = -ERESTARTSYS;
  1697. break;
  1698. }
  1699. #ifdef SERIAL_DEBUG_OPEN
  1700. printk("block_til_ready blocking: ttys%d, count = %dn",
  1701.        info->line, info->count);
  1702. #endif
  1703. schedule();
  1704. }
  1705. current->state = TASK_RUNNING;
  1706. remove_wait_queue(&info->open_wait, &wait);
  1707. if (!tty_hung_up_p(filp))
  1708. info->count++;
  1709. info->blocked_open--;
  1710. #ifdef SERIAL_DEBUG_OPEN
  1711. printk("block_til_ready after blocking: ttys%d, count = %dn",
  1712.        info->line, info->count);
  1713. #endif
  1714. if (retval)
  1715. return retval;
  1716. info->flags |= ZILOG_NORMAL_ACTIVE;
  1717. return 0;
  1718. }
  1720. /*
  1721.  * This routine is called whenever a serial port is opened.  It
  1722.  * enables interrupts for a serial port, linking in its ZILOG structure into
  1723.  * the IRQ chain.   It also performs the serial-specific
  1724.  * initialization for the tty structure.
  1725.  */
  1726. int rs_open(struct tty_struct *tty, struct file * filp)
  1727. {
  1728. struct sgi_serial *info;
  1729. int  retval, line;
  1731. line = MINOR(tty->device) - tty->driver.minor_start;
  1732. /* The zilog lines for the mouse/keyboard must be
  1733.  * opened using their respective drivers.
  1734.  */
  1735. if ((line < 0) || (line >= NUM_CHANNELS))
  1736. return -ENODEV;
  1737. info = zs_soft + line;
  1738. /* Is the kgdb running over this line? */
  1739. if (info->kgdb_channel)
  1740. return -ENODEV;
  1741. if (serial_paranoia_check(info, tty->device, "rs_open"))
  1742. return -ENODEV;
  1743. #ifdef SERIAL_DEBUG_OPEN
  1744. printk("rs_open %s%d, count = %dn", tty->driver.name, info->line,
  1745.        info->count);
  1746. #endif
  1747. info->count++;
  1748. tty->driver_data = info;
  1749. info->tty = tty;
  1751. /*
  1752.  * Start up serial port
  1753.  */
  1754. retval = startup(info);
  1755. if (retval)
  1756. return retval;
  1758. retval = block_til_ready(tty, filp, info);
  1759. if (retval) {
  1760. #ifdef SERIAL_DEBUG_OPEN
  1761. printk("rs_open returning after block_til_ready with %dn",
  1762.        retval);
  1763. #endif
  1764. return retval;
  1765. }
  1767. if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
  1768. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1769. *tty->termios = info->normal_termios;
  1770. else
  1771. *tty->termios = info->callout_termios;
  1772. change_speed(info);
  1773. }
  1775. /* If this is the serial console change the speed to
  1776.  * the right value
  1777.  */
  1778. if (info->is_cons) {
  1779. info->tty->termios->c_cflag = sgisercon->cflag;
  1780. change_speed(info);
  1781. }
  1783. info->session = current->session;
  1784. info->pgrp = current->pgrp;
  1786. #ifdef SERIAL_DEBUG_OPEN
  1787. printk("rs_open ttys%d successful...n", info->line);
  1788. #endif
  1789. return 0;
  1790. }
  1792. /* Finally, routines used to initialize the serial driver. */
  1794. static void show_serial_version(void)
  1795. {
  1796. printk("SGI Zilog8530 serial driver version 1.00n");
  1797. }
  1799. /* Return layout for the requested zs chip number. */
  1800. static inline struct sgi_zslayout *get_zs(int chip)
  1801. {
  1802. extern struct hpc3_miscregs *hpc3mregs;
  1804. if (chip > 0)
  1805. panic("Wheee, bogus zs chip number requested.");
  1807. return (struct sgi_zslayout *) (&hpc3mregs->ser1cmd);
  1808. }
  1811. static inline void
  1812. rs_cons_check(struct sgi_serial *ss, int channel)
  1813. {
  1814. int i, o, io;
  1815. static int msg_printed = 0;
  1817. i = o = io = 0;
  1819. /* Is this one of the serial console lines? */
  1820. if((zs_cons_chanout != channel) &&
  1821.    (zs_cons_chanin != channel))
  1822. return;
  1823. zs_conschan = ss->zs_channel;
  1824. zs_consinfo = ss;
  1828. /* If this is console input, we handle the break received
  1829.  * status interrupt on this line to mean prom_halt().
  1830.  */
  1831. if(zs_cons_chanin == channel) {
  1832. ss->break_abort = 1;
  1833. i = 1;
  1834. }
  1835. if(o && i)
  1836. io = 1;
  1838. /* Set flag variable for this port so that it cannot be
  1839.  * opened for other uses by accident.
  1840.  */
  1841. ss->is_cons = 1;
  1843. if(io) {
  1844. if (!msg_printed) {
  1845. printk("zs%d: console I/On", ((channel>>1)&1));
  1846. msg_printed = 1;
  1847. }
  1849. } else {
  1850. printk("zs%d: console %sn", ((channel>>1)&1),
  1851.        (i==1 ? "input" : (o==1 ? "output" : "WEIRD")));
  1852. }
  1853. }
  1855. volatile int test_done;
  1857. /* rs_init inits the driver */
  1858. int rs_init(void)
  1859. {
  1860. int chip, channel, i, flags;
  1861. struct sgi_serial *info;
  1864. /* Setup base handler, and timer table. */
  1865. init_bh(SERIAL_BH, do_serial_bh);
  1867. show_serial_version();
  1869. /* Initialize the tty_driver structure */
  1870. /* SGI: Not all of this is exactly right for us. */
  1872. memset(&serial_driver, 0, sizeof(struct tty_driver));
  1873. serial_driver.magic = TTY_DRIVER_MAGIC;
  1874. #ifdef CONFIG_DEVFS_FS
  1875. serial_driver.name = "tts/%d";
  1876. #else
  1877. serial_driver.name = "ttyS";
  1878. #endif
  1879. serial_driver.major = TTY_MAJOR;
  1880. serial_driver.minor_start = 64;
  1881. serial_driver.num = NUM_CHANNELS;
  1882. serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  1883. serial_driver.subtype = SERIAL_TYPE_NORMAL;
  1884. serial_driver.init_termios = tty_std_termios;
  1886. serial_driver.init_termios.c_cflag =
  1887. B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  1888. serial_driver.flags = TTY_DRIVER_REAL_RAW;
  1889. serial_driver.refcount = &serial_refcount;
  1890. serial_driver.table = serial_table;
  1891. serial_driver.termios = serial_termios;
  1892. serial_driver.termios_locked = serial_termios_locked;
  1894. serial_driver.open = rs_open;
  1895. serial_driver.close = rs_close;
  1896. serial_driver.write = rs_write;
  1897. serial_driver.flush_chars = rs_flush_chars;
  1898. serial_driver.write_room = rs_write_room;
  1899. serial_driver.chars_in_buffer = rs_chars_in_buffer;
  1900. serial_driver.flush_buffer = rs_flush_buffer;
  1901. serial_driver.ioctl = rs_ioctl;
  1902. serial_driver.throttle = rs_throttle;
  1903. serial_driver.unthrottle = rs_unthrottle;
  1904. serial_driver.set_termios = rs_set_termios;
  1905. serial_driver.stop = rs_stop;
  1906. serial_driver.start = rs_start;
  1907. serial_driver.hangup = rs_hangup;
  1909. /*
  1910.  * The callout device is just like normal device except for
  1911.  * major number and the subtype code.
  1912.  */
  1913. callout_driver = serial_driver;
  1914. #ifdef CONFIG_DEVFS_FS
  1915. callout_driver.name = "cua/%d";
  1916. #else
  1917. callout_driver.name = "cua";
  1918. #endif
  1919. callout_driver.major = TTYAUX_MAJOR;
  1920. callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  1922. if (tty_register_driver(&serial_driver))
  1923. panic("Couldn't register serial driver");
  1924. if (tty_register_driver(&callout_driver))
  1925. panic("Couldn't register callout driver");
  1927. save_flags(flags); cli();
  1929. /* Set up our interrupt linked list */
  1930. zs_chain = &zs_soft[0];
  1931. zs_soft[0].zs_next = &zs_soft[1];
  1932. zs_soft[1].zs_next = 0;
  1934. for(chip = 0; chip < NUM_SERIAL; chip++) {
  1935. /* If we are doing kgdb over one of the channels on
  1936.  * chip zero, kgdb_channel will be set to 1 by the
  1937.  * rs_kgdb_hook() routine below.
  1938.  */
  1939. if(!zs_chips[chip]) {
  1940. zs_chips[chip] = get_zs(chip);
  1941. /* Two channels per chip */
  1942. zs_channels[(chip*2)] = &zs_chips[chip]->channelB;
  1943. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelA;
  1944. zs_soft[(chip*2)].kgdb_channel = 0;
  1945. zs_soft[(chip*2)+1].kgdb_channel = 0;
  1946. }
  1947. /* First, set up channel A on this chip. */
  1948. channel = chip * 2;
  1949. zs_soft[channel].zs_channel = zs_channels[channel];
  1950. zs_soft[channel].change_needed = 0;
  1951. zs_soft[channel].clk_divisor = 16;
  1952. zs_soft[channel].zs_baud = get_zsbaud(&zs_soft[channel]);
  1953. zs_soft[channel].cons_mouse = 0;
  1954. /* If not keyboard/mouse and is console serial
  1955.  * line, then enable receiver interrupts.
  1956.  */
  1957. if(zs_soft[channel].is_cons) {
  1958. write_zsreg(zs_soft[channel].zs_channel, R1,
  1959.     (EXT_INT_ENAB | INT_ALL_Rx));
  1960. write_zsreg(zs_soft[channel].zs_channel, R9, (NV | MIE));
  1961. write_zsreg(zs_soft[channel].zs_channel, R10, (NRZ));
  1962. write_zsreg(zs_soft[channel].zs_channel, R3, (Rx8|RxENABLE));
  1963. write_zsreg(zs_soft[channel].zs_channel, R5, (Tx8 | TxENAB));
  1964. }
  1965. /* If this is the kgdb line, enable interrupts because we
  1966.  * now want to receive the 'control-c' character from the
  1967.  * client attached to us asynchronously.
  1968.  */
  1969. if(zs_soft[channel].kgdb_channel)
  1970. kgdb_chaninit(&zs_soft[channel], 1,
  1971.       zs_soft[channel].zs_baud);
  1973. /* Now, channel B */
  1974. channel++;
  1975. zs_soft[channel].zs_channel = zs_channels[channel];
  1976. zs_soft[channel].change_needed = 0;
  1977. zs_soft[channel].clk_divisor = 16;
  1978. zs_soft[channel].zs_baud = get_zsbaud(&zs_soft[channel]);
  1979. zs_soft[channel].cons_keyb = 0;
  1980. /* If console serial line, then enable receiver interrupts. */
  1981. if(zs_soft[channel].is_cons) {
  1982. write_zsreg(zs_soft[channel].zs_channel, R1,
  1983.     (EXT_INT_ENAB | INT_ALL_Rx));
  1984. write_zsreg(zs_soft[channel].zs_channel, R9,
  1985.     (NV | MIE));
  1986. write_zsreg(zs_soft[channel].zs_channel, R10,
  1987.     (NRZ));
  1988. write_zsreg(zs_soft[channel].zs_channel, R3,
  1989.     (Rx8|RxENABLE));
  1990. write_zsreg(zs_soft[channel].zs_channel, R5,
  1991.     (Tx8 | TxENAB | RTS | DTR));
  1992. }
  1993. }
  1995. for(info=zs_chain, i=0; info; info = info->zs_next, i++)
  1996. {
  1997. info->magic = SERIAL_MAGIC;
  1998. info->port = (int) info->zs_channel;
  1999. info->line = i;
  2000. info->tty = 0;
  2001. info->irq = zilog_irq;
  2002. info->custom_divisor = 16;
  2003. info->close_delay = 50;
  2004. info->closing_wait = 3000;
  2005. info->x_char = 0;
  2006. info->event = 0;
  2007. info->count = 0;
  2008. info->blocked_open = 0;
  2009. info->tqueue.routine = do_softint;
  2010. info->tqueue.data = info;
  2011. info->tqueue_hangup.routine = do_serial_hangup;
  2012. info->tqueue_hangup.data = info;
  2013. info->callout_termios =callout_driver.init_termios;
  2014. info->normal_termios = serial_driver.init_termios;
  2015. init_waitqueue_head(&info->open_wait);
  2016. init_waitqueue_head(&info->close_wait);
  2017. printk("tty%02d at 0x%04x (irq = %d)", info->line,
  2018.        info->port, info->irq);
  2019. printk(" is a Zilog8530n");
  2020. }
  2022. if (request_irq(zilog_irq, rs_interrupt, (SA_INTERRUPT),
  2023. "Zilog8530", zs_chain))
  2024. panic("Unable to attach zs intr");
  2025. restore_flags(flags);
  2027. return 0;
  2028. }
  2030. /*
  2031.  * register_serial and unregister_serial allows for serial ports to be
  2032.  * configured at run-time, to support PCMCIA modems.
  2033.  */
  2034. /* SGI: Unused at this time, just here to make things link. */
  2035. int register_serial(struct serial_struct *req)
  2036. {
  2037. return -1;
  2038. }
  2040. void unregister_serial(int line)
  2041. {
  2042. return;
  2043. }
  2045. /* Hooks for running a serial console.  con_init() calls this if the
  2046.  * console is being run over one of the ttya/ttyb serial ports.
  2047.  * 'chip' should be zero, as chip 1 drives the mouse/keyboard.
  2048.  * 'channel' is decoded as 0=TTYA 1=TTYB, note that the channels
  2049.  * are addressed backwards, channel B is first, then channel A.
  2050.  */
  2051. void
  2052. rs_cons_hook(int chip, int out, int line)
  2053. {
  2054. int channel;
  2056. if(chip)
  2057. panic("rs_cons_hook called with chip not zero");
  2058. if(line != 0 && line != 1)
  2059. panic("rs_cons_hook called with line not ttya or ttyb");
  2060. channel = line;
  2061. if(!zs_chips[chip]) {
  2062. zs_chips[chip] = get_zs(chip);
  2063. /* Two channels per chip */
  2064. zs_channels[(chip*2)] = &zs_chips[chip]->channelB;
  2065. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelA;
  2066. }
  2067. zs_soft[channel].zs_channel = zs_channels[channel];
  2068. zs_soft[channel].change_needed = 0;
  2069. zs_soft[channel].clk_divisor = 16;
  2070. zs_soft[channel].zs_baud = get_zsbaud(&zs_soft[channel]);
  2071. if(out)
  2072. zs_cons_chanout = ((chip * 2) + channel);
  2073. else
  2074. zs_cons_chanin = ((chip * 2) + channel);
  2076. rs_cons_check(&zs_soft[channel], channel);
  2077. }
  2079. /* This is called at boot time to prime the kgdb serial debugging
  2080.  * serial line.  The 'tty_num' argument is 0 for /dev/ttyd2 and 1 for
  2081.  * /dev/ttyd1 (yes they are backwards on purpose) which is determined
  2082.  * in setup_arch() from the boot command line flags.
  2083.  */
  2084. void
  2085. rs_kgdb_hook(int tty_num)
  2086. {
  2087. int chip = 0;
  2089. if(!zs_chips[chip]) {
  2090. zs_chips[chip] = get_zs(chip);
  2091. /* Two channels per chip */
  2092. zs_channels[(chip*2)] = &zs_chips[chip]->channelA;
  2093. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelB;
  2094. }
  2095. zs_soft[tty_num].zs_channel = zs_channels[tty_num];
  2096. zs_kgdbchan = zs_soft[tty_num].zs_channel;
  2097. zs_soft[tty_num].change_needed = 0;
  2098. zs_soft[tty_num].clk_divisor = 16;
  2099. zs_soft[tty_num].zs_baud = get_zsbaud(&zs_soft[tty_num]);
  2100. zs_soft[tty_num].kgdb_channel = 1;     /* This runs kgdb */
  2101. zs_soft[tty_num ^ 1].kgdb_channel = 0; /* This does not */
  2103. /* Turn on transmitter/receiver at 8-bits/char */
  2104. kgdb_chaninit(&zs_soft[tty_num], 0, 9600);
  2105. ZS_CLEARERR(zs_kgdbchan);
  2106. udelay(5);
  2107. ZS_CLEARFIFO(zs_kgdbchan);
  2108. }
  2110. static void zs_console_write(struct console *co, const char *str,
  2111.                              unsigned int count)
  2112. {
  2114. while(count--) {
  2115. if(*str == 'n')
  2116. zs_cons_put_char('r');
  2117. zs_cons_put_char(*str++);
  2118. }
  2120. /* Comment this if you want to have a strict interrupt-driven output */
  2121. rs_fair_output();
  2122. }
  2124. static kdev_t zs_console_device(struct console *con)
  2125. {
  2126. return MKDEV(TTY_MAJOR, 64 + con->index);
  2127. }
  2130. static int __init zs_console_setup(struct console *con, char *options)
  2131. {
  2132. struct sgi_serial *info;
  2133. int baud;
  2134. int bits = 8;
  2135. int parity = 'n';
  2136. int cflag = CREAD | HUPCL | CLOCAL;
  2137. char *s, *dbaud;
  2138. int     i, brg;
  2140. if (options) {
  2141. baud = simple_strtoul(options, NULL, 10);
  2142. s = options;
  2143. while(*s >= '0' && *s <= '9')
  2144. s++;
  2145. if (*s) parity = *s++;
  2146. if (*s) bits   = *s - '0';
  2147. }
  2148. else {
  2149. /* If the user doesn't set console=... try to read the
  2150.  * PROM variable - if this fails use 9600 baud and
  2151.  * inform the user about the problem
  2152.  */
  2153. dbaud = ArcGetEnvironmentVariable("dbaud");
  2154. if(dbaud) baud = simple_strtoul(dbaud, NULL, 10);
  2155. else {
  2156. /* Use prom_printf() to make sure that the user
  2157.  * is getting anything ...
  2158.  */
  2159. prom_printf("No dbaud set in PROM ?!? Using 9600.n");
  2160. baud = 9600;
  2161. }
  2162. }
  2164. /*
  2165.  * Now construct a cflag setting.
  2166.  */
  2167. switch(baud) {
  2168. case 1200:
  2169. cflag |= B1200;
  2170. break;
  2171. case 2400:
  2172. cflag |= B2400;
  2173. break;
  2174. case 4800:
  2175. cflag |= B4800;
  2176. break;
  2177. case 19200:
  2178. cflag |= B19200;
  2179. break;
  2180. case 38400:
  2181. cflag |= B38400;
  2182. break;
  2183. case 57600:
  2184. cflag |= B57600;
  2185. break;
  2186. case 115200:
  2187. cflag |= B115200;
  2188. break;
  2189. case 9600:
  2190. default:
  2191. cflag |= B9600;
  2192. break;
  2193. }
  2194. switch(bits) {
  2195. case 7:
  2196. cflag |= CS7;
  2197. break;
  2198. default:
  2199. case 8:
  2200. cflag |= CS8;
  2201. break;
  2202. }
  2203. switch(parity) {
  2204. case 'o': case 'O':
  2205. cflag |= PARODD;
  2206. break;
  2207. case 'e': case 'E':
  2208. cflag |= PARENB;
  2209. break;
  2210. }
  2211. con->cflag = cflag;
  2213.         rs_cons_hook(0, 0, con->index);
  2214. info = zs_soft + con->index;
  2215. info->is_cons = 1;
  2217. printk("Console: ttyS%d (Zilog8530), %d baudn",
  2218. info->line, baud);
  2220. i = con->cflag & CBAUD;
  2221. if (con->cflag & CBAUDEX) {
  2222. i &= ~CBAUDEX;
  2223. con->cflag &= ~CBAUDEX;
  2224. }
  2225. info->zs_baud = baud;
  2227. switch (con->cflag & CSIZE) {
  2228. case CS5:
  2229. zscons_regs[3] = Rx5 | RxENABLE;
  2230. zscons_regs[5] = Tx5 | TxENAB;
  2231. break;
  2232. case CS6:
  2233. zscons_regs[3] = Rx6 | RxENABLE;
  2234. zscons_regs[5] = Tx6 | TxENAB;
  2235. break;
  2236. case CS7:
  2237. zscons_regs[3] = Rx7 | RxENABLE;
  2238. zscons_regs[5] = Tx7 | TxENAB;
  2239. break;
  2240. default:
  2241. case CS8:
  2242. zscons_regs[3] = Rx8 | RxENABLE;
  2243. zscons_regs[5] = Tx8 | TxENAB;
  2244. break;
  2245. }
  2246. zscons_regs[5] |= DTR;
  2248. if (con->cflag & PARENB)
  2249. zscons_regs[4] |= PAR_ENA;
  2250. if (!(con->cflag & PARODD))
  2251. zscons_regs[4] |= PAR_EVEN;
  2253. if (con->cflag & CSTOPB)
  2254. zscons_regs[4] |= SB2;
  2255. else
  2256. zscons_regs[4] |= SB1;
  2258. sgisercon = con;
  2260. brg = BPS_TO_BRG(baud, ZS_CLOCK / info->clk_divisor);
  2261. zscons_regs[12] = brg & 0xff;
  2262. zscons_regs[13] = (brg >> 8) & 0xff;
  2263. memcpy(info->curregs, zscons_regs, sizeof(zscons_regs));
  2264. memcpy(info->pendregs, zscons_regs, sizeof(zscons_regs));
  2265. load_zsregs(info->zs_channel, zscons_regs);
  2266. ZS_CLEARERR(info->zs_channel);
  2267. ZS_CLEARFIFO(info->zs_channel);
  2268. return 0;
  2269. }
  2271. static struct console sgi_console_driver = {
  2272. name: "ttyS",
  2273. write: zs_console_write,
  2274. device: zs_console_device,
  2275. setup: zs_console_setup,
  2276. flags: CON_PRINTBUFFER,
  2277. index: -1,
  2278. };
  2280. /*
  2281.  * Register console.
  2282.  */
  2283. void __init sgi_serial_console_init(void)
  2284. {
  2285. register_console(&sgi_console_driver);
  2286. }
  2287. __initcall(rs_init);