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

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

Linux/Unix编程

开发平台：

Unix_Linux

zs.c：源码内容
  1. /* $Id: zs.c,v 1.68.2.2 2002/01/12 07:04:33 davem Exp $
  2.  * zs.c: Zilog serial port driver for the Sparc.
  3.  *
  4.  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  5.  * Copyright (C) 1996 Eddie C. Dost   (ecd@skynet.be)
  6.  * Fixes by Pete A. Zaitcev <zaitcev@yahoo.com>.
  7.  *
  8.  * Fixed to use tty_get_baud_rate().
  9.  *   Theodore Ts'o <tytso@mit.edu>, 2001-Oct-12
  10.  *
  11.  * /proc/tty/driver/serial now exists and is readable.
  12.  *   Alex Buell <alex.buell@tahallah.demon.co.uk>, 2001-12-23
  13.  *
  14.  */
  16. #include <linux/errno.h>
  17. #include <linux/signal.h>
  18. #include <linux/sched.h>
  19. #include <linux/timer.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/tty.h>
  22. #include <linux/tty_flip.h>
  23. #include <linux/config.h>
  24. #include <linux/major.h>
  25. #include <linux/string.h>
  26. #include <linux/fcntl.h>
  27. #include <linux/mm.h>
  28. #include <linux/kernel.h>
  29. #include <linux/keyboard.h>
  30. #include <linux/console.h>
  31. #include <linux/delay.h>
  32. #include <linux/init.h>
  33. #include <linux/bootmem.h>
  34. #include <linux/sysrq.h>
  36. #include <asm/io.h>
  37. #include <asm/irq.h>
  38. #include <asm/oplib.h>
  39. #include <asm/system.h>
  40. #include <asm/uaccess.h>
  41. #include <asm/bitops.h>
  42. #include <asm/kdebug.h>
  43. #include <asm/page.h>
  44. #include <asm/pgtable.h>
  46. #include <asm/sbus.h>
  47. #ifdef __sparc_v9__
  48. #include <asm/fhc.h>
  49. #endif
  50. #ifdef CONFIG_PCI
  51. #include <linux/pci.h>
  52. #endif
  54. #include "sunserial.h"
  55. #include "zs.h"
  56. #include "sunkbd.h"
  57. #include "sunmouse.h"
  59. static int num_serial = 2; /* sun4/sun4c/sun4m - Two chips on board. */
  60. #define NUM_SERIAL num_serial
  61. #define NUM_CHANNELS (NUM_SERIAL * 2)
  63. #define KEYBOARD_LINE 0x2
  64. #define MOUSE_LINE    0x3
  66. /* On 32-bit sparcs we need to delay after register accesses
  67.  * to accomodate sun4 systems, but we do not need to flush writes.
  68.  * On 64-bit sparc we only need to flush single writes to ensure
  69.  * completion.
  70.  */
  71. #ifndef __sparc_v9__
  72. #define ZSDELAY() udelay(5)
  73. #define ZSDELAY_LONG() udelay(20)
  74. #define ZS_WSYNC(channel) do { } while(0)
  75. #else
  76. #define ZSDELAY()
  77. #define ZSDELAY_LONG()
  78. #define ZS_WSYNC(__channel) 
  79. sbus_readb(&((__channel)->control))
  80. #endif
  82. struct sun_zslayout **zs_chips;
  83. struct sun_zschannel **zs_channels;
  84. struct sun_zschannel *zs_mousechan;
  85. struct sun_zschannel *zs_kbdchan;
  86. struct sun_zschannel *zs_kgdbchan;
  87. int *zs_nodes;
  89. struct sun_serial *zs_soft;
  90. struct sun_serial *zs_chain;  /* IRQ servicing chain */
  91. int zilog_irq;
  93. struct tty_struct *zs_ttys;
  95. /* Console hooks... */
  96. #ifdef CONFIG_SERIAL_CONSOLE
  97. static struct console zs_console;
  98. static int zs_console_init(void);
  100. /*
  101.  * Define this to get the zs_fair_output() functionality.
  102.  */
  103. #undef SERIAL_CONSOLE_FAIR_OUTPUT
  104. #endif /* CONFIG_SERIAL_CONSOLE */
  106. static unsigned char kgdb_regs[16] = {
  107. 0, 0, 0,                     /* write 0, 1, 2 */
  108. (Rx8 | RxENAB),              /* write 3 */
  109. (X16CLK | SB1 | PAR_EVEN),   /* write 4 */
  110. (DTR | Tx8 | TxENAB),        /* write 5 */
  111. 0, 0, 0,                     /* write 6, 7, 8 */
  112. (NV),                        /* write 9 */
  113. (NRZ),                       /* write 10 */
  114. (TCBR | RCBR),               /* write 11 */
  115. 0, 0,                        /* BRG time constant, write 12 + 13 */
  116. (BRSRC | BRENAB),            /* write 14 */
  117. (DCDIE)                      /* write 15 */
  118. };
  120. static unsigned char zscons_regs[16] = {
  121. 0,                           /* write 0 */
  122. (EXT_INT_ENAB | INT_ALL_Rx), /* write 1 */
  123. 0,                           /* write 2 */
  124. (Rx8 | RxENAB),              /* write 3 */
  125. (X16CLK),                    /* write 4 */
  126. (DTR | Tx8 | TxENAB),        /* write 5 */
  127. 0, 0, 0,                     /* write 6, 7, 8 */
  128. (NV | MIE),                  /* write 9 */
  129. (NRZ),                       /* write 10 */
  130. (TCBR | RCBR),               /* write 11 */
  131. 0, 0,                        /* BRG time constant, write 12 + 13 */
  132. (BRSRC | BRENAB),            /* write 14 */
  133. (DCDIE | CTSIE | TxUIE | BRKIE) /* write 15 */
  134. };
  136. #define ZS_CLOCK         4915200   /* Zilog input clock rate */
  138. DECLARE_TASK_QUEUE(tq_serial);
  140. static struct tty_driver serial_driver, callout_driver;
  141. static int serial_refcount;
  143. /* serial subtype definitions */
  144. #define SERIAL_TYPE_NORMAL 1
  145. #define SERIAL_TYPE_CALLOUT 2
  146.   
  147. /* number of characters left in xmit buffer before we ask for more */
  148. #define WAKEUP_CHARS 256
  150. #define SERIAL_DO_RESTART
  152. /* Debugging... DEBUG_INTR is bad to use when one of the zs
  153.  * lines is your console ;(
  154.  */
  155. #undef SERIAL_DEBUG_INTR
  156. #undef SERIAL_DEBUG_OPEN
  157. #undef SERIAL_DEBUG_FLOW
  159. #define RS_STROBE_TIME 10
  160. #define RS_ISR_PASS_LIMIT 256
  162. #define _INLINE_ inline
  164. int zs_init(void);
  165. static void zs_kgdb_hook(int);
  167. static void change_speed(struct sun_serial *info);
  169. static struct tty_struct **serial_table;
  170. static struct termios **serial_termios;
  171. static struct termios **serial_termios_locked;
  173. #ifndef MIN
  174. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  175. #endif
  177. #undef ZS_LOG
  178. #ifdef ZS_LOG
  179. struct zs_logent {
  180. u8 reg, val;
  181. u8 write, __pad;
  182. #define REGIRQ 0xff
  183. #define REGDATA 0xfe
  184. #define REGCTRL 0xfd
  185. };
  186. struct zs_logent zslog[32];
  187. int zs_curlog;
  188. #define ZSLOG(__reg, __val, __write) 
  189. do{ int index = zs_curlog; 
  190. zslog[index].reg = (__reg); 
  191. zslog[index].val = (__val); 
  192. zslog[index].write = (__write); 
  193. zs_curlog = (index + 1) & (32 - 1); 
  194. }while(0)
  195. int zs_dumplog(char *buffer)
  196. {
  197. int len = 0;
  198. int i;
  200. for (i = 0; i < 32; i++) {
  201. u8 reg, val, write;
  203. reg = zslog[i].reg;
  204. val = zslog[i].val;
  205. write = zslog[i].write;
  206. len += sprintf(buffer + len,
  207.        "ZSLOG[%2d]: reg %2x val %2x %sn",
  208.        i, reg, val, write ? "write" : "read");
  209. }
  210. len += sprintf(buffer + len, "ZS current log index %dn",
  211.        zs_curlog);
  212. return len;
  213. }
  214. #else
  215. #define ZSLOG(x,y,z) do { } while (0)
  216. #endif
  218. /*
  219.  * tmp_buf is used as a temporary buffer by serial_write.  We need to
  220.  * lock it in case the memcpy_fromfs blocks while swapping in a page,
  221.  * and some other program tries to do a serial write at the same time.
  222.  * Since the lock will only come under contention when the system is
  223.  * swapping and available memory is low, it makes sense to share one
  224.  * buffer across all the serial ports, since it significantly saves
  225.  * memory if large numbers of serial ports are open.
  226.  */
  227. static unsigned char *tmp_buf = 0;
  228. static DECLARE_MUTEX(tmp_buf_sem);
  230. static inline int serial_paranoia_check(struct sun_serial *info,
  231. dev_t device, const char *routine)
  232. {
  233. #ifdef SERIAL_PARANOIA_CHECK
  234. static const char *badmagic =
  235. "Warning: bad magic number for serial struct (%d, %d) in %sn";
  236. static const char *badinfo =
  237. "Warning: null sun_serial for (%d, %d) in %sn";
  239. if (!info) {
  240. printk(badinfo, MAJOR(device), MINOR(device), routine);
  241. return 1;
  242. }
  243. if (info->magic != SERIAL_MAGIC) {
  244. printk(badmagic, MAJOR(device), MINOR(device), routine);
  245. return 1;
  246. }
  247. #endif
  248. return 0;
  249. }
  251. /* Reading and writing Zilog8530 registers.  The delays are to make this
  252.  * driver work on the Sun4 which needs a settling delay after each chip
  253.  * register access, other machines handle this in hardware via auxiliary
  254.  * flip-flops which implement the settle time we do in software.
  255.  */
  256. static unsigned char read_zsreg(struct sun_zschannel *channel,
  257. unsigned char reg)
  258. {
  259. unsigned char retval;
  261. sbus_writeb(reg, &channel->control);
  262. ZSDELAY();
  263. retval = sbus_readb(&channel->control);
  264. ZSDELAY();
  265. ZSLOG(reg, retval, 0);
  266. return retval;
  267. }
  269. static void write_zsreg(struct sun_zschannel *channel,
  270. unsigned char reg, unsigned char value)
  271. {
  272. ZSLOG(reg, value, 1);
  273. sbus_writeb(reg, &channel->control);
  274. ZSDELAY();
  275. sbus_writeb(value, &channel->control);
  276. ZSDELAY();
  277. }
  279. static void load_zsregs(struct sun_serial *info, unsigned char *regs)
  280. {
  281. struct sun_zschannel *channel = info->zs_channel;
  282. unsigned long flags;
  283. unsigned char stat;
  284. int i;
  286. for (i = 0; i < 1000; i++) {
  287. stat = read_zsreg(channel, R1);
  288. if (stat & ALL_SNT)
  289. break;
  290. udelay(100);
  291. }
  292. write_zsreg(channel, R3, 0);
  293. ZS_CLEARSTAT(channel);
  294. ZS_CLEARERR(channel);
  295. ZS_CLEARFIFO(channel);
  297. /* Load 'em up */
  298. save_flags(flags); cli();
  299. if (info->channelA)
  300. write_zsreg(channel, R9, CHRA);
  301. else
  302. write_zsreg(channel, R9, CHRB);
  303. ZSDELAY_LONG();
  304. write_zsreg(channel, R4, regs[R4]);
  305. write_zsreg(channel, R3, regs[R3] & ~RxENAB);
  306. write_zsreg(channel, R5, regs[R5] & ~TxENAB);
  307. write_zsreg(channel, R9, regs[R9] & ~MIE);
  308. write_zsreg(channel, R10, regs[R10]);
  309. write_zsreg(channel, R11, regs[R11]);
  310. write_zsreg(channel, R12, regs[R12]);
  311. write_zsreg(channel, R13, regs[R13]);
  312. write_zsreg(channel, R14, regs[R14] & ~BRENAB);
  313. write_zsreg(channel, R14, regs[R14]);
  314. write_zsreg(channel, R14, (regs[R14] & ~SNRZI) | BRENAB);
  315. write_zsreg(channel, R3, regs[R3]);
  316. write_zsreg(channel, R5, regs[R5]);
  317. write_zsreg(channel, R15, regs[R15]);
  318. write_zsreg(channel, R0, RES_EXT_INT);
  319. write_zsreg(channel, R0, ERR_RES);
  320. write_zsreg(channel, R1, regs[R1]);
  321. write_zsreg(channel, R9, regs[R9]);
  322. restore_flags(flags);
  323. }
  325. #define ZS_PUT_CHAR_MAX_DELAY 2000 /* 10 ms */
  327. static void zs_put_char(struct sun_zschannel *channel, char ch)
  328. {
  329. int loops = ZS_PUT_CHAR_MAX_DELAY;
  331. /* Do not change this to use ZSDELAY as this is
  332.  * a timed polling loop and on sparc64 ZSDELAY
  333.  * is a nop.  -DaveM
  334.  */
  335. do {
  336. u8 val = sbus_readb(&channel->control);
  337. ZSLOG(REGCTRL, val, 0);
  338. if (val & Tx_BUF_EMP)
  339. break;
  340. udelay(5);
  341. } while (--loops);
  343. sbus_writeb(ch, &channel->data);
  344. ZSDELAY();
  345. ZS_WSYNC(channel);
  346. ZSLOG(REGDATA, ch, 1);
  347. }
  349. /* Sets or clears DTR/RTS on the requested line */
  350. static void zs_rtsdtr(struct sun_serial *ss, int set)
  351. {
  352. unsigned long flags;
  354. save_flags(flags); cli();
  355. if(set) {
  356. ss->curregs[5] |= (RTS | DTR);
  357. write_zsreg(ss->zs_channel, 5, ss->curregs[5]);
  358. } else {
  359. ss->curregs[5] &= ~(RTS | DTR);
  360. write_zsreg(ss->zs_channel, 5, ss->curregs[5]);
  361. }
  362. restore_flags(flags);
  363. return;
  364. }
  366. static void kgdb_chaninit(struct sun_serial *ss, int intson, int bps)
  367. {
  368. int brg;
  370. if(intson) {
  371. kgdb_regs[R1] = INT_ALL_Rx;
  372. kgdb_regs[R9] |= MIE;
  373. } else {
  374. kgdb_regs[R1] = 0;
  375. kgdb_regs[R9] &= ~MIE;
  376. }
  377. brg = BPS_TO_BRG(bps, ZS_CLOCK/16);
  378. kgdb_regs[R12] = (brg & 255);
  379. kgdb_regs[R13] = ((brg >> 8) & 255);
  380. load_zsregs(ss, kgdb_regs);
  381. }
  383. /*
  384.  * ------------------------------------------------------------
  385.  * zs_stop() and zs_start()
  386.  *
  387.  * This routines are called before setting or resetting tty->stopped.
  388.  * They enable or disable transmitter interrupts, as necessary.
  389.  * ------------------------------------------------------------
  390.  */
  391. static void zs_stop(struct tty_struct *tty)
  392. {
  393. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  394. unsigned long flags;
  396. if (serial_paranoia_check(info, tty->device, "zs_stop"))
  397. return;
  399. save_flags(flags); cli();
  400. if (info->curregs[5] & TxENAB) {
  401. info->curregs[5] &= ~TxENAB;
  402. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  403. }
  404. restore_flags(flags);
  405. }
  407. static void zs_start(struct tty_struct *tty)
  408. {
  409. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  410. unsigned long flags;
  412. if (serial_paranoia_check(info, tty->device, "zs_start"))
  413. return;
  415. save_flags(flags); cli();
  416. if (info->xmit_cnt && info->xmit_buf && !(info->curregs[5] & TxENAB)) {
  417. info->curregs[5] |= TxENAB;
  418. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  419. }
  420. restore_flags(flags);
  421. }
  423. /* Drop into either the boot monitor or kadb upon receiving a break
  424.  * from keyboard/console input.
  425.  */
  426. void batten_down_hatches(void)
  427. {
  428. if (!stop_a_enabled)
  429. return;
  430. /* If we are doing kadb, we call the debugger
  431.  * else we just drop into the boot monitor.
  432.  * Note that we must flush the user windows
  433.  * first before giving up control.
  434.  */
  435. printk("n");
  436. flush_user_windows();
  437. #ifndef __sparc_v9__
  438. if((((unsigned long)linux_dbvec)>=DEBUG_FIRSTVADDR) &&
  439.    (((unsigned long)linux_dbvec)<=DEBUG_LASTVADDR))
  440. sp_enter_debugger();
  441. else
  442. #endif
  443. prom_cmdline();
  445. /* XXX We want to notify the keyboard driver that all
  446.  * XXX keys are in the up state or else weird things
  447.  * XXX happen...
  448.  */
  450. return;
  451. }
  454. /*
  455.  * ----------------------------------------------------------------------
  456.  *
  457.  * Here starts the interrupt handling routines.  All of the following
  458.  * subroutines are declared as inline and are folded into
  459.  * zs_interrupt().  They were separated out for readability's sake.
  460.  *
  461.  * Note: zs_interrupt() is a "fast" interrupt, which means that it
  462.  * runs with interrupts turned off.  People who may want to modify
  463.  * zs_interrupt() should try to keep the interrupt handler as fast as
  464.  * possible.  After you are done making modifications, it is not a bad
  465.  * idea to do:
  466.  * 
  467.  * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
  468.  *
  469.  * and look at the resulting assemble code in serial.s.
  470.  *
  471.  *  - Ted Ts'o (tytso@mit.edu), 7-Mar-93
  472.  * -----------------------------------------------------------------------
  473.  */
  475. /*
  476.  * This routine is used by the interrupt handler to schedule
  477.  * processing in the software interrupt portion of the driver.
  478.  */
  479. static void zs_sched_event(struct sun_serial *info, int event)
  480. {
  481. info->event |= 1 << event;
  482. queue_task(&info->tqueue, &tq_serial);
  483. mark_bh(SERIAL_BH);
  484. }
  486. #ifndef __sparc_v9__
  487. extern void breakpoint(void);  /* For the KGDB frame character */
  488. #endif
  490. static void receive_chars(struct sun_serial *info, struct pt_regs *regs)
  491. {
  492. struct tty_struct *tty = info->tty;
  493. int do_queue_task = 0;
  495. while (1) {
  496. unsigned char ch, r1;
  498. r1 = read_zsreg(info->zs_channel, R1);
  499. if (r1 & (PAR_ERR | Rx_OVR | CRC_ERR)) {
  500. sbus_writeb(ERR_RES, &info->zs_channel->control);
  501. ZSDELAY();
  502. ZS_WSYNC(info->zs_channel);
  503. ZSLOG(REGCTRL, ERR_RES, 1);
  504. }
  506. ch = sbus_readb(&info->zs_channel->data);
  507. ZSLOG(REGDATA, ch, 0);
  508. ch &= info->parity_mask;
  509. ZSDELAY();
  511. /* If this is the console keyboard, we need to handle
  512.  * L1-A's here.
  513.  */
  514. if (info->cons_keyb) {
  515. if (ch == SUNKBD_RESET) {
  516. l1a_state.kbd_id = 1;
  517. l1a_state.l1_down = 0;
  518. } else if (l1a_state.kbd_id) {
  519. l1a_state.kbd_id = 0;
  520. } else if (ch == SUNKBD_L1) {
  521. l1a_state.l1_down = 1;
  522. } else if (ch == (SUNKBD_L1|SUNKBD_UP)) {
  523. l1a_state.l1_down = 0;
  524. } else if (ch == SUNKBD_A && l1a_state.l1_down) {
  525. /* whee... */
  526. batten_down_hatches();
  527. /* Continue execution... */
  528. l1a_state.l1_down = 0;
  529. l1a_state.kbd_id = 0;
  530. return;
  531. }
  532. sunkbd_inchar(ch, regs);
  533. goto next_char;
  534. }
  535. if (info->cons_mouse) {
  536. sun_mouse_inbyte(ch, 0);
  537. goto next_char;
  538. }
  539. if (info->is_cons) {
  540. if (ch == 0) {
  541. /* whee, break received */
  542. batten_down_hatches();
  543. /* Continue execution... */
  544. return;
  545. }
  546. }
  547. #ifndef __sparc_v9__
  548. /* Look for kgdb 'stop' character, consult the gdb
  549.  * documentation for remote target debugging and
  550.  * arch/sparc/kernel/sparc-stub.c to see how all this works.
  551.  */
  552. if (info->kgdb_channel && (ch =='03')) {
  553. breakpoint();
  554. return;
  555. }
  556. #endif
  557. if (!tty)
  558. return;
  560. do_queue_task++;
  562. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  563. break;
  565. tty->flip.count++;
  566. if (r1 & PAR_ERR)
  567. *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  568. else if (r1 & Rx_OVR)
  569. *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  570. else if (r1 & CRC_ERR)
  571. *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  572. else
  573. *tty->flip.flag_buf_ptr++ = 0;
  574. *tty->flip.char_buf_ptr++ = ch;
  576. next_char:
  577. {
  578. unsigned char stat;
  580. /* Check if we have another character... */
  581. stat = sbus_readb(&info->zs_channel->control);
  582. ZSDELAY();
  583. ZSLOG(REGCTRL, stat, 0);
  584. if (!(stat & Rx_CH_AV))
  585. break;
  586. }
  587. }
  589. if (do_queue_task != 0)
  590. queue_task(&tty->flip.tqueue, &tq_timer);
  591. }
  593. static void transmit_chars(struct sun_serial *info)
  594. {
  595. struct tty_struct *tty = info->tty;
  597. if (info->x_char) {
  598. /* Send next char */
  599. zs_put_char(info->zs_channel, info->x_char);
  600. info->x_char = 0;
  601. return;
  602. }
  604. if ((info->xmit_cnt <= 0) || (tty != 0 && tty->stopped)) {
  605. /* That's peculiar... */
  606. sbus_writeb(RES_Tx_P, &info->zs_channel->control);
  607. ZSDELAY();
  608. ZS_WSYNC(info->zs_channel);
  609. ZSLOG(REGCTRL, RES_Tx_P, 1);
  610. return;
  611. }
  613. /* Send char */
  614. zs_put_char(info->zs_channel, info->xmit_buf[info->xmit_tail++]);
  615. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  616. info->xmit_cnt--;
  618. if (info->xmit_cnt < WAKEUP_CHARS)
  619. zs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  621. if (info->xmit_cnt <= 0) {
  622. sbus_writeb(RES_Tx_P, &info->zs_channel->control);
  623. ZSDELAY();
  624. ZS_WSYNC(info->zs_channel);
  625. ZSLOG(REGCTRL, RES_Tx_P, 1);
  626. }
  627. }
  629. static void status_handle(struct sun_serial *info)
  630. {
  631. unsigned char status;
  633. /* Get status from Read Register 0 */
  634. status = sbus_readb(&info->zs_channel->control);
  635. ZSDELAY();
  636. ZSLOG(REGCTRL, status, 0);
  637. /* Clear status condition... */
  638. sbus_writeb(RES_EXT_INT, &info->zs_channel->control);
  639. ZSDELAY();
  640. ZS_WSYNC(info->zs_channel);
  641. ZSLOG(REGCTRL, RES_EXT_INT, 1);
  642. #if 0
  643. if (status & DCD) {
  644. if ((info->tty->termios->c_cflag & CRTSCTS) &&
  645.     ((info->curregs[3] & AUTO_ENAB)==0)) {
  646. info->curregs[3] |= AUTO_ENAB;
  647. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  648. }
  649. } else {
  650. if ((info->curregs[3] & AUTO_ENAB)) {
  651. info->curregs[3] &= ~AUTO_ENAB;
  652. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  653. }
  654. }
  655. #endif
  656. /* Whee, if this is console input and this is a
  657.  * 'break asserted' status change interrupt, call
  658.  * the boot prom.
  659.  */
  660. if (status & BRK_ABRT) {
  661. if (info->break_abort)
  662. batten_down_hatches();
  663. if (info->cons_mouse)
  664. sun_mouse_inbyte(0, 1);
  665. }
  667. /* XXX Whee, put in a buffer somewhere, the status information
  668.  * XXX whee whee whee... Where does the information go...
  669.  */
  670. return;
  671. }
  673. /*
  674.  * This is the serial driver's generic interrupt routine
  675.  */
  676. void zs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  677. {
  678. struct sun_serial *info;
  679. int i;
  681. info = (struct sun_serial *)dev_id;
  682. ZSLOG(REGIRQ, 0, 0);
  683. for (i = 0; i < NUM_SERIAL; i++) {
  684. unsigned char r3 = read_zsreg(info->zs_channel, 3);
  686. /* Channel A -- /dev/ttya or /dev/kbd, could be the console */
  687. if (r3 & (CHAEXT | CHATxIP | CHARxIP)) {
  688. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  689. ZSDELAY();
  690. ZS_WSYNC(info->zs_channel);
  691. ZSLOG(REGCTRL, RES_H_IUS, 1);
  692. if (r3 & CHARxIP)
  693. receive_chars(info, regs);
  694. if (r3 & CHAEXT)
  695. status_handle(info);
  696. if (r3 & CHATxIP)
  697. transmit_chars(info);
  698. }
  700. /* Channel B -- /dev/ttyb or /dev/mouse, could be the console */
  701. info = info->zs_next;
  702. if (r3 & (CHBEXT | CHBTxIP | CHBRxIP)) {
  703. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  704. ZSDELAY();
  705. ZS_WSYNC(info->zs_channel);
  706. ZSLOG(REGCTRL, RES_H_IUS, 1);
  707. if (r3 & CHBRxIP)
  708. receive_chars(info, regs);
  709. if (r3 & CHBEXT)
  710. status_handle(info);
  711. if (r3 & CHBTxIP)
  712. transmit_chars(info);
  713. }
  715. info = info->zs_next;
  716. }
  717. }
  719. /*
  720.  * -------------------------------------------------------------------
  721.  * Here ends the serial interrupt routines.
  722.  * -------------------------------------------------------------------
  723.  */
  725. /*
  726.  * This routine is used to handle the "bottom half" processing for the
  727.  * serial driver, known also the "software interrupt" processing.
  728.  * This processing is done at the kernel interrupt level, after the
  729.  * zs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  730.  * is where time-consuming activities which can not be done in the
  731.  * interrupt driver proper are done; the interrupt driver schedules
  732.  * them using zs_sched_event(), and they get done here.
  733.  */
  734. static void do_serial_bh(void)
  735. {
  736. run_task_queue(&tq_serial);
  737. }
  739. static void do_softint(void *private_)
  740. {
  741. struct sun_serial *info = (struct sun_serial *) private_;
  742. struct tty_struct *tty;
  744. tty = info->tty;
  745. if (!tty)
  746. return;
  748. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  749. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  750.     tty->ldisc.write_wakeup)
  751. (tty->ldisc.write_wakeup)(tty);
  752. wake_up_interruptible(&tty->write_wait);
  753. }
  754. }
  756. /*
  757.  * This routine is called from the scheduler tqueue when the interrupt
  758.  * routine has signalled that a hangup has occurred.  The path of
  759.  * hangup processing is:
  760.  *
  761.  *  serial interrupt routine -> (scheduler tqueue) ->
  762.  *  do_serial_hangup() -> tty->hangup() -> zs_hangup()
  763.  * 
  764.  */
  765. static void do_serial_hangup(void *private_)
  766. {
  767. struct sun_serial *info = (struct sun_serial *) private_;
  768. struct tty_struct *tty;
  770. tty = info->tty;
  771. if (!tty)
  772. return;
  773. #ifdef SERIAL_DEBUG_OPEN
  774. printk("do_serial_hangup<%p: tty-%dn",
  775. __builtin_return_address(0), info->line);
  776. #endif
  778. tty_hangup(tty);
  779. }
  781. static int startup(struct sun_serial * info)
  782. {
  783. unsigned long flags;
  785. if (info->flags & ZILOG_INITIALIZED)
  786. return 0;
  788. if (!info->xmit_buf) {
  789. info->xmit_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  790. if (!info->xmit_buf)
  791. return -ENOMEM;
  792. }
  794. save_flags(flags); cli();
  796. #ifdef SERIAL_DEBUG_OPEN
  797. printk("Starting up tty-%d (irq %d)...n", info->line, info->irq);
  798. #endif
  800. /*
  801.  * Clear the FIFO buffers and disable them
  802.  * (they will be reenabled in change_speed())
  803.  */
  804. ZS_CLEARFIFO(info->zs_channel);
  805. info->xmit_fifo_size = 1;
  807. /*
  808.  * Clear the interrupt registers.
  809.  */
  810. sbus_writeb(ERR_RES, &info->zs_channel->control);
  811. ZSDELAY();
  812. ZS_WSYNC(info->zs_channel);
  813. ZSLOG(REGCTRL, ERR_RES, 1);
  815. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  816. ZSDELAY();
  817. ZS_WSYNC(info->zs_channel);
  818. ZSLOG(REGCTRL, RES_H_IUS, 1);
  820. /*
  821.  * Now, initialize the Zilog
  822.  */
  823. zs_rtsdtr(info, 1);
  825. /*
  826.  * Finally, enable sequencing and interrupts
  827.  */
  828. info->curregs[1] |= (info->curregs[1] & ~(RxINT_MASK)) |
  829. (EXT_INT_ENAB | INT_ALL_Rx);
  830. info->curregs[3] |= (RxENAB | Rx8);
  831. /* We enable Tx interrupts as needed. */
  832. info->curregs[5] |= (TxENAB | Tx8);
  833. info->curregs[9] |= (NV | MIE);
  834. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  835. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  836. write_zsreg(info->zs_channel, 9, info->curregs[9]);
  838. /*
  839.  * And clear the interrupt registers again for luck.
  840.  */
  841. sbus_writeb(ERR_RES, &info->zs_channel->control);
  842. ZSDELAY();
  843. ZS_WSYNC(info->zs_channel);
  844. ZSLOG(REGCTRL, ERR_RES, 1);
  846. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  847. ZSDELAY();
  848. ZS_WSYNC(info->zs_channel);
  849. ZSLOG(REGCTRL, RES_H_IUS, 1);
  851. if (info->tty)
  852. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  853. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  855. /*
  856.  * and set the speed of the serial port
  857.  */
  858. change_speed(info);
  860. info->flags |= ZILOG_INITIALIZED;
  861. restore_flags(flags);
  862. return 0;
  863. }
  865. /*
  866.  * This routine will shutdown a serial port; interrupts are disabled, and
  867.  * DTR is dropped if the hangup on close termio flag is on.
  868.  */
  869. static void shutdown(struct sun_serial * info)
  870. {
  871. unsigned long flags;
  873. if (!(info->flags & ZILOG_INITIALIZED))
  874. return;
  876. #ifdef SERIAL_DEBUG_OPEN
  877. printk("Shutting down serial port %d (irq %d)....", info->line,
  878.        info->irq);
  879. #endif
  881. save_flags(flags); cli(); /* Disable interrupts */
  883. if (info->xmit_buf) {
  884. free_page((unsigned long) info->xmit_buf);
  885. info->xmit_buf = 0;
  886. }
  888. if (info->tty)
  889. set_bit(TTY_IO_ERROR, &info->tty->flags);
  891. info->flags &= ~ZILOG_INITIALIZED;
  892. restore_flags(flags);
  893. }
  895. /*
  896.  * This routine is called to set the UART divisor registers to match
  897.  * the specified baud rate for a serial port.
  898.  */
  899. static void change_speed(struct sun_serial *info)
  900. {
  901. unsigned cflag;
  902. int baud, quot = 0;
  903. int brg;
  905. if (!info->tty || !info->tty->termios)
  906. return;
  907. cflag = info->tty->termios->c_cflag;
  908. if (!info->port)
  909. return;
  910. baud = tty_get_baud_rate(info->tty);
  912. if ((baud == 38400) && 
  913.     ((info->flags & ZILOG_SPD_MASK) == ZILOG_SPD_CUST))
  914. quot = info->custom_divisor;
  916. if (quot) {
  917. info->zs_baud = info->baud_base / quot;
  918. info->clk_divisor = 16;
  920. info->curregs[4] = X16CLK;
  921. info->curregs[11] = TCBR | RCBR;
  922. brg = BPS_TO_BRG(info->zs_baud, ZS_CLOCK/info->clk_divisor);
  923. info->curregs[12] = (brg & 255);
  924. info->curregs[13] = ((brg >> 8) & 255);
  925. info->curregs[14] = BRSRC | BRENAB;
  926. zs_rtsdtr(info, 1);
  927. } else if (baud) {
  928. info->zs_baud = baud;
  929. info->clk_divisor = 16;
  931. info->curregs[4] = X16CLK;
  932. info->curregs[11] = TCBR | RCBR;
  933. brg = BPS_TO_BRG(info->zs_baud, ZS_CLOCK/info->clk_divisor);
  934. info->curregs[12] = (brg & 255);
  935. info->curregs[13] = ((brg >> 8) & 255);
  936. info->curregs[14] = BRSRC | BRENAB;
  937. zs_rtsdtr(info, 1);
  938. } else {
  939. zs_rtsdtr(info, 0);
  940. return;
  941. }
  943. /* byte size and parity */
  944. switch (cflag & CSIZE) {
  945. case CS5:
  946. info->curregs[3] &= ~(RxN_MASK);
  947. info->curregs[3] |= Rx5;
  948. info->curregs[5] &= ~(TxN_MASK);
  949. info->curregs[5] |= Tx5;
  950. info->parity_mask = 0x1f;
  951. break;
  952. case CS6:
  953. info->curregs[3] &= ~(RxN_MASK);
  954. info->curregs[3] |= Rx6;
  955. info->curregs[5] &= ~(TxN_MASK);
  956. info->curregs[5] |= Tx6;
  957. info->parity_mask = 0x3f;
  958. break;
  959. case CS7:
  960. info->curregs[3] &= ~(RxN_MASK);
  961. info->curregs[3] |= Rx7;
  962. info->curregs[5] &= ~(TxN_MASK);
  963. info->curregs[5] |= Tx7;
  964. info->parity_mask = 0x7f;
  965. break;
  966. case CS8:
  967. default: /* defaults to 8 bits */
  968. info->curregs[3] &= ~(RxN_MASK);
  969. info->curregs[3] |= Rx8;
  970. info->curregs[5] &= ~(TxN_MASK);
  971. info->curregs[5] |= Tx8;
  972. info->parity_mask = 0xff;
  973. break;
  974. }
  975. info->curregs[4] &= ~(0x0c);
  976. if (cflag & CSTOPB) {
  977. info->curregs[4] |= SB2;
  978. } else {
  979. info->curregs[4] |= SB1;
  980. }
  981. if (cflag & PARENB) {
  982. info->curregs[4] |= PAR_ENAB;
  983. } else {
  984. info->curregs[4] &= ~PAR_ENAB;
  985. }
  986. if (!(cflag & PARODD)) {
  987. info->curregs[4] |= PAR_EVEN;
  988. } else {
  989. info->curregs[4] &= ~PAR_EVEN;
  990. }
  992. /* Load up the new values */
  993. load_zsregs(info, info->curregs);
  995. return;
  996. }
  998. /* This is for mouse/keyboard output.
  999.  * XXX mouse output??? can we send it commands??? XXX
  1000.  */
  1001. static void kbd_put_char(unsigned char ch)
  1002. {
  1003. struct sun_zschannel *chan = zs_kbdchan;
  1004. unsigned long flags;
  1006. if(!chan)
  1007. return;
  1009. save_flags(flags); cli();
  1010. zs_put_char(chan, ch);
  1011. restore_flags(flags);
  1012. }
  1014. void mouse_put_char(char ch)
  1015. {
  1016. struct sun_zschannel *chan = zs_mousechan;
  1017. unsigned long flags;
  1019. if(!chan)
  1020. return;
  1022. save_flags(flags); cli();
  1023. zs_put_char(chan, ch);
  1024. restore_flags(flags);
  1025. }
  1027. /* These are for receiving and sending characters under the kgdb
  1028.  * source level kernel debugger.
  1029.  */
  1030. void putDebugChar(char kgdb_char)
  1031. {
  1032. struct sun_zschannel *chan = zs_kgdbchan;
  1034. while((sbus_readb(&chan->control) & Tx_BUF_EMP)==0)
  1035. udelay(5);
  1036. sbus_writeb(kgdb_char, &chan->data);
  1037. ZS_WSYNC(chan);
  1038. ZSLOG(REGDATA, kgdb_char, 1);
  1039. }
  1041. char getDebugChar(void)
  1042. {
  1043. struct sun_zschannel *chan = zs_kgdbchan;
  1044. u8 val;
  1046. do {
  1047. val = sbus_readb(&chan->control);
  1048. ZSLOG(REGCTRL, val, 0);
  1049. udelay(5);
  1050. } while ((val & Rx_CH_AV) == 0);
  1052. val = sbus_readb(&chan->data);
  1053. ZSLOG(REGDATA, val, 0);
  1054. return val;
  1055. }
  1057. static void zs_flush_chars(struct tty_struct *tty)
  1058. {
  1059. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1060. unsigned long flags;
  1062. if (serial_paranoia_check(info, tty->device, "zs_flush_chars"))
  1063. return;
  1065. save_flags(flags); cli();
  1066. if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  1067.     !info->xmit_buf)
  1068. goto out;
  1070. /* Enable transmitter */
  1071. info->curregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1072. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1073. info->curregs[5] |= TxENAB;
  1074. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1076. /*
  1077.  * Send a first (bootstrapping) character. A best solution is
  1078.  * to call transmit_chars() here which handles output in a
  1079.  * generic way. Current transmit_chars() not only transmits,
  1080.  * but resets interrupts also what we do not desire here.
  1081.  * XXX Discuss with David.
  1082.  */
  1083. zs_put_char(info->zs_channel, info->xmit_buf[info->xmit_tail++]);
  1084. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  1085. info->xmit_cnt--;
  1087. out:
  1088. restore_flags(flags);
  1089. }
  1091. static int zs_write(struct tty_struct * tty, int from_user,
  1092.     const unsigned char *buf, int count)
  1093. {
  1094. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1095. unsigned long flags;
  1096. int c, total = 0;
  1098. if (serial_paranoia_check(info, tty->device, "zs_write"))
  1099. return 0;
  1101. if (!info || !info->xmit_buf || !tmp_buf)
  1102. return 0;
  1104. save_flags(flags);
  1105. if (from_user) {
  1106. down(&tmp_buf_sem);
  1107. while (1) {
  1108. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1109.    SERIAL_XMIT_SIZE - info->xmit_head));
  1110. if (c <= 0)
  1111. break;
  1112. c -= copy_from_user(tmp_buf, buf, c);
  1113. if (!c) {
  1114. if (!total)
  1115. total = -EFAULT;
  1116. break;
  1117. }
  1118. cli();
  1119. c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1120.        SERIAL_XMIT_SIZE - info->xmit_head));
  1121. memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  1122. info->xmit_head = ((info->xmit_head + c) &
  1123.    (SERIAL_XMIT_SIZE - 1));
  1124. info->xmit_cnt += c;
  1125. restore_flags(flags);
  1127. buf += c;
  1128. count -= c;
  1129. total += c;
  1130. }
  1131. up(&tmp_buf_sem);
  1132. } else {
  1133. while (1) {
  1134. cli();
  1135. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1136.    SERIAL_XMIT_SIZE - info->xmit_head));
  1137. if (c <= 0) {
  1138. restore_flags(flags);
  1139. break;
  1140. }
  1141. memcpy(info->xmit_buf + info->xmit_head, buf, c);
  1142. info->xmit_head = ((info->xmit_head + c) &
  1143.    (SERIAL_XMIT_SIZE - 1));
  1144. info->xmit_cnt += c;
  1145. restore_flags(flags);
  1146. buf += c;
  1147. count -= c;
  1148. total += c;
  1149. }
  1150. }
  1152. cli();
  1153. if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
  1154. /* Enable transmitter */
  1155. info->curregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1156. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1157. info->curregs[5] |= TxENAB;
  1158. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1159. #if 1
  1160. zs_put_char(info->zs_channel,
  1161.     info->xmit_buf[info->xmit_tail++]);
  1162. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  1163. info->xmit_cnt--;
  1164. #endif
  1165. }
  1167. restore_flags(flags);
  1168. return total;
  1169. }
  1171. static int zs_write_room(struct tty_struct *tty)
  1172. {
  1173. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1174. int ret;
  1176. if (serial_paranoia_check(info, tty->device, "zs_write_room"))
  1177. return 0;
  1178. ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  1179. if (ret < 0)
  1180. ret = 0;
  1181. return ret;
  1182. }
  1184. static int zs_chars_in_buffer(struct tty_struct *tty)
  1185. {
  1186. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1188. if (serial_paranoia_check(info, tty->device, "zs_chars_in_buffer"))
  1189. return 0;
  1190. return info->xmit_cnt;
  1191. }
  1193. static void zs_flush_buffer(struct tty_struct *tty)
  1194. {
  1195. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1197. if (serial_paranoia_check(info, tty->device, "zs_flush_buffer"))
  1198. return;
  1199. cli();
  1200. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  1201. sti();
  1202. wake_up_interruptible(&tty->write_wait);
  1203. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1204.     tty->ldisc.write_wakeup)
  1205. (tty->ldisc.write_wakeup)(tty);
  1206. }
  1208. /*
  1209.  * ------------------------------------------------------------
  1210.  * zs_throttle()
  1211.  * 
  1212.  * This routine is called by the upper-layer tty layer to signal that
  1213.  * incoming characters should be throttled.
  1214.  * ------------------------------------------------------------
  1215.  */
  1216. static void zs_throttle(struct tty_struct * tty)
  1217. {
  1218. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1219. #ifdef SERIAL_DEBUG_THROTTLE
  1220. char buf[64];
  1222. printk("throttle %s: %d....n", _tty_name(tty, buf),
  1223.        tty->ldisc.chars_in_buffer(tty));
  1224. #endif
  1226. if (serial_paranoia_check(info, tty->device, "zs_throttle"))
  1227. return;
  1229. if (I_IXOFF(tty))
  1230. info->x_char = STOP_CHAR(tty);
  1232. /* Turn off RTS line */
  1233. cli();
  1234. info->curregs[5] &= ~RTS;
  1235. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1236. sti();
  1237. }
  1239. static void zs_unthrottle(struct tty_struct * tty)
  1240. {
  1241. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1242. #ifdef SERIAL_DEBUG_THROTTLE
  1243. char buf[64];
  1245. printk("unthrottle %s: %d....n", _tty_name(tty, buf),
  1246.        tty->ldisc.chars_in_buffer(tty));
  1247. #endif
  1249. if (serial_paranoia_check(info, tty->device, "zs_unthrottle"))
  1250. return;
  1252. if (I_IXOFF(tty)) {
  1253. if (info->x_char)
  1254. info->x_char = 0;
  1255. else
  1256. info->x_char = START_CHAR(tty);
  1257. }
  1259. /* Assert RTS line */
  1260. cli();
  1261. info->curregs[5] |= RTS;
  1262. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1263. sti();
  1264. }
  1266. /*
  1267.  * ------------------------------------------------------------
  1268.  * zs_ioctl() and friends
  1269.  * ------------------------------------------------------------
  1270.  */
  1272. static int get_serial_info(struct sun_serial * info,
  1273.    struct serial_struct * retinfo)
  1274. {
  1275. struct serial_struct tmp;
  1276.   
  1277. if (!retinfo)
  1278. return -EFAULT;
  1279. memset(&tmp, 0, sizeof(tmp));
  1280. tmp.type = info->type;
  1281. tmp.line = info->line;
  1282. tmp.port = info->port;
  1283. tmp.irq = info->irq;
  1284. tmp.flags = info->flags;
  1285. tmp.baud_base = info->baud_base;
  1286. tmp.close_delay = info->close_delay;
  1287. tmp.closing_wait = info->closing_wait;
  1288. tmp.custom_divisor = info->custom_divisor;
  1289. if (copy_to_user(retinfo,&tmp,sizeof(*retinfo)))
  1290. return -EFAULT;
  1291. return 0;
  1292. }
  1294. static int set_serial_info(struct sun_serial * info,
  1295.    struct serial_struct * new_info)
  1296. {
  1297. struct serial_struct new_serial;
  1298. struct sun_serial old_info;
  1299. int retval = 0;
  1301. if (!new_info || copy_from_user(&new_serial,new_info,sizeof(new_serial)))
  1302. return -EFAULT;
  1303. old_info = *info;
  1305. if (!capable(CAP_SYS_ADMIN)) {
  1306. if ((new_serial.baud_base != info->baud_base) ||
  1307.     (new_serial.type != info->type) ||
  1308.     (new_serial.close_delay != info->close_delay) ||
  1309.     ((new_serial.flags & ~ZILOG_USR_MASK) !=
  1310.      (info->flags & ~ZILOG_USR_MASK)))
  1311. return -EPERM;
  1312. info->flags = ((info->flags & ~ZILOG_USR_MASK) |
  1313.        (new_serial.flags & ZILOG_USR_MASK));
  1314. info->custom_divisor = new_serial.custom_divisor;
  1315. goto check_and_exit;
  1316. }
  1318. if(new_serial.baud_base < 9600)
  1319. return -EINVAL;
  1321. if (info->count > 1)
  1322. return -EBUSY;
  1324. /*
  1325.  * OK, past this point, all the error checking has been done.
  1326.  * At this point, we start making changes.....
  1327.  */
  1329. info->baud_base = new_serial.baud_base;
  1330. info->flags = ((info->flags & ~ZILOG_FLAGS) |
  1331. (new_serial.flags & ZILOG_FLAGS));
  1332. info->custom_divisor = new_serial.custom_divisor;
  1333. info->type = new_serial.type;
  1334. info->close_delay = new_serial.close_delay;
  1335. info->closing_wait = new_serial.closing_wait;
  1337. check_and_exit:
  1338. retval = startup(info);
  1339. return retval;
  1340. }
  1342. /*
  1343.  * get_lsr_info - get line status register info
  1344.  *
  1345.  * Purpose: Let user call ioctl() to get info when the UART physically
  1346.  *      is emptied.  On bus types like RS485, the transmitter must
  1347.  *      release the bus after transmitting. This must be done when
  1348.  *      the transmit shift register is empty, not be done when the
  1349.  *      transmit holding register is empty.  This functionality
  1350.  *      allows an RS485 driver to be written in user space. 
  1351.  */
  1352. static int get_lsr_info(struct sun_serial * info, unsigned int *value)
  1353. {
  1354. unsigned char status;
  1356. cli();
  1357. status = sbus_readb(&info->zs_channel->control);
  1358. ZSDELAY();
  1359. ZSLOG(REGCTRL, status, 0);
  1360. sti();
  1361. if (put_user(status, value))
  1362. return -EFAULT;
  1363. return 0;
  1364. }
  1366. static int get_modem_info(struct sun_serial * info, unsigned int *value)
  1367. {
  1368. unsigned char status;
  1369. unsigned int result;
  1371. cli();
  1372. status = sbus_readb(&info->zs_channel->control);
  1373. ZSDELAY();
  1374. ZSLOG(REGCTRL, status, 0);
  1375. sti();
  1376. result =  ((info->curregs[5] & RTS) ? TIOCM_RTS : 0)
  1377. | ((info->curregs[5] & DTR) ? TIOCM_DTR : 0)
  1378. | ((status  & DCD) ? TIOCM_CAR : 0)
  1379. | ((status  & SYNC) ? TIOCM_DSR : 0)
  1380. | ((status  & CTS) ? TIOCM_CTS : 0);
  1381. if (put_user(result, value))
  1382. return -EFAULT;
  1383. return 0;
  1384. }
  1386. static int set_modem_info(struct sun_serial * info, unsigned int cmd,
  1387.   unsigned int *value)
  1388. {
  1389. unsigned int arg;
  1391. if (get_user(arg, value))
  1392. return -EFAULT;
  1393. switch (cmd) {
  1394. case TIOCMBIS: 
  1395. if (arg & TIOCM_RTS)
  1396. info->curregs[5] |= RTS;
  1397. if (arg & TIOCM_DTR)
  1398. info->curregs[5] |= DTR;
  1399. break;
  1400. case TIOCMBIC:
  1401. if (arg & TIOCM_RTS)
  1402. info->curregs[5] &= ~RTS;
  1403. if (arg & TIOCM_DTR)
  1404. info->curregs[5] &= ~DTR;
  1405. break;
  1406. case TIOCMSET:
  1407. info->curregs[5] = ((info->curregs[5] & ~(RTS | DTR))
  1408.      | ((arg & TIOCM_RTS) ? RTS : 0)
  1409.      | ((arg & TIOCM_DTR) ? DTR : 0));
  1410. break;
  1411. default:
  1412. return -EINVAL;
  1413. }
  1414. cli();
  1415. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1416. sti();
  1417. return 0;
  1418. }
  1420. /*
  1421.  * This routine sends a break character out the serial port.
  1422.  */
  1423. static void send_break( struct sun_serial * info, int duration)
  1424. {
  1425. if (!info->port)
  1426. return;
  1427. current->state = TASK_INTERRUPTIBLE;
  1428. cli();
  1429. write_zsreg(info->zs_channel, 5, (info->curregs[5] | SND_BRK));
  1430. schedule_timeout(duration);
  1431. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1432. sti();
  1433. }
  1435. static int zs_ioctl(struct tty_struct *tty, struct file * file,
  1436.     unsigned int cmd, unsigned long arg)
  1437. {
  1438. struct sun_serial * info = (struct sun_serial *) tty->driver_data;
  1439. int retval;
  1441. if (serial_paranoia_check(info, tty->device, "zs_ioctl"))
  1442. return -ENODEV;
  1444. if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  1445.     (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
  1446.     (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
  1447. if (tty->flags & (1 << TTY_IO_ERROR))
  1448.     return -EIO;
  1449. }
  1451. switch (cmd) {
  1452. case TCSBRK: /* SVID version: non-zero arg --> no break */
  1453. retval = tty_check_change(tty);
  1454. if (retval)
  1455. return retval;
  1456. tty_wait_until_sent(tty, 0);
  1457. if (!arg)
  1458. send_break(info, HZ/4); /* 1/4 second */
  1459. return 0;
  1460. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1461. retval = tty_check_change(tty);
  1462. if (retval)
  1463. return retval;
  1464. tty_wait_until_sent(tty, 0);
  1465. send_break(info, arg ? arg*(HZ/10) : HZ/4);
  1466. return 0;
  1467. case TIOCGSOFTCAR:
  1468. if (put_user(C_CLOCAL(tty) ? 1 : 0,
  1469.      (unsigned long *) arg))
  1470. return -EFAULT;
  1471. return 0;
  1472. case TIOCSSOFTCAR:
  1473. if (get_user(arg, (unsigned long *) arg))
  1474. return -EFAULT;
  1475. tty->termios->c_cflag =
  1476. ((tty->termios->c_cflag & ~CLOCAL) |
  1477.  (arg ? CLOCAL : 0));
  1478. return 0;
  1479. case TIOCMGET:
  1480. return get_modem_info(info, (unsigned int *) arg);
  1481. case TIOCMBIS:
  1482. case TIOCMBIC:
  1483. case TIOCMSET:
  1484. return set_modem_info(info, cmd, (unsigned int *) arg);
  1485. case TIOCGSERIAL:
  1486. return get_serial_info(info,
  1487.        (struct serial_struct *) arg);
  1488. case TIOCSSERIAL:
  1489. return set_serial_info(info,
  1490.        (struct serial_struct *) arg);
  1491. case TIOCSERGETLSR: /* Get line status register */
  1492. return get_lsr_info(info, (unsigned int *) arg);
  1494. case TIOCSERGSTRUCT:
  1495. if (copy_to_user((struct sun_serial *) arg,
  1496.     info, sizeof(struct sun_serial)))
  1497. return -EFAULT;
  1498. return 0;
  1500. default:
  1501. return -ENOIOCTLCMD;
  1502. }
  1503. return 0;
  1504. }
  1506. static void zs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  1507. {
  1508. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1510. if (tty->termios->c_cflag == old_termios->c_cflag)
  1511. return;
  1513. change_speed(info);
  1515. if ((old_termios->c_cflag & CRTSCTS) &&
  1516.     !(tty->termios->c_cflag & CRTSCTS)) {
  1517. tty->hw_stopped = 0;
  1518. zs_start(tty);
  1519. }
  1520. }
  1522. /*
  1523.  * ------------------------------------------------------------
  1524.  * zs_close()
  1525.  * 
  1526.  * This routine is called when the serial port gets closed.  First, we
  1527.  * wait for the last remaining data to be sent.  Then, we unlink its
  1528.  * ZILOG structure from the interrupt chain if necessary, and we free
  1529.  * that IRQ if nothing is left in the chain.
  1530.  * ------------------------------------------------------------
  1531.  */
  1532. static void zs_close(struct tty_struct *tty, struct file * filp)
  1533. {
  1534. struct sun_serial * info = (struct sun_serial *) tty->driver_data;
  1535. unsigned long flags;
  1537. if (!info || serial_paranoia_check(info, tty->device, "zs_close"))
  1538. return;
  1540. save_flags(flags); cli();
  1542. if (tty_hung_up_p(filp)) {
  1543. restore_flags(flags);
  1544. return;
  1545. }
  1547. #ifdef SERIAL_DEBUG_OPEN
  1548. printk("zs_close tty-%d, count = %dn", info->line, info->count);
  1549. #endif
  1550. if ((tty->count == 1) && (info->count != 1)) {
  1551. /*
  1552.  * Uh, oh.  tty->count is 1, which means that the tty
  1553.  * structure will be freed.  Info->count should always
  1554.  * be one in these conditions.  If it's greater than
  1555.  * one, we've got real problems, since it means the
  1556.  * serial port won't be shutdown.
  1557.  */
  1558. printk("zs_close: bad serial port count; tty->count is 1, "
  1559.        "info->count is %dn", info->count);
  1560. info->count = 1;
  1561. }
  1562. if (--info->count < 0) {
  1563. printk("zs_close: bad serial port count for ttys%d: %dn",
  1564.        info->line, info->count);
  1565. info->count = 0;
  1566. }
  1567. if (info->count) {
  1568. restore_flags(flags);
  1569. return;
  1570. }
  1571. info->flags |= ZILOG_CLOSING;
  1572. /*
  1573.  * Save the termios structure, since this port may have
  1574.  * separate termios for callout and dialin.
  1575.  */
  1576. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1577. info->normal_termios = *tty->termios;
  1578. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1579. info->callout_termios = *tty->termios;
  1580. /*
  1581.  * Now we wait for the transmit buffer to clear; and we notify 
  1582.  * the line discipline to only process XON/XOFF characters.
  1583.  */
  1584. tty->closing = 1;
  1585. if (info->closing_wait != ZILOG_CLOSING_WAIT_NONE)
  1586. tty_wait_until_sent(tty, info->closing_wait);
  1587. /*
  1588.  * At this point we stop accepting input.  To do this, we
  1589.  * disable the receive line status interrupts, and tell the
  1590.  * interrupt driver to stop checking the data ready bit in the
  1591.  * line status register.
  1592.  */
  1593. /** if (!info->iscons) ... **/
  1594. info->curregs[3] &= ~RxENAB;
  1595. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  1596. info->curregs[1] &= ~(RxINT_MASK);
  1597. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1598. ZS_CLEARFIFO(info->zs_channel);
  1600. shutdown(info);
  1601. if (tty->driver.flush_buffer)
  1602. tty->driver.flush_buffer(tty);
  1603. if (tty->ldisc.flush_buffer)
  1604. tty->ldisc.flush_buffer(tty);
  1605. tty->closing = 0;
  1606. info->event = 0;
  1607. info->tty = 0;
  1608. if (tty->ldisc.num != ldiscs[N_TTY].num) {
  1609. if (tty->ldisc.close)
  1610. (tty->ldisc.close)(tty);
  1611. tty->ldisc = ldiscs[N_TTY];
  1612. tty->termios->c_line = N_TTY;
  1613. if (tty->ldisc.open)
  1614. (tty->ldisc.open)(tty);
  1615. }
  1616. if (info->blocked_open) {
  1617. if (info->close_delay) {
  1618. current->state = TASK_INTERRUPTIBLE;
  1619. schedule_timeout(info->close_delay);
  1620. }
  1621. wake_up_interruptible(&info->open_wait);
  1622. }
  1623. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE|
  1624.  ZILOG_CLOSING);
  1625. wake_up_interruptible(&info->close_wait);
  1626. #ifdef SERIAL_DEBUG_OPEN
  1627. printk("zs_close tty-%d exiting, count = %dn", info->line, info->count);
  1628. #endif
  1629. restore_flags(flags);
  1630. }
  1632. /*
  1633.  * zs_hangup() --- called by tty_hangup() when a hangup is signaled.
  1634.  */
  1635. void zs_hangup(struct tty_struct *tty)
  1636. {
  1637. struct sun_serial * info = (struct sun_serial *) tty->driver_data;
  1639. if (serial_paranoia_check(info, tty->device, "zs_hangup"))
  1640. return;
  1642. if (info->is_cons)
  1643. return;
  1645. #ifdef SERIAL_DEBUG_OPEN
  1646. printk("zs_hangup<%p: tty-%d, count = %d byen",
  1647. __builtin_return_address(0), info->line, info->count);
  1648. #endif
  1650. zs_flush_buffer(tty);
  1651. shutdown(info);
  1652. info->event = 0;
  1653. info->count = 0;
  1654. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE);
  1655. info->tty = 0;
  1656. wake_up_interruptible(&info->open_wait);
  1657. }
  1659. /*
  1660.  *
  1661.  * line_info - returns information about each channel
  1662.  *
  1663.  */
  1664. static inline int line_info(char *buf, struct sun_serial *info)
  1665. {
  1666. unsigned char status;
  1667. char stat_buf[30];
  1668. int ret;
  1670. ret = sprintf(buf, "%d: uart:Zilog8530 port:%x irq:%d",
  1671. info->line, info->port, info->irq);
  1673. cli();
  1674. status = sbus_readb(&info->zs_channel->control);
  1675. ZSDELAY();
  1676. ZSLOG(REGCTRL, status, 0);
  1677. sti();
  1679. stat_buf[0] = 0;
  1680. stat_buf[1] = 0;
  1681. if (info->curregs[5] & RTS)
  1682. strcat(stat_buf, "|RTS");
  1683. if (status & CTS)
  1684. strcat(stat_buf, "|CTS");
  1685. if (info->curregs[5] & DTR)
  1686. strcat(stat_buf, "|DTR");
  1687. if (status & SYNC)
  1688. strcat(stat_buf, "|DSR");
  1689. if (status & DCD)
  1690. strcat(stat_buf, "|CD");
  1692. ret += sprintf(buf + ret, " baud:%d %sn", info->zs_baud, stat_buf + 1);
  1693. return ret;
  1694. }
  1696. /*
  1697.  *
  1698.  * zs_read_proc() - called when /proc/tty/driver/serial is read.
  1699.  *
  1700.  */
  1701. int zs_read_proc(char *page, char **start, off_t off, int count,
  1702.                  int *eof, void *data)
  1703. {
  1704. char *revision = "$Revision: 1.68.2.2 $";
  1705. char *version, *p;
  1706. int i, len = 0, l;
  1707. off_t begin = 0;
  1709. version = strchr(revision, ' ');
  1710. p = strchr(++version, ' ');
  1711. *p = '';
  1712. len += sprintf(page, "serinfo:1.0 driver:%sn", version);
  1713. *p = ' ';
  1715. for (i = 0; i < NUM_CHANNELS && len < 4000; i++) {
  1716. l = line_info(page + len, &zs_soft[i]);
  1717. len += l;
  1718. if (len+begin > off+count)
  1719. goto done;
  1720. if (len+begin < off) {
  1721. begin += len;
  1722. len = 0;
  1723. }
  1724. }
  1726. *eof = 1;
  1727. done:
  1728. if (off >= len+begin)
  1729. return 0;
  1730. *start = page + (off-begin);
  1731. return ((count < begin+len-off) ? count : begin+len-off);
  1732. }
  1734. /*
  1735.  * ------------------------------------------------------------
  1736.  * zs_open() and friends
  1737.  * ------------------------------------------------------------
  1738.  */
  1739. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1740.    struct sun_serial *info)
  1741. {
  1742. DECLARE_WAITQUEUE(wait, current);
  1743. int retval, do_clocal = 0;
  1744. unsigned char r0;
  1746. /*
  1747.  * If the device is in the middle of being closed, then block
  1748.  * until it's done, and then try again.
  1749.  */
  1750. if (info->flags & ZILOG_CLOSING) {
  1751. interruptible_sleep_on(&info->close_wait);
  1752. #ifdef SERIAL_DO_RESTART
  1753. if (info->flags & ZILOG_HUP_NOTIFY)
  1754. return -EAGAIN;
  1755. else
  1756. return -ERESTARTSYS;
  1757. #else
  1758. return -EAGAIN;
  1759. #endif
  1760. }
  1762. /*
  1763.  * If this is a callout device, then just make sure the normal
  1764.  * device isn't being used.
  1765.  */
  1766. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1767. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1768. return -EBUSY;
  1769. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1770.     (info->flags & ZILOG_SESSION_LOCKOUT) &&
  1771.     (info->session != current->session))
  1772.     return -EBUSY;
  1773. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1774.     (info->flags & ZILOG_PGRP_LOCKOUT) &&
  1775.     (info->pgrp != current->pgrp))
  1776.     return -EBUSY;
  1777. info->flags |= ZILOG_CALLOUT_ACTIVE;
  1778. return 0;
  1779. }
  1781. /*
  1782.  * If non-blocking mode is set, or the port is not enabled,
  1783.  * then make the check up front and then exit.
  1784.  */
  1785. if ((filp->f_flags & O_NONBLOCK) ||
  1786.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1787. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1788. return -EBUSY;
  1789. info->flags |= ZILOG_NORMAL_ACTIVE;
  1790. return 0;
  1791. }
  1793. if (info->flags & ZILOG_CALLOUT_ACTIVE) {
  1794. if (info->normal_termios.c_cflag & CLOCAL)
  1795. do_clocal = 1;
  1796. } else {
  1797. if (tty->termios->c_cflag & CLOCAL)
  1798. do_clocal = 1;
  1799. }
  1801. /*
  1802.  * Block waiting for the carrier detect and the line to become
  1803.  * free (i.e., not in use by the callout).  While we are in
  1804.  * this loop, info->count is dropped by one, so that
  1805.  * zs_close() knows when to free things.  We restore it upon
  1806.  * exit, either normal or abnormal.
  1807.  */
  1808. retval = 0;
  1809. add_wait_queue(&info->open_wait, &wait);
  1810. #ifdef SERIAL_DEBUG_OPEN
  1811. printk("block_til_ready before block: ttys%d, count = %dn",
  1812.        info->line, info->count);
  1813. #endif
  1814. cli();
  1815. if(!tty_hung_up_p(filp))
  1816. info->count--;
  1817. sti();
  1818. info->blocked_open++;
  1819. while (1) {
  1820. cli();
  1821. if (!(info->flags & ZILOG_CALLOUT_ACTIVE))
  1822. zs_rtsdtr(info, 1);
  1823. sti();
  1824. set_current_state(TASK_INTERRUPTIBLE);
  1825. if (tty_hung_up_p(filp) ||
  1826.     !(info->flags & ZILOG_INITIALIZED)) {
  1827. #ifdef SERIAL_DEBUG_OPEN
  1828. printk("block_til_ready hup-ed: ttys%d, count = %dn",
  1829. info->line, info->count);
  1830. #endif
  1831. #ifdef SERIAL_DO_RESTART
  1832. if (info->flags & ZILOG_HUP_NOTIFY)
  1833. retval = -EAGAIN;
  1834. else
  1835. retval = -ERESTARTSYS;
  1836. #else
  1837. retval = -EAGAIN;
  1838. #endif
  1839. break;
  1840. }
  1842. cli();
  1843. r0 = read_zsreg(info->zs_channel, R0);
  1844. sti();
  1845. if (!(info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1846.     !(info->flags & ZILOG_CLOSING) &&
  1847.     (do_clocal || (DCD & r0)))
  1848. break;
  1849. if (signal_pending(current)) {
  1850. retval = -ERESTARTSYS;
  1851. break;
  1852. }
  1853. #ifdef SERIAL_DEBUG_OPEN
  1854. printk("block_til_ready blocking: ttys%d, count = %dn",
  1855.        info->line, info->count);
  1856. #endif
  1857. schedule();
  1858. }
  1859. current->state = TASK_RUNNING;
  1860. remove_wait_queue(&info->open_wait, &wait);
  1861. if (!tty_hung_up_p(filp))
  1862. info->count++;
  1863. info->blocked_open--;
  1864. #ifdef SERIAL_DEBUG_OPEN
  1865. printk("block_til_ready after blocking: ttys%d, count = %dn",
  1866.        info->line, info->count);
  1867. #endif
  1868. if (retval)
  1869. return retval;
  1870. info->flags |= ZILOG_NORMAL_ACTIVE;
  1871. return 0;
  1872. }
  1874. /*
  1875.  * This routine is called whenever a serial port is opened.  It
  1876.  * enables interrupts for a serial port, linking in its ZILOG structure into
  1877.  * the IRQ chain.   It also performs the serial-specific
  1878.  * initialization for the tty structure.
  1879.  */
  1880. int zs_open(struct tty_struct *tty, struct file * filp)
  1881. {
  1882. struct sun_serial *info;
  1883. int retval, line;
  1885. line = MINOR(tty->device) - tty->driver.minor_start;
  1887. /* The zilog lines for the mouse/keyboard must be
  1888.  * opened using their respective drivers.
  1889.  */
  1890. if ((line < 0) || (line >= NUM_CHANNELS))
  1891. return -ENODEV;
  1892. if((line == KEYBOARD_LINE) || (line == MOUSE_LINE))
  1893. return -ENODEV;
  1894. info = zs_soft + line;
  1895. /* Is the kgdb running over this line? */
  1896. if (info->kgdb_channel)
  1897. return -ENODEV;
  1898. if (serial_paranoia_check(info, tty->device, "zs_open"))
  1899. return -ENODEV;
  1900. #ifdef SERIAL_DEBUG_OPEN
  1901. printk("zs_open %s%d, count = %dn", tty->driver.name, info->line,
  1902.        info->count);
  1903. #endif
  1904. if (info->tty != 0 && info->tty != tty) {
  1905. /* Never happen? */
  1906. printk("zs_open %s%d, tty overwrite.n", tty->driver.name, info->line);
  1907. return -EBUSY;
  1908. }
  1910. if (!tmp_buf) {
  1911. unsigned long page = get_free_page(GFP_KERNEL);
  1912. if (!page)
  1913. return -ENOMEM;
  1914. if (tmp_buf)
  1915. free_page(page);
  1916. else
  1917. tmp_buf = (unsigned char *) page;
  1918. }
  1920. info->count++;
  1921. tty->driver_data = info;
  1922. info->tty = tty;
  1924. /*
  1925.  * Start up serial port
  1926.  */
  1927. retval = startup(info);
  1928. if (retval)
  1929. return retval;
  1931. retval = block_til_ready(tty, filp, info);
  1932. if (retval) {
  1933. #ifdef SERIAL_DEBUG_OPEN
  1934. printk("zs_open returning after block_til_ready with %dn",
  1935.        retval);
  1936. #endif
  1937. return retval;
  1938. }
  1940. if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
  1941. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1942. *tty->termios = info->normal_termios;
  1943. else 
  1944. *tty->termios = info->callout_termios;
  1945. change_speed(info);
  1946. }
  1948. #ifdef CONFIG_SERIAL_CONSOLE
  1949. if (zs_console.cflag && zs_console.index == line) {
  1950. tty->termios->c_cflag = zs_console.cflag;
  1951. zs_console.cflag = 0;
  1952. change_speed(info);
  1953. }
  1954. #endif
  1956. info->session = current->session;
  1957. info->pgrp = current->pgrp;
  1959. #ifdef SERIAL_DEBUG_OPEN
  1960. printk("zs_open ttys%d successful...", info->line);
  1961. #endif
  1962. return 0;
  1963. }
  1965. /* Finally, routines used to initialize the serial driver. */
  1967. static void show_serial_version(void)
  1968. {
  1969. char *revision = "$Revision: 1.68.2.2 $";
  1970. char *version, *p;
  1972. version = strchr(revision, ' ');
  1973. p = strchr(++version, ' ');
  1974. *p = '';
  1975. printk("Sparc Zilog8530 serial driver version %sn", version);
  1976. *p = ' ';
  1977. }
  1979. /* Probe the PROM for the request zs chip number.
  1980.  *
  1981.  * Note: The Sun Voyager shows two addresses and two intr for it's
  1982.  *       Zilogs, what the second does, I don't know. It does work
  1983.  *       with using only the first number of each property.  Also
  1984.  *       we have a special version for sun4u.
  1985.  */
  1986. #ifdef __sparc_v9__
  1987. static struct sun_zslayout * __init get_zs(int chip)
  1988. {
  1989. unsigned int vaddr[2] = { 0, 0 };
  1990. unsigned long mapped_addr = 0;
  1991. int busnode, seen, zsnode, sun4u_ino;
  1992. static int irq = 0;
  1994. if(chip < 0 || chip >= NUM_SERIAL) {
  1995. prom_printf("get_zs bogon zs chip number");
  1996. prom_halt();
  1997. }
  1999. if(central_bus)
  2000. busnode = central_bus->child->prom_node;
  2001. else
  2002. busnode = prom_searchsiblings(prom_getchild(prom_root_node), "sbus");
  2003. if(busnode == 0 || busnode == -1) {
  2004. prom_printf("get_zs: no zs bus to search");
  2005. prom_halt();
  2006. }
  2007. zsnode = prom_getchild(busnode);
  2008. seen = 0;
  2009. while(zsnode) {
  2010. int slave;
  2012. zsnode = prom_searchsiblings(zsnode, "zs");
  2013. slave = prom_getintdefault(zsnode, "slave", -1);
  2014. if((slave == chip) || (seen == chip)) {
  2015. int len = prom_getproperty(zsnode, "address",
  2016.    (void *) vaddr, sizeof(vaddr));
  2018. if(len == -1 || central_bus != NULL) {
  2019. struct sbus_bus *sbus = NULL;
  2020. struct sbus_dev *sdev = NULL;
  2022. /* "address" property is not guarenteed,
  2023.  * everything in I/O is implicitly mapped
  2024.  * anyways by our clever TLB miss handling
  2025.  * scheme, so don't fail here.  -DaveM
  2026.  */
  2027. if (central_bus == NULL) {
  2028. for_each_sbus(sbus) {
  2029. for_each_sbusdev(sdev, sbus) {
  2030. if (sdev->prom_node == zsnode)
  2031. goto found;
  2032. }
  2033. }
  2034. }
  2035. found:
  2036. if (sdev == NULL && central_bus == NULL)
  2037. prom_halt();
  2038. if (central_bus == NULL) {
  2039. mapped_addr =
  2040.     sbus_ioremap(&sdev->resource[0], 0,
  2041.  PAGE_SIZE, "Zilog Registers");
  2042. } else {
  2043. struct linux_prom_registers zsregs[1];
  2044. int err;
  2046. err = prom_getproperty(zsnode, "reg",
  2047.        (char *)&zsregs[0],
  2048.        sizeof(zsregs));
  2049. if (err == -1) {
  2050. prom_printf("ZS: Cannot map Zilog regs.n");
  2051. prom_halt();
  2052. }
  2053. apply_fhc_ranges(central_bus->child, &zsregs[0], 1);
  2054. apply_central_ranges(central_bus, &zsregs[0], 1);
  2055. mapped_addr =
  2056. ((((u64)zsregs[0].which_io)<<32UL)|
  2057.  ((u64)zsregs[0].phys_addr));
  2058. }
  2059. } else if(len % sizeof(unsigned int)) {
  2060. prom_printf("WHOOPS:  proplen for %s "
  2061.     "was %d, need multiple of "
  2062.     "%dn", "address", len,
  2063.     sizeof(unsigned int));
  2064. panic("zilog: address property");
  2065. }
  2066. zs_nodes[chip] = zsnode;
  2067. len = prom_getproperty(zsnode, "interrupts",
  2068.        (char *) &sun4u_ino,
  2069.        (sizeof(sun4u_ino)));
  2070. if(!irq) {
  2071. if (central_bus) {
  2072. unsigned long iclr, imap;
  2074. iclr = central_bus->child->fhc_regs.uregs + FHC_UREGS_ICLR;
  2075. imap = central_bus->child->fhc_regs.uregs + FHC_UREGS_IMAP;
  2076. irq = zilog_irq = build_irq(12, 0, iclr, imap);
  2077. } else {
  2078. irq = zilog_irq = 
  2079. sbus_build_irq(sbus_root, sun4u_ino);
  2080. }
  2081. }
  2082. break;
  2083. }
  2084. zsnode = prom_getsibling(zsnode);
  2085. seen++;
  2086. }
  2087. if(!zsnode)
  2088. panic("get_zs: whee chip not found");
  2089. if(!vaddr[0] && !mapped_addr)
  2090. panic("get_zs: whee no serial chip mappable");
  2091. if (mapped_addr != 0) {
  2092. return (struct sun_zslayout *) mapped_addr;
  2093. } else {
  2094. return (struct sun_zslayout *) prom_virt_to_phys((unsigned long)vaddr[0], 0);
  2095. }
  2096. }
  2097. #else /* !(__sparc_v9__) */
  2098. static struct sun_zslayout * __init get_zs(int chip)
  2099. {
  2100. struct linux_prom_irqs tmp_irq[2];
  2101. unsigned int paddr = 0;
  2102. unsigned int vaddr[2] = { 0, 0 };
  2103. int zsnode, tmpnode, iospace, slave, len;
  2104. int cpunode = 0, bbnode = 0;
  2105. static int irq = 0;
  2106. int chipid = chip;
  2108. iospace = 0;
  2109. if(chip < 0 || chip >= NUM_SERIAL)
  2110. panic("get_zs bogon zs chip number");
  2112. if(sparc_cpu_model == sun4) {
  2113. struct resource dummy_resource;
  2115. /* Grrr, these have to be hardcoded aieee */
  2116. switch(chip) {
  2117. case 0:
  2118. paddr = 0xf1000000;
  2119. break;
  2120. case 1:
  2121. paddr = 0xf0000000;
  2122. break;
  2123. };
  2124. iospace = 0;
  2125. zs_nodes[chip] = 0;
  2126. if(!irq)
  2127. zilog_irq = irq = 12;
  2128. dummy_resource.start = paddr;
  2129. dummy_resource.end = paddr + 8 - 1;
  2130. dummy_resource.flags = IORESOURCE_IO;
  2131. vaddr[0] = sbus_ioremap(&dummy_resource, 0,
  2132. 8, "Zilog Serial");
  2133. } else {
  2134. /* Can use the prom for other machine types */
  2135. zsnode = prom_getchild(prom_root_node);
  2136. if (sparc_cpu_model == sun4d) {
  2137. int no = 0;
  2139. tmpnode = zsnode;
  2140. zsnode = 0;
  2141. bbnode = 0;
  2142. while (tmpnode && (tmpnode = prom_searchsiblings(tmpnode, "cpu-unit"))) {
  2143. bbnode = prom_getchild(tmpnode);
  2144. if (bbnode && (bbnode = prom_searchsiblings(bbnode, "bootbus"))) {
  2145. if (no == (chip >> 1)) {
  2146. cpunode = tmpnode;
  2147. zsnode = prom_getchild(bbnode);
  2148. chipid = (chip & 1);
  2149. break;
  2150. }
  2151. no++;
  2152. }
  2153. tmpnode = prom_getsibling(tmpnode);
  2154. }
  2155. if (!tmpnode)
  2156. panic ("get_zs: couldn't find %dth bootbusn", chip >> 1);
  2157. } else {
  2158. tmpnode = prom_searchsiblings(zsnode, "obio");
  2159. if(tmpnode)
  2160. zsnode = prom_getchild(tmpnode);
  2161. }
  2162. if(!zsnode)
  2163. panic("get_zs no zs serial prom node");
  2164. while(zsnode) {
  2165. zsnode = prom_searchsiblings(zsnode, "zs");
  2166. slave = prom_getintdefault(zsnode, "slave", -1);
  2167. if(slave == chipid) {
  2168. /* The one we want */
  2169. if (sparc_cpu_model != sun4d) {
  2170. len = prom_getproperty(zsnode, "address",
  2171.        (void *) vaddr,
  2172.        sizeof(vaddr));
  2173.          if (len % sizeof(unsigned int)) {
  2174. prom_printf("WHOOPS:  proplen for %s "
  2175. "was %d, need multiple of "
  2176. "%dn", "address", len,
  2177. sizeof(unsigned int));
  2178. panic("zilog: address property");
  2179. }
  2180. } else {
  2181. /* On sun4d don't have address property :( */
  2182. struct linux_prom_registers zsreg[4];
  2183. struct resource res;
  2185. if (prom_getproperty(zsnode, "reg", (char *)zsreg, sizeof(zsreg)) == -1) {
  2186. prom_printf ("Cannot map zs regsn");
  2187. prom_halt();
  2188. }
  2189. prom_apply_generic_ranges(bbnode, cpunode, zsreg, 1);
  2190. res.start = zsreg[0].phys_addr;
  2191. res.end = res.start + 8 - 1;
  2192. res.flags = zsreg[0].which_io | IORESOURCE_IO;
  2193. vaddr[0] = sbus_ioremap(&res, 0,
  2194. 8, "Zilog Serial");
  2195. }
  2196. zs_nodes[chip] = zsnode;
  2197. len = prom_getproperty(zsnode, "intr",
  2198.        (char *) tmp_irq,
  2199.        sizeof(tmp_irq));
  2200. if (len % sizeof(struct linux_prom_irqs)) {
  2201. prom_printf(
  2202.       "WHOOPS:  proplen for %s "
  2203.       "was %d, need multiple of "
  2204.       "%dn", "intr", len,
  2205.       sizeof(struct linux_prom_irqs));
  2206. panic("zilog: intr property");
  2207. }
  2208. if(!irq) {
  2209. irq = zilog_irq = tmp_irq[0].pri;
  2210. } else {
  2211. if(tmp_irq[0].pri != irq)
  2212. panic("zilog: bogon irqs");
  2213. }
  2214. break;
  2215. }
  2216. zsnode = prom_getsibling(zsnode);
  2217. }
  2218. if(!zsnode)
  2219. panic("get_zs whee chip not found");
  2220. }
  2221. if(!vaddr[0])
  2222. panic("get_zs whee no serial chip mappable");
  2224. return (struct sun_zslayout *)(unsigned long) vaddr[0];
  2225. }
  2226. #endif
  2227. /* This is for the auto baud rate detection in the mouse driver. */
  2228. void zs_change_mouse_baud(int newbaud)
  2229. {
  2230. int channel = MOUSE_LINE;
  2231. int brg;
  2233. zs_soft[channel].zs_baud = newbaud;
  2234. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2235.  (ZS_CLOCK / zs_soft[channel].clk_divisor));
  2236. write_zsreg(zs_soft[channel].zs_channel, R12, (brg & 0xff));
  2237. write_zsreg(zs_soft[channel].zs_channel, R13, ((brg >> 8) & 0xff));
  2238. }
  2240. void __init zs_init_alloc_failure(const char *table_name)
  2241. {
  2242. prom_printf("zs_probe: Cannot alloc %s.n", table_name);
  2243. prom_halt();
  2244. }
  2246. void * __init zs_alloc_bootmem(unsigned long size)
  2247. {
  2248. void *ret;
  2250. ret = __alloc_bootmem(size, SMP_CACHE_BYTES, 0UL);
  2251. if (ret != NULL)
  2252. memset(ret, 0, size);
  2254. return ret;
  2255. }
  2257. void __init zs_alloc_tables(void)
  2258. {
  2259. zs_chips = (struct sun_zslayout **)
  2260. zs_alloc_bootmem(NUM_SERIAL * sizeof(struct sun_zslayout *));
  2261. if (zs_chips == NULL)
  2262. zs_init_alloc_failure("zs_chips");
  2263. zs_channels = (struct sun_zschannel **)
  2264. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct sun_zschannel *));
  2265. if (zs_channels == NULL)
  2266. zs_init_alloc_failure("zs_channels");
  2267. zs_nodes = (int *)
  2268. zs_alloc_bootmem(NUM_SERIAL * sizeof(int));
  2269. if (zs_nodes == NULL)
  2270. zs_init_alloc_failure("zs_nodes");
  2271. zs_soft = (struct sun_serial *)
  2272. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct sun_serial));
  2273. if (zs_soft == NULL)
  2274. zs_init_alloc_failure("zs_soft");
  2275. zs_ttys = (struct tty_struct *)
  2276. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct tty_struct));
  2277. if (zs_ttys == NULL)
  2278. zs_init_alloc_failure("zs_ttys");
  2279. serial_table = (struct tty_struct **)
  2280. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct tty_struct *));
  2281. if (serial_table == NULL)
  2282. zs_init_alloc_failure("serial_table");
  2283. serial_termios = (struct termios **)
  2284. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct termios *));
  2285. if (serial_termios == NULL)
  2286. zs_init_alloc_failure("serial_termios");
  2287. serial_termios_locked = (struct termios **)
  2288. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct termios *));
  2289. if (serial_termios_locked == NULL)
  2290. zs_init_alloc_failure("serial_termios_locked");
  2291. }
  2293. int __init zs_probe(void)
  2294. {
  2295. int node;
  2297. if(sparc_cpu_model == sun4)
  2298. goto no_probe;
  2300. NUM_SERIAL = 0;
  2302. node = prom_getchild(prom_root_node);
  2303. if (sparc_cpu_model == sun4d) {
  2304. int bbnode;
  2306. while (node && (node = prom_searchsiblings(node, "cpu-unit"))) {
  2307. bbnode = prom_getchild(node);
  2308. if (bbnode && prom_searchsiblings(bbnode, "bootbus"))
  2309. NUM_SERIAL += 2;
  2310. node = prom_getsibling(node);
  2311. }
  2312. goto no_probe;
  2313. }
  2314. #ifdef __sparc_v9__
  2315. else if (sparc_cpu_model == sun4u) {
  2316. int central_node;
  2318. /* Central bus zilogs must be checked for first,
  2319.  * since Enterprise boxes might have SBUSes as well.
  2320.  */
  2321. central_node = prom_finddevice("/central");
  2322. if(central_node != 0 && central_node != -1)
  2323. node = prom_searchsiblings(prom_getchild(central_node), "fhc");
  2324. else
  2325. node = prom_searchsiblings(node, "sbus");
  2326. if(node != 0 && node != -1)
  2327. node = prom_getchild(node);
  2328. if(node == 0 || node == -1)
  2329. return -ENODEV;
  2330. }
  2331. #endif /* __sparc_v9__ */
  2332. else {
  2333. node = prom_searchsiblings(node, "obio");
  2334. if(node)
  2335. node = prom_getchild(node);
  2336. NUM_SERIAL = 2;
  2337. goto no_probe;
  2338. }
  2340. node = prom_searchsiblings(node, "zs");
  2341. if (!node)
  2342. return -ENODEV;
  2344. NUM_SERIAL = 2;
  2346. no_probe:
  2347. zs_alloc_tables();
  2349. /* Fill in rs_ops struct... */
  2350. #ifdef CONFIG_SERIAL_CONSOLE
  2351. sunserial_setinitfunc(zs_console_init);
  2352. #endif
  2353. sunserial_setinitfunc(zs_init);
  2354. rs_ops.rs_kgdb_hook = zs_kgdb_hook;
  2355. rs_ops.rs_change_mouse_baud = zs_change_mouse_baud;
  2357. sunkbd_setinitfunc(sun_kbd_init);
  2358. kbd_ops.compute_shiftstate = sun_compute_shiftstate;
  2359. kbd_ops.setledstate = sun_setledstate;
  2360. kbd_ops.getledstate = sun_getledstate;
  2361. kbd_ops.setkeycode = sun_setkeycode;
  2362. kbd_ops.getkeycode = sun_getkeycode;
  2363. #if defined(__sparc_v9__) && defined(CONFIG_PCI)
  2364. sunkbd_install_keymaps(sun_key_maps, sun_keymap_count,
  2365.        sun_func_buf, sun_func_table,
  2366.        sun_funcbufsize, sun_funcbufleft,
  2367.        sun_accent_table, sun_accent_table_size);
  2368. #endif
  2369. return 0;
  2370. }
  2372. static inline void zs_prepare(void)
  2373. {
  2374. int channel, chip;
  2375. unsigned long flags;
  2377. if (!NUM_SERIAL)
  2378. return;
  2380. save_and_cli(flags);
  2382. /* Set up our interrupt linked list */
  2383. zs_chain = &zs_soft[0];
  2384. for(channel = 0; channel < NUM_CHANNELS - 1; channel++) {
  2385. zs_soft[channel].zs_next = &zs_soft[channel + 1];
  2386. zs_soft[channel].line = channel;
  2387. }
  2388. zs_soft[channel].zs_next = 0;
  2390. /* Initialize Softinfo */
  2391. for(chip = 0; chip < NUM_SERIAL; chip++) {
  2392. /* If we are doing kgdb over one of the channels on
  2393.  * chip zero, kgdb_channel will be set to 1 by the
  2394.  * zs_kgdb_hook() routine below.
  2395.  */
  2396. if(!zs_chips[chip]) {
  2397. zs_chips[chip] = get_zs(chip);
  2398. /* Two channels per chip */
  2399. zs_channels[(chip*2)] = &zs_chips[chip]->channelA;
  2400. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelB;
  2401. zs_soft[(chip*2)].kgdb_channel = 0;
  2402. zs_soft[(chip*2)+1].kgdb_channel = 0;
  2403. }
  2405. /* First, set up channel A on this chip. */
  2406. channel = chip * 2;
  2407. zs_soft[channel].zs_channel = zs_channels[channel];
  2408. zs_soft[channel].change_needed = 0;
  2409. zs_soft[channel].clk_divisor = 16;
  2410. zs_soft[channel].cons_keyb = 0;
  2411. zs_soft[channel].cons_mouse = 0;
  2412. zs_soft[channel].channelA = 1;
  2414. /* Now, channel B */
  2415. channel++;
  2416. zs_soft[channel].zs_channel = zs_channels[channel];
  2417. zs_soft[channel].change_needed = 0;
  2418. zs_soft[channel].clk_divisor = 16;
  2419. zs_soft[channel].cons_keyb = 0;
  2420. zs_soft[channel].cons_mouse = 0;
  2421. zs_soft[channel].channelA = 0;
  2422. }
  2424. restore_flags(flags);
  2425. }
  2427. int __init zs_init(void)
  2428. {
  2429. int channel, brg, i;
  2430. unsigned long flags;
  2431. struct sun_serial *info;
  2432. char dummy;
  2434. /* Setup base handler, and timer table. */
  2435. init_bh(SERIAL_BH, do_serial_bh);
  2437. show_serial_version();
  2439. /* Initialize the tty_driver structure */
  2440. /* SPARC: Not all of this is exactly right for us. */
  2442. memset(&serial_driver, 0, sizeof(struct tty_driver));
  2443. serial_driver.magic = TTY_DRIVER_MAGIC;
  2444. serial_driver.driver_name = "serial";
  2445. #ifdef CONFIG_DEVFS_FS
  2446. serial_driver.name = "tts/%d";
  2447. #else
  2448. serial_driver.name = "ttyS";
  2449. #endif
  2450. serial_driver.major = TTY_MAJOR;
  2451. serial_driver.minor_start = 64;
  2452. serial_driver.num = NUM_CHANNELS;
  2453. serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  2454. serial_driver.subtype = SERIAL_TYPE_NORMAL;
  2455. serial_driver.init_termios = tty_std_termios;
  2456. serial_driver.init_termios.c_cflag =
  2457. B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  2458. serial_driver.flags = TTY_DRIVER_REAL_RAW;
  2459. serial_driver.refcount = &serial_refcount;
  2460. serial_driver.table = serial_table;
  2461. serial_driver.termios = serial_termios;
  2462. serial_driver.termios_locked = serial_termios_locked;
  2464. serial_driver.open = zs_open;
  2465. serial_driver.close = zs_close;
  2466. serial_driver.write = zs_write;
  2467. serial_driver.flush_chars = zs_flush_chars;
  2468. serial_driver.write_room = zs_write_room;
  2469. serial_driver.chars_in_buffer = zs_chars_in_buffer;
  2470. serial_driver.flush_buffer = zs_flush_buffer;
  2471. serial_driver.ioctl = zs_ioctl;
  2472. serial_driver.throttle = zs_throttle;
  2473. serial_driver.unthrottle = zs_unthrottle;
  2474. serial_driver.set_termios = zs_set_termios;
  2475. serial_driver.stop = zs_stop;
  2476. serial_driver.start = zs_start;
  2477. serial_driver.hangup = zs_hangup;
  2479. /* I'm too lazy, someone write versions of this for us. -DaveM */
  2480. /* I just did. :-) -AIB 2001-12-23 */
  2481. serial_driver.read_proc = zs_read_proc;
  2483. /*
  2484.  * The callout device is just like normal device except for
  2485.  * major number and the subtype code.
  2486.  */
  2487. callout_driver = serial_driver;
  2488. callout_driver.name = "cua/%d";
  2489. callout_driver.major = TTYAUX_MAJOR;
  2490. callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  2491. callout_driver.read_proc = 0;
  2492. callout_driver.proc_entry = 0;
  2494. if (tty_register_driver(&serial_driver))
  2495. panic("Couldn't register serial drivern");
  2496. if (tty_register_driver(&callout_driver))
  2497. panic("Couldn't register callout drivern");
  2499. save_flags(flags); cli();
  2501. /* Initialize Softinfo */
  2502. zs_prepare();
  2504. /* Grab IRQ line before poking the chips so we do
  2505.  * not lose any interrupts.
  2506.  */
  2507. if (request_irq(zilog_irq, zs_interrupt, SA_SHIRQ,
  2508. "Zilog8530", zs_chain)) {
  2509. prom_printf("Unable to attach zs intrn");
  2510. prom_halt();
  2511. }
  2513. /* Initialize Hardware */
  2514. for(channel = 0; channel < NUM_CHANNELS; channel++) {
  2515. /* Hardware reset each chip */
  2516. if (!(channel & 1)) {
  2517. write_zsreg(zs_soft[channel].zs_channel, R9, FHWRES);
  2518. ZSDELAY_LONG();
  2519. dummy = read_zsreg(zs_soft[channel].zs_channel, R0);
  2520. }
  2522. if(channel == KEYBOARD_LINE) {
  2523. zs_soft[channel].cons_keyb = 1;
  2524. zs_soft[channel].parity_mask = 0xff;
  2525. zs_kbdchan = zs_soft[channel].zs_channel;
  2527. write_zsreg(zs_soft[channel].zs_channel, R4,
  2528.     (PAR_EVEN | X16CLK | SB1));
  2529. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2530. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2531. write_zsreg(zs_soft[channel].zs_channel, R9, NV);
  2532. write_zsreg(zs_soft[channel].zs_channel, R10, NRZ);
  2533. write_zsreg(zs_soft[channel].zs_channel, R11,
  2534.     (TCBR | RCBR));
  2535. zs_soft[channel].zs_baud = 1200;
  2536. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2537.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2538. write_zsreg(zs_soft[channel].zs_channel, R12,
  2539.     (brg & 0xff));
  2540. write_zsreg(zs_soft[channel].zs_channel, R13,
  2541.     ((brg >> 8) & 0xff));
  2542. write_zsreg(zs_soft[channel].zs_channel, R14, BRSRC);
  2544. /* Enable Rx/Tx, IRQs, and inform kbd driver */
  2545. write_zsreg(zs_soft[channel].zs_channel, R14,
  2546.     (BRSRC | BRENAB));
  2547. write_zsreg(zs_soft[channel].zs_channel, R3,
  2548.     (Rx8 | RxENAB));
  2549. write_zsreg(zs_soft[channel].zs_channel, R5,
  2550.     (Tx8 | TxENAB | DTR | RTS));
  2552. write_zsreg(zs_soft[channel].zs_channel, R15,
  2553.     (DCDIE | CTSIE | TxUIE | BRKIE));
  2554. write_zsreg(zs_soft[channel].zs_channel, R0,
  2555.     RES_EXT_INT);
  2556. write_zsreg(zs_soft[channel].zs_channel, R0,
  2557.     RES_EXT_INT);
  2559. write_zsreg(zs_soft[channel].zs_channel, R1,
  2560.     (EXT_INT_ENAB | INT_ALL_Rx));
  2561. write_zsreg(zs_soft[channel].zs_channel, R9,
  2562.     (NV | MIE));
  2563. ZS_CLEARERR(zs_soft[channel].zs_channel);
  2564. ZS_CLEARFIFO(zs_soft[channel].zs_channel);
  2565. } else if(channel == MOUSE_LINE) {
  2566. zs_soft[channel].cons_mouse = 1;
  2567. zs_soft[channel].parity_mask = 0xff;
  2568. zs_mousechan = zs_soft[channel].zs_channel;
  2570. write_zsreg(zs_soft[channel].zs_channel, R4,
  2571.     (PAR_EVEN | X16CLK | SB1));
  2572. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2573. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2574. write_zsreg(zs_soft[channel].zs_channel, R9, NV);
  2575. write_zsreg(zs_soft[channel].zs_channel, R10, NRZ);
  2576. write_zsreg(zs_soft[channel].zs_channel, R11,
  2577.     (TCBR | RCBR));
  2579. zs_soft[channel].zs_baud = 4800;
  2580. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2581.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2582. write_zsreg(zs_soft[channel].zs_channel, R12,
  2583.     (brg & 0xff));
  2584. write_zsreg(zs_soft[channel].zs_channel, R13,
  2585.     ((brg >> 8) & 0xff));
  2586. write_zsreg(zs_soft[channel].zs_channel, R14, BRSRC);
  2588. /* Enable Rx, IRQs, and inform mouse driver */
  2589. write_zsreg(zs_soft[channel].zs_channel, R14,
  2590.     (BRSRC | BRENAB));
  2591. write_zsreg(zs_soft[channel].zs_channel, R3,
  2592.     (Rx8 | RxENAB));
  2593. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2595. write_zsreg(zs_soft[channel].zs_channel, R15,
  2596.     (DCDIE | CTSIE | TxUIE | BRKIE));
  2597. write_zsreg(zs_soft[channel].zs_channel, R0,
  2598.     RES_EXT_INT);
  2599. write_zsreg(zs_soft[channel].zs_channel, R0,
  2600.     RES_EXT_INT);
  2602. write_zsreg(zs_soft[channel].zs_channel, R1,
  2603.     (EXT_INT_ENAB | INT_ALL_Rx));
  2604. write_zsreg(zs_soft[channel].zs_channel, R9,
  2605.     (NV | MIE));
  2607. sun_mouse_zsinit();
  2608. } else if (zs_soft[channel].is_cons) {
  2609. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2610.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2611. zscons_regs[12] = brg & 0xff;
  2612. zscons_regs[13] = (brg >> 8) & 0xff;
  2614. memcpy(zs_soft[channel].curregs, zscons_regs, sizeof(zscons_regs));
  2615. load_zsregs(&zs_soft[channel], zscons_regs);
  2617. ZS_CLEARERR(zs_soft[channel].zs_channel);
  2618. ZS_CLEARFIFO(zs_soft[channel].zs_channel);
  2619. } else if (zs_soft[channel].kgdb_channel) {
  2620. /* If this is the kgdb line, enable interrupts because
  2621.  * we now want to receive the 'control-c' character
  2622.  * from the client attached to us asynchronously.
  2623.  */
  2624. zs_soft[channel].parity_mask = 0xff;
  2625.          kgdb_chaninit(&zs_soft[channel], 1,
  2626.       zs_soft[channel].zs_baud);
  2627. } else {
  2628. zs_soft[channel].parity_mask = 0xff;
  2629. write_zsreg(zs_soft[channel].zs_channel, R4,
  2630.     (PAR_EVEN | X16CLK | SB1));
  2631. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2632. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2633. write_zsreg(zs_soft[channel].zs_channel, R9, NV);
  2634. write_zsreg(zs_soft[channel].zs_channel, R10, NRZ);
  2635. write_zsreg(zs_soft[channel].zs_channel, R11,
  2636.     (RCBR | TCBR));
  2637. zs_soft[channel].zs_baud = 9600;
  2638. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2639.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2640. write_zsreg(zs_soft[channel].zs_channel, R12,
  2641.     (brg & 0xff));
  2642. write_zsreg(zs_soft[channel].zs_channel, R13,
  2643.     ((brg >> 8) & 0xff));
  2644. write_zsreg(zs_soft[channel].zs_channel, R14, BRSRC);
  2645. write_zsreg(zs_soft[channel].zs_channel, R14,
  2646.     (BRSRC | BRENAB));
  2647. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2648. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2649. write_zsreg(zs_soft[channel].zs_channel, R15, DCDIE);
  2650. write_zsreg(zs_soft[channel].zs_channel, R9, NV | MIE);
  2651. write_zsreg(zs_soft[channel].zs_channel, R0,
  2652.     RES_EXT_INT);
  2653. write_zsreg(zs_soft[channel].zs_channel, R0,
  2654.     RES_EXT_INT);
  2655. }
  2656. }
  2658. for (info = zs_chain, i=0; info; info = info->zs_next, i++) {
  2659. info->magic = SERIAL_MAGIC;
  2660. info->port = (long) info->zs_channel;
  2661. info->line = i;
  2662. info->tty = 0;
  2663. info->irq = zilog_irq;
  2664. info->custom_divisor = 16;
  2665. info->close_delay = 50;
  2666. info->closing_wait = 3000;
  2667. info->x_char = 0;
  2668. info->event = 0;
  2669. info->count = 0;
  2670. info->blocked_open = 0;
  2671. info->tqueue.routine = do_softint;
  2672. info->tqueue.data = info;
  2673. info->tqueue_hangup.routine = do_serial_hangup;
  2674. info->tqueue_hangup.data = info;
  2675. info->callout_termios = callout_driver.init_termios;
  2676. info->normal_termios = serial_driver.init_termios;
  2677. init_waitqueue_head(&info->open_wait);
  2678. init_waitqueue_head(&info->close_wait);
  2679. printk("tty%02d at 0x%04x (irq = %s)", info->line, 
  2680.        info->port, __irq_itoa(info->irq));
  2681. printk(" is a Zilog8530n");
  2682. }
  2684. restore_flags(flags);
  2686. keyboard_zsinit(kbd_put_char);
  2687. return 0;
  2688. }
  2690. /* This is called at boot time to prime the kgdb serial debugging
  2691.  * serial line.  The 'tty_num' argument is 0 for /dev/ttya and 1
  2692.  * for /dev/ttyb which is determined in setup_arch() from the
  2693.  * boot command line flags.
  2694.  */
  2695. static void __init zs_kgdb_hook(int tty_num)
  2696. {
  2697. int chip = 0;
  2699. if(!zs_chips[chip]) {
  2700. zs_chips[chip] = get_zs(chip);
  2701. /* Two channels per chip */
  2702. zs_channels[(chip*2)] = &zs_chips[chip]->channelA;
  2703. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelB;
  2704. }
  2705. zs_soft[tty_num].zs_channel = zs_channels[tty_num];
  2706. zs_kgdbchan = zs_soft[tty_num].zs_channel;
  2707. zs_soft[tty_num].change_needed = 0;
  2708. zs_soft[tty_num].clk_divisor = 16;
  2709. zs_soft[tty_num].zs_baud = 9600;
  2710. zs_soft[tty_num].kgdb_channel = 1;     /* This runs kgdb */
  2711. zs_soft[tty_num ^ 1].kgdb_channel = 0; /* This does not */
  2712. /* Turn on transmitter/receiver at 8-bits/char */
  2713.         kgdb_chaninit(&zs_soft[tty_num], 0, 9600);
  2714.         ZS_CLEARERR(zs_kgdbchan);
  2715.         ZS_CLEARFIFO(zs_kgdbchan);
  2716. }
  2718. #ifdef CONFIG_SERIAL_CONSOLE
  2720. /* This is for console output over ttya/ttyb */
  2721. static void
  2722. zs_console_putchar(struct sun_serial *info, char ch)
  2723. {
  2724. int loops = ZS_PUT_CHAR_MAX_DELAY;
  2725. unsigned long flags;
  2727. if(!info->zs_channel)
  2728. return;
  2730. save_flags(flags); cli();
  2731. zs_put_char(info->zs_channel, ch);
  2732. while (!(read_zsreg(info->zs_channel, R1) & ALL_SNT) && --loops)
  2733. udelay(5);
  2734. restore_flags(flags);
  2735. }
  2737. #ifdef SERIAL_CONSOLE_FAIR_OUTPUT
  2738. /*
  2739.  * Fair output driver allows a process to speak.
  2740.  */
  2741. static void zs_fair_output(struct sun_serial *info)
  2742. {
  2743. unsigned long flags;
  2744. int left; /* Output no more than that */
  2745. char c;
  2747. if (info == NULL)
  2748. return;
  2749. if (info->xmit_buf == NULL)
  2750. return;
  2752. save_flags(flags);  cli();
  2753. left = info->xmit_cnt;
  2754. while (left != 0) {
  2755. c = info->xmit_buf[info->xmit_tail];
  2756. info->xmit_tail = (info->xmit_tail+1) & (SERIAL_XMIT_SIZE-1);
  2757. info->xmit_cnt--;
  2758. restore_flags(flags);
  2760. zs_console_putchar(info, c);
  2762. cli();
  2763. left = MIN(info->xmit_cnt, left-1);
  2764. }
  2766. /* Last character is being transmitted now (hopefully). */
  2767. sbus_writeb(RES_Tx_P, &info->zs_channel->control);
  2768. ZSDELAY();
  2769. ZSLOG(REGCTRL, RES_Tx_P, 1);
  2771. restore_flags(flags);
  2772. return;
  2773. }
  2774. #endif
  2776. /*
  2777.  * zs_console_write is registered for printk.
  2778.  */
  2779. static void
  2780. zs_console_write(struct console *con, const char *s, unsigned count)
  2781. {
  2782. struct sun_serial *info;
  2783. int i;
  2785. info = zs_soft + con->index;
  2787. for (i = 0; i < count; i++, s++) {
  2788. if(*s == 'n')
  2789. zs_console_putchar(info, 'r');
  2790. zs_console_putchar(info, *s);
  2791. }
  2792. #ifdef SERIAL_CONSOLE_FAIR_OUTPUT
  2793. /* Comment this if you want to have a strict interrupt-driven output */
  2794. zs_fair_output(info);
  2795. #endif
  2796. }
  2798. static kdev_t zs_console_device(struct console *con)
  2799. {
  2800. return MKDEV(TTY_MAJOR, 64 + con->index);
  2801. }
  2803. static int __init zs_console_setup(struct console *con, char *options)
  2804. {
  2805. static struct tty_struct c_tty;
  2806. static struct termios c_termios;
  2807. struct sun_serial *info;
  2808. int brg, baud;
  2810. info = zs_soft + con->index;
  2811. info->is_cons = 1;
  2813. printk("Console: ttyS%d (Zilog8530)n", info->line);
  2815. sunserial_console_termios(con);
  2816. memset(&c_tty, 0, sizeof(c_tty));
  2817. memset(&c_termios, 0, sizeof(c_termios));
  2818. c_tty.termios = &c_termios;
  2819. c_termios.c_cflag = con->cflag;
  2820. baud = tty_get_baud_rate(&c_tty);
  2822. info->zs_baud = baud;
  2824. switch (con->cflag & CSIZE) {
  2825. case CS5:
  2826. zscons_regs[3] = Rx5 | RxENAB;
  2827. zscons_regs[5] = Tx5 | TxENAB;
  2828. info->parity_mask = 0x1f;
  2829. break;
  2830. case CS6:
  2831. zscons_regs[3] = Rx6 | RxENAB;
  2832. zscons_regs[5] = Tx6 | TxENAB;
  2833. info->parity_mask = 0x3f;
  2834. break;
  2835. case CS7:
  2836. zscons_regs[3] = Rx7 | RxENAB;
  2837. zscons_regs[5] = Tx7 | TxENAB;
  2838. info->parity_mask = 0x7f;
  2839. break;
  2840. default:
  2841. case CS8:
  2842. zscons_regs[3] = Rx8 | RxENAB;
  2843. zscons_regs[5] = Tx8 | TxENAB;
  2844. info->parity_mask = 0xff;
  2845. break;
  2846. }
  2847. zscons_regs[5] |= DTR;
  2849. if (con->cflag & PARENB)
  2850. zscons_regs[4] |= PAR_ENAB;
  2851. if (!(con->cflag & PARODD))
  2852. zscons_regs[4] |= PAR_EVEN;
  2854. if (con->cflag & CSTOPB)
  2855. zscons_regs[4] |= SB2;
  2856. else
  2857. zscons_regs[4] |= SB1;
  2859. brg = BPS_TO_BRG(baud, ZS_CLOCK / info->clk_divisor);
  2860. zscons_regs[12] = brg & 0xff;
  2861. zscons_regs[13] = (brg >> 8) & 0xff;
  2863. memcpy(info->curregs, zscons_regs, sizeof(zscons_regs));
  2864. load_zsregs(info, zscons_regs);
  2866. ZS_CLEARERR(info->zs_channel);
  2867. ZS_CLEARFIFO(info->zs_channel);
  2868. return 0;
  2869. }
  2871. static struct console zs_console = {
  2872. name: "ttyS",
  2873. write: zs_console_write,
  2874. device: zs_console_device,
  2875. setup: zs_console_setup,
  2876. flags: CON_PRINTBUFFER,
  2877. index: -1,
  2878. };
  2880. static int __init zs_console_init(void)
  2881. {
  2882. extern int con_is_present(void);
  2884. if (con_is_present())
  2885. return 0;
  2887. zs_console.index = serial_console - 1;
  2888. register_console(&zs_console);
  2889. return 0;
  2890. }
  2892. #endif /* CONFIG_SERIAL_CONSOLE */