Changed timer library function args.
Added select() support for tty fd's (not ptys yet).
This commit is contained in:
parent
3c7120d830
commit
471e0448c3
8 changed files with 220 additions and 64 deletions
|
@ -328,7 +328,7 @@ PRIVATE void f_expire_tmrs(struct driver *dp)
|
|||
* for each expired timers. FLOPPY watchdog functions are f_tmr_timeout()
|
||||
* and stop_motor(). Possibly a new alarm call must be scheduled.
|
||||
*/
|
||||
tmrs_exptimers(&f_timers, now);
|
||||
tmrs_exptimers(&f_timers, now, NULL);
|
||||
if (f_timers == NULL) {
|
||||
f_next_timeout = TMR_NEVER;
|
||||
} else { /* set new sync alarm */
|
||||
|
@ -354,7 +354,7 @@ tmr_func_t watchdog; /* watchdog function to be called */
|
|||
panic("FLOPPY","Couldn't get uptime from clock.", s);
|
||||
|
||||
/* Add the timer to the local timer queue. */
|
||||
tmrs_settimer(&f_timers, tp, now + delta, watchdog);
|
||||
tmrs_settimer(&f_timers, tp, now + delta, watchdog, NULL);
|
||||
|
||||
/* Possibly reschedule an alarm call. This happens when the front of the
|
||||
* timers queue was reinserted at another position, i.e., when a timer was
|
||||
|
|
|
@ -2369,7 +2369,7 @@ tmr_func_t watchdog; /* watchdog function to be called */
|
|||
panic("FXP","unable to get uptime from clock", r);
|
||||
|
||||
/* Add the timer to the local timer queue. */
|
||||
tmrs_settimer(&fxp_timers, tp, now + delta, watchdog);
|
||||
tmrs_settimer(&fxp_timers, tp, now + delta, watchdog, NULL);
|
||||
|
||||
/* Possibly reschedule an alarm call. This happens when a new timer
|
||||
* is added in front.
|
||||
|
@ -2407,7 +2407,7 @@ PRIVATE void fxp_expire_timers()
|
|||
/* Scan the timers queue for expired timers. Dispatch the watchdog function
|
||||
* for each expired timers. Possibly a new alarm call must be scheduled.
|
||||
*/
|
||||
tmrs_exptimers(&fxp_timers, now);
|
||||
tmrs_exptimers(&fxp_timers, now, NULL);
|
||||
if (fxp_timers == NULL)
|
||||
fxp_next_timeout= TMR_NEVER;
|
||||
else
|
||||
|
|
|
@ -114,7 +114,7 @@ struct sequence {
|
|||
unsigned char value;
|
||||
};
|
||||
|
||||
FORWARD _PROTOTYPE( void cons_write, (struct tty *tp) );
|
||||
FORWARD _PROTOTYPE( int cons_write, (struct tty *tp, int try) );
|
||||
FORWARD _PROTOTYPE( void cons_echo, (tty_t *tp, int c) );
|
||||
FORWARD _PROTOTYPE( void out_char, (console_t *cons, int c) );
|
||||
FORWARD _PROTOTYPE( void putk, (int c) );
|
||||
|
@ -128,14 +128,15 @@ FORWARD _PROTOTYPE( void get_6845, (int reg, unsigned *val) );
|
|||
FORWARD _PROTOTYPE( void stop_beep, (timer_t *tmrp) );
|
||||
FORWARD _PROTOTYPE( void cons_org0, (void) );
|
||||
FORWARD _PROTOTYPE( int ga_program, (struct sequence *seq) );
|
||||
FORWARD _PROTOTYPE( void cons_ioctl, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( int cons_ioctl, (tty_t *tp, int) );
|
||||
|
||||
|
||||
/*===========================================================================*
|
||||
* cons_write *
|
||||
*===========================================================================*/
|
||||
PRIVATE void cons_write(tp)
|
||||
PRIVATE int cons_write(tp, try)
|
||||
register struct tty *tp; /* tells which terminal is to be used */
|
||||
int try;
|
||||
{
|
||||
/* Copy as much data as possible to the output queue, then start I/O. On
|
||||
* memory-mapped terminals, such as the IBM console, the I/O will also be
|
||||
|
@ -148,6 +149,8 @@ register struct tty *tp; /* tells which terminal is to be used */
|
|||
char buf[64];
|
||||
console_t *cons = tp->tty_priv;
|
||||
|
||||
if(try) return 1; /* we can always write to console */
|
||||
|
||||
/* Check quickly for nothing to do, so this can be called often without
|
||||
* unmodular tests elsewhere.
|
||||
*/
|
||||
|
@ -757,7 +760,7 @@ PRIVATE void beep()
|
|||
}
|
||||
}
|
||||
/* Add a timer to the timers list. Possibly reschedule the alarm. */
|
||||
tmrs_settimer(&tty_timers, &tmr_stop_beep, now+B_TIME, stop_beep);
|
||||
tmrs_settimer(&tty_timers, &tmr_stop_beep, now+B_TIME, stop_beep, NULL);
|
||||
if (tty_timers->tmr_exp_time != tty_next_timeout) {
|
||||
tty_next_timeout = tty_timers->tmr_exp_time;
|
||||
if ((s=sys_syncalrm(SELF, tty_next_timeout, 1)) != OK)
|
||||
|
@ -873,7 +876,7 @@ tty_t *tp;
|
|||
cons->c_column = 0;
|
||||
}
|
||||
select_console(0);
|
||||
cons_ioctl(tp);
|
||||
cons_ioctl(tp, 0);
|
||||
}
|
||||
|
||||
/*==========================================================================*
|
||||
|
@ -1110,8 +1113,9 @@ struct sequence *seq;
|
|||
/*===========================================================================*
|
||||
* cons_ioctl *
|
||||
*===========================================================================*/
|
||||
PRIVATE void cons_ioctl(tp)
|
||||
PRIVATE int cons_ioctl(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* Set the screen dimensions. */
|
||||
|
||||
|
|
|
@ -7,6 +7,8 @@
|
|||
*/
|
||||
|
||||
#include "../drivers.h"
|
||||
#include <sys/time.h>
|
||||
#include <sys/select.h>
|
||||
#include <termios.h>
|
||||
#include <signal.h>
|
||||
#include <unistd.h>
|
||||
|
@ -84,7 +86,7 @@ FORWARD _PROTOTYPE( int scan_keyboard, (void) );
|
|||
FORWARD _PROTOTYPE( unsigned make_break, (int scode) );
|
||||
FORWARD _PROTOTYPE( void set_leds, (void) );
|
||||
FORWARD _PROTOTYPE( void show_key_mappings, (void) );
|
||||
FORWARD _PROTOTYPE( void kb_read, (struct tty *tp) );
|
||||
FORWARD _PROTOTYPE( int kb_read, (struct tty *tp, int try) );
|
||||
FORWARD _PROTOTYPE( unsigned map_key, (int scode) );
|
||||
|
||||
|
||||
|
@ -147,6 +149,9 @@ message *m_ptr;
|
|||
if (ihead == ibuf + KB_IN_BYTES) ihead = ibuf;
|
||||
icount++;
|
||||
tty_table[ccurrent].tty_events = 1;
|
||||
if(tty_table[ccurrent].tty_select_ops & SEL_RD) {
|
||||
select_retry(&tty_table[ccurrent]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -154,8 +159,9 @@ message *m_ptr;
|
|||
/*==========================================================================*
|
||||
* kb_read *
|
||||
*==========================================================================*/
|
||||
PRIVATE void kb_read(tp)
|
||||
PRIVATE int kb_read(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* Process characters from the circular keyboard buffer. */
|
||||
|
||||
|
@ -165,6 +171,12 @@ tty_t *tp;
|
|||
|
||||
tp = &tty_table[ccurrent]; /* always use the current console */
|
||||
|
||||
if(try) {
|
||||
printf("tty: kb: try: %d icount: %d\n", try, icount);
|
||||
if(icount > 0) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (icount > 0) {
|
||||
scode = *itail++; /* take one key scan code */
|
||||
if (itail == ibuf + KB_IN_BYTES) itail = ibuf;
|
||||
|
@ -213,6 +225,8 @@ tty_t *tp;
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -59,14 +59,14 @@ typedef struct pty {
|
|||
PRIVATE pty_t pty_table[NR_PTYS]; /* PTY bookkeeping */
|
||||
|
||||
|
||||
FORWARD _PROTOTYPE( void pty_write, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( int pty_write, (tty_t *tp, int try) );
|
||||
FORWARD _PROTOTYPE( void pty_echo, (tty_t *tp, int c) );
|
||||
FORWARD _PROTOTYPE( void pty_start, (pty_t *pp) );
|
||||
FORWARD _PROTOTYPE( void pty_finish, (pty_t *pp) );
|
||||
FORWARD _PROTOTYPE( void pty_read, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( void pty_close, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( void pty_icancel, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( void pty_ocancel, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( int pty_read, (tty_t *tp, int try) );
|
||||
FORWARD _PROTOTYPE( int pty_close, (tty_t *tp, int try) );
|
||||
FORWARD _PROTOTYPE( int pty_icancel, (tty_t *tp, int try) );
|
||||
FORWARD _PROTOTYPE( int pty_ocancel, (tty_t *tp, int try) );
|
||||
|
||||
|
||||
/*==========================================================================*
|
||||
|
@ -201,8 +201,9 @@ message *m_ptr;
|
|||
/*==========================================================================*
|
||||
* pty_write *
|
||||
*==========================================================================*/
|
||||
PRIVATE void pty_write(tp)
|
||||
PRIVATE int pty_write(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* (*dev_write)() routine for PTYs. Transfer bytes from the writer on
|
||||
* /dev/ttypX to the output buffer.
|
||||
|
@ -213,6 +214,7 @@ tty_t *tp;
|
|||
|
||||
/* PTY closed down? */
|
||||
if (pp->state & PTY_CLOSED) {
|
||||
if(try) return 1;
|
||||
if (tp->tty_outleft > 0) {
|
||||
tty_reply(tp->tty_outrepcode, tp->tty_outcaller,
|
||||
tp->tty_outproc, EIO);
|
||||
|
@ -227,7 +229,11 @@ tty_t *tp;
|
|||
count = bufend(pp->obuf) - pp->ohead;
|
||||
if (count > ocount) count = ocount;
|
||||
if (count > tp->tty_outleft) count = tp->tty_outleft;
|
||||
if (count == 0 || tp->tty_inhibited) break;
|
||||
if (count == 0 || tp->tty_inhibited) {
|
||||
if(try) return 0;
|
||||
break;
|
||||
}
|
||||
if(try) return 1;
|
||||
|
||||
/* Copy from user space to the PTY output buffer. */
|
||||
if((s = sys_vircopy(tp->tty_outproc, D, (vir_bytes) tp->tty_out_vir,
|
||||
|
@ -258,9 +264,9 @@ tty_t *tp;
|
|||
}
|
||||
}
|
||||
pty_finish(pp);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*==========================================================================*
|
||||
* pty_echo *
|
||||
*==========================================================================*/
|
||||
|
@ -341,8 +347,9 @@ pty_t *pp;
|
|||
/*==========================================================================*
|
||||
* pty_read *
|
||||
*==========================================================================*/
|
||||
PRIVATE void pty_read(tp)
|
||||
PRIVATE int pty_read(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* Offer bytes from the PTY writer for input on the TTY. (Do it one byte at
|
||||
* a time, 99% of the writes will be for one byte, so no sense in being smart.)
|
||||
|
@ -351,12 +358,19 @@ tty_t *tp;
|
|||
char c;
|
||||
|
||||
if (pp->state & PTY_CLOSED) {
|
||||
if(try) return 1;
|
||||
if (tp->tty_inleft > 0) {
|
||||
tty_reply(tp->tty_inrepcode, tp->tty_incaller, tp->tty_inproc,
|
||||
tp->tty_incum);
|
||||
tp->tty_inleft = tp->tty_incum = 0;
|
||||
}
|
||||
return;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if(try) {
|
||||
if(pp->wrleft > 0)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (pp->wrleft > 0) {
|
||||
|
@ -386,8 +400,9 @@ tty_t *tp;
|
|||
/*==========================================================================*
|
||||
* pty_close *
|
||||
*==========================================================================*/
|
||||
PRIVATE void pty_close(tp)
|
||||
PRIVATE int pty_close(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* The tty side has closed, so shut down the pty side. */
|
||||
pty_t *pp = tp->tty_priv;
|
||||
|
@ -411,8 +426,9 @@ tty_t *tp;
|
|||
/*==========================================================================*
|
||||
* pty_icancel *
|
||||
*==========================================================================*/
|
||||
PRIVATE void pty_icancel(tp)
|
||||
PRIVATE int pty_icancel(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* Discard waiting input. */
|
||||
pty_t *pp = tp->tty_priv;
|
||||
|
@ -428,8 +444,9 @@ tty_t *tp;
|
|||
/*==========================================================================*
|
||||
* pty_ocancel *
|
||||
*==========================================================================*/
|
||||
PRIVATE void pty_ocancel(tp)
|
||||
PRIVATE int pty_ocancel(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* Drain the output buffer. */
|
||||
pty_t *pp = tp->tty_priv;
|
||||
|
|
|
@ -253,11 +253,11 @@ FORWARD _PROTOTYPE( int rs232_handler, (message *m) );
|
|||
FORWARD _PROTOTYPE( void in_int, (rs232_t *rs) );
|
||||
FORWARD _PROTOTYPE( void line_int, (rs232_t *rs) );
|
||||
FORWARD _PROTOTYPE( void modem_int, (rs232_t *rs) );
|
||||
FORWARD _PROTOTYPE( void rs_write, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( int rs_write, (tty_t *tp, int try) );
|
||||
FORWARD _PROTOTYPE( void rs_echo, (tty_t *tp, int c) );
|
||||
FORWARD _PROTOTYPE( void rs_ioctl, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( void rs_config, (rs232_t *rs) );
|
||||
FORWARD _PROTOTYPE( void rs_read, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( int rs_read, (tty_t *tp, int try) );
|
||||
FORWARD _PROTOTYPE( void rs_icancel, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( void rs_ocancel, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( void rs_ostart, (rs232_t *rs) );
|
||||
|
@ -282,8 +282,9 @@ PRIVATE int my_inb(port_t port)
|
|||
/*==========================================================================*
|
||||
* rs_write *
|
||||
*==========================================================================*/
|
||||
PRIVATE void rs_write(tp)
|
||||
PRIVATE void rs_write(tp, try)
|
||||
register tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* (*devwrite)() routine for RS232. */
|
||||
|
||||
|
@ -301,7 +302,7 @@ register tty_t *tp;
|
|||
|
||||
if (rs->drain) {
|
||||
/* Wait for the line to drain then reconfigure and continue output. */
|
||||
if (rs->ocount > 0) return;
|
||||
if (rs->ocount > 0) return 0;
|
||||
rs->drain = FALSE;
|
||||
rs_config(rs);
|
||||
}
|
||||
|
@ -312,7 +313,11 @@ register tty_t *tp;
|
|||
count = bufend(rs->obuf) - rs->ohead;
|
||||
if (count > ocount) count = ocount;
|
||||
if (count > tp->tty_outleft) count = tp->tty_outleft;
|
||||
if (count == 0 || tp->tty_inhibited) break;
|
||||
if (count == 0 || tp->tty_inhibited) {
|
||||
if(try) return 0;
|
||||
break;
|
||||
}
|
||||
if(try) return 1;
|
||||
|
||||
/* Copy from user space to the RS232 output buffer. */
|
||||
sys_vircopy(tp->tty_outproc, D, (vir_bytes) tp->tty_out_vir,
|
||||
|
@ -346,6 +351,8 @@ register tty_t *tp;
|
|||
tty_reply(tp->tty_outrepcode, tp->tty_outcaller, tp->tty_outproc, EIO);
|
||||
tp->tty_outleft = tp->tty_outcum = 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
@ -650,8 +657,9 @@ tty_t *tp; /* which TTY */
|
|||
/*==========================================================================*
|
||||
* rs_read *
|
||||
*==========================================================================*/
|
||||
PRIVATE void rs_read(tp)
|
||||
PRIVATE void rs_read(tp, try)
|
||||
tty_t *tp; /* which tty */
|
||||
int try;
|
||||
{
|
||||
/* Process characters from the circular input buffer. */
|
||||
|
||||
|
@ -659,6 +667,7 @@ tty_t *tp; /* which tty */
|
|||
int icount, count, ostate;
|
||||
|
||||
if (!(tp->tty_termios.c_cflag & CLOCAL)) {
|
||||
if(try) return 1;
|
||||
/* Send a SIGHUP if hangup detected. */
|
||||
lock();
|
||||
ostate = rs->ostate;
|
||||
|
@ -671,6 +680,12 @@ tty_t *tp; /* which tty */
|
|||
}
|
||||
}
|
||||
|
||||
if(try) {
|
||||
if(rs->icount > 0)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
while ((count = rs->icount) > 0) {
|
||||
icount = bufend(rs->ibuf) - rs->itail;
|
||||
if (count > icount) count = icount;
|
||||
|
|
|
@ -25,6 +25,8 @@
|
|||
* DEV_IOCTL: a process wants to change a terminal's parameters
|
||||
* DEV_OPEN: a tty line has been opened
|
||||
* DEV_CLOSE: a tty line has been closed
|
||||
* DEV_SELECT: start select notification request
|
||||
* DEV_SELECT_CAN: cancel select notification
|
||||
* CANCEL: terminate a previous incomplete system call immediately
|
||||
*
|
||||
* m_type TTY_LINE PROC_NR COUNT TTY_SPEK TTY_FLAGS ADDRESS
|
||||
|
@ -52,6 +54,7 @@
|
|||
* Jul 13, 2004 support for function key observers (Jorrit N. Herder)
|
||||
*/
|
||||
|
||||
#include "../drivers.h"
|
||||
#include "../drivers.h"
|
||||
#include <termios.h>
|
||||
#if ENABLE_SRCCOMPAT || ENABLE_BINCOMPAT
|
||||
|
@ -65,6 +68,9 @@
|
|||
#endif
|
||||
#include "tty.h"
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <sys/select.h>
|
||||
|
||||
extern int irq_hook_id;
|
||||
|
||||
/* Address of a tty structure. */
|
||||
|
@ -105,6 +111,7 @@ FORWARD _PROTOTYPE( void do_open, (tty_t *tp, message *m_ptr) );
|
|||
FORWARD _PROTOTYPE( void do_close, (tty_t *tp, message *m_ptr) );
|
||||
FORWARD _PROTOTYPE( void do_read, (tty_t *tp, message *m_ptr) );
|
||||
FORWARD _PROTOTYPE( void do_write, (tty_t *tp, message *m_ptr) );
|
||||
FORWARD _PROTOTYPE( void do_select, (tty_t *tp, message *m_ptr) );
|
||||
FORWARD _PROTOTYPE( void in_transfer, (tty_t *tp) );
|
||||
FORWARD _PROTOTYPE( int tty_echo, (tty_t *tp, int ch) );
|
||||
FORWARD _PROTOTYPE( void rawecho, (tty_t *tp, int ch) );
|
||||
|
@ -270,6 +277,7 @@ PUBLIC void main(void)
|
|||
case DEV_IOCTL: do_ioctl(tp, &tty_mess); break;
|
||||
case DEV_OPEN: do_open(tp, &tty_mess); break;
|
||||
case DEV_CLOSE: do_close(tp, &tty_mess); break;
|
||||
case DEV_SELECT: do_select(tp, &tty_mess); break;
|
||||
case CANCEL: do_cancel(tp, &tty_mess); break;
|
||||
default:
|
||||
printf("Warning, TTY got unexpected request %d from %d\n",
|
||||
|
@ -335,8 +343,11 @@ register message *m_ptr; /* pointer to message sent to the task */
|
|||
in_transfer(tp);
|
||||
/* ...then go back for more. */
|
||||
handle_events(tp);
|
||||
if (tp->tty_inleft == 0)
|
||||
if (tp->tty_inleft == 0) {
|
||||
if(tp->tty_select_ops)
|
||||
select_retry(tp);
|
||||
return; /* already done */
|
||||
}
|
||||
|
||||
/* There were no bytes in the input queue available, so either suspend
|
||||
* the caller or break off the read if nonblocking.
|
||||
|
@ -350,6 +361,8 @@ register message *m_ptr; /* pointer to message sent to the task */
|
|||
}
|
||||
}
|
||||
tty_reply(TASK_REPLY, m_ptr->m_source, m_ptr->PROC_NR, r);
|
||||
if(tp->tty_select_ops)
|
||||
select_retry(tp);
|
||||
}
|
||||
|
||||
|
||||
|
@ -386,7 +399,11 @@ register message *m_ptr; /* pointer to message sent to the task */
|
|||
|
||||
/* Try to write. */
|
||||
handle_events(tp);
|
||||
if (tp->tty_outleft == 0) return; /* already done */
|
||||
if (tp->tty_outleft == 0) {
|
||||
if(tp->tty_select_ops)
|
||||
select_retry(tp);
|
||||
return; /* already done */
|
||||
}
|
||||
|
||||
/* None or not all the bytes could be written, so either suspend the
|
||||
* caller or break off the write if nonblocking.
|
||||
|
@ -400,6 +417,8 @@ register message *m_ptr; /* pointer to message sent to the task */
|
|||
}
|
||||
}
|
||||
tty_reply(TASK_REPLY, m_ptr->m_source, m_ptr->PROC_NR, r);
|
||||
if(tp->tty_select_ops)
|
||||
select_retry(tp);
|
||||
}
|
||||
|
||||
|
||||
|
@ -509,8 +528,8 @@ message *m_ptr; /* pointer to message sent to task */
|
|||
if (r != OK) break;
|
||||
switch (param.i) {
|
||||
case TCIFLUSH: tty_icancel(tp); break;
|
||||
case TCOFLUSH: (*tp->tty_ocancel)(tp); break;
|
||||
case TCIOFLUSH: tty_icancel(tp); (*tp->tty_ocancel)(tp);break;
|
||||
case TCOFLUSH: (*tp->tty_ocancel)(tp, 0); break;
|
||||
case TCIOFLUSH: tty_icancel(tp); (*tp->tty_ocancel)(tp, 0);break;
|
||||
default: r = EINVAL;
|
||||
}
|
||||
break;
|
||||
|
@ -537,7 +556,7 @@ message *m_ptr; /* pointer to message sent to task */
|
|||
break;
|
||||
|
||||
case TCSBRK:
|
||||
if (tp->tty_break != NULL) (*tp->tty_break)(tp);
|
||||
if (tp->tty_break != NULL) (*tp->tty_break)(tp,0);
|
||||
break;
|
||||
|
||||
case TIOCGWINSZ:
|
||||
|
@ -658,8 +677,8 @@ message *m_ptr; /* pointer to message sent to task */
|
|||
if (m_ptr->TTY_LINE != LOG_MINOR && --tp->tty_openct == 0) {
|
||||
tp->tty_pgrp = 0;
|
||||
tty_icancel(tp);
|
||||
(*tp->tty_ocancel)(tp);
|
||||
(*tp->tty_close)(tp);
|
||||
(*tp->tty_ocancel)(tp, 0);
|
||||
(*tp->tty_close)(tp, 0);
|
||||
tp->tty_termios = termios_defaults;
|
||||
tp->tty_winsize = winsize_defaults;
|
||||
setattr(tp);
|
||||
|
@ -692,7 +711,7 @@ message *m_ptr; /* pointer to message sent to task */
|
|||
}
|
||||
if ((mode & W_BIT) && tp->tty_outleft != 0 && proc_nr == tp->tty_outproc) {
|
||||
/* Process was writing when killed. Clean up output. */
|
||||
(*tp->tty_ocancel)(tp);
|
||||
(*tp->tty_ocancel)(tp, 0);
|
||||
tp->tty_outleft = tp->tty_outcum = 0;
|
||||
}
|
||||
if (tp->tty_ioreq != 0 && proc_nr == tp->tty_ioproc) {
|
||||
|
@ -703,6 +722,60 @@ message *m_ptr; /* pointer to message sent to task */
|
|||
tty_reply(TASK_REPLY, m_ptr->m_source, proc_nr, EINTR);
|
||||
}
|
||||
|
||||
PUBLIC int select_try(struct tty *tp, int ops)
|
||||
{
|
||||
int ready_ops = 0;
|
||||
|
||||
/* special case. if line is hung up, no operations will block.
|
||||
* (and it can be seen as an exceptional condition.)
|
||||
*/
|
||||
if (tp->tty_termios.c_ospeed == B0) {
|
||||
printf("tty: hangup always ok\n");
|
||||
ready_ops |= ops;
|
||||
}
|
||||
|
||||
if(ops & SEL_RD) {
|
||||
/* will i/o not block on read? */
|
||||
if (tp->tty_inleft > 0) {
|
||||
ready_ops |= SEL_RD; /* EIO - no blocking */
|
||||
} else if(tp->tty_incount > 0) {
|
||||
/* is a regular read possible? tty_incount
|
||||
* says there is data. but a read will only succeed
|
||||
* in canonical mode if a newline has been seen.
|
||||
*/
|
||||
if(!(tp->tty_termios.c_lflag & ICANON) ||
|
||||
tp->tty_eotct > 0) {
|
||||
ready_ops |= SEL_RD;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(ops & SEL_WR) {
|
||||
if (tp->tty_outleft > 0) {
|
||||
ready_ops |= SEL_WR; /* EIO - no blocking */
|
||||
}
|
||||
if((*tp->tty_devwrite)(tp, 1)) {
|
||||
ready_ops |= SEL_WR; /* real write possible */
|
||||
}
|
||||
}
|
||||
|
||||
return ready_ops;
|
||||
}
|
||||
|
||||
PUBLIC int select_retry(struct tty *tp)
|
||||
{
|
||||
int ops;
|
||||
if((ops = select_try(tp, tp->tty_select_ops))) {
|
||||
message m;
|
||||
m.NOTIFY_TYPE = DEV_SELECTED;
|
||||
m.NOTIFY_ARG = tp->tty_index;
|
||||
m.NOTIFY_FLAGS = ops;
|
||||
notify(tp->tty_select_proc, &m);
|
||||
tp->tty_select_ops &= ~ops;
|
||||
}
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/*===========================================================================*
|
||||
* handle_events *
|
||||
|
@ -731,10 +804,10 @@ tty_t *tp; /* TTY to check for events. */
|
|||
tp->tty_events = 0;
|
||||
|
||||
/* Read input and perform input processing. */
|
||||
(*tp->tty_devread)(tp);
|
||||
(*tp->tty_devread)(tp, 0);
|
||||
|
||||
/* Perform output processing and write output. */
|
||||
(*tp->tty_devwrite)(tp);
|
||||
(*tp->tty_devwrite)(tp, 0);
|
||||
|
||||
/* Ioctl waiting for some event? */
|
||||
if (tp->tty_ioreq != 0) dev_ioctl(tp);
|
||||
|
@ -1288,7 +1361,7 @@ tty_t *tp;
|
|||
if (tp->tty_termios.c_ospeed == B0) sigchar(tp, SIGHUP);
|
||||
|
||||
/* Set new line speed, character size, etc at the device level. */
|
||||
(*tp->tty_ioctl)(tp);
|
||||
(*tp->tty_ioctl)(tp, 0);
|
||||
}
|
||||
|
||||
|
||||
|
@ -1335,7 +1408,7 @@ int sig; /* SIGINT, SIGQUIT, SIGKILL or SIGHUP */
|
|||
if (!(tp->tty_termios.c_lflag & NOFLSH)) {
|
||||
tp->tty_incount = tp->tty_eotct = 0; /* kill earlier input */
|
||||
tp->tty_intail = tp->tty_inhead;
|
||||
(*tp->tty_ocancel)(tp); /* kill all output */
|
||||
(*tp->tty_ocancel)(tp, 0); /* kill all output */
|
||||
tp->tty_inhibited = RUNNING;
|
||||
tp->tty_events = 1;
|
||||
}
|
||||
|
@ -1352,7 +1425,7 @@ register tty_t *tp;
|
|||
|
||||
tp->tty_incount = tp->tty_eotct = 0;
|
||||
tp->tty_intail = tp->tty_inhead;
|
||||
(*tp->tty_icancel)(tp);
|
||||
(*tp->tty_icancel)(tp, 0);
|
||||
}
|
||||
|
||||
|
||||
|
@ -1411,7 +1484,7 @@ PRIVATE void expire_timers(void)
|
|||
/* Scan the queue of timers for expired timers. This dispatch the watchdog
|
||||
* functions of expired timers. Possibly a new alarm call must be scheduled.
|
||||
*/
|
||||
tmrs_exptimers(&tty_timers, now);
|
||||
tmrs_exptimers(&tty_timers, now, NULL);
|
||||
if (tty_timers == NULL) tty_next_timeout = TMR_NEVER;
|
||||
else { /* set new sync alarm */
|
||||
tty_next_timeout = tty_timers->tmr_exp_time;
|
||||
|
@ -1438,10 +1511,10 @@ int enable; /* set timer if true, otherwise unset */
|
|||
exp_time = now + tty_ptr->tty_termios.c_cc[VTIME] * (HZ/10);
|
||||
/* Set a new timer for enabling the TTY events flags. */
|
||||
tmrs_settimer(&tty_timers, &tty_ptr->tty_tmr,
|
||||
exp_time, tty_timed_out);
|
||||
exp_time, tty_timed_out, NULL);
|
||||
} else {
|
||||
/* Remove the timer from the active and expired lists. */
|
||||
tmrs_clrtimer(&tty_timers, &tty_ptr->tty_tmr);
|
||||
tmrs_clrtimer(&tty_timers, &tty_ptr->tty_tmr, NULL);
|
||||
}
|
||||
|
||||
/* Now check if a new alarm must be scheduled. This happens when the front
|
||||
|
@ -1460,12 +1533,39 @@ int enable; /* set timer if true, otherwise unset */
|
|||
/*==========================================================================*
|
||||
* tty_devnop *
|
||||
*==========================================================================*/
|
||||
PUBLIC void tty_devnop(tp)
|
||||
PUBLIC int tty_devnop(tp, try)
|
||||
tty_t *tp;
|
||||
int try;
|
||||
{
|
||||
/* Some functions need not be implemented at the device level. */
|
||||
}
|
||||
|
||||
/*===========================================================================*
|
||||
* do_select *
|
||||
*===========================================================================*/
|
||||
PRIVATE void do_select(tp, m_ptr)
|
||||
register tty_t *tp; /* pointer to tty struct */
|
||||
register message *m_ptr; /* pointer to message sent to the task */
|
||||
{
|
||||
int ops, ready_ops = 0, watch;
|
||||
printf("doing select..\n");
|
||||
|
||||
ops = m_ptr->PROC_NR & (SEL_RD|SEL_WR|SEL_ERR);
|
||||
watch = (m_ptr->PROC_NR & SEL_NOTIFY) ? 1 : 0;
|
||||
|
||||
ready_ops = select_try(tp, ops);
|
||||
|
||||
if(!ready_ops && ops && watch) {
|
||||
printf("doing select.. ops %d\n", ops);
|
||||
tp->tty_select_ops |= ops;
|
||||
tp->tty_select_proc = m_ptr->m_source;
|
||||
} else printf("not doing select.. ready_ops %d ops %d watch %d\n",
|
||||
ready_ops, ops, watch);
|
||||
|
||||
tty_reply(TASK_REPLY, m_ptr->m_source, m_ptr->PROC_NR, ready_ops);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#if ENABLE_SRCCOMPAT || ENABLE_BINCOMPAT
|
||||
/*===========================================================================*
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
#define O_NONBLOCK 04000
|
||||
|
||||
struct tty;
|
||||
typedef _PROTOTYPE( void (*devfun_t), (struct tty *tp) );
|
||||
typedef _PROTOTYPE( int (*devfun_t), (struct tty *tp, int try_only) );
|
||||
typedef _PROTOTYPE( void (*devfunarg_t), (struct tty *tp, int c) );
|
||||
|
||||
typedef struct tty {
|
||||
|
@ -62,6 +62,10 @@ typedef struct tty {
|
|||
int tty_ioreq; /* ioctl request code */
|
||||
vir_bytes tty_iovir; /* virtual address of ioctl buffer */
|
||||
|
||||
/* select() data */
|
||||
int tty_select_ops; /* which operations are interesting */
|
||||
int tty_select_proc; /* which process wants notification */
|
||||
|
||||
/* Miscellaneous. */
|
||||
devfun_t tty_ioctl; /* set line speed, etc. at the device level */
|
||||
devfun_t tty_close; /* tell the device that the tty is closed */
|
||||
|
@ -70,6 +74,7 @@ typedef struct tty {
|
|||
struct winsize tty_winsize; /* window size (#lines and #columns) */
|
||||
|
||||
u16_t tty_inbuf[TTY_IN_BYTES];/* tty input buffer */
|
||||
|
||||
} tty_t;
|
||||
|
||||
/* Memory allocated in tty.c, so extern here. */
|
||||
|
@ -116,7 +121,8 @@ _PROTOTYPE( void out_process, (struct tty *tp, char *bstart, char *bpos,
|
|||
_PROTOTYPE( void tty_wakeup, (clock_t now) );
|
||||
_PROTOTYPE( void tty_reply, (int code, int replyee, int proc_nr,
|
||||
int status) );
|
||||
_PROTOTYPE( void tty_devnop, (struct tty *tp) );
|
||||
_PROTOTYPE( int tty_devnop, (struct tty *tp, int try) );
|
||||
_PROTOTYPE( int select_retry, (struct tty *tp) );
|
||||
|
||||
/* rs232.c */
|
||||
_PROTOTYPE( void rs_init, (struct tty *tp) );
|
||||
|
|
Loading…
Reference in a new issue