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

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

嵌入式Linux

开发平台：

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. /* It is a 'keyboard interrupt' ;-) */
  547. wake_up(&keypress_wait);
  548. }
  549. #ifndef __sparc_v9__
  550. /* Look for kgdb 'stop' character, consult the gdb
  551.  * documentation for remote target debugging and
  552.  * arch/sparc/kernel/sparc-stub.c to see how all this works.
  553.  */
  554. if (info->kgdb_channel && (ch =='03')) {
  555. breakpoint();
  556. return;
  557. }
  558. #endif
  559. if (!tty)
  560. return;
  562. do_queue_task++;
  564. if (tty->flip.count >= TTY_FLIPBUF_SIZE)
  565. break;
  567. tty->flip.count++;
  568. if (r1 & PAR_ERR)
  569. *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  570. else if (r1 & Rx_OVR)
  571. *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  572. else if (r1 & CRC_ERR)
  573. *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  574. else
  575. *tty->flip.flag_buf_ptr++ = 0;
  576. *tty->flip.char_buf_ptr++ = ch;
  578. next_char:
  579. {
  580. unsigned char stat;
  582. /* Check if we have another character... */
  583. stat = sbus_readb(&info->zs_channel->control);
  584. ZSDELAY();
  585. ZSLOG(REGCTRL, stat, 0);
  586. if (!(stat & Rx_CH_AV))
  587. break;
  588. }
  589. }
  591. if (do_queue_task != 0)
  592. queue_task(&tty->flip.tqueue, &tq_timer);
  593. }
  595. static void transmit_chars(struct sun_serial *info)
  596. {
  597. struct tty_struct *tty = info->tty;
  599. if (info->x_char) {
  600. /* Send next char */
  601. zs_put_char(info->zs_channel, info->x_char);
  602. info->x_char = 0;
  603. return;
  604. }
  606. if ((info->xmit_cnt <= 0) || (tty != 0 && tty->stopped)) {
  607. /* That's peculiar... */
  608. sbus_writeb(RES_Tx_P, &info->zs_channel->control);
  609. ZSDELAY();
  610. ZS_WSYNC(info->zs_channel);
  611. ZSLOG(REGCTRL, RES_Tx_P, 1);
  612. return;
  613. }
  615. /* Send char */
  616. zs_put_char(info->zs_channel, info->xmit_buf[info->xmit_tail++]);
  617. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  618. info->xmit_cnt--;
  620. if (info->xmit_cnt < WAKEUP_CHARS)
  621. zs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
  623. if (info->xmit_cnt <= 0) {
  624. sbus_writeb(RES_Tx_P, &info->zs_channel->control);
  625. ZSDELAY();
  626. ZS_WSYNC(info->zs_channel);
  627. ZSLOG(REGCTRL, RES_Tx_P, 1);
  628. }
  629. }
  631. static void status_handle(struct sun_serial *info)
  632. {
  633. unsigned char status;
  635. /* Get status from Read Register 0 */
  636. status = sbus_readb(&info->zs_channel->control);
  637. ZSDELAY();
  638. ZSLOG(REGCTRL, status, 0);
  639. /* Clear status condition... */
  640. sbus_writeb(RES_EXT_INT, &info->zs_channel->control);
  641. ZSDELAY();
  642. ZS_WSYNC(info->zs_channel);
  643. ZSLOG(REGCTRL, RES_EXT_INT, 1);
  644. #if 0
  645. if (status & DCD) {
  646. if ((info->tty->termios->c_cflag & CRTSCTS) &&
  647.     ((info->curregs[3] & AUTO_ENAB)==0)) {
  648. info->curregs[3] |= AUTO_ENAB;
  649. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  650. }
  651. } else {
  652. if ((info->curregs[3] & AUTO_ENAB)) {
  653. info->curregs[3] &= ~AUTO_ENAB;
  654. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  655. }
  656. }
  657. #endif
  658. /* Whee, if this is console input and this is a
  659.  * 'break asserted' status change interrupt, call
  660.  * the boot prom.
  661.  */
  662. if (status & BRK_ABRT) {
  663. if (info->break_abort)
  664. batten_down_hatches();
  665. if (info->cons_mouse)
  666. sun_mouse_inbyte(0, 1);
  667. }
  669. /* XXX Whee, put in a buffer somewhere, the status information
  670.  * XXX whee whee whee... Where does the information go...
  671.  */
  672. return;
  673. }
  675. /*
  676.  * This is the serial driver's generic interrupt routine
  677.  */
  678. void zs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  679. {
  680. struct sun_serial *info;
  681. int i;
  683. info = (struct sun_serial *)dev_id;
  684. ZSLOG(REGIRQ, 0, 0);
  685. for (i = 0; i < NUM_SERIAL; i++) {
  686. unsigned char r3 = read_zsreg(info->zs_channel, 3);
  688. /* Channel A -- /dev/ttya or /dev/kbd, could be the console */
  689. if (r3 & (CHAEXT | CHATxIP | CHARxIP)) {
  690. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  691. ZSDELAY();
  692. ZS_WSYNC(info->zs_channel);
  693. ZSLOG(REGCTRL, RES_H_IUS, 1);
  694. if (r3 & CHARxIP)
  695. receive_chars(info, regs);
  696. if (r3 & CHAEXT)
  697. status_handle(info);
  698. if (r3 & CHATxIP)
  699. transmit_chars(info);
  700. }
  702. /* Channel B -- /dev/ttyb or /dev/mouse, could be the console */
  703. info = info->zs_next;
  704. if (r3 & (CHBEXT | CHBTxIP | CHBRxIP)) {
  705. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  706. ZSDELAY();
  707. ZS_WSYNC(info->zs_channel);
  708. ZSLOG(REGCTRL, RES_H_IUS, 1);
  709. if (r3 & CHBRxIP)
  710. receive_chars(info, regs);
  711. if (r3 & CHBEXT)
  712. status_handle(info);
  713. if (r3 & CHBTxIP)
  714. transmit_chars(info);
  715. }
  717. info = info->zs_next;
  718. }
  719. }
  721. /*
  722.  * -------------------------------------------------------------------
  723.  * Here ends the serial interrupt routines.
  724.  * -------------------------------------------------------------------
  725.  */
  727. /*
  728.  * This routine is used to handle the "bottom half" processing for the
  729.  * serial driver, known also the "software interrupt" processing.
  730.  * This processing is done at the kernel interrupt level, after the
  731.  * zs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
  732.  * is where time-consuming activities which can not be done in the
  733.  * interrupt driver proper are done; the interrupt driver schedules
  734.  * them using zs_sched_event(), and they get done here.
  735.  */
  736. static void do_serial_bh(void)
  737. {
  738. run_task_queue(&tq_serial);
  739. }
  741. static void do_softint(void *private_)
  742. {
  743. struct sun_serial *info = (struct sun_serial *) private_;
  744. struct tty_struct *tty;
  746. tty = info->tty;
  747. if (!tty)
  748. return;
  750. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
  751. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  752.     tty->ldisc.write_wakeup)
  753. (tty->ldisc.write_wakeup)(tty);
  754. wake_up_interruptible(&tty->write_wait);
  755. }
  756. }
  758. /*
  759.  * This routine is called from the scheduler tqueue when the interrupt
  760.  * routine has signalled that a hangup has occurred.  The path of
  761.  * hangup processing is:
  762.  *
  763.  *  serial interrupt routine -> (scheduler tqueue) ->
  764.  *  do_serial_hangup() -> tty->hangup() -> zs_hangup()
  765.  * 
  766.  */
  767. static void do_serial_hangup(void *private_)
  768. {
  769. struct sun_serial *info = (struct sun_serial *) private_;
  770. struct tty_struct *tty;
  772. tty = info->tty;
  773. if (!tty)
  774. return;
  775. #ifdef SERIAL_DEBUG_OPEN
  776. printk("do_serial_hangup<%p: tty-%dn",
  777. __builtin_return_address(0), info->line);
  778. #endif
  780. tty_hangup(tty);
  781. }
  783. static int startup(struct sun_serial * info)
  784. {
  785. unsigned long flags;
  787. if (info->flags & ZILOG_INITIALIZED)
  788. return 0;
  790. if (!info->xmit_buf) {
  791. info->xmit_buf = (unsigned char *) get_free_page(GFP_KERNEL);
  792. if (!info->xmit_buf)
  793. return -ENOMEM;
  794. }
  796. save_flags(flags); cli();
  798. #ifdef SERIAL_DEBUG_OPEN
  799. printk("Starting up tty-%d (irq %d)...n", info->line, info->irq);
  800. #endif
  802. /*
  803.  * Clear the FIFO buffers and disable them
  804.  * (they will be reenabled in change_speed())
  805.  */
  806. ZS_CLEARFIFO(info->zs_channel);
  807. info->xmit_fifo_size = 1;
  809. /*
  810.  * Clear the interrupt registers.
  811.  */
  812. sbus_writeb(ERR_RES, &info->zs_channel->control);
  813. ZSDELAY();
  814. ZS_WSYNC(info->zs_channel);
  815. ZSLOG(REGCTRL, ERR_RES, 1);
  817. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  818. ZSDELAY();
  819. ZS_WSYNC(info->zs_channel);
  820. ZSLOG(REGCTRL, RES_H_IUS, 1);
  822. /*
  823.  * Now, initialize the Zilog
  824.  */
  825. zs_rtsdtr(info, 1);
  827. /*
  828.  * Finally, enable sequencing and interrupts
  829.  */
  830. info->curregs[1] |= (info->curregs[1] & ~(RxINT_MASK)) |
  831. (EXT_INT_ENAB | INT_ALL_Rx);
  832. info->curregs[3] |= (RxENAB | Rx8);
  833. /* We enable Tx interrupts as needed. */
  834. info->curregs[5] |= (TxENAB | Tx8);
  835. info->curregs[9] |= (NV | MIE);
  836. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  837. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  838. write_zsreg(info->zs_channel, 9, info->curregs[9]);
  840. /*
  841.  * And clear the interrupt registers again for luck.
  842.  */
  843. sbus_writeb(ERR_RES, &info->zs_channel->control);
  844. ZSDELAY();
  845. ZS_WSYNC(info->zs_channel);
  846. ZSLOG(REGCTRL, ERR_RES, 1);
  848. sbus_writeb(RES_H_IUS, &info->zs_channel->control);
  849. ZSDELAY();
  850. ZS_WSYNC(info->zs_channel);
  851. ZSLOG(REGCTRL, RES_H_IUS, 1);
  853. if (info->tty)
  854. clear_bit(TTY_IO_ERROR, &info->tty->flags);
  855. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  857. /*
  858.  * and set the speed of the serial port
  859.  */
  860. change_speed(info);
  862. info->flags |= ZILOG_INITIALIZED;
  863. restore_flags(flags);
  864. return 0;
  865. }
  867. /*
  868.  * This routine will shutdown a serial port; interrupts are disabled, and
  869.  * DTR is dropped if the hangup on close termio flag is on.
  870.  */
  871. static void shutdown(struct sun_serial * info)
  872. {
  873. unsigned long flags;
  875. if (!(info->flags & ZILOG_INITIALIZED))
  876. return;
  878. #ifdef SERIAL_DEBUG_OPEN
  879. printk("Shutting down serial port %d (irq %d)....", info->line,
  880.        info->irq);
  881. #endif
  883. save_flags(flags); cli(); /* Disable interrupts */
  885. if (info->xmit_buf) {
  886. free_page((unsigned long) info->xmit_buf);
  887. info->xmit_buf = 0;
  888. }
  890. if (info->tty)
  891. set_bit(TTY_IO_ERROR, &info->tty->flags);
  893. info->flags &= ~ZILOG_INITIALIZED;
  894. restore_flags(flags);
  895. }
  897. /*
  898.  * This routine is called to set the UART divisor registers to match
  899.  * the specified baud rate for a serial port.
  900.  */
  901. static void change_speed(struct sun_serial *info)
  902. {
  903. unsigned cflag;
  904. int baud, quot = 0;
  905. int brg;
  907. if (!info->tty || !info->tty->termios)
  908. return;
  909. cflag = info->tty->termios->c_cflag;
  910. if (!info->port)
  911. return;
  912. baud = tty_get_baud_rate(info->tty);
  914. if ((baud == 38400) && 
  915.     ((info->flags & ZILOG_SPD_MASK) == ZILOG_SPD_CUST))
  916. quot = info->custom_divisor;
  918. if (quot) {
  919. info->zs_baud = info->baud_base / quot;
  920. info->clk_divisor = 16;
  922. info->curregs[4] = X16CLK;
  923. info->curregs[11] = TCBR | RCBR;
  924. brg = BPS_TO_BRG(info->zs_baud, ZS_CLOCK/info->clk_divisor);
  925. info->curregs[12] = (brg & 255);
  926. info->curregs[13] = ((brg >> 8) & 255);
  927. info->curregs[14] = BRSRC | BRENAB;
  928. zs_rtsdtr(info, 1);
  929. } else if (baud) {
  930. info->zs_baud = baud;
  931. info->clk_divisor = 16;
  933. info->curregs[4] = X16CLK;
  934. info->curregs[11] = TCBR | RCBR;
  935. brg = BPS_TO_BRG(info->zs_baud, ZS_CLOCK/info->clk_divisor);
  936. info->curregs[12] = (brg & 255);
  937. info->curregs[13] = ((brg >> 8) & 255);
  938. info->curregs[14] = BRSRC | BRENAB;
  939. zs_rtsdtr(info, 1);
  940. } else {
  941. zs_rtsdtr(info, 0);
  942. return;
  943. }
  945. /* byte size and parity */
  946. switch (cflag & CSIZE) {
  947. case CS5:
  948. info->curregs[3] &= ~(RxN_MASK);
  949. info->curregs[3] |= Rx5;
  950. info->curregs[5] &= ~(TxN_MASK);
  951. info->curregs[5] |= Tx5;
  952. info->parity_mask = 0x1f;
  953. break;
  954. case CS6:
  955. info->curregs[3] &= ~(RxN_MASK);
  956. info->curregs[3] |= Rx6;
  957. info->curregs[5] &= ~(TxN_MASK);
  958. info->curregs[5] |= Tx6;
  959. info->parity_mask = 0x3f;
  960. break;
  961. case CS7:
  962. info->curregs[3] &= ~(RxN_MASK);
  963. info->curregs[3] |= Rx7;
  964. info->curregs[5] &= ~(TxN_MASK);
  965. info->curregs[5] |= Tx7;
  966. info->parity_mask = 0x7f;
  967. break;
  968. case CS8:
  969. default: /* defaults to 8 bits */
  970. info->curregs[3] &= ~(RxN_MASK);
  971. info->curregs[3] |= Rx8;
  972. info->curregs[5] &= ~(TxN_MASK);
  973. info->curregs[5] |= Tx8;
  974. info->parity_mask = 0xff;
  975. break;
  976. }
  977. info->curregs[4] &= ~(0x0c);
  978. if (cflag & CSTOPB) {
  979. info->curregs[4] |= SB2;
  980. } else {
  981. info->curregs[4] |= SB1;
  982. }
  983. if (cflag & PARENB) {
  984. info->curregs[4] |= PAR_ENAB;
  985. } else {
  986. info->curregs[4] &= ~PAR_ENAB;
  987. }
  988. if (!(cflag & PARODD)) {
  989. info->curregs[4] |= PAR_EVEN;
  990. } else {
  991. info->curregs[4] &= ~PAR_EVEN;
  992. }
  994. /* Load up the new values */
  995. load_zsregs(info, info->curregs);
  997. return;
  998. }
  1000. /* This is for mouse/keyboard output.
  1001.  * XXX mouse output??? can we send it commands??? XXX
  1002.  */
  1003. static void kbd_put_char(unsigned char ch)
  1004. {
  1005. struct sun_zschannel *chan = zs_kbdchan;
  1006. unsigned long flags;
  1008. if(!chan)
  1009. return;
  1011. save_flags(flags); cli();
  1012. zs_put_char(chan, ch);
  1013. restore_flags(flags);
  1014. }
  1016. void mouse_put_char(char ch)
  1017. {
  1018. struct sun_zschannel *chan = zs_mousechan;
  1019. unsigned long flags;
  1021. if(!chan)
  1022. return;
  1024. save_flags(flags); cli();
  1025. zs_put_char(chan, ch);
  1026. restore_flags(flags);
  1027. }
  1029. /* These are for receiving and sending characters under the kgdb
  1030.  * source level kernel debugger.
  1031.  */
  1032. void putDebugChar(char kgdb_char)
  1033. {
  1034. struct sun_zschannel *chan = zs_kgdbchan;
  1036. while((sbus_readb(&chan->control) & Tx_BUF_EMP)==0)
  1037. udelay(5);
  1038. sbus_writeb(kgdb_char, &chan->data);
  1039. ZS_WSYNC(chan);
  1040. ZSLOG(REGDATA, kgdb_char, 1);
  1041. }
  1043. char getDebugChar(void)
  1044. {
  1045. struct sun_zschannel *chan = zs_kgdbchan;
  1046. u8 val;
  1048. do {
  1049. val = sbus_readb(&chan->control);
  1050. ZSLOG(REGCTRL, val, 0);
  1051. udelay(5);
  1052. } while ((val & Rx_CH_AV) == 0);
  1054. val = sbus_readb(&chan->data);
  1055. ZSLOG(REGDATA, val, 0);
  1056. return val;
  1057. }
  1059. static void zs_flush_chars(struct tty_struct *tty)
  1060. {
  1061. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1062. unsigned long flags;
  1064. if (serial_paranoia_check(info, tty->device, "zs_flush_chars"))
  1065. return;
  1067. save_flags(flags); cli();
  1068. if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  1069.     !info->xmit_buf)
  1070. goto out;
  1072. /* Enable transmitter */
  1073. info->curregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1074. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1075. info->curregs[5] |= TxENAB;
  1076. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1078. /*
  1079.  * Send a first (bootstrapping) character. A best solution is
  1080.  * to call transmit_chars() here which handles output in a
  1081.  * generic way. Current transmit_chars() not only transmits,
  1082.  * but resets interrupts also what we do not desire here.
  1083.  * XXX Discuss with David.
  1084.  */
  1085. zs_put_char(info->zs_channel, info->xmit_buf[info->xmit_tail++]);
  1086. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  1087. info->xmit_cnt--;
  1089. out:
  1090. restore_flags(flags);
  1091. }
  1093. static int zs_write(struct tty_struct * tty, int from_user,
  1094.     const unsigned char *buf, int count)
  1095. {
  1096. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1097. unsigned long flags;
  1098. int c, total = 0;
  1100. if (serial_paranoia_check(info, tty->device, "zs_write"))
  1101. return 0;
  1103. if (!info || !info->xmit_buf || !tmp_buf)
  1104. return 0;
  1106. save_flags(flags);
  1107. if (from_user) {
  1108. down(&tmp_buf_sem);
  1109. while (1) {
  1110. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1111.    SERIAL_XMIT_SIZE - info->xmit_head));
  1112. if (c <= 0)
  1113. break;
  1114. c -= copy_from_user(tmp_buf, buf, c);
  1115. if (!c) {
  1116. if (!total)
  1117. total = -EFAULT;
  1118. break;
  1119. }
  1120. cli();
  1121. c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1122.        SERIAL_XMIT_SIZE - info->xmit_head));
  1123. memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
  1124. info->xmit_head = ((info->xmit_head + c) &
  1125.    (SERIAL_XMIT_SIZE - 1));
  1126. info->xmit_cnt += c;
  1127. restore_flags(flags);
  1129. buf += c;
  1130. count -= c;
  1131. total += c;
  1132. }
  1133. up(&tmp_buf_sem);
  1134. } else {
  1135. while (1) {
  1136. cli();
  1137. c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  1138.    SERIAL_XMIT_SIZE - info->xmit_head));
  1139. if (c <= 0) {
  1140. restore_flags(flags);
  1141. break;
  1142. }
  1143. memcpy(info->xmit_buf + info->xmit_head, buf, c);
  1144. info->xmit_head = ((info->xmit_head + c) &
  1145.    (SERIAL_XMIT_SIZE - 1));
  1146. info->xmit_cnt += c;
  1147. restore_flags(flags);
  1148. buf += c;
  1149. count -= c;
  1150. total += c;
  1151. }
  1152. }
  1154. cli();
  1155. if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
  1156. /* Enable transmitter */
  1157. info->curregs[1] |= TxINT_ENAB|EXT_INT_ENAB;
  1158. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1159. info->curregs[5] |= TxENAB;
  1160. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1161. #if 1
  1162. zs_put_char(info->zs_channel,
  1163.     info->xmit_buf[info->xmit_tail++]);
  1164. info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
  1165. info->xmit_cnt--;
  1166. #endif
  1167. }
  1169. restore_flags(flags);
  1170. return total;
  1171. }
  1173. static int zs_write_room(struct tty_struct *tty)
  1174. {
  1175. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1176. int ret;
  1178. if (serial_paranoia_check(info, tty->device, "zs_write_room"))
  1179. return 0;
  1180. ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
  1181. if (ret < 0)
  1182. ret = 0;
  1183. return ret;
  1184. }
  1186. static int zs_chars_in_buffer(struct tty_struct *tty)
  1187. {
  1188. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1190. if (serial_paranoia_check(info, tty->device, "zs_chars_in_buffer"))
  1191. return 0;
  1192. return info->xmit_cnt;
  1193. }
  1195. static void zs_flush_buffer(struct tty_struct *tty)
  1196. {
  1197. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1199. if (serial_paranoia_check(info, tty->device, "zs_flush_buffer"))
  1200. return;
  1201. cli();
  1202. info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
  1203. sti();
  1204. wake_up_interruptible(&tty->write_wait);
  1205. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1206.     tty->ldisc.write_wakeup)
  1207. (tty->ldisc.write_wakeup)(tty);
  1208. }
  1210. /*
  1211.  * ------------------------------------------------------------
  1212.  * zs_throttle()
  1213.  * 
  1214.  * This routine is called by the upper-layer tty layer to signal that
  1215.  * incoming characters should be throttled.
  1216.  * ------------------------------------------------------------
  1217.  */
  1218. static void zs_throttle(struct tty_struct * tty)
  1219. {
  1220. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1221. #ifdef SERIAL_DEBUG_THROTTLE
  1222. char buf[64];
  1224. printk("throttle %s: %d....n", _tty_name(tty, buf),
  1225.        tty->ldisc.chars_in_buffer(tty));
  1226. #endif
  1228. if (serial_paranoia_check(info, tty->device, "zs_throttle"))
  1229. return;
  1231. if (I_IXOFF(tty))
  1232. info->x_char = STOP_CHAR(tty);
  1234. /* Turn off RTS line */
  1235. cli();
  1236. info->curregs[5] &= ~RTS;
  1237. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1238. sti();
  1239. }
  1241. static void zs_unthrottle(struct tty_struct * tty)
  1242. {
  1243. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1244. #ifdef SERIAL_DEBUG_THROTTLE
  1245. char buf[64];
  1247. printk("unthrottle %s: %d....n", _tty_name(tty, buf),
  1248.        tty->ldisc.chars_in_buffer(tty));
  1249. #endif
  1251. if (serial_paranoia_check(info, tty->device, "zs_unthrottle"))
  1252. return;
  1254. if (I_IXOFF(tty)) {
  1255. if (info->x_char)
  1256. info->x_char = 0;
  1257. else
  1258. info->x_char = START_CHAR(tty);
  1259. }
  1261. /* Assert RTS line */
  1262. cli();
  1263. info->curregs[5] |= RTS;
  1264. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1265. sti();
  1266. }
  1268. /*
  1269.  * ------------------------------------------------------------
  1270.  * zs_ioctl() and friends
  1271.  * ------------------------------------------------------------
  1272.  */
  1274. static int get_serial_info(struct sun_serial * info,
  1275.    struct serial_struct * retinfo)
  1276. {
  1277. struct serial_struct tmp;
  1278.   
  1279. if (!retinfo)
  1280. return -EFAULT;
  1281. memset(&tmp, 0, sizeof(tmp));
  1282. tmp.type = info->type;
  1283. tmp.line = info->line;
  1284. tmp.port = info->port;
  1285. tmp.irq = info->irq;
  1286. tmp.flags = info->flags;
  1287. tmp.baud_base = info->baud_base;
  1288. tmp.close_delay = info->close_delay;
  1289. tmp.closing_wait = info->closing_wait;
  1290. tmp.custom_divisor = info->custom_divisor;
  1291. if (copy_to_user(retinfo,&tmp,sizeof(*retinfo)))
  1292. return -EFAULT;
  1293. return 0;
  1294. }
  1296. static int set_serial_info(struct sun_serial * info,
  1297.    struct serial_struct * new_info)
  1298. {
  1299. struct serial_struct new_serial;
  1300. struct sun_serial old_info;
  1301. int retval = 0;
  1303. if (!new_info || copy_from_user(&new_serial,new_info,sizeof(new_serial)))
  1304. return -EFAULT;
  1305. old_info = *info;
  1307. if (!capable(CAP_SYS_ADMIN)) {
  1308. if ((new_serial.baud_base != info->baud_base) ||
  1309.     (new_serial.type != info->type) ||
  1310.     (new_serial.close_delay != info->close_delay) ||
  1311.     ((new_serial.flags & ~ZILOG_USR_MASK) !=
  1312.      (info->flags & ~ZILOG_USR_MASK)))
  1313. return -EPERM;
  1314. info->flags = ((info->flags & ~ZILOG_USR_MASK) |
  1315.        (new_serial.flags & ZILOG_USR_MASK));
  1316. info->custom_divisor = new_serial.custom_divisor;
  1317. goto check_and_exit;
  1318. }
  1320. if(new_serial.baud_base < 9600)
  1321. return -EINVAL;
  1323. if (info->count > 1)
  1324. return -EBUSY;
  1326. /*
  1327.  * OK, past this point, all the error checking has been done.
  1328.  * At this point, we start making changes.....
  1329.  */
  1331. info->baud_base = new_serial.baud_base;
  1332. info->flags = ((info->flags & ~ZILOG_FLAGS) |
  1333. (new_serial.flags & ZILOG_FLAGS));
  1334. info->custom_divisor = new_serial.custom_divisor;
  1335. info->type = new_serial.type;
  1336. info->close_delay = new_serial.close_delay;
  1337. info->closing_wait = new_serial.closing_wait;
  1339. check_and_exit:
  1340. retval = startup(info);
  1341. return retval;
  1342. }
  1344. /*
  1345.  * get_lsr_info - get line status register info
  1346.  *
  1347.  * Purpose: Let user call ioctl() to get info when the UART physically
  1348.  *      is emptied.  On bus types like RS485, the transmitter must
  1349.  *      release the bus after transmitting. This must be done when
  1350.  *      the transmit shift register is empty, not be done when the
  1351.  *      transmit holding register is empty.  This functionality
  1352.  *      allows an RS485 driver to be written in user space. 
  1353.  */
  1354. static int get_lsr_info(struct sun_serial * info, unsigned int *value)
  1355. {
  1356. unsigned char status;
  1358. cli();
  1359. status = sbus_readb(&info->zs_channel->control);
  1360. ZSDELAY();
  1361. ZSLOG(REGCTRL, status, 0);
  1362. sti();
  1363. if (put_user(status, value))
  1364. return -EFAULT;
  1365. return 0;
  1366. }
  1368. static int get_modem_info(struct sun_serial * info, unsigned int *value)
  1369. {
  1370. unsigned char status;
  1371. unsigned int result;
  1373. cli();
  1374. status = sbus_readb(&info->zs_channel->control);
  1375. ZSDELAY();
  1376. ZSLOG(REGCTRL, status, 0);
  1377. sti();
  1378. result =  ((info->curregs[5] & RTS) ? TIOCM_RTS : 0)
  1379. | ((info->curregs[5] & DTR) ? TIOCM_DTR : 0)
  1380. | ((status  & DCD) ? TIOCM_CAR : 0)
  1381. | ((status  & SYNC) ? TIOCM_DSR : 0)
  1382. | ((status  & CTS) ? TIOCM_CTS : 0);
  1383. if (put_user(result, value))
  1384. return -EFAULT;
  1385. return 0;
  1386. }
  1388. static int set_modem_info(struct sun_serial * info, unsigned int cmd,
  1389.   unsigned int *value)
  1390. {
  1391. unsigned int arg;
  1393. if (get_user(arg, value))
  1394. return -EFAULT;
  1395. switch (cmd) {
  1396. case TIOCMBIS: 
  1397. if (arg & TIOCM_RTS)
  1398. info->curregs[5] |= RTS;
  1399. if (arg & TIOCM_DTR)
  1400. info->curregs[5] |= DTR;
  1401. break;
  1402. case TIOCMBIC:
  1403. if (arg & TIOCM_RTS)
  1404. info->curregs[5] &= ~RTS;
  1405. if (arg & TIOCM_DTR)
  1406. info->curregs[5] &= ~DTR;
  1407. break;
  1408. case TIOCMSET:
  1409. info->curregs[5] = ((info->curregs[5] & ~(RTS | DTR))
  1410.      | ((arg & TIOCM_RTS) ? RTS : 0)
  1411.      | ((arg & TIOCM_DTR) ? DTR : 0));
  1412. break;
  1413. default:
  1414. return -EINVAL;
  1415. }
  1416. cli();
  1417. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1418. sti();
  1419. return 0;
  1420. }
  1422. /*
  1423.  * This routine sends a break character out the serial port.
  1424.  */
  1425. static void send_break( struct sun_serial * info, int duration)
  1426. {
  1427. if (!info->port)
  1428. return;
  1429. current->state = TASK_INTERRUPTIBLE;
  1430. cli();
  1431. write_zsreg(info->zs_channel, 5, (info->curregs[5] | SND_BRK));
  1432. schedule_timeout(duration);
  1433. write_zsreg(info->zs_channel, 5, info->curregs[5]);
  1434. sti();
  1435. }
  1437. static int zs_ioctl(struct tty_struct *tty, struct file * file,
  1438.     unsigned int cmd, unsigned long arg)
  1439. {
  1440. struct sun_serial * info = (struct sun_serial *) tty->driver_data;
  1441. int retval;
  1443. if (serial_paranoia_check(info, tty->device, "zs_ioctl"))
  1444. return -ENODEV;
  1446. if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
  1447.     (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
  1448.     (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT)) {
  1449. if (tty->flags & (1 << TTY_IO_ERROR))
  1450.     return -EIO;
  1451. }
  1453. switch (cmd) {
  1454. case TCSBRK: /* SVID version: non-zero arg --> no break */
  1455. retval = tty_check_change(tty);
  1456. if (retval)
  1457. return retval;
  1458. tty_wait_until_sent(tty, 0);
  1459. if (!arg)
  1460. send_break(info, HZ/4); /* 1/4 second */
  1461. return 0;
  1462. case TCSBRKP: /* support for POSIX tcsendbreak() */
  1463. retval = tty_check_change(tty);
  1464. if (retval)
  1465. return retval;
  1466. tty_wait_until_sent(tty, 0);
  1467. send_break(info, arg ? arg*(HZ/10) : HZ/4);
  1468. return 0;
  1469. case TIOCGSOFTCAR:
  1470. if (put_user(C_CLOCAL(tty) ? 1 : 0,
  1471.      (unsigned long *) arg))
  1472. return -EFAULT;
  1473. return 0;
  1474. case TIOCSSOFTCAR:
  1475. if (get_user(arg, (unsigned long *) arg))
  1476. return -EFAULT;
  1477. tty->termios->c_cflag =
  1478. ((tty->termios->c_cflag & ~CLOCAL) |
  1479.  (arg ? CLOCAL : 0));
  1480. return 0;
  1481. case TIOCMGET:
  1482. return get_modem_info(info, (unsigned int *) arg);
  1483. case TIOCMBIS:
  1484. case TIOCMBIC:
  1485. case TIOCMSET:
  1486. return set_modem_info(info, cmd, (unsigned int *) arg);
  1487. case TIOCGSERIAL:
  1488. return get_serial_info(info,
  1489.        (struct serial_struct *) arg);
  1490. case TIOCSSERIAL:
  1491. return set_serial_info(info,
  1492.        (struct serial_struct *) arg);
  1493. case TIOCSERGETLSR: /* Get line status register */
  1494. return get_lsr_info(info, (unsigned int *) arg);
  1496. case TIOCSERGSTRUCT:
  1497. if (copy_to_user((struct sun_serial *) arg,
  1498.     info, sizeof(struct sun_serial)))
  1499. return -EFAULT;
  1500. return 0;
  1502. default:
  1503. return -ENOIOCTLCMD;
  1504. }
  1505. return 0;
  1506. }
  1508. static void zs_set_termios(struct tty_struct *tty, struct termios *old_termios)
  1509. {
  1510. struct sun_serial *info = (struct sun_serial *) tty->driver_data;
  1512. if (tty->termios->c_cflag == old_termios->c_cflag)
  1513. return;
  1515. change_speed(info);
  1517. if ((old_termios->c_cflag & CRTSCTS) &&
  1518.     !(tty->termios->c_cflag & CRTSCTS)) {
  1519. tty->hw_stopped = 0;
  1520. zs_start(tty);
  1521. }
  1522. }
  1524. /*
  1525.  * ------------------------------------------------------------
  1526.  * zs_close()
  1527.  * 
  1528.  * This routine is called when the serial port gets closed.  First, we
  1529.  * wait for the last remaining data to be sent.  Then, we unlink its
  1530.  * ZILOG structure from the interrupt chain if necessary, and we free
  1531.  * that IRQ if nothing is left in the chain.
  1532.  * ------------------------------------------------------------
  1533.  */
  1534. static void zs_close(struct tty_struct *tty, struct file * filp)
  1535. {
  1536. struct sun_serial * info = (struct sun_serial *) tty->driver_data;
  1537. unsigned long flags;
  1539. if (!info || serial_paranoia_check(info, tty->device, "zs_close"))
  1540. return;
  1542. save_flags(flags); cli();
  1544. if (tty_hung_up_p(filp)) {
  1545. restore_flags(flags);
  1546. return;
  1547. }
  1549. #ifdef SERIAL_DEBUG_OPEN
  1550. printk("zs_close tty-%d, count = %dn", info->line, info->count);
  1551. #endif
  1552. if ((tty->count == 1) && (info->count != 1)) {
  1553. /*
  1554.  * Uh, oh.  tty->count is 1, which means that the tty
  1555.  * structure will be freed.  Info->count should always
  1556.  * be one in these conditions.  If it's greater than
  1557.  * one, we've got real problems, since it means the
  1558.  * serial port won't be shutdown.
  1559.  */
  1560. printk("zs_close: bad serial port count; tty->count is 1, "
  1561.        "info->count is %dn", info->count);
  1562. info->count = 1;
  1563. }
  1564. if (--info->count < 0) {
  1565. printk("zs_close: bad serial port count for ttys%d: %dn",
  1566.        info->line, info->count);
  1567. info->count = 0;
  1568. }
  1569. if (info->count) {
  1570. restore_flags(flags);
  1571. return;
  1572. }
  1573. info->flags |= ZILOG_CLOSING;
  1574. /*
  1575.  * Save the termios structure, since this port may have
  1576.  * separate termios for callout and dialin.
  1577.  */
  1578. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1579. info->normal_termios = *tty->termios;
  1580. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1581. info->callout_termios = *tty->termios;
  1582. /*
  1583.  * Now we wait for the transmit buffer to clear; and we notify 
  1584.  * the line discipline to only process XON/XOFF characters.
  1585.  */
  1586. tty->closing = 1;
  1587. if (info->closing_wait != ZILOG_CLOSING_WAIT_NONE)
  1588. tty_wait_until_sent(tty, info->closing_wait);
  1589. /*
  1590.  * At this point we stop accepting input.  To do this, we
  1591.  * disable the receive line status interrupts, and tell the
  1592.  * interrupt driver to stop checking the data ready bit in the
  1593.  * line status register.
  1594.  */
  1595. /** if (!info->iscons) ... **/
  1596. info->curregs[3] &= ~RxENAB;
  1597. write_zsreg(info->zs_channel, 3, info->curregs[3]);
  1598. info->curregs[1] &= ~(RxINT_MASK);
  1599. write_zsreg(info->zs_channel, 1, info->curregs[1]);
  1600. ZS_CLEARFIFO(info->zs_channel);
  1602. shutdown(info);
  1603. if (tty->driver.flush_buffer)
  1604. tty->driver.flush_buffer(tty);
  1605. if (tty->ldisc.flush_buffer)
  1606. tty->ldisc.flush_buffer(tty);
  1607. tty->closing = 0;
  1608. info->event = 0;
  1609. info->tty = 0;
  1610. if (tty->ldisc.num != ldiscs[N_TTY].num) {
  1611. if (tty->ldisc.close)
  1612. (tty->ldisc.close)(tty);
  1613. tty->ldisc = ldiscs[N_TTY];
  1614. tty->termios->c_line = N_TTY;
  1615. if (tty->ldisc.open)
  1616. (tty->ldisc.open)(tty);
  1617. }
  1618. if (info->blocked_open) {
  1619. if (info->close_delay) {
  1620. current->state = TASK_INTERRUPTIBLE;
  1621. schedule_timeout(info->close_delay);
  1622. }
  1623. wake_up_interruptible(&info->open_wait);
  1624. }
  1625. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE|
  1626.  ZILOG_CLOSING);
  1627. wake_up_interruptible(&info->close_wait);
  1628. #ifdef SERIAL_DEBUG_OPEN
  1629. printk("zs_close tty-%d exiting, count = %dn", info->line, info->count);
  1630. #endif
  1631. restore_flags(flags);
  1632. }
  1634. /*
  1635.  * zs_hangup() --- called by tty_hangup() when a hangup is signaled.
  1636.  */
  1637. void zs_hangup(struct tty_struct *tty)
  1638. {
  1639. struct sun_serial * info = (struct sun_serial *) tty->driver_data;
  1641. if (serial_paranoia_check(info, tty->device, "zs_hangup"))
  1642. return;
  1644. if (info->is_cons)
  1645. return;
  1647. #ifdef SERIAL_DEBUG_OPEN
  1648. printk("zs_hangup<%p: tty-%d, count = %d byen",
  1649. __builtin_return_address(0), info->line, info->count);
  1650. #endif
  1652. zs_flush_buffer(tty);
  1653. shutdown(info);
  1654. info->event = 0;
  1655. info->count = 0;
  1656. info->flags &= ~(ZILOG_NORMAL_ACTIVE|ZILOG_CALLOUT_ACTIVE);
  1657. info->tty = 0;
  1658. wake_up_interruptible(&info->open_wait);
  1659. }
  1661. /*
  1662.  *
  1663.  * line_info - returns information about each channel
  1664.  *
  1665.  */
  1666. static inline int line_info(char *buf, struct sun_serial *info)
  1667. {
  1668. unsigned char status;
  1669. char stat_buf[30];
  1670. int ret;
  1672. ret = sprintf(buf, "%d: uart:Zilog8530 port:%x irq:%d",
  1673. info->line, info->port, info->irq);
  1675. cli();
  1676. status = sbus_readb(&info->zs_channel->control);
  1677. ZSDELAY();
  1678. ZSLOG(REGCTRL, status, 0);
  1679. sti();
  1681. stat_buf[0] = 0;
  1682. stat_buf[1] = 0;
  1683. if (info->curregs[5] & RTS)
  1684. strcat(stat_buf, "|RTS");
  1685. if (status & CTS)
  1686. strcat(stat_buf, "|CTS");
  1687. if (info->curregs[5] & DTR)
  1688. strcat(stat_buf, "|DTR");
  1689. if (status & SYNC)
  1690. strcat(stat_buf, "|DSR");
  1691. if (status & DCD)
  1692. strcat(stat_buf, "|CD");
  1694. ret += sprintf(buf + ret, " baud:%d %sn", info->zs_baud, stat_buf + 1);
  1695. return ret;
  1696. }
  1698. /*
  1699.  *
  1700.  * zs_read_proc() - called when /proc/tty/driver/serial is read.
  1701.  *
  1702.  */
  1703. int zs_read_proc(char *page, char **start, off_t off, int count,
  1704.                  int *eof, void *data)
  1705. {
  1706. char *revision = "$Revision: 1.68.2.2 $";
  1707. char *version, *p;
  1708. int i, len = 0, l;
  1709. off_t begin = 0;
  1711. version = strchr(revision, ' ');
  1712. p = strchr(++version, ' ');
  1713. *p = '';
  1714. len += sprintf(page, "serinfo:1.0 driver:%sn", version);
  1715. *p = ' ';
  1717. for (i = 0; i < NUM_CHANNELS && len < 4000; i++) {
  1718. l = line_info(page + len, &zs_soft[i]);
  1719. len += l;
  1720. if (len+begin > off+count)
  1721. goto done;
  1722. if (len+begin < off) {
  1723. begin += len;
  1724. len = 0;
  1725. }
  1726. }
  1728. *eof = 1;
  1729. done:
  1730. if (off >= len+begin)
  1731. return 0;
  1732. *start = page + (off-begin);
  1733. return ((count < begin+len-off) ? count : begin+len-off);
  1734. }
  1736. /*
  1737.  * ------------------------------------------------------------
  1738.  * zs_open() and friends
  1739.  * ------------------------------------------------------------
  1740.  */
  1741. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1742.    struct sun_serial *info)
  1743. {
  1744. DECLARE_WAITQUEUE(wait, current);
  1745. int retval, do_clocal = 0;
  1746. unsigned char r0;
  1748. /*
  1749.  * If the device is in the middle of being closed, then block
  1750.  * until it's done, and then try again.
  1751.  */
  1752. if (info->flags & ZILOG_CLOSING) {
  1753. interruptible_sleep_on(&info->close_wait);
  1754. #ifdef SERIAL_DO_RESTART
  1755. if (info->flags & ZILOG_HUP_NOTIFY)
  1756. return -EAGAIN;
  1757. else
  1758. return -ERESTARTSYS;
  1759. #else
  1760. return -EAGAIN;
  1761. #endif
  1762. }
  1764. /*
  1765.  * If this is a callout device, then just make sure the normal
  1766.  * device isn't being used.
  1767.  */
  1768. if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
  1769. if (info->flags & ZILOG_NORMAL_ACTIVE)
  1770. return -EBUSY;
  1771. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1772.     (info->flags & ZILOG_SESSION_LOCKOUT) &&
  1773.     (info->session != current->session))
  1774.     return -EBUSY;
  1775. if ((info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1776.     (info->flags & ZILOG_PGRP_LOCKOUT) &&
  1777.     (info->pgrp != current->pgrp))
  1778.     return -EBUSY;
  1779. info->flags |= ZILOG_CALLOUT_ACTIVE;
  1780. return 0;
  1781. }
  1783. /*
  1784.  * If non-blocking mode is set, or the port is not enabled,
  1785.  * then make the check up front and then exit.
  1786.  */
  1787. if ((filp->f_flags & O_NONBLOCK) ||
  1788.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1789. if (info->flags & ZILOG_CALLOUT_ACTIVE)
  1790. return -EBUSY;
  1791. info->flags |= ZILOG_NORMAL_ACTIVE;
  1792. return 0;
  1793. }
  1795. if (info->flags & ZILOG_CALLOUT_ACTIVE) {
  1796. if (info->normal_termios.c_cflag & CLOCAL)
  1797. do_clocal = 1;
  1798. } else {
  1799. if (tty->termios->c_cflag & CLOCAL)
  1800. do_clocal = 1;
  1801. }
  1803. /*
  1804.  * Block waiting for the carrier detect and the line to become
  1805.  * free (i.e., not in use by the callout).  While we are in
  1806.  * this loop, info->count is dropped by one, so that
  1807.  * zs_close() knows when to free things.  We restore it upon
  1808.  * exit, either normal or abnormal.
  1809.  */
  1810. retval = 0;
  1811. add_wait_queue(&info->open_wait, &wait);
  1812. #ifdef SERIAL_DEBUG_OPEN
  1813. printk("block_til_ready before block: ttys%d, count = %dn",
  1814.        info->line, info->count);
  1815. #endif
  1816. cli();
  1817. if(!tty_hung_up_p(filp))
  1818. info->count--;
  1819. sti();
  1820. info->blocked_open++;
  1821. while (1) {
  1822. cli();
  1823. if (!(info->flags & ZILOG_CALLOUT_ACTIVE))
  1824. zs_rtsdtr(info, 1);
  1825. sti();
  1826. set_current_state(TASK_INTERRUPTIBLE);
  1827. if (tty_hung_up_p(filp) ||
  1828.     !(info->flags & ZILOG_INITIALIZED)) {
  1829. #ifdef SERIAL_DEBUG_OPEN
  1830. printk("block_til_ready hup-ed: ttys%d, count = %dn",
  1831. info->line, info->count);
  1832. #endif
  1833. #ifdef SERIAL_DO_RESTART
  1834. if (info->flags & ZILOG_HUP_NOTIFY)
  1835. retval = -EAGAIN;
  1836. else
  1837. retval = -ERESTARTSYS;
  1838. #else
  1839. retval = -EAGAIN;
  1840. #endif
  1841. break;
  1842. }
  1844. cli();
  1845. r0 = read_zsreg(info->zs_channel, R0);
  1846. sti();
  1847. if (!(info->flags & ZILOG_CALLOUT_ACTIVE) &&
  1848.     !(info->flags & ZILOG_CLOSING) &&
  1849.     (do_clocal || (DCD & r0)))
  1850. break;
  1851. if (signal_pending(current)) {
  1852. retval = -ERESTARTSYS;
  1853. break;
  1854. }
  1855. #ifdef SERIAL_DEBUG_OPEN
  1856. printk("block_til_ready blocking: ttys%d, count = %dn",
  1857.        info->line, info->count);
  1858. #endif
  1859. schedule();
  1860. }
  1861. current->state = TASK_RUNNING;
  1862. remove_wait_queue(&info->open_wait, &wait);
  1863. if (!tty_hung_up_p(filp))
  1864. info->count++;
  1865. info->blocked_open--;
  1866. #ifdef SERIAL_DEBUG_OPEN
  1867. printk("block_til_ready after blocking: ttys%d, count = %dn",
  1868.        info->line, info->count);
  1869. #endif
  1870. if (retval)
  1871. return retval;
  1872. info->flags |= ZILOG_NORMAL_ACTIVE;
  1873. return 0;
  1874. }
  1876. /*
  1877.  * This routine is called whenever a serial port is opened.  It
  1878.  * enables interrupts for a serial port, linking in its ZILOG structure into
  1879.  * the IRQ chain.   It also performs the serial-specific
  1880.  * initialization for the tty structure.
  1881.  */
  1882. int zs_open(struct tty_struct *tty, struct file * filp)
  1883. {
  1884. struct sun_serial *info;
  1885. int retval, line;
  1887. line = MINOR(tty->device) - tty->driver.minor_start;
  1889. /* The zilog lines for the mouse/keyboard must be
  1890.  * opened using their respective drivers.
  1891.  */
  1892. if ((line < 0) || (line >= NUM_CHANNELS))
  1893. return -ENODEV;
  1894. if((line == KEYBOARD_LINE) || (line == MOUSE_LINE))
  1895. return -ENODEV;
  1896. info = zs_soft + line;
  1897. /* Is the kgdb running over this line? */
  1898. if (info->kgdb_channel)
  1899. return -ENODEV;
  1900. if (serial_paranoia_check(info, tty->device, "zs_open"))
  1901. return -ENODEV;
  1902. #ifdef SERIAL_DEBUG_OPEN
  1903. printk("zs_open %s%d, count = %dn", tty->driver.name, info->line,
  1904.        info->count);
  1905. #endif
  1906. if (info->tty != 0 && info->tty != tty) {
  1907. /* Never happen? */
  1908. printk("zs_open %s%d, tty overwrite.n", tty->driver.name, info->line);
  1909. return -EBUSY;
  1910. }
  1912. if (!tmp_buf) {
  1913. unsigned long page = get_free_page(GFP_KERNEL);
  1914. if (!page)
  1915. return -ENOMEM;
  1916. if (tmp_buf)
  1917. free_page(page);
  1918. else
  1919. tmp_buf = (unsigned char *) page;
  1920. }
  1922. info->count++;
  1923. tty->driver_data = info;
  1924. info->tty = tty;
  1926. /*
  1927.  * Start up serial port
  1928.  */
  1929. retval = startup(info);
  1930. if (retval)
  1931. return retval;
  1933. retval = block_til_ready(tty, filp, info);
  1934. if (retval) {
  1935. #ifdef SERIAL_DEBUG_OPEN
  1936. printk("zs_open returning after block_til_ready with %dn",
  1937.        retval);
  1938. #endif
  1939. return retval;
  1940. }
  1942. if ((info->count == 1) && (info->flags & ZILOG_SPLIT_TERMIOS)) {
  1943. if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
  1944. *tty->termios = info->normal_termios;
  1945. else 
  1946. *tty->termios = info->callout_termios;
  1947. change_speed(info);
  1948. }
  1950. #ifdef CONFIG_SERIAL_CONSOLE
  1951. if (zs_console.cflag && zs_console.index == line) {
  1952. tty->termios->c_cflag = zs_console.cflag;
  1953. zs_console.cflag = 0;
  1954. change_speed(info);
  1955. }
  1956. #endif
  1958. info->session = current->session;
  1959. info->pgrp = current->pgrp;
  1961. #ifdef SERIAL_DEBUG_OPEN
  1962. printk("zs_open ttys%d successful...", info->line);
  1963. #endif
  1964. return 0;
  1965. }
  1967. /* Finally, routines used to initialize the serial driver. */
  1969. static void show_serial_version(void)
  1970. {
  1971. char *revision = "$Revision: 1.68.2.2 $";
  1972. char *version, *p;
  1974. version = strchr(revision, ' ');
  1975. p = strchr(++version, ' ');
  1976. *p = '';
  1977. printk("Sparc Zilog8530 serial driver version %sn", version);
  1978. *p = ' ';
  1979. }
  1981. /* Probe the PROM for the request zs chip number.
  1982.  *
  1983.  * Note: The Sun Voyager shows two addresses and two intr for it's
  1984.  *       Zilogs, what the second does, I don't know. It does work
  1985.  *       with using only the first number of each property.  Also
  1986.  *       we have a special version for sun4u.
  1987.  */
  1988. #ifdef __sparc_v9__
  1989. static struct sun_zslayout * __init get_zs(int chip)
  1990. {
  1991. unsigned int vaddr[2] = { 0, 0 };
  1992. unsigned long mapped_addr = 0;
  1993. int busnode, seen, zsnode, sun4u_ino;
  1994. static int irq = 0;
  1996. if(chip < 0 || chip >= NUM_SERIAL) {
  1997. prom_printf("get_zs bogon zs chip number");
  1998. prom_halt();
  1999. }
  2001. if(central_bus)
  2002. busnode = central_bus->child->prom_node;
  2003. else
  2004. busnode = prom_searchsiblings(prom_getchild(prom_root_node), "sbus");
  2005. if(busnode == 0 || busnode == -1) {
  2006. prom_printf("get_zs: no zs bus to search");
  2007. prom_halt();
  2008. }
  2009. zsnode = prom_getchild(busnode);
  2010. seen = 0;
  2011. while(zsnode) {
  2012. int slave;
  2014. zsnode = prom_searchsiblings(zsnode, "zs");
  2015. slave = prom_getintdefault(zsnode, "slave", -1);
  2016. if((slave == chip) || (seen == chip)) {
  2017. int len = prom_getproperty(zsnode, "address",
  2018.    (void *) vaddr, sizeof(vaddr));
  2020. if(len == -1 || central_bus != NULL) {
  2021. struct sbus_bus *sbus = NULL;
  2022. struct sbus_dev *sdev = NULL;
  2024. /* "address" property is not guarenteed,
  2025.  * everything in I/O is implicitly mapped
  2026.  * anyways by our clever TLB miss handling
  2027.  * scheme, so don't fail here.  -DaveM
  2028.  */
  2029. if (central_bus == NULL) {
  2030. for_each_sbus(sbus) {
  2031. for_each_sbusdev(sdev, sbus) {
  2032. if (sdev->prom_node == zsnode)
  2033. goto found;
  2034. }
  2035. }
  2036. }
  2037. found:
  2038. if (sdev == NULL && central_bus == NULL)
  2039. prom_halt();
  2040. if (central_bus == NULL) {
  2041. mapped_addr =
  2042.     sbus_ioremap(&sdev->resource[0], 0,
  2043.  PAGE_SIZE, "Zilog Registers");
  2044. } else {
  2045. struct linux_prom_registers zsregs[1];
  2046. int err;
  2048. err = prom_getproperty(zsnode, "reg",
  2049.        (char *)&zsregs[0],
  2050.        sizeof(zsregs));
  2051. if (err == -1) {
  2052. prom_printf("ZS: Cannot map Zilog regs.n");
  2053. prom_halt();
  2054. }
  2055. apply_fhc_ranges(central_bus->child, &zsregs[0], 1);
  2056. apply_central_ranges(central_bus, &zsregs[0], 1);
  2057. mapped_addr =
  2058. ((((u64)zsregs[0].which_io)<<32UL)|
  2059.  ((u64)zsregs[0].phys_addr));
  2060. }
  2061. } else if(len % sizeof(unsigned int)) {
  2062. prom_printf("WHOOPS:  proplen for %s "
  2063.     "was %d, need multiple of "
  2064.     "%dn", "address", len,
  2065.     sizeof(unsigned int));
  2066. panic("zilog: address property");
  2067. }
  2068. zs_nodes[chip] = zsnode;
  2069. len = prom_getproperty(zsnode, "interrupts",
  2070.        (char *) &sun4u_ino,
  2071.        (sizeof(sun4u_ino)));
  2072. if(!irq) {
  2073. if (central_bus) {
  2074. unsigned long iclr, imap;
  2076. iclr = central_bus->child->fhc_regs.uregs + FHC_UREGS_ICLR;
  2077. imap = central_bus->child->fhc_regs.uregs + FHC_UREGS_IMAP;
  2078. irq = zilog_irq = build_irq(12, 0, iclr, imap);
  2079. } else {
  2080. irq = zilog_irq = 
  2081. sbus_build_irq(sbus_root, sun4u_ino);
  2082. }
  2083. }
  2084. break;
  2085. }
  2086. zsnode = prom_getsibling(zsnode);
  2087. seen++;
  2088. }
  2089. if(!zsnode)
  2090. panic("get_zs: whee chip not found");
  2091. if(!vaddr[0] && !mapped_addr)
  2092. panic("get_zs: whee no serial chip mappable");
  2093. if (mapped_addr != 0) {
  2094. return (struct sun_zslayout *) mapped_addr;
  2095. } else {
  2096. return (struct sun_zslayout *) prom_virt_to_phys((unsigned long)vaddr[0], 0);
  2097. }
  2098. }
  2099. #else /* !(__sparc_v9__) */
  2100. static struct sun_zslayout * __init get_zs(int chip)
  2101. {
  2102. struct linux_prom_irqs tmp_irq[2];
  2103. unsigned int paddr = 0;
  2104. unsigned int vaddr[2] = { 0, 0 };
  2105. int zsnode, tmpnode, iospace, slave, len;
  2106. int cpunode = 0, bbnode = 0;
  2107. static int irq = 0;
  2108. int chipid = chip;
  2110. iospace = 0;
  2111. if(chip < 0 || chip >= NUM_SERIAL)
  2112. panic("get_zs bogon zs chip number");
  2114. if(sparc_cpu_model == sun4) {
  2115. struct resource dummy_resource;
  2117. /* Grrr, these have to be hardcoded aieee */
  2118. switch(chip) {
  2119. case 0:
  2120. paddr = 0xf1000000;
  2121. break;
  2122. case 1:
  2123. paddr = 0xf0000000;
  2124. break;
  2125. };
  2126. iospace = 0;
  2127. zs_nodes[chip] = 0;
  2128. if(!irq)
  2129. zilog_irq = irq = 12;
  2130. dummy_resource.start = paddr;
  2131. dummy_resource.end = paddr + 8 - 1;
  2132. dummy_resource.flags = IORESOURCE_IO;
  2133. vaddr[0] = sbus_ioremap(&dummy_resource, 0,
  2134. 8, "Zilog Serial");
  2135. } else {
  2136. /* Can use the prom for other machine types */
  2137. zsnode = prom_getchild(prom_root_node);
  2138. if (sparc_cpu_model == sun4d) {
  2139. int no = 0;
  2141. tmpnode = zsnode;
  2142. zsnode = 0;
  2143. bbnode = 0;
  2144. while (tmpnode && (tmpnode = prom_searchsiblings(tmpnode, "cpu-unit"))) {
  2145. bbnode = prom_getchild(tmpnode);
  2146. if (bbnode && (bbnode = prom_searchsiblings(bbnode, "bootbus"))) {
  2147. if (no == (chip >> 1)) {
  2148. cpunode = tmpnode;
  2149. zsnode = prom_getchild(bbnode);
  2150. chipid = (chip & 1);
  2151. break;
  2152. }
  2153. no++;
  2154. }
  2155. tmpnode = prom_getsibling(tmpnode);
  2156. }
  2157. if (!tmpnode)
  2158. panic ("get_zs: couldn't find %dth bootbusn", chip >> 1);
  2159. } else {
  2160. tmpnode = prom_searchsiblings(zsnode, "obio");
  2161. if(tmpnode)
  2162. zsnode = prom_getchild(tmpnode);
  2163. }
  2164. if(!zsnode)
  2165. panic("get_zs no zs serial prom node");
  2166. while(zsnode) {
  2167. zsnode = prom_searchsiblings(zsnode, "zs");
  2168. slave = prom_getintdefault(zsnode, "slave", -1);
  2169. if(slave == chipid) {
  2170. /* The one we want */
  2171. if (sparc_cpu_model != sun4d) {
  2172. len = prom_getproperty(zsnode, "address",
  2173.        (void *) vaddr,
  2174.        sizeof(vaddr));
  2175.          if (len % sizeof(unsigned int)) {
  2176. prom_printf("WHOOPS:  proplen for %s "
  2177. "was %d, need multiple of "
  2178. "%dn", "address", len,
  2179. sizeof(unsigned int));
  2180. panic("zilog: address property");
  2181. }
  2182. } else {
  2183. /* On sun4d don't have address property :( */
  2184. struct linux_prom_registers zsreg[4];
  2185. struct resource res;
  2187. if (prom_getproperty(zsnode, "reg", (char *)zsreg, sizeof(zsreg)) == -1) {
  2188. prom_printf ("Cannot map zs regsn");
  2189. prom_halt();
  2190. }
  2191. prom_apply_generic_ranges(bbnode, cpunode, zsreg, 1);
  2192. res.start = zsreg[0].phys_addr;
  2193. res.end = res.start + 8 - 1;
  2194. res.flags = zsreg[0].which_io | IORESOURCE_IO;
  2195. vaddr[0] = sbus_ioremap(&res, 0,
  2196. 8, "Zilog Serial");
  2197. }
  2198. zs_nodes[chip] = zsnode;
  2199. len = prom_getproperty(zsnode, "intr",
  2200.        (char *) tmp_irq,
  2201.        sizeof(tmp_irq));
  2202. if (len % sizeof(struct linux_prom_irqs)) {
  2203. prom_printf(
  2204.       "WHOOPS:  proplen for %s "
  2205.       "was %d, need multiple of "
  2206.       "%dn", "intr", len,
  2207.       sizeof(struct linux_prom_irqs));
  2208. panic("zilog: intr property");
  2209. }
  2210. if(!irq) {
  2211. irq = zilog_irq = tmp_irq[0].pri;
  2212. } else {
  2213. if(tmp_irq[0].pri != irq)
  2214. panic("zilog: bogon irqs");
  2215. }
  2216. break;
  2217. }
  2218. zsnode = prom_getsibling(zsnode);
  2219. }
  2220. if(!zsnode)
  2221. panic("get_zs whee chip not found");
  2222. }
  2223. if(!vaddr[0])
  2224. panic("get_zs whee no serial chip mappable");
  2226. return (struct sun_zslayout *)(unsigned long) vaddr[0];
  2227. }
  2228. #endif
  2229. /* This is for the auto baud rate detection in the mouse driver. */
  2230. void zs_change_mouse_baud(int newbaud)
  2231. {
  2232. int channel = MOUSE_LINE;
  2233. int brg;
  2235. zs_soft[channel].zs_baud = newbaud;
  2236. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2237.  (ZS_CLOCK / zs_soft[channel].clk_divisor));
  2238. write_zsreg(zs_soft[channel].zs_channel, R12, (brg & 0xff));
  2239. write_zsreg(zs_soft[channel].zs_channel, R13, ((brg >> 8) & 0xff));
  2240. }
  2242. void __init zs_init_alloc_failure(const char *table_name)
  2243. {
  2244. prom_printf("zs_probe: Cannot alloc %s.n", table_name);
  2245. prom_halt();
  2246. }
  2248. void * __init zs_alloc_bootmem(unsigned long size)
  2249. {
  2250. void *ret;
  2252. ret = __alloc_bootmem(size, SMP_CACHE_BYTES, 0UL);
  2253. if (ret != NULL)
  2254. memset(ret, 0, size);
  2256. return ret;
  2257. }
  2259. void __init zs_alloc_tables(void)
  2260. {
  2261. zs_chips = (struct sun_zslayout **)
  2262. zs_alloc_bootmem(NUM_SERIAL * sizeof(struct sun_zslayout *));
  2263. if (zs_chips == NULL)
  2264. zs_init_alloc_failure("zs_chips");
  2265. zs_channels = (struct sun_zschannel **)
  2266. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct sun_zschannel *));
  2267. if (zs_channels == NULL)
  2268. zs_init_alloc_failure("zs_channels");
  2269. zs_nodes = (int *)
  2270. zs_alloc_bootmem(NUM_SERIAL * sizeof(int));
  2271. if (zs_nodes == NULL)
  2272. zs_init_alloc_failure("zs_nodes");
  2273. zs_soft = (struct sun_serial *)
  2274. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct sun_serial));
  2275. if (zs_soft == NULL)
  2276. zs_init_alloc_failure("zs_soft");
  2277. zs_ttys = (struct tty_struct *)
  2278. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct tty_struct));
  2279. if (zs_ttys == NULL)
  2280. zs_init_alloc_failure("zs_ttys");
  2281. serial_table = (struct tty_struct **)
  2282. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct tty_struct *));
  2283. if (serial_table == NULL)
  2284. zs_init_alloc_failure("serial_table");
  2285. serial_termios = (struct termios **)
  2286. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct termios *));
  2287. if (serial_termios == NULL)
  2288. zs_init_alloc_failure("serial_termios");
  2289. serial_termios_locked = (struct termios **)
  2290. zs_alloc_bootmem(NUM_CHANNELS * sizeof(struct termios *));
  2291. if (serial_termios_locked == NULL)
  2292. zs_init_alloc_failure("serial_termios_locked");
  2293. }
  2295. int __init zs_probe(void)
  2296. {
  2297. int node;
  2299. if(sparc_cpu_model == sun4)
  2300. goto no_probe;
  2302. NUM_SERIAL = 0;
  2304. node = prom_getchild(prom_root_node);
  2305. if (sparc_cpu_model == sun4d) {
  2306. int bbnode;
  2308. while (node && (node = prom_searchsiblings(node, "cpu-unit"))) {
  2309. bbnode = prom_getchild(node);
  2310. if (bbnode && prom_searchsiblings(bbnode, "bootbus"))
  2311. NUM_SERIAL += 2;
  2312. node = prom_getsibling(node);
  2313. }
  2314. goto no_probe;
  2315. }
  2316. #ifdef __sparc_v9__
  2317. else if (sparc_cpu_model == sun4u) {
  2318. int central_node;
  2320. /* Central bus zilogs must be checked for first,
  2321.  * since Enterprise boxes might have SBUSes as well.
  2322.  */
  2323. central_node = prom_finddevice("/central");
  2324. if(central_node != 0 && central_node != -1)
  2325. node = prom_searchsiblings(prom_getchild(central_node), "fhc");
  2326. else
  2327. node = prom_searchsiblings(node, "sbus");
  2328. if(node != 0 && node != -1)
  2329. node = prom_getchild(node);
  2330. if(node == 0 || node == -1)
  2331. return -ENODEV;
  2332. }
  2333. #endif /* __sparc_v9__ */
  2334. else {
  2335. node = prom_searchsiblings(node, "obio");
  2336. if(node)
  2337. node = prom_getchild(node);
  2338. NUM_SERIAL = 2;
  2339. goto no_probe;
  2340. }
  2342. node = prom_searchsiblings(node, "zs");
  2343. if (!node)
  2344. return -ENODEV;
  2346. NUM_SERIAL = 2;
  2348. no_probe:
  2349. zs_alloc_tables();
  2351. /* Fill in rs_ops struct... */
  2352. #ifdef CONFIG_SERIAL_CONSOLE
  2353. sunserial_setinitfunc(zs_console_init);
  2354. #endif
  2355. sunserial_setinitfunc(zs_init);
  2356. rs_ops.rs_kgdb_hook = zs_kgdb_hook;
  2357. rs_ops.rs_change_mouse_baud = zs_change_mouse_baud;
  2359. sunkbd_setinitfunc(sun_kbd_init);
  2360. kbd_ops.compute_shiftstate = sun_compute_shiftstate;
  2361. kbd_ops.setledstate = sun_setledstate;
  2362. kbd_ops.getledstate = sun_getledstate;
  2363. kbd_ops.setkeycode = sun_setkeycode;
  2364. kbd_ops.getkeycode = sun_getkeycode;
  2365. #if defined(__sparc_v9__) && defined(CONFIG_PCI)
  2366. sunkbd_install_keymaps(sun_key_maps, sun_keymap_count,
  2367.        sun_func_buf, sun_func_table,
  2368.        sun_funcbufsize, sun_funcbufleft,
  2369.        sun_accent_table, sun_accent_table_size);
  2370. #endif
  2371. return 0;
  2372. }
  2374. static inline void zs_prepare(void)
  2375. {
  2376. int channel, chip;
  2377. unsigned long flags;
  2379. if (!NUM_SERIAL)
  2380. return;
  2382. save_and_cli(flags);
  2384. /* Set up our interrupt linked list */
  2385. zs_chain = &zs_soft[0];
  2386. for(channel = 0; channel < NUM_CHANNELS - 1; channel++) {
  2387. zs_soft[channel].zs_next = &zs_soft[channel + 1];
  2388. zs_soft[channel].line = channel;
  2389. }
  2390. zs_soft[channel].zs_next = 0;
  2392. /* Initialize Softinfo */
  2393. for(chip = 0; chip < NUM_SERIAL; chip++) {
  2394. /* If we are doing kgdb over one of the channels on
  2395.  * chip zero, kgdb_channel will be set to 1 by the
  2396.  * zs_kgdb_hook() routine below.
  2397.  */
  2398. if(!zs_chips[chip]) {
  2399. zs_chips[chip] = get_zs(chip);
  2400. /* Two channels per chip */
  2401. zs_channels[(chip*2)] = &zs_chips[chip]->channelA;
  2402. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelB;
  2403. zs_soft[(chip*2)].kgdb_channel = 0;
  2404. zs_soft[(chip*2)+1].kgdb_channel = 0;
  2405. }
  2407. /* First, set up channel A on this chip. */
  2408. channel = chip * 2;
  2409. zs_soft[channel].zs_channel = zs_channels[channel];
  2410. zs_soft[channel].change_needed = 0;
  2411. zs_soft[channel].clk_divisor = 16;
  2412. zs_soft[channel].cons_keyb = 0;
  2413. zs_soft[channel].cons_mouse = 0;
  2414. zs_soft[channel].channelA = 1;
  2416. /* Now, channel B */
  2417. channel++;
  2418. zs_soft[channel].zs_channel = zs_channels[channel];
  2419. zs_soft[channel].change_needed = 0;
  2420. zs_soft[channel].clk_divisor = 16;
  2421. zs_soft[channel].cons_keyb = 0;
  2422. zs_soft[channel].cons_mouse = 0;
  2423. zs_soft[channel].channelA = 0;
  2424. }
  2426. restore_flags(flags);
  2427. }
  2429. int __init zs_init(void)
  2430. {
  2431. int channel, brg, i;
  2432. unsigned long flags;
  2433. struct sun_serial *info;
  2434. char dummy;
  2436. /* Setup base handler, and timer table. */
  2437. init_bh(SERIAL_BH, do_serial_bh);
  2439. show_serial_version();
  2441. /* Initialize the tty_driver structure */
  2442. /* SPARC: Not all of this is exactly right for us. */
  2444. memset(&serial_driver, 0, sizeof(struct tty_driver));
  2445. serial_driver.magic = TTY_DRIVER_MAGIC;
  2446. serial_driver.driver_name = "serial";
  2447. #ifdef CONFIG_DEVFS_FS
  2448. serial_driver.name = "tts/%d";
  2449. #else
  2450. serial_driver.name = "ttyS";
  2451. #endif
  2452. serial_driver.major = TTY_MAJOR;
  2453. serial_driver.minor_start = 64;
  2454. serial_driver.num = NUM_CHANNELS;
  2455. serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
  2456. serial_driver.subtype = SERIAL_TYPE_NORMAL;
  2457. serial_driver.init_termios = tty_std_termios;
  2458. serial_driver.init_termios.c_cflag =
  2459. B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  2460. serial_driver.flags = TTY_DRIVER_REAL_RAW;
  2461. serial_driver.refcount = &serial_refcount;
  2462. serial_driver.table = serial_table;
  2463. serial_driver.termios = serial_termios;
  2464. serial_driver.termios_locked = serial_termios_locked;
  2466. serial_driver.open = zs_open;
  2467. serial_driver.close = zs_close;
  2468. serial_driver.write = zs_write;
  2469. serial_driver.flush_chars = zs_flush_chars;
  2470. serial_driver.write_room = zs_write_room;
  2471. serial_driver.chars_in_buffer = zs_chars_in_buffer;
  2472. serial_driver.flush_buffer = zs_flush_buffer;
  2473. serial_driver.ioctl = zs_ioctl;
  2474. serial_driver.throttle = zs_throttle;
  2475. serial_driver.unthrottle = zs_unthrottle;
  2476. serial_driver.set_termios = zs_set_termios;
  2477. serial_driver.stop = zs_stop;
  2478. serial_driver.start = zs_start;
  2479. serial_driver.hangup = zs_hangup;
  2481. /* I'm too lazy, someone write versions of this for us. -DaveM */
  2482. /* I just did. :-) -AIB 2001-12-23 */
  2483. serial_driver.read_proc = zs_read_proc;
  2485. /*
  2486.  * The callout device is just like normal device except for
  2487.  * major number and the subtype code.
  2488.  */
  2489. callout_driver = serial_driver;
  2490. callout_driver.name = "cua/%d";
  2491. callout_driver.major = TTYAUX_MAJOR;
  2492. callout_driver.subtype = SERIAL_TYPE_CALLOUT;
  2493. callout_driver.read_proc = 0;
  2494. callout_driver.proc_entry = 0;
  2496. if (tty_register_driver(&serial_driver))
  2497. panic("Couldn't register serial drivern");
  2498. if (tty_register_driver(&callout_driver))
  2499. panic("Couldn't register callout drivern");
  2501. save_flags(flags); cli();
  2503. /* Initialize Softinfo */
  2504. zs_prepare();
  2506. /* Grab IRQ line before poking the chips so we do
  2507.  * not lose any interrupts.
  2508.  */
  2509. if (request_irq(zilog_irq, zs_interrupt, SA_SHIRQ,
  2510. "Zilog8530", zs_chain)) {
  2511. prom_printf("Unable to attach zs intrn");
  2512. prom_halt();
  2513. }
  2515. /* Initialize Hardware */
  2516. for(channel = 0; channel < NUM_CHANNELS; channel++) {
  2517. /* Hardware reset each chip */
  2518. if (!(channel & 1)) {
  2519. write_zsreg(zs_soft[channel].zs_channel, R9, FHWRES);
  2520. ZSDELAY_LONG();
  2521. dummy = read_zsreg(zs_soft[channel].zs_channel, R0);
  2522. }
  2524. if(channel == KEYBOARD_LINE) {
  2525. zs_soft[channel].cons_keyb = 1;
  2526. zs_soft[channel].parity_mask = 0xff;
  2527. zs_kbdchan = zs_soft[channel].zs_channel;
  2529. write_zsreg(zs_soft[channel].zs_channel, R4,
  2530.     (PAR_EVEN | X16CLK | SB1));
  2531. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2532. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2533. write_zsreg(zs_soft[channel].zs_channel, R9, NV);
  2534. write_zsreg(zs_soft[channel].zs_channel, R10, NRZ);
  2535. write_zsreg(zs_soft[channel].zs_channel, R11,
  2536.     (TCBR | RCBR));
  2537. zs_soft[channel].zs_baud = 1200;
  2538. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2539.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2540. write_zsreg(zs_soft[channel].zs_channel, R12,
  2541.     (brg & 0xff));
  2542. write_zsreg(zs_soft[channel].zs_channel, R13,
  2543.     ((brg >> 8) & 0xff));
  2544. write_zsreg(zs_soft[channel].zs_channel, R14, BRSRC);
  2546. /* Enable Rx/Tx, IRQs, and inform kbd driver */
  2547. write_zsreg(zs_soft[channel].zs_channel, R14,
  2548.     (BRSRC | BRENAB));
  2549. write_zsreg(zs_soft[channel].zs_channel, R3,
  2550.     (Rx8 | RxENAB));
  2551. write_zsreg(zs_soft[channel].zs_channel, R5,
  2552.     (Tx8 | TxENAB | DTR | RTS));
  2554. write_zsreg(zs_soft[channel].zs_channel, R15,
  2555.     (DCDIE | CTSIE | TxUIE | BRKIE));
  2556. write_zsreg(zs_soft[channel].zs_channel, R0,
  2557.     RES_EXT_INT);
  2558. write_zsreg(zs_soft[channel].zs_channel, R0,
  2559.     RES_EXT_INT);
  2561. write_zsreg(zs_soft[channel].zs_channel, R1,
  2562.     (EXT_INT_ENAB | INT_ALL_Rx));
  2563. write_zsreg(zs_soft[channel].zs_channel, R9,
  2564.     (NV | MIE));
  2565. ZS_CLEARERR(zs_soft[channel].zs_channel);
  2566. ZS_CLEARFIFO(zs_soft[channel].zs_channel);
  2567. } else if(channel == MOUSE_LINE) {
  2568. zs_soft[channel].cons_mouse = 1;
  2569. zs_soft[channel].parity_mask = 0xff;
  2570. zs_mousechan = zs_soft[channel].zs_channel;
  2572. write_zsreg(zs_soft[channel].zs_channel, R4,
  2573.     (PAR_EVEN | X16CLK | SB1));
  2574. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2575. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2576. write_zsreg(zs_soft[channel].zs_channel, R9, NV);
  2577. write_zsreg(zs_soft[channel].zs_channel, R10, NRZ);
  2578. write_zsreg(zs_soft[channel].zs_channel, R11,
  2579.     (TCBR | RCBR));
  2581. zs_soft[channel].zs_baud = 4800;
  2582. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2583.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2584. write_zsreg(zs_soft[channel].zs_channel, R12,
  2585.     (brg & 0xff));
  2586. write_zsreg(zs_soft[channel].zs_channel, R13,
  2587.     ((brg >> 8) & 0xff));
  2588. write_zsreg(zs_soft[channel].zs_channel, R14, BRSRC);
  2590. /* Enable Rx, IRQs, and inform mouse driver */
  2591. write_zsreg(zs_soft[channel].zs_channel, R14,
  2592.     (BRSRC | BRENAB));
  2593. write_zsreg(zs_soft[channel].zs_channel, R3,
  2594.     (Rx8 | RxENAB));
  2595. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2597. write_zsreg(zs_soft[channel].zs_channel, R15,
  2598.     (DCDIE | CTSIE | TxUIE | BRKIE));
  2599. write_zsreg(zs_soft[channel].zs_channel, R0,
  2600.     RES_EXT_INT);
  2601. write_zsreg(zs_soft[channel].zs_channel, R0,
  2602.     RES_EXT_INT);
  2604. write_zsreg(zs_soft[channel].zs_channel, R1,
  2605.     (EXT_INT_ENAB | INT_ALL_Rx));
  2606. write_zsreg(zs_soft[channel].zs_channel, R9,
  2607.     (NV | MIE));
  2609. sun_mouse_zsinit();
  2610. } else if (zs_soft[channel].is_cons) {
  2611. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2612.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2613. zscons_regs[12] = brg & 0xff;
  2614. zscons_regs[13] = (brg >> 8) & 0xff;
  2616. memcpy(zs_soft[channel].curregs, zscons_regs, sizeof(zscons_regs));
  2617. load_zsregs(&zs_soft[channel], zscons_regs);
  2619. ZS_CLEARERR(zs_soft[channel].zs_channel);
  2620. ZS_CLEARFIFO(zs_soft[channel].zs_channel);
  2621. } else if (zs_soft[channel].kgdb_channel) {
  2622. /* If this is the kgdb line, enable interrupts because
  2623.  * we now want to receive the 'control-c' character
  2624.  * from the client attached to us asynchronously.
  2625.  */
  2626. zs_soft[channel].parity_mask = 0xff;
  2627.          kgdb_chaninit(&zs_soft[channel], 1,
  2628.       zs_soft[channel].zs_baud);
  2629. } else {
  2630. zs_soft[channel].parity_mask = 0xff;
  2631. write_zsreg(zs_soft[channel].zs_channel, R4,
  2632.     (PAR_EVEN | X16CLK | SB1));
  2633. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2634. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2635. write_zsreg(zs_soft[channel].zs_channel, R9, NV);
  2636. write_zsreg(zs_soft[channel].zs_channel, R10, NRZ);
  2637. write_zsreg(zs_soft[channel].zs_channel, R11,
  2638.     (RCBR | TCBR));
  2639. zs_soft[channel].zs_baud = 9600;
  2640. brg = BPS_TO_BRG(zs_soft[channel].zs_baud,
  2641.  ZS_CLOCK/zs_soft[channel].clk_divisor);
  2642. write_zsreg(zs_soft[channel].zs_channel, R12,
  2643.     (brg & 0xff));
  2644. write_zsreg(zs_soft[channel].zs_channel, R13,
  2645.     ((brg >> 8) & 0xff));
  2646. write_zsreg(zs_soft[channel].zs_channel, R14, BRSRC);
  2647. write_zsreg(zs_soft[channel].zs_channel, R14,
  2648.     (BRSRC | BRENAB));
  2649. write_zsreg(zs_soft[channel].zs_channel, R3, Rx8);
  2650. write_zsreg(zs_soft[channel].zs_channel, R5, Tx8);
  2651. write_zsreg(zs_soft[channel].zs_channel, R15, DCDIE);
  2652. write_zsreg(zs_soft[channel].zs_channel, R9, NV | MIE);
  2653. write_zsreg(zs_soft[channel].zs_channel, R0,
  2654.     RES_EXT_INT);
  2655. write_zsreg(zs_soft[channel].zs_channel, R0,
  2656.     RES_EXT_INT);
  2657. }
  2658. }
  2660. for (info = zs_chain, i=0; info; info = info->zs_next, i++) {
  2661. info->magic = SERIAL_MAGIC;
  2662. info->port = (long) info->zs_channel;
  2663. info->line = i;
  2664. info->tty = 0;
  2665. info->irq = zilog_irq;
  2666. info->custom_divisor = 16;
  2667. info->close_delay = 50;
  2668. info->closing_wait = 3000;
  2669. info->x_char = 0;
  2670. info->event = 0;
  2671. info->count = 0;
  2672. info->blocked_open = 0;
  2673. info->tqueue.routine = do_softint;
  2674. info->tqueue.data = info;
  2675. info->tqueue_hangup.routine = do_serial_hangup;
  2676. info->tqueue_hangup.data = info;
  2677. info->callout_termios = callout_driver.init_termios;
  2678. info->normal_termios = serial_driver.init_termios;
  2679. init_waitqueue_head(&info->open_wait);
  2680. init_waitqueue_head(&info->close_wait);
  2681. printk("tty%02d at 0x%04x (irq = %s)", info->line, 
  2682.        info->port, __irq_itoa(info->irq));
  2683. printk(" is a Zilog8530n");
  2684. }
  2686. restore_flags(flags);
  2688. keyboard_zsinit(kbd_put_char);
  2689. return 0;
  2690. }
  2692. /* This is called at boot time to prime the kgdb serial debugging
  2693.  * serial line.  The 'tty_num' argument is 0 for /dev/ttya and 1
  2694.  * for /dev/ttyb which is determined in setup_arch() from the
  2695.  * boot command line flags.
  2696.  */
  2697. static void __init zs_kgdb_hook(int tty_num)
  2698. {
  2699. int chip = 0;
  2701. if(!zs_chips[chip]) {
  2702. zs_chips[chip] = get_zs(chip);
  2703. /* Two channels per chip */
  2704. zs_channels[(chip*2)] = &zs_chips[chip]->channelA;
  2705. zs_channels[(chip*2)+1] = &zs_chips[chip]->channelB;
  2706. }
  2707. zs_soft[tty_num].zs_channel = zs_channels[tty_num];
  2708. zs_kgdbchan = zs_soft[tty_num].zs_channel;
  2709. zs_soft[tty_num].change_needed = 0;
  2710. zs_soft[tty_num].clk_divisor = 16;
  2711. zs_soft[tty_num].zs_baud = 9600;
  2712. zs_soft[tty_num].kgdb_channel = 1;     /* This runs kgdb */
  2713. zs_soft[tty_num ^ 1].kgdb_channel = 0; /* This does not */
  2714. /* Turn on transmitter/receiver at 8-bits/char */
  2715.         kgdb_chaninit(&zs_soft[tty_num], 0, 9600);
  2716.         ZS_CLEARERR(zs_kgdbchan);
  2717.         ZS_CLEARFIFO(zs_kgdbchan);
  2718. }
  2720. #ifdef CONFIG_SERIAL_CONSOLE
  2722. /* This is for console output over ttya/ttyb */
  2723. static void
  2724. zs_console_putchar(struct sun_serial *info, char ch)
  2725. {
  2726. int loops = ZS_PUT_CHAR_MAX_DELAY;
  2727. unsigned long flags;
  2729. if(!info->zs_channel)
  2730. return;
  2732. save_flags(flags); cli();
  2733. zs_put_char(info->zs_channel, ch);
  2734. while (!(read_zsreg(info->zs_channel, R1) & ALL_SNT) && --loops)
  2735. udelay(5);
  2736. restore_flags(flags);
  2737. }
  2739. #ifdef SERIAL_CONSOLE_FAIR_OUTPUT
  2740. /*
  2741.  * Fair output driver allows a process to speak.
  2742.  */
  2743. static void zs_fair_output(struct sun_serial *info)
  2744. {
  2745. unsigned long flags;
  2746. int left; /* Output no more than that */
  2747. char c;
  2749. if (info == NULL)
  2750. return;
  2751. if (info->xmit_buf == NULL)
  2752. return;
  2754. save_flags(flags);  cli();
  2755. left = info->xmit_cnt;
  2756. while (left != 0) {
  2757. c = info->xmit_buf[info->xmit_tail];
  2758. info->xmit_tail = (info->xmit_tail+1) & (SERIAL_XMIT_SIZE-1);
  2759. info->xmit_cnt--;
  2760. restore_flags(flags);
  2762. zs_console_putchar(info, c);
  2764. cli();
  2765. left = MIN(info->xmit_cnt, left-1);
  2766. }
  2768. /* Last character is being transmitted now (hopefully). */
  2769. sbus_writeb(RES_Tx_P, &info->zs_channel->control);
  2770. ZSDELAY();
  2771. ZSLOG(REGCTRL, RES_Tx_P, 1);
  2773. restore_flags(flags);
  2774. return;
  2775. }
  2776. #endif
  2778. /*
  2779.  * zs_console_write is registered for printk.
  2780.  */
  2781. static void
  2782. zs_console_write(struct console *con, const char *s, unsigned count)
  2783. {
  2784. struct sun_serial *info;
  2785. int i;
  2787. info = zs_soft + con->index;
  2789. for (i = 0; i < count; i++, s++) {
  2790. if(*s == 'n')
  2791. zs_console_putchar(info, 'r');
  2792. zs_console_putchar(info, *s);
  2793. }
  2794. #ifdef SERIAL_CONSOLE_FAIR_OUTPUT
  2795. /* Comment this if you want to have a strict interrupt-driven output */
  2796. zs_fair_output(info);
  2797. #endif
  2798. }
  2800. static int
  2801. zs_console_wait_key(struct console *con)
  2802. {
  2803. sleep_on(&keypress_wait);
  2804. return 0;
  2805. }
  2807. static kdev_t zs_console_device(struct console *con)
  2808. {
  2809. return MKDEV(TTY_MAJOR, 64 + con->index);
  2810. }
  2812. static int __init zs_console_setup(struct console *con, char *options)
  2813. {
  2814. static struct tty_struct c_tty;
  2815. static struct termios c_termios;
  2816. struct sun_serial *info;
  2817. int brg, baud;
  2819. info = zs_soft + con->index;
  2820. info->is_cons = 1;
  2822. printk("Console: ttyS%d (Zilog8530)n", info->line);
  2824. sunserial_console_termios(con);
  2825. memset(&c_tty, 0, sizeof(c_tty));
  2826. memset(&c_termios, 0, sizeof(c_termios));
  2827. c_tty.termios = &c_termios;
  2828. c_termios.c_cflag = con->cflag;
  2829. baud = tty_get_baud_rate(&c_tty);
  2831. info->zs_baud = baud;
  2833. switch (con->cflag & CSIZE) {
  2834. case CS5:
  2835. zscons_regs[3] = Rx5 | RxENAB;
  2836. zscons_regs[5] = Tx5 | TxENAB;
  2837. info->parity_mask = 0x1f;
  2838. break;
  2839. case CS6:
  2840. zscons_regs[3] = Rx6 | RxENAB;
  2841. zscons_regs[5] = Tx6 | TxENAB;
  2842. info->parity_mask = 0x3f;
  2843. break;
  2844. case CS7:
  2845. zscons_regs[3] = Rx7 | RxENAB;
  2846. zscons_regs[5] = Tx7 | TxENAB;
  2847. info->parity_mask = 0x7f;
  2848. break;
  2849. default:
  2850. case CS8:
  2851. zscons_regs[3] = Rx8 | RxENAB;
  2852. zscons_regs[5] = Tx8 | TxENAB;
  2853. info->parity_mask = 0xff;
  2854. break;
  2855. }
  2856. zscons_regs[5] |= DTR;
  2858. if (con->cflag & PARENB)
  2859. zscons_regs[4] |= PAR_ENAB;
  2860. if (!(con->cflag & PARODD))
  2861. zscons_regs[4] |= PAR_EVEN;
  2863. if (con->cflag & CSTOPB)
  2864. zscons_regs[4] |= SB2;
  2865. else
  2866. zscons_regs[4] |= SB1;
  2868. brg = BPS_TO_BRG(baud, ZS_CLOCK / info->clk_divisor);
  2869. zscons_regs[12] = brg & 0xff;
  2870. zscons_regs[13] = (brg >> 8) & 0xff;
  2872. memcpy(info->curregs, zscons_regs, sizeof(zscons_regs));
  2873. load_zsregs(info, zscons_regs);
  2875. ZS_CLEARERR(info->zs_channel);
  2876. ZS_CLEARFIFO(info->zs_channel);
  2877. return 0;
  2878. }
  2880. static struct console zs_console = {
  2881. name: "ttyS",
  2882. write: zs_console_write,
  2883. device: zs_console_device,
  2884. wait_key: zs_console_wait_key,
  2885. setup: zs_console_setup,
  2886. flags: CON_PRINTBUFFER,
  2887. index: -1,
  2888. };
  2890. static int __init zs_console_init(void)
  2891. {
  2892. extern int con_is_present(void);
  2894. if (con_is_present())
  2895. return 0;
  2897. zs_console.index = serial_console - 1;
  2898. register_console(&zs_console);
  2899. return 0;
  2900. }
  2902. #endif /* CONFIG_SERIAL_CONSOLE */