tacit/minix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Andy's code fixes

Browse Source
This commit is contained in:
Ben Gras 2005-09-11 17:09:11 +00:00
parent 42fbd9aced
commit e3709af1b8
10 changed files with 402 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
drivers/at_wini/at_wini.c
View File

@ -293,9 +293,9 @@ PUBLIC int main()
return(OK);
}
/*============================================================================*
/*===========================================================================*
* init_params *
*============================================================================*/
*===========================================================================*/
PRIVATE void init_params()
{
/* This routine is called at startup to initialize the drive parameters. */
@ -365,9 +365,9 @@ PRIVATE void init_params()
#define ATA_IF_NOTCOMPAT1 (1L << 0)
#define ATA_IF_NOTCOMPAT2 (1L << 2)
/*============================================================================*
/*===========================================================================*
* init_drive *
*============================================================================*/
*===========================================================================*/
PRIVATE void init_drive(struct wini *w, int base_cmd, int base_ctl, int irq, int ack, int hook, int drive)
{
w->state = 0;
@ -383,9 +383,9 @@ PRIVATE void init_drive(struct wini *w, int base_cmd, int base_ctl, int irq, int
w->lba48 = 0;
}
/*============================================================================*
/*===========================================================================*
* init_params_pci *
*============================================================================*/
*===========================================================================*/
PRIVATE void init_params_pci(int skip)
{
int r, devind, drive;
@ -467,9 +467,9 @@ PRIVATE void init_params_pci(int skip)
}
}
/*============================================================================*
/*===========================================================================*
* w_do_open *
*============================================================================*/
*===========================================================================*/
PRIVATE int w_do_open(dp, m_ptr)
struct driver *dp;
message *m_ptr;
@ -942,9 +942,9 @@ unsigned nr_req; /* length of request vector */
return(OK);
}
/*============================================================================*
/*===========================================================================*
* com_out *
*============================================================================*/
*===========================================================================*/
PRIVATE int com_out(cmd)
struct command *cmd; /* Command block */
{
@ -1011,9 +1011,9 @@ PRIVATE void w_need_reset()
}
}
/*============================================================================*
/*===========================================================================*
* w_do_close *
*============================================================================*/
*===========================================================================*/
PRIVATE int w_do_close(dp, m_ptr)
struct driver *dp;
message *m_ptr;
@ -1028,9 +1028,9 @@ message *m_ptr;
return(OK);
}
/*============================================================================*
/*===========================================================================*
* com_simple *
*============================================================================*/
*===========================================================================*/
PRIVATE int com_simple(cmd)
struct command *cmd; /* Command block */
{
@ -1121,9 +1121,9 @@ PRIVATE int w_reset()
return(OK);
}
/*============================================================================*
/*===========================================================================*
* w_intr_wait *
*============================================================================*/
*===========================================================================*/
PRIVATE void w_intr_wait()
{
/* Wait for a task completion interrupt. */
@ -1150,9 +1150,9 @@ PRIVATE void w_intr_wait()
}
}
/*============================================================================*
/*===========================================================================*
* at_intr_wait *
*============================================================================*/
*===========================================================================*/
PRIVATE int at_intr_wait()
{
/* Wait for an interrupt, study the status bits and return error/success. */
@ -1175,9 +1175,9 @@ PRIVATE int at_intr_wait()
return(r);
}
/*==========================================================================*
/*===========================================================================*
* w_waitfor *
*==========================================================================*/
*===========================================================================*/
PRIVATE int w_waitfor(mask, value)
int mask; /* status mask */
int value; /* required status */
@ -1203,9 +1203,9 @@ int value; /* required status */
return(0);
}
/*============================================================================*
/*===========================================================================*
* w_geometry *
*============================================================================*/
*===========================================================================*/
PRIVATE void w_geometry(entry)
struct partition *entry;
{
@ -1475,9 +1475,9 @@ unsigned cnt;
return(OK);
}
/*============================================================================*
/*===========================================================================*
* w_other *
*============================================================================*/
*===========================================================================*/
PRIVATE int w_other(dr, m)
struct driver *dr;
message *m;
@ -1535,9 +1535,9 @@ message *m;
}
/*============================================================================*
/*===========================================================================*
* w_hw_int *
*============================================================================*/
*===========================================================================*/
PRIVATE int w_hw_int(dr, m)
struct driver *dr;
message *m;
@ -1549,9 +1549,9 @@ message *m;
}
/*============================================================================*
/*===========================================================================*
* ack_irqs *
*============================================================================*/
*===========================================================================*/
PRIVATE void ack_irqs(unsigned int irqs)
{
unsigned int drive;
@ -1600,9 +1600,9 @@ char *strerr(int e)
return str;
}
/*============================================================================*
/*===========================================================================*
* atapi_intr_wait *
*============================================================================*/
*===========================================================================*/
PRIVATE int atapi_intr_wait()
{
/* Wait for an interrupt and study the results. Returns a number of bytes

21
drivers/floppy/floppy.c
View File

@ -6,6 +6,7 @@
* floppy_task: main entry when system is brought up
*
* Changes:
* Sep 11, 2005 code cleanup (Andy Tanenbaum)
* Dec 01, 2004 floppy driver moved to user-space (Jorrit N. Herder)
* Sep 15, 2004 sync alarms/ local timer management (Jorrit N. Herder)
* Aug 12, 2003 null seek no interrupt fix (Mike Haertel)
@ -875,9 +876,9 @@ int opcode; /* DEV_GATHER or DEV_SCATTER */
return(OK);
}
/*==========================================================================*
/*===========================================================================*
* fdc_results *
*==========================================================================*/
*===========================================================================*/
PRIVATE int fdc_results()
{
/* Extract results from the controller after an operation, then allow floppy
@ -1137,9 +1138,9 @@ timer_t *tp;
}
}
/*==========================================================================*
/*===========================================================================*
* read_id *
*==========================================================================*/
*===========================================================================*/
PRIVATE int read_id()
{
/* Determine current cylinder and sector. */
@ -1170,9 +1171,9 @@ PRIVATE int read_id()
return(OK);
}
/*==========================================================================*
/*===========================================================================*
* f_do_open *
*==========================================================================*/
*===========================================================================*/
PRIVATE int f_do_open(dp, m_ptr)
struct driver *dp;
message *m_ptr; /* pointer to open message */
@ -1231,9 +1232,9 @@ message *m_ptr; /* pointer to open message */
return(EIO); /* nothing worked */
}
/*==========================================================================*
/*===========================================================================*
* test_read *
*==========================================================================*/
*===========================================================================*/
PRIVATE int test_read(density)
int density;
{
@ -1261,9 +1262,9 @@ int density;
return(OK);
}
/*============================================================================*
/*===========================================================================*
* f_geometry *
*============================================================================*/
*===========================================================================*/
PRIVATE void f_geometry(entry)
struct partition *entry;
{

8
drivers/memory/memory.c
View File

@ -196,9 +196,9 @@ unsigned nr_req; /* length of request vector */
return(OK);
}
/*============================================================================*
/*===========================================================================*
* m_do_open *
*============================================================================*/
*===========================================================================*/
PRIVATE int m_do_open(dp, m_ptr)
struct driver *dp;
message *m_ptr;
@ -317,9 +317,9 @@ message *m_ptr; /* pointer to control message */
return(OK);
}
/*============================================================================*
/*===========================================================================*
* m_geometry *
*============================================================================*/
*===========================================================================*/
PRIVATE void m_geometry(entry)
struct partition *entry;
{

12
drivers/tty/console.c
View File

@ -870,18 +870,18 @@ tty_t *tp;
cons_ioctl(tp, 0);
}
/*==========================================================================*
/*===========================================================================*
* kputc *
*==========================================================================*/
*===========================================================================*/
PUBLIC void kputc(c)
int c;
{
putk(c);
}
/*==========================================================================*
/*===========================================================================*
* do_new_kmess *
*==========================================================================*/
*===========================================================================*/
PUBLIC void do_new_kmess(m)
message *m;
{
@ -928,9 +928,9 @@ message *m;
prev_next = kmess.km_next;
}
/*==========================================================================*
/*===========================================================================*
* do_diagnostics *
*==========================================================================*/
*===========================================================================*/
PUBLIC void do_diagnostics(m_ptr)
message *m_ptr; /* pointer to request message */
{

24
drivers/tty/keyboard.c
View File

@ -155,9 +155,9 @@ message *m_ptr;
}
}
/*==========================================================================*
/*===========================================================================*
* kb_read *
*==========================================================================*/
*===========================================================================*/
PRIVATE int kb_read(tp, try)
tty_t *tp;
int try;
@ -326,9 +326,9 @@ PRIVATE void set_leds()
kb_ack(); /* wait for ack response */
}
/*==========================================================================*
/*===========================================================================*
* kb_wait *
*==========================================================================*/
*===========================================================================*/
PRIVATE int kb_wait()
{
/* Wait until the controller is ready; return zero if this times out. */
@ -348,9 +348,9 @@ PRIVATE int kb_wait()
return(retries); /* zero on timeout, positive if ready */
}
/*==========================================================================*
/*===========================================================================*
* kb_ack *
*==========================================================================*/
*===========================================================================*/
PRIVATE int kb_ack()
{
/* Wait until kbd acknowledges last command; return zero if this times out. */
@ -559,9 +559,9 @@ int scode; /* scan code for a function key */
return(TRUE);
}
/*==========================================================================*
/*===========================================================================*
* show_key_mappings *
*==========================================================================*/
*===========================================================================*/
PRIVATE void show_key_mappings()
{
int i,s;
@ -596,9 +596,9 @@ PRIVATE void show_key_mappings()
printf("\n");
}
/*==========================================================================*
/*===========================================================================*
* scan_keyboard *
*==========================================================================*/
*===========================================================================*/
PRIVATE int scan_keyboard()
{
/* Fetch the character from the keyboard hardware and acknowledge it. */
@ -615,9 +615,9 @@ PRIVATE int scan_keyboard()
return(byte_in[0].value); /* return scan code */
}
/*==========================================================================*
/*===========================================================================*
* do_panic_dumps *
*==========================================================================*/
*===========================================================================*/
PUBLIC void do_panic_dumps(m)
message *m; /* request message to TTY */
{

56
drivers/tty/pty.c
View File

@ -75,9 +75,9 @@ FORWARD _PROTOTYPE( int pty_icancel, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( int pty_ocancel, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( int pty_select, (tty_t *tp, message *m) );
/*==========================================================================*
/*===========================================================================*
* do_pty *
*==========================================================================*/
*===========================================================================*/
PUBLIC void do_pty(tp, m_ptr)
tty_t *tp;
message *m_ptr;
@ -209,9 +209,9 @@ message *m_ptr;
tty_reply(TASK_REPLY, m_ptr->m_source, m_ptr->PROC_NR, r);
}
/*==========================================================================*
/*===========================================================================*
* pty_write *
*==========================================================================*/
*===========================================================================*/
PRIVATE int pty_write(tp, try)
tty_t *tp;
int try;
@ -276,9 +276,9 @@ int try;
return 1;
}
/*==========================================================================*
/*===========================================================================*
* pty_echo *
*==========================================================================*/
*===========================================================================*/
PRIVATE void pty_echo(tp, c)
tty_t *tp;
int c;
@ -301,9 +301,9 @@ int c;
pty_start(pp);
}
/*==========================================================================*
/*===========================================================================*
* pty_start *
*==========================================================================*/
*===========================================================================*/
PRIVATE void pty_start(pp)
pty_t *pp;
{
@ -334,9 +334,9 @@ pty_t *pp;
}
}
/*==========================================================================*
/*===========================================================================*
* pty_finish *
*==========================================================================*/
*===========================================================================*/
PRIVATE void pty_finish(pp)
pty_t *pp;
{
@ -354,9 +354,9 @@ pty_t *pp;
}
/*==========================================================================*
/*===========================================================================*
* pty_read *
*==========================================================================*/
*===========================================================================*/
PRIVATE int pty_read(tp, try)
tty_t *tp;
int try;
@ -411,9 +411,9 @@ int try;
}
}
/*==========================================================================*
/*===========================================================================*
* pty_close *
*==========================================================================*/
*===========================================================================*/
PRIVATE int pty_close(tp, try)
tty_t *tp;
int try;
@ -436,9 +436,9 @@ int try;
if (pp->state & PTY_CLOSED) pp->state = 0; else pp->state |= TTY_CLOSED;
}
/*==========================================================================*
/*===========================================================================*
* pty_icancel *
*==========================================================================*/
*===========================================================================*/
PRIVATE int pty_icancel(tp, try)
tty_t *tp;
int try;
@ -454,9 +454,9 @@ int try;
}
}
/*==========================================================================*
/*===========================================================================*
* pty_ocancel *
*==========================================================================*/
*===========================================================================*/
PRIVATE int pty_ocancel(tp, try)
tty_t *tp;
int try;
@ -468,9 +468,9 @@ int try;
pp->otail = pp->ohead;
}
/*==========================================================================*
/*===========================================================================*
* pty_init *
*==========================================================================*/
*===========================================================================*/
PUBLIC void pty_init(tp)
tty_t *tp;
{
@ -496,9 +496,9 @@ tty_t *tp;
tp->tty_select_ops = 0;
}
/*==========================================================================*
/*===========================================================================*
* pty_status *
*==========================================================================*/
*===========================================================================*/
PUBLIC int pty_status(message *m_ptr)
{
int i, event_found;
@ -547,9 +547,9 @@ PUBLIC int pty_status(message *m_ptr)
return event_found;
}
/*==========================================================================*
/*===========================================================================*
* select_try_pty *
*==========================================================================*/
*===========================================================================*/
PRIVATE int select_try_pty(tty_t *tp, int ops)
{
pty_t *pp = tp->tty_priv;
@ -572,9 +572,9 @@ PRIVATE int select_try_pty(tty_t *tp, int ops)
return r;
}
/*==========================================================================*
/*===========================================================================*
* select_retry_pty *
*==========================================================================*/
*===========================================================================*/
PUBLIC void select_retry_pty(tty_t *tp)
{
pty_t *pp = tp->tty_priv;
@ -588,9 +588,9 @@ PUBLIC void select_retry_pty(tty_t *tp)
}
}
/*==========================================================================*
/*===========================================================================*
* pty_select *
*==========================================================================*/
*===========================================================================*/
PRIVATE int pty_select(tty_t *tp, message *m)
{
pty_t *pp = tp->tty_priv;

76
drivers/tty/rs232.c
View File

@ -1,8 +1,8 @@
#include <minix/config.h>
/*==========================================================================*
/*---------------------------------------------------------------------------*
* rs232.c - serial driver for 8250 and 16450 UARTs *
* Added support for Atari ST M68901 and YM-2149 --kub *
*==========================================================================*/
*---------------------------------------------------------------------------*/
#include "../drivers.h"
#include <termios.h>
@ -279,9 +279,9 @@ PRIVATE int my_inb(port_t port)
return v;
}
/*==========================================================================*
/*===========================================================================*
* rs_write *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_write(tp, try)
register tty_t *tp;
int try;
@ -355,9 +355,9 @@ int try;
return 1;
}
/*==========================================================================*
/*===========================================================================*
* rs_echo *
*==========================================================================*/
*===========================================================================*/
PRIVATE void rs_echo(tp, c)
tty_t *tp; /* which TTY */
int c; /* character to echo */
@ -382,9 +382,9 @@ int c; /* character to echo */
if ((rs->ohead += ocount) >= bufend(rs->obuf)) rs->ohead -= buflen(rs->obuf);
}
/*==========================================================================*
/*===========================================================================*
* rs_ioctl *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_ioctl(tp, dummy)
tty_t *tp; /* which TTY */
int dummy;
@ -396,9 +396,9 @@ int dummy;
return 0; /* dummy */
}
/*==========================================================================*
/*===========================================================================*
* rs_config *
*==========================================================================*/
*===========================================================================*/
PRIVATE void rs_config(rs)
rs232_t *rs; /* which line */
{
@ -504,9 +504,9 @@ rs232_t *rs; /* which line */
#endif /* MACHINE == ATARI */
}
/*==========================================================================*
/*===========================================================================*
* rs_init *
*==========================================================================*/
*===========================================================================*/
PUBLIC void rs_init(tp)
tty_t *tp; /* which TTY */
{
@ -622,9 +622,9 @@ tty_t *tp; /* which TTY */
}
/*==========================================================================*
/*===========================================================================*
* rs_interrupt *
*==========================================================================*/
*===========================================================================*/
PUBLIC void rs_interrupt(m)
message *m; /* which TTY */
{
@ -640,9 +640,9 @@ message *m; /* which TTY */
}
}
/*==========================================================================*
/*===========================================================================*
* rs_icancel *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_icancel(tp, dummy)
tty_t *tp; /* which TTY */
int dummy;
@ -659,9 +659,9 @@ int dummy;
return 0; /* dummy */
}
/*==========================================================================*
/*===========================================================================*
* rs_ocancel *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_ocancel(tp, dummy)
tty_t *tp; /* which TTY */
int dummy;
@ -678,9 +678,9 @@ int dummy;
return 0; /* dummy */
}
/*==========================================================================*
/*===========================================================================*
* rs_read *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_read(tp, try)
tty_t *tp; /* which tty */
int try;
@ -725,9 +725,9 @@ int try;
}
}
/*==========================================================================*
/*===========================================================================*
* rs_ostart *
*==========================================================================*/
*===========================================================================*/
PRIVATE void rs_ostart(rs)
rs232_t *rs; /* which rs line */
{
@ -737,9 +737,9 @@ rs232_t *rs; /* which rs line */
if (txready(rs)) out_int(rs);
}
/*==========================================================================*
/*===========================================================================*
* rs_break *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_break(tp, dummy)
tty_t *tp; /* which tty */
int dummy;
@ -757,9 +757,9 @@ int dummy;
return 0; /* dummy */
}
/*==========================================================================*
/*===========================================================================*
* rs_close *
*==========================================================================*/
*===========================================================================*/
PRIVATE int rs_close(tp, dummy)
tty_t *tp; /* which tty */
int dummy;
@ -777,9 +777,9 @@ int dummy;
/* Low level (interrupt) routines. */
#if (MACHINE == IBM_PC)
/*==========================================================================*
/*===========================================================================*
* rs232_handler *
*==========================================================================*/
*===========================================================================*/
PRIVATE void rs232_handler(rs)
struct rs232 *rs;
{
@ -813,9 +813,9 @@ struct rs232 *rs;
#endif /* MACHINE == IBM_PC */
#if (MACHINE == ATARI)
/*==========================================================================*
/*===========================================================================*
* siaint *
*==========================================================================*/
*===========================================================================*/
PRIVATE void siaint(type)
int type; /* interrupt type */
{
@ -855,9 +855,9 @@ int type; /* interrupt type */
}
#endif /* MACHINE == ATARI */
/*==========================================================================*
/*===========================================================================*
* in_int *
*==========================================================================*/
*===========================================================================*/
PRIVATE void in_int(rs)
register rs232_t *rs; /* line with input interrupt */
{
@ -897,9 +897,9 @@ register rs232_t *rs; /* line with input interrupt */
}
}
/*==========================================================================*
/*===========================================================================*
* line_int *
*==========================================================================*/
*===========================================================================*/
PRIVATE void line_int(rs)
register rs232_t *rs; /* line with line status interrupt */
{
@ -918,9 +918,9 @@ register rs232_t *rs; /* line with line status interrupt */
if (rs->lstatus & LS_BREAK_INTERRUPT) ++rs->break_interrupts;
}
/*==========================================================================*
/*===========================================================================*
* modem_int *
*==========================================================================*/
*===========================================================================*/
PRIVATE void modem_int(rs)
register rs232_t *rs; /* line with modem interrupt */
{
@ -948,9 +948,9 @@ register rs232_t *rs; /* line with modem interrupt */
}
}
/*==========================================================================*
/*===========================================================================*
* out_int *
*==========================================================================*/
*===========================================================================*/
PRIVATE void out_int(rs)
register rs232_t *rs; /* line with output interrupt */
{

36
drivers/tty/tty.c
View File

@ -1179,9 +1179,9 @@ register int ch; /* pointer to character to echo */
return(ch | (len << IN_LSHIFT));
}
/*==========================================================================*
/*===========================================================================*
* rawecho *
*==========================================================================*/
*===========================================================================*/
PRIVATE void rawecho(tp, ch)
register tty_t *tp;
int ch;
@ -1192,9 +1192,9 @@ int ch;
tp->tty_reprint = rp;
}
/*==========================================================================*
/*===========================================================================*
* back_over *
*==========================================================================*/
*===========================================================================*/
PRIVATE int back_over(tp)
register tty_t *tp;
{
@ -1221,9 +1221,9 @@ register tty_t *tp;
return(1); /* one character erased */
}
/*==========================================================================*
/*===========================================================================*
* reprint *
*==========================================================================*/
*===========================================================================*/
PRIVATE void reprint(tp)
register tty_t *tp; /* pointer to tty struct */
{
@ -1260,9 +1260,9 @@ register tty_t *tp; /* pointer to tty struct */
} while (count < tp->tty_incount);
}
/*==========================================================================*
/*===========================================================================*
* out_process *
*==========================================================================*/
*===========================================================================*/
PUBLIC void out_process(tp, bstart, bpos, bend, icount, ocount)
tty_t *tp;
char *bstart, *bpos, *bend; /* start/pos/end of circular buffer */
@ -1471,9 +1471,9 @@ int sig; /* SIGINT, SIGQUIT, SIGKILL or SIGHUP */
}
}
/*==========================================================================*
/*===========================================================================*
* tty_icancel *
*==========================================================================*/
*===========================================================================*/
PRIVATE void tty_icancel(tp)
register tty_t *tp;
{
@ -1484,9 +1484,9 @@ register tty_t *tp;
(*tp->tty_icancel)(tp, 0);
}
/*==========================================================================*
/*===========================================================================*
* tty_init *
*==========================================================================*/
*===========================================================================*/
PRIVATE void tty_init()
{
/* Initialize tty structure and call device initialization routines. */
@ -1530,9 +1530,9 @@ PRIVATE void tty_init()
#endif
}
/*==========================================================================*
/*===========================================================================*
* tty_timed_out *
*==========================================================================*/
*===========================================================================*/
PRIVATE void tty_timed_out(timer_t *tp)
{
/* This timer has expired. Set the events flag, to force processing. */
@ -1542,9 +1542,9 @@ PRIVATE void tty_timed_out(timer_t *tp)
tty_ptr->tty_events = 1;
}
/*==========================================================================*
/*===========================================================================*
* expire_timers *
*==========================================================================*/
*===========================================================================*/
PRIVATE void expire_timers(void)
{
/* A synchronous alarm message was received. Check if there are any expired
@ -1605,9 +1605,9 @@ int enable; /* set timer if true, otherwise unset */
}
}
/*==========================================================================*
/*===========================================================================*
* tty_devnop *
*==========================================================================*/
*===========================================================================*/
PUBLIC int tty_devnop(tp, try)
tty_t *tp;
int try;