Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

retire _PROTOTYPE

Browse Source 
. only good for obsolete K&R support
	. also remove a stray ansi.h and the proto cmd
This commit is contained in:
Ben Gras
2012-03-24 16:16:34 +01:00
parent cf720a028a
commit 6a73e85ad1
475 changed files with 5256 additions and 6252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/acpi/pci.h
View File

@@ -3,10 +3,10 @@
#include <minix/ipc.h>
_PROTOTYPE(void do_map_bridge, (message *m));
_PROTOTYPE(void do_get_irq, (message *m));
void do_map_bridge(message *m);
void do_get_irq(message *m);
_PROTOTYPE(void pci_scan_devices, (void));
void pci_scan_devices(void);
#endif /* __ACPI_PCI_H__ */

6
drivers/amddev/amddev.c
View File

@@ -59,9 +59,9 @@ static void del_range(phys_bytes busaddr, phys_bytes size);
static void report_exceptions(void);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
int main(void)
{

100
drivers/at_wini/at_wini.c
View File

@@ -136,63 +136,59 @@ PRIVATE struct quirk
{ 0, 0, 0, 0, 0 } /* end of list */
};
FORWARD _PROTOTYPE( void init_params, (void) );
FORWARD _PROTOTYPE( void init_drive, (struct wini *w, int base_cmd,
int base_ctl, int base_dma, int irq, int ack, int hook,
int drive) );
FORWARD _PROTOTYPE( void init_params_pci, (int) );
FORWARD _PROTOTYPE( int w_do_open, (dev_t minor, int access) );
FORWARD _PROTOTYPE( struct device *w_prepare, (dev_t dev) );
FORWARD _PROTOTYPE( struct device *w_part, (dev_t minor) );
FORWARD _PROTOTYPE( int w_identify, (void) );
FORWARD _PROTOTYPE( char *w_name, (void) );
FORWARD _PROTOTYPE( int w_specify, (void) );
FORWARD _PROTOTYPE( int w_io_test, (void) );
FORWARD _PROTOTYPE( ssize_t w_transfer, (dev_t minor, int do_write,
u64_t position, endpoint_t proc_nr, iovec_t *iov,
unsigned int nr_req, int flags) );
FORWARD _PROTOTYPE( int com_out, (struct command *cmd) );
FORWARD _PROTOTYPE( int com_out_ext, (struct command *cmd) );
FORWARD _PROTOTYPE( int setup_dma, (unsigned *sizep, endpoint_t proc_nr,
iovec_t *iov, size_t addr_offset, int do_write) );
FORWARD _PROTOTYPE( void w_need_reset, (void) );
FORWARD _PROTOTYPE( void ack_irqs, (unsigned int) );
FORWARD _PROTOTYPE( int w_do_close, (dev_t minor) );
FORWARD _PROTOTYPE( int w_ioctl, (dev_t minor, unsigned int request,
endpoint_t endpt, cp_grant_id_t grant) );
FORWARD _PROTOTYPE( void w_hw_int, (unsigned int irqs) );
FORWARD _PROTOTYPE( int com_simple, (struct command *cmd) );
FORWARD _PROTOTYPE( void w_timeout, (void) );
FORWARD _PROTOTYPE( int w_reset, (void) );
FORWARD _PROTOTYPE( void w_intr_wait, (void) );
FORWARD _PROTOTYPE( int at_intr_wait, (void) );
FORWARD _PROTOTYPE( int w_waitfor, (int mask, int value) );
FORWARD _PROTOTYPE( int w_waitfor_dma, (int mask, int value) );
FORWARD _PROTOTYPE( void w_geometry, (dev_t minor,
struct partition *entry) );
FORWARD void init_params(void);
FORWARD void init_drive(struct wini *w, int base_cmd, int base_ctl, int
base_dma, int irq, int ack, int hook, int drive);
FORWARD void init_params_pci(int);
FORWARD int w_do_open(dev_t minor, int access);
FORWARD struct device *w_prepare(dev_t dev);
FORWARD struct device *w_part(dev_t minor);
FORWARD int w_identify(void);
FORWARD char *w_name(void);
FORWARD int w_specify(void);
FORWARD int w_io_test(void);
FORWARD ssize_t w_transfer(dev_t minor, int do_write, u64_t position,
endpoint_t proc_nr, iovec_t *iov, unsigned int nr_req, int flags);
FORWARD int com_out(struct command *cmd);
FORWARD int com_out_ext(struct command *cmd);
FORWARD int setup_dma(unsigned *sizep, endpoint_t proc_nr, iovec_t *iov,
size_t addr_offset, int do_write);
FORWARD void w_need_reset(void);
FORWARD void ack_irqs(unsigned int);
FORWARD int w_do_close(dev_t minor);
FORWARD int w_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
cp_grant_id_t grant);
FORWARD void w_hw_int(unsigned int irqs);
FORWARD int com_simple(struct command *cmd);
FORWARD void w_timeout(void);
FORWARD int w_reset(void);
FORWARD void w_intr_wait(void);
FORWARD int at_intr_wait(void);
FORWARD int w_waitfor(int mask, int value);
FORWARD int w_waitfor_dma(int mask, int value);
FORWARD void w_geometry(dev_t minor, struct partition *entry);
#if ENABLE_ATAPI
FORWARD _PROTOTYPE( int atapi_sendpacket, (u8_t *packet, unsigned cnt,
int do_dma) );
FORWARD _PROTOTYPE( int atapi_intr_wait, (int dma, size_t max) );
FORWARD _PROTOTYPE( int atapi_open, (void) );
FORWARD _PROTOTYPE( void atapi_close, (void) );
FORWARD _PROTOTYPE( int atapi_transfer, (int do_write, u64_t position,
endpoint_t endpt, iovec_t *iov, unsigned int nr_req) );
FORWARD int atapi_sendpacket(u8_t *packet, unsigned cnt, int do_dma);
FORWARD int atapi_intr_wait(int dma, size_t max);
FORWARD int atapi_open(void);
FORWARD void atapi_close(void);
FORWARD int atapi_transfer(int do_write, u64_t position, endpoint_t
endpt, iovec_t *iov, unsigned int nr_req);
#endif
#define sys_voutb(out, n) at_voutb((out), (n))
FORWARD _PROTOTYPE( int at_voutb, (pvb_pair_t *, int n));
FORWARD int at_voutb(pvb_pair_t *, int n);
#define sys_vinb(in, n) at_vinb((in), (n))
FORWARD _PROTOTYPE( int at_vinb, (pvb_pair_t *, int n));
FORWARD int at_vinb(pvb_pair_t *, int n);
#undef sys_outb
#undef sys_inb
#undef sys_outl
FORWARD _PROTOTYPE( int at_out, (int line, u32_t port, u32_t value,
char *typename, int type));
FORWARD _PROTOTYPE( int at_in, (int line, u32_t port, u32_t *value,
char *typename, int type));
FORWARD int at_out(int line, u32_t port, u32_t value, char *typename,
int type);
FORWARD int at_in(int line, u32_t port, u32_t *value, char *typename,
int type);
#define sys_outb(p, v) at_out(__LINE__, (p), (v), "outb", _DIO_BYTE)
#define sys_inb(p, v) at_in(__LINE__, (p), (v), "inb", _DIO_BYTE)
@@ -215,11 +211,11 @@ PRIVATE struct blockdriver w_dtab = {
};
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
EXTERN _PROTOTYPE( int sef_cb_lu_prepare, (int state) );
EXTERN _PROTOTYPE( int sef_cb_lu_state_isvalid, (int state) );
EXTERN _PROTOTYPE( void sef_cb_lu_state_dump, (int state) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
EXTERN int sef_cb_lu_prepare(int state);
EXTERN int sef_cb_lu_state_isvalid(int state);
EXTERN void sef_cb_lu_state_dump(int state);
/*===========================================================================*
* at_winchester_task *

8
drivers/audio/es1370/ak4531.c
View File

@@ -26,10 +26,10 @@
#define MUTE 0x80
FORWARD _PROTOTYPE( int ak4531_write, (u8_t address, u8_t data) );
FORWARD _PROTOTYPE( int ak4531_finished, (void) );
FORWARD _PROTOTYPE( int set_volume, (struct volume_level *level,
int cmd_left, int cmd_right, int max_level) );
FORWARD int ak4531_write(u8_t address, u8_t data);
FORWARD int ak4531_finished(void);
FORWARD int set_volume(struct volume_level *level, int cmd_left, int
cmd_right, int max_level);
PRIVATE u16_t base_address;
PRIVATE u16_t status_register;

5
drivers/audio/es1370/ak4531.h
View File

@@ -5,8 +5,7 @@
#include <minix/drivers.h>
#include <minix/sound.h>
_PROTOTYPE( int ak4531_init, (u16_t base, u16_t status_reg, u16_t bit,
u16_t poll) );
_PROTOTYPE( int ak4531_get_set_volume, (struct volume_level *level, int flag) );
int ak4531_init(u16_t base, u16_t status_reg, u16_t bit, u16_t poll);
int ak4531_get_set_volume(struct volume_level *level, int flag);
#endif

30
drivers/audio/es1370/es1370.c
View File

@@ -28,22 +28,20 @@
/* prototypes of private functions */
FORWARD _PROTOTYPE( int detect_hw, (void) );
FORWARD _PROTOTYPE( int disable_int, (int sub_dev) );
FORWARD _PROTOTYPE( int set_stereo, (u32_t stereo, int sub_dev) );
FORWARD _PROTOTYPE( int set_bits, (u32_t nr_of_bits, int sub_dev) );
FORWARD _PROTOTYPE( int set_sample_rate, (u32_t rate, int sub_dev) );
FORWARD _PROTOTYPE( int set_sign, (u32_t val, int sub_dev) );
FORWARD _PROTOTYPE( int get_max_frag_size,
(u32_t * val, int *len, int sub_dev) );
FORWARD _PROTOTYPE( int set_frag_size, (u32_t fragment_size, int sub_dev) );
FORWARD _PROTOTYPE( int set_int_cnt, (int sub_dev) );
FORWARD _PROTOTYPE( int free_buf, (u32_t *val, int *len, int sub_dev) );
FORWARD _PROTOTYPE( int get_samples_in_buf,
(u32_t *val, int *len, int sub_dev) );
FORWARD _PROTOTYPE( int get_set_volume, (struct volume_level *level, int *len,
int sub_dev, int flag) );
FORWARD _PROTOTYPE( int reset, (int sub_dev) );
FORWARD int detect_hw(void);
FORWARD int disable_int(int sub_dev);
FORWARD int set_stereo(u32_t stereo, int sub_dev);
FORWARD int set_bits(u32_t nr_of_bits, int sub_dev);
FORWARD int set_sample_rate(u32_t rate, int sub_dev);
FORWARD int set_sign(u32_t val, int sub_dev);
FORWARD int get_max_frag_size(u32_t * val, int *len, int sub_dev);
FORWARD int set_frag_size(u32_t fragment_size, int sub_dev);
FORWARD int set_int_cnt(int sub_dev);
FORWARD int free_buf(u32_t *val, int *len, int sub_dev);
FORWARD int get_samples_in_buf(u32_t *val, int *len, int sub_dev);
FORWARD int get_set_volume(struct volume_level *level, int *len, int
sub_dev, int flag);
FORWARD int reset(int sub_dev);
DEV_STRUCT dev;

12
drivers/audio/es1370/pci_helper.h
View File

@@ -1,12 +1,12 @@
#ifndef PCI_HELPER
#define PCI_HELPER
_PROTOTYPE( unsigned pci_inb, (u16_t port) );
_PROTOTYPE( unsigned pci_inw, (u16_t port) );
_PROTOTYPE( unsigned pci_inl, (u16_t port) );
unsigned pci_inb(u16_t port);
unsigned pci_inw(u16_t port);
unsigned pci_inl(u16_t port);
_PROTOTYPE( void pci_outb, (u16_t port, u8_t value) );
_PROTOTYPE( void pci_outw, (u16_t port, u16_t value) );
_PROTOTYPE( void pci_outl, (u16_t port, u32_t value) );
void pci_outb(u16_t port, u8_t value);
void pci_outw(u16_t port, u16_t value);
void pci_outl(u16_t port, u32_t value);
#endif

18
drivers/audio/es1371/AC97.c
View File

@@ -6,15 +6,15 @@
/* AC97 Mixer and Mode control function prototypes */
FORWARD _PROTOTYPE( int AC97_write,
(const DEV_STRUCT * pCC, u16_t wAddr, u16_t wData) );
FORWARD _PROTOTYPE( int AC97_write_unsynced,
(const DEV_STRUCT * pCC, u16_t wAddr, u16_t wData) );
FORWARD _PROTOTYPE( int AC97_read_unsynced,
(const DEV_STRUCT * pCC, u16_t wAddr, u16_t *data) );
FORWARD _PROTOTYPE( void set_nice_volume, (void) );
FORWARD _PROTOTYPE( int AC97_get_volume, (struct volume_level *level) );
FORWARD _PROTOTYPE( int AC97_set_volume, (const struct volume_level *level) );
FORWARD int AC97_write(const DEV_STRUCT * pCC, u16_t wAddr, u16_t
wData);
FORWARD int AC97_write_unsynced(const DEV_STRUCT * pCC, u16_t wAddr,
u16_t wData);
FORWARD int AC97_read_unsynced(const DEV_STRUCT * pCC, u16_t wAddr,
u16_t *data);
FORWARD void set_nice_volume(void);
FORWARD int AC97_get_volume(struct volume_level *level);
FORWARD int AC97_set_volume(const struct volume_level *level);

8
drivers/audio/es1371/SRC.h
View File

@@ -4,10 +4,10 @@
#include "es1371.h"
#include "wait.h"
_PROTOTYPE( int SRCInit, (DEV_STRUCT * DSP) );
_PROTOTYPE( int SRCRegRead, (DEV_STRUCT * DSP, u16_t reg, u16_t *data) );
_PROTOTYPE( int SRCRegWrite, (DEV_STRUCT * DSP, u16_t reg, u16_t val) );
_PROTOTYPE( void SRCSetRate, (DEV_STRUCT * DSP, char src_base, u16_t rate) );
int SRCInit(DEV_STRUCT * DSP);
int SRCRegRead(DEV_STRUCT * DSP, u16_t reg, u16_t *data);
int SRCRegWrite(DEV_STRUCT * DSP, u16_t reg, u16_t val);
void SRCSetRate(DEV_STRUCT * DSP, char src_base, u16_t rate);
/* register/base and control equates for the SRC RAM */

30
drivers/audio/es1371/es1371.c
View File

@@ -34,22 +34,20 @@
/* prototypes of private functions */
FORWARD _PROTOTYPE( int detect_hw, (void) );
FORWARD _PROTOTYPE( int disable_int, (int sub_dev) );
FORWARD _PROTOTYPE( int set_stereo, (u32_t stereo, int sub_dev) );
FORWARD _PROTOTYPE( int set_bits, (u32_t nr_of_bits, int sub_dev) );
FORWARD _PROTOTYPE( int set_sample_rate, (u32_t rate, int sub_dev) );
FORWARD _PROTOTYPE( int set_sign, (u32_t val, int sub_dev) );
FORWARD _PROTOTYPE( int get_max_frag_size,
(u32_t * val, int *len, int sub_dev) );
FORWARD _PROTOTYPE( int set_frag_size, (u32_t fragment_size, int sub_dev) );
FORWARD _PROTOTYPE( int set_int_cnt, (int sub_dev) );
FORWARD _PROTOTYPE( int free_buf, (u32_t *val, int *len, int sub_dev) );
FORWARD _PROTOTYPE( int get_samples_in_buf,
(u32_t *val, int *len, int sub_dev) );
FORWARD _PROTOTYPE( int get_set_volume, (struct volume_level *level, int *len,
int sub_dev, int flag) );
FORWARD _PROTOTYPE( int reset, (int sub_dev) );
FORWARD int detect_hw(void);
FORWARD int disable_int(int sub_dev);
FORWARD int set_stereo(u32_t stereo, int sub_dev);
FORWARD int set_bits(u32_t nr_of_bits, int sub_dev);
FORWARD int set_sample_rate(u32_t rate, int sub_dev);
FORWARD int set_sign(u32_t val, int sub_dev);
FORWARD int get_max_frag_size(u32_t * val, int *len, int sub_dev);
FORWARD int set_frag_size(u32_t fragment_size, int sub_dev);
FORWARD int set_int_cnt(int sub_dev);
FORWARD int free_buf(u32_t *val, int *len, int sub_dev);
FORWARD int get_samples_in_buf(u32_t *val, int *len, int sub_dev);
FORWARD int get_set_volume(struct volume_level *level, int *len, int
sub_dev, int flag);
FORWARD int reset(int sub_dev);
DEV_STRUCT dev;

12
drivers/audio/es1371/pci_helper.h
View File

@@ -1,12 +1,12 @@
#ifndef PCI_HELPER
#define PCI_HELPER
_PROTOTYPE( unsigned pci_inb, (u16_t port) );
_PROTOTYPE( unsigned pci_inw, (u16_t port) );
_PROTOTYPE( unsigned pci_inl, (u16_t port) );
unsigned pci_inb(u16_t port);
unsigned pci_inw(u16_t port);
unsigned pci_inl(u16_t port);
_PROTOTYPE( void pci_outb, (u16_t port, u8_t value) );
_PROTOTYPE( void pci_outw, (u16_t port, u16_t value) );
_PROTOTYPE( void pci_outl, (u16_t port, u32_t value) );
void pci_outb(u16_t port, u8_t value);
void pci_outw(u16_t port, u16_t value);
void pci_outl(u16_t port, u32_t value);
#endif

7
drivers/audio/es1371/sample_rate_converter.c
View File

@@ -34,10 +34,9 @@
FORWARD _PROTOTYPE( int src_reg_read, (const DEV_STRUCT * DSP,
u16_t reg, u16_t *data) );
FORWARD _PROTOTYPE( int src_reg_write, (const DEV_STRUCT * DSP,
u16_t reg, u16_t val) );
FORWARD int src_reg_read(const DEV_STRUCT * DSP, u16_t reg, u16_t
*data);
FORWARD int src_reg_write(const DEV_STRUCT * DSP, u16_t reg, u16_t val);
int src_init ( DEV_STRUCT * DSP ) {

4
drivers/audio/es1371/sample_rate_converter.h
View File

@@ -5,8 +5,8 @@
#include "wait.h"
#include "pci_helper.h"
_PROTOTYPE( int src_init, (DEV_STRUCT * DSP) );
_PROTOTYPE( void src_set_rate, (const DEV_STRUCT * DSP, char src_base, u16_t rate) );
int src_init(DEV_STRUCT * DSP);
void src_set_rate(const DEV_STRUCT * DSP, char src_base, u16_t rate);
#define SRC_SYNTH_BASE 0x70
#define SRC_DAC_BASE 0x74

7
drivers/audio/sb16/mixer.c
View File

@@ -3,9 +3,10 @@
FORWARD _PROTOTYPE( int get_set_volume, (struct volume_level *level, int flag));
FORWARD _PROTOTYPE( int get_set_input, (struct inout_ctrl *input, int flag, int channel));
FORWARD _PROTOTYPE( int get_set_output, (struct inout_ctrl *output, int flag));
FORWARD int get_set_volume(struct volume_level *level, int flag);
FORWARD int get_set_input(struct inout_ctrl *input, int flag, int
channel);
FORWARD int get_set_output(struct inout_ctrl *output, int flag);

8
drivers/audio/sb16/mixer.h
View File

@@ -1,10 +1,10 @@
#ifndef SB16_MIXER_H
#define SB16_MIXER_H
_PROTOTYPE( int mixer_init, (void));
_PROTOTYPE( int mixer_ioctl, (int request, void *val, int *len));
int mixer_init(void);
int mixer_ioctl(int request, void *val, int *len);
_PROTOTYPE( int mixer_set, (int reg, int data));
_PROTOTYPE( int mixer_get, (int reg));
int mixer_set(int reg, int data);
int mixer_get(int reg);
#endif

16
drivers/audio/sb16/sb16.c
View File

@@ -11,15 +11,15 @@
#include "mixer.h"
FORWARD _PROTOTYPE( void dsp_dma_setup, (phys_bytes address, int count, int sub_dev) );
FORWARD void dsp_dma_setup(phys_bytes address, int count, int sub_dev);
FORWARD _PROTOTYPE( int dsp_ioctl, (int request, void *val, int *len));
FORWARD _PROTOTYPE( int dsp_set_size, (unsigned int size) );
FORWARD _PROTOTYPE( int dsp_set_speed, (unsigned int speed) );
FORWARD _PROTOTYPE( int dsp_set_stereo, (unsigned int stereo) );
FORWARD _PROTOTYPE( int dsp_set_bits, (unsigned int bits) );
FORWARD _PROTOTYPE( int dsp_set_sign, (unsigned int sign) );
FORWARD _PROTOTYPE( int dsp_get_max_frag_size, (u32_t *val, int *len) );
FORWARD int dsp_ioctl(int request, void *val, int *len);
FORWARD int dsp_set_size(unsigned int size);
FORWARD int dsp_set_speed(unsigned int speed);
FORWARD int dsp_set_stereo(unsigned int stereo);
FORWARD int dsp_set_bits(unsigned int bits);
FORWARD int dsp_set_sign(unsigned int sign);
FORWARD int dsp_get_max_frag_size(u32_t *val, int *len);
PRIVATE unsigned int DspStereo = DEFAULT_STEREO;

6
drivers/audio/sb16/sb16.h
View File

@@ -172,8 +172,8 @@
#define dma_bytes_left(phys) \
((unsigned) (sizeof(int) == 2 ? 0 : 0x10000) - (unsigned) ((phys) & 0xFFFF))
_PROTOTYPE( int dsp_command, (int value) );
_PROTOTYPE( int sb16_inb, (int port) );
_PROTOTYPE( void sb16_outb, (int port, int value) );
int dsp_command(int value);
int sb16_inb(int port);
void sb16_outb(int port, int value);
#endif /* SB16_H */

27
drivers/bios_wini/bios_wini.c
View File

@@ -55,18 +55,17 @@ PRIVATE phys_bytes bios_buf_phys;
PRIVATE int remap_first = 0; /* Remap drives for CD HD emulation */
#define BIOSBUF 16384
_PROTOTYPE(int main, (void) );
FORWARD _PROTOTYPE( struct device *w_prepare, (dev_t device) );
FORWARD _PROTOTYPE( struct device *w_part, (dev_t minor) );
FORWARD _PROTOTYPE( ssize_t w_transfer, (dev_t minor, int do_write,
u64_t position, endpoint_t endpt, iovec_t *iov, unsigned int nr_req,
int flags) );
FORWARD _PROTOTYPE( int w_do_open, (dev_t minor, int access) );
FORWARD _PROTOTYPE( int w_do_close, (dev_t minor) );
FORWARD _PROTOTYPE( void w_init, (void) );
FORWARD _PROTOTYPE( void w_geometry, (dev_t minor, struct partition *entry));
FORWARD _PROTOTYPE( int w_ioctl, (dev_t minor, unsigned int request,
endpoint_t endpt, cp_grant_id_t grant) );
int main(void);
FORWARD struct device *w_prepare(dev_t device);
FORWARD struct device *w_part(dev_t minor);
FORWARD ssize_t w_transfer(dev_t minor, int do_write, u64_t position,
endpoint_t endpt, iovec_t *iov, unsigned int nr_req, int flags);
FORWARD int w_do_open(dev_t minor, int access);
FORWARD int w_do_close(dev_t minor);
FORWARD void w_init(void);
FORWARD void w_geometry(dev_t minor, struct partition *entry);
FORWARD int w_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
cp_grant_id_t grant);
/* Entry points to this driver. */
PRIVATE struct blockdriver w_dtab = {
@@ -85,8 +84,8 @@ PRIVATE struct blockdriver w_dtab = {
};
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
/*===========================================================================*
* bios_winchester_task *

48
drivers/dec21140A/dec21140A.c
View File

@@ -26,29 +26,29 @@
#include "dec21140A.h"
_PROTOTYPE( PRIVATE u32_t io_inl, (u16_t) );
_PROTOTYPE( PRIVATE void io_outl, (u16_t, u32_t) );
_PROTOTYPE( PRIVATE void do_conf, (const message *) );
_PROTOTYPE( PRIVATE void do_get_stat_s, (message *) );
_PROTOTYPE( PRIVATE void do_interrupt, (const dpeth_t *) );
_PROTOTYPE( PRIVATE void do_reply, (dpeth_t *) );
_PROTOTYPE( PRIVATE void do_vread_s, (const message *, int) );
_PROTOTYPE( PRIVATE void do_watchdog, (void *) );
PRIVATE u32_t io_inl(u16_t);
PRIVATE void io_outl(u16_t, u32_t);
PRIVATE void do_conf(const message *);
PRIVATE void do_get_stat_s(message *);
PRIVATE void do_interrupt(const dpeth_t *);
PRIVATE void do_reply(dpeth_t *);
PRIVATE void do_vread_s(const message *, int);
PRIVATE void do_watchdog(void *);
_PROTOTYPE( PRIVATE void de_update_conf, (dpeth_t *) );
_PROTOTYPE( PRIVATE int de_probe, (dpeth_t *, int skip) );
_PROTOTYPE( PRIVATE void de_conf_addr, (dpeth_t *) );
_PROTOTYPE( PRIVATE void de_first_init, (dpeth_t *) );
_PROTOTYPE( PRIVATE void de_reset, (const dpeth_t *) );
_PROTOTYPE( PRIVATE void de_hw_conf, (const dpeth_t *) );
_PROTOTYPE( PRIVATE void de_start, (const dpeth_t *) );
_PROTOTYPE( PRIVATE void de_setup_frame, (const dpeth_t *) );
_PROTOTYPE( PRIVATE u16_t de_read_rom, (const dpeth_t *, u8_t, u8_t) );
_PROTOTYPE( PRIVATE int de_calc_iov_size, (iovec_dat_s_t *) );
_PROTOTYPE( PRIVATE void de_next_iov, (iovec_dat_s_t *) );
_PROTOTYPE( PRIVATE void do_vwrite_s, (const message *, int) );
_PROTOTYPE( PRIVATE void de_get_userdata_s, (int, cp_grant_id_t,
vir_bytes, int, void *) );
PRIVATE void de_update_conf(dpeth_t *);
PRIVATE int de_probe(dpeth_t *, int skip);
PRIVATE void de_conf_addr(dpeth_t *);
PRIVATE void de_first_init(dpeth_t *);
PRIVATE void de_reset(const dpeth_t *);
PRIVATE void de_hw_conf(const dpeth_t *);
PRIVATE void de_start(const dpeth_t *);
PRIVATE void de_setup_frame(const dpeth_t *);
PRIVATE u16_t de_read_rom(const dpeth_t *, u8_t, u8_t);
PRIVATE int de_calc_iov_size(iovec_dat_s_t *);
PRIVATE void de_next_iov(iovec_dat_s_t *);
PRIVATE void do_vwrite_s(const message *, int);
PRIVATE void de_get_userdata_s(int, cp_grant_id_t, vir_bytes, int, void
*);
/* Error messages */
static char str_CopyErrMsg[] = "unable to read/write user data";
@@ -64,8 +64,8 @@ PRIVATE dpeth_t de_state;
PRIVATE int de_instance;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
/*===========================================================================*
* main *

6
drivers/dp8390/3c503.c
View File

@@ -26,9 +26,9 @@ extern u32_t system_hz;
#define MILLIS_TO_TICKS(m) (((m)*system_hz/1000)+1)
_PROTOTYPE(static void el2_init, (dpeth_t *dep));
_PROTOTYPE(static void el2_stop, (dpeth_t *dep));
_PROTOTYPE( static void milli_delay, (unsigned long millis) );
static void el2_init(dpeth_t *dep);
static void el2_stop(dpeth_t *dep);
static void milli_delay(unsigned long millis);
/*===========================================================================*
* el2_init *

110
drivers/dp8390/dp8390.c
View File

@@ -71,66 +71,62 @@ PRIVATE dp_conf_t dp_conf[DP_CONF_NR]= /* Card addresses */
#define CR_EXTRA CR_STA
#if ENABLE_PCI
_PROTOTYPE( static void pci_conf, (void) );
static void pci_conf(void);
#endif
_PROTOTYPE( static void do_vwrite_s, (message *mp, int from_int) );
_PROTOTYPE( static void do_vread_s, (message *mp) );
_PROTOTYPE( static void do_init, (message *mp) );
_PROTOTYPE( static void do_int, (dpeth_t *dep) );
_PROTOTYPE( static void do_getstat_s, (message *mp) );
_PROTOTYPE( static void dp_stop, (dpeth_t *dep) );
_PROTOTYPE( static void dp_init, (dpeth_t *dep) );
_PROTOTYPE( static void dp_confaddr, (dpeth_t *dep) );
_PROTOTYPE( static void dp_reinit, (dpeth_t *dep) );
_PROTOTYPE( static void dp_reset, (dpeth_t *dep) );
_PROTOTYPE( static void dp_check_ints, (dpeth_t *dep) );
_PROTOTYPE( static void dp_recv, (dpeth_t *dep) );
_PROTOTYPE( static void dp_send, (dpeth_t *dep) );
_PROTOTYPE( static void dp_getblock, (dpeth_t *dep, int page,
size_t offset, size_t size, void *dst) );
_PROTOTYPE( static void dp_pio8_getblock, (dpeth_t *dep, int page,
size_t offset, size_t size, void *dst) );
_PROTOTYPE( static void dp_pio16_getblock, (dpeth_t *dep, int page,
size_t offset, size_t size, void *dst) );
_PROTOTYPE( static int dp_pkt2user_s, (dpeth_t *dep, int page,
vir_bytes length) );
_PROTOTYPE( static void dp_user2nic_s, (dpeth_t *dep, iovec_dat_s_t *iovp,
vir_bytes offset, int nic_addr, vir_bytes count) );
_PROTOTYPE( static void dp_pio8_user2nic_s, (dpeth_t *dep,
iovec_dat_s_t *iovp, vir_bytes offset,
int nic_addr, vir_bytes count) );
_PROTOTYPE( static void dp_pio16_user2nic_s, (dpeth_t *dep,
iovec_dat_s_t *iovp, vir_bytes offset,
int nic_addr, vir_bytes count) );
_PROTOTYPE( static void dp_nic2user_s, (dpeth_t *dep, int nic_addr,
iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count) );
_PROTOTYPE( static void dp_pio8_nic2user_s, (dpeth_t *dep, int nic_addr,
iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count) );
_PROTOTYPE( static void dp_pio16_nic2user_s, (dpeth_t *dep, int nic_addr,
iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count) );
_PROTOTYPE( static void dp_next_iovec_s, (iovec_dat_s_t *iovp) );
_PROTOTYPE( static void conf_hw, (dpeth_t *dep) );
_PROTOTYPE( static void update_conf, (dpeth_t *dep, dp_conf_t *dcp) );
_PROTOTYPE( static void map_hw_buffer, (dpeth_t *dep) );
_PROTOTYPE( static int calc_iovec_size_s, (iovec_dat_s_t *iovp) );
_PROTOTYPE( static void reply, (dpeth_t *dep) );
_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
_PROTOTYPE( static void get_userdata_s, (int user_proc,
cp_grant_id_t grant, vir_bytes offset, vir_bytes count,
void *loc_addr) );
_PROTOTYPE( static void put_userdata_s, (int user_proc,
cp_grant_id_t grant, size_t count, void *loc_addr) );
_PROTOTYPE( static void insb, (port_t port, void *buf, size_t size) );
_PROTOTYPE( static void insw, (port_t port, void *buf, size_t size) );
_PROTOTYPE( static void do_vir_insb, (port_t port, int proc,
vir_bytes buf, size_t size) );
_PROTOTYPE( static void do_vir_insw, (port_t port, int proc,
vir_bytes buf, size_t size) );
static void do_vwrite_s(message *mp, int from_int);
static void do_vread_s(message *mp);
static void do_init(message *mp);
static void do_int(dpeth_t *dep);
static void do_getstat_s(message *mp);
static void dp_stop(dpeth_t *dep);
static void dp_init(dpeth_t *dep);
static void dp_confaddr(dpeth_t *dep);
static void dp_reinit(dpeth_t *dep);
static void dp_reset(dpeth_t *dep);
static void dp_check_ints(dpeth_t *dep);
static void dp_recv(dpeth_t *dep);
static void dp_send(dpeth_t *dep);
static void dp_getblock(dpeth_t *dep, int page, size_t offset, size_t
size, void *dst);
static void dp_pio8_getblock(dpeth_t *dep, int page, size_t offset,
size_t size, void *dst);
static void dp_pio16_getblock(dpeth_t *dep, int page, size_t offset,
size_t size, void *dst);
static int dp_pkt2user_s(dpeth_t *dep, int page, vir_bytes length);
static void dp_user2nic_s(dpeth_t *dep, iovec_dat_s_t *iovp, vir_bytes
offset, int nic_addr, vir_bytes count);
static void dp_pio8_user2nic_s(dpeth_t *dep, iovec_dat_s_t *iovp,
vir_bytes offset, int nic_addr, vir_bytes count);
static void dp_pio16_user2nic_s(dpeth_t *dep, iovec_dat_s_t *iovp,
vir_bytes offset, int nic_addr, vir_bytes count);
static void dp_nic2user_s(dpeth_t *dep, int nic_addr, iovec_dat_s_t
*iovp, vir_bytes offset, vir_bytes count);
static void dp_pio8_nic2user_s(dpeth_t *dep, int nic_addr, iovec_dat_s_t
*iovp, vir_bytes offset, vir_bytes count);
static void dp_pio16_nic2user_s(dpeth_t *dep, int nic_addr,
iovec_dat_s_t *iovp, vir_bytes offset, vir_bytes count);
static void dp_next_iovec_s(iovec_dat_s_t *iovp);
static void conf_hw(dpeth_t *dep);
static void update_conf(dpeth_t *dep, dp_conf_t *dcp);
static void map_hw_buffer(dpeth_t *dep);
static int calc_iovec_size_s(iovec_dat_s_t *iovp);
static void reply(dpeth_t *dep);
static void mess_reply(message *req, message *reply);
static void get_userdata_s(int user_proc, cp_grant_id_t grant, vir_bytes
offset, vir_bytes count, void *loc_addr);
static void put_userdata_s(int user_proc, cp_grant_id_t grant, size_t
count, void *loc_addr);
static void insb(port_t port, void *buf, size_t size);
static void insw(port_t port, void *buf, size_t size);
static void do_vir_insb(port_t port, int proc, vir_bytes buf, size_t
size);
static void do_vir_insw(port_t port, int proc, vir_bytes buf, size_t
size);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
PRIVATE void handle_hw_intr(void)
{

32
drivers/dp8390/dp8390.h
View File

@@ -173,26 +173,22 @@ typedef struct dp_rcvhdr
struct dpeth;
struct iovec_dat;
struct iovec_dat_s;
_PROTOTYPE( typedef void (*dp_initf_t), (struct dpeth *dep) );
_PROTOTYPE( typedef void (*dp_stopf_t), (struct dpeth *dep) );
_PROTOTYPE( typedef void (*dp_user2nicf_t), (struct dpeth *dep,
struct iovec_dat *iovp, vir_bytes offset,
int nic_addr, vir_bytes count) );
_PROTOTYPE( typedef void (*dp_user2nicf_s_t), (struct dpeth *dep,
struct iovec_dat_s *iovp, vir_bytes offset,
int nic_addr, vir_bytes count) );
_PROTOTYPE( typedef void (*dp_nic2userf_t), (struct dpeth *dep,
int nic_addr, struct iovec_dat *iovp,
vir_bytes offset, vir_bytes count) );
_PROTOTYPE( typedef void (*dp_nic2userf_s_t), (struct dpeth *dep,
int nic_addr, struct iovec_dat_s *iovp,
vir_bytes offset, vir_bytes count) );
typedef void(*dp_initf_t) (struct dpeth *dep);
typedef void(*dp_stopf_t) (struct dpeth *dep);
typedef void(*dp_user2nicf_t) (struct dpeth *dep, struct iovec_dat
*iovp, vir_bytes offset, int nic_addr, vir_bytes count);
typedef void(*dp_user2nicf_s_t) (struct dpeth *dep, struct iovec_dat_s
*iovp, vir_bytes offset, int nic_addr, vir_bytes count);
typedef void(*dp_nic2userf_t) (struct dpeth *dep, int nic_addr, struct
iovec_dat *iovp, vir_bytes offset, vir_bytes count);
typedef void(*dp_nic2userf_s_t) (struct dpeth *dep, int nic_addr, struct
iovec_dat_s *iovp, vir_bytes offset, vir_bytes count);
#if 0
_PROTOTYPE( typedef void (*dp_getheaderf_t), (struct dpeth *dep,
int page, struct dp_rcvhdr *h, u16_t *eth_type) );
typedef void(*dp_getheaderf_t) (struct dpeth *dep, int page, struct
dp_rcvhdr *h, u16_t *eth_type);
#endif
_PROTOTYPE( typedef void (*dp_getblock_t), (struct dpeth *dep,
int page, size_t offset, size_t size, void *dst) );
typedef void(*dp_getblock_t) (struct dpeth *dep, int page, size_t
offset, size_t size, void *dst);
/* iovectors are handled IOVEC_NR entries at a time. */
#define IOVEC_NR 16

18
drivers/dp8390/local.h
View File

@@ -10,21 +10,21 @@ local.h
struct dpeth;
/* 3c503.c */
_PROTOTYPE( int el2_probe, (struct dpeth* dep) );
int el2_probe(struct dpeth* dep);
/* dp8390.c */
_PROTOTYPE( u8_t inb, (port_t port) );
_PROTOTYPE( u16_t inw, (port_t port) );
_PROTOTYPE( void outb, (port_t port, u8_t v) );
_PROTOTYPE( void outw, (port_t port, u16_t v) );
u8_t inb(port_t port);
u16_t inw(port_t port);
void outb(port_t port, u8_t v);
void outw(port_t port, u16_t v);
/* ne2000.c */
_PROTOTYPE( int ne_probe, (struct dpeth *dep) );
_PROTOTYPE( void ne_init, (struct dpeth *dep) );
int ne_probe(struct dpeth *dep);
void ne_init(struct dpeth *dep);
/* rtl8029.c */
_PROTOTYPE( int rtl_probe, (struct dpeth *dep, int skip) );
int rtl_probe(struct dpeth *dep, int skip);
/* wdeth.c */
_PROTOTYPE( int wdeth_probe, (struct dpeth* dep) );
int wdeth_probe(struct dpeth* dep);

10
drivers/dp8390/ne2000.c
View File

@@ -27,17 +27,17 @@ extern u32_t system_hz;
#define MILLIS_TO_TICKS(m) (((m)*system_hz/1000)+1)
_PROTOTYPE( typedef int (*testf_t), (dpeth_t *dep, int pos, u8_t *pat) );
typedef int(*testf_t) (dpeth_t *dep, int pos, u8_t *pat);
PRIVATE u8_t pat0[]= { 0x00, 0x00, 0x00, 0x00 };
PRIVATE u8_t pat1[]= { 0xFF, 0xFF, 0xFF, 0xFF };
PRIVATE u8_t pat2[]= { 0xA5, 0x5A, 0x69, 0x96 };
PRIVATE u8_t pat3[]= { 0x96, 0x69, 0x5A, 0xA5 };
_PROTOTYPE( static int test_8, (dpeth_t *dep, int pos, u8_t *pat) );
_PROTOTYPE( static int test_16, (dpeth_t *dep, int pos, u8_t *pat) );
_PROTOTYPE( static void ne_stop, (dpeth_t *dep) );
_PROTOTYPE( static void milli_delay, (unsigned long millis) );
static int test_8(dpeth_t *dep, int pos, u8_t *pat);
static int test_16(dpeth_t *dep, int pos, u8_t *pat);
static void ne_stop(dpeth_t *dep);
static void milli_delay(unsigned long millis);
/*===========================================================================*
* ne_probe *

10
drivers/dp8390/rtl8029.c
View File

@@ -22,12 +22,12 @@ Created: April 2000 by Philip Homburg <philip@f-mnx.phicoh.com>
#if ENABLE_PCI
_PROTOTYPE( static void rtl_init, (struct dpeth *dep) );
static void rtl_init(struct dpeth *dep);
#if 0
_PROTOTYPE( static u16_t get_ee_word, (dpeth_t *dep, int a) );
_PROTOTYPE( static void ee_wen, (dpeth_t *dep) );
_PROTOTYPE( static void set_ee_word, (dpeth_t *dep, int a, u16_t w) );
_PROTOTYPE( static void ee_wds, (dpeth_t *dep) );
static u16_t get_ee_word(dpeth_t *dep, int a);
static void ee_wen(dpeth_t *dep);
static void set_ee_word(dpeth_t *dep, int a, u16_t w);
static void ee_wds(dpeth_t *dep);
#endif
PUBLIC int rtl_probe(dep, skip)

14
drivers/dp8390/wdeth.c
View File

@@ -26,13 +26,13 @@ Created: March 14, 1994 by Philip Homburg
static int we_int_table[8]= { 9, 3, 5, 7, 10, 11, 15, 4 };
static int we_790int_table[8]= { 0, 9, 3, 5, 7, 10, 11, 15 };
_PROTOTYPE( static void we_init, (dpeth_t *dep) );
_PROTOTYPE( static void we_stop, (dpeth_t *dep) );
_PROTOTYPE( static int we_aliasing, (dpeth_t *dep) );
_PROTOTYPE( static int we_interface_chip, (dpeth_t *dep) );
_PROTOTYPE( static int we_16bitboard, (dpeth_t *dep) );
_PROTOTYPE( static int we_16bitslot, (dpeth_t *dep) );
_PROTOTYPE( static int we_ultra, (dpeth_t *dep) );
static void we_init(dpeth_t *dep);
static void we_stop(dpeth_t *dep);
static int we_aliasing(dpeth_t *dep);
static int we_interface_chip(dpeth_t *dep);
static int we_16bitboard(dpeth_t *dep);
static int we_16bitslot(dpeth_t *dep);
static int we_ultra(dpeth_t *dep);
/*===========================================================================*
* wdeth_probe *

6
drivers/dpeth/dp.c
View File

@@ -488,9 +488,9 @@ PRIVATE void handle_hw_intr(void)
}
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*
** Name: int dpeth_task(void)

14
drivers/dpeth/wd.c
View File

@@ -32,13 +32,13 @@
static const int we_int_table[8] = {9, 3, 5, 7, 10, 11, 15, 4};
static const int we_790int_table[8] = {0, 9, 3, 5, 7, 10, 11, 15};
_PROTOTYPE(static void we_init, (dpeth_t * dep));
_PROTOTYPE(static void we_stop, (dpeth_t * dep));
_PROTOTYPE(static int we_aliasing, (dpeth_t * dep));
_PROTOTYPE(static int we_interface_chip, (dpeth_t * dep));
_PROTOTYPE(static int we_16bitboard, (dpeth_t * dep));
_PROTOTYPE(static int we_16bitslot, (dpeth_t * dep));
_PROTOTYPE(static int we_ultra, (dpeth_t * dep));
static void we_init(dpeth_t * dep);
static void we_stop(dpeth_t * dep);
static int we_aliasing(dpeth_t * dep);
static int we_interface_chip(dpeth_t * dep);
static int we_16bitboard(dpeth_t * dep);
static int we_16bitslot(dpeth_t * dep);
static int we_ultra(dpeth_t * dep);
/*===========================================================================*
* wdeth_probe *

55
drivers/e1000/e1000.c
View File

@@ -24,37 +24,34 @@
PRIVATE int e1000_instance;
PRIVATE e1000_t e1000_state;
_PROTOTYPE( PRIVATE void e1000_init, (message *mp) );
_PROTOTYPE( PRIVATE void e1000_init_pci, (void) );
_PROTOTYPE( PRIVATE int e1000_probe, (e1000_t *e, int skip) );
_PROTOTYPE( PRIVATE int e1000_init_hw, (e1000_t *e) );
_PROTOTYPE( PRIVATE void e1000_init_addr, (e1000_t *e) );
_PROTOTYPE( PRIVATE void e1000_init_buf, (e1000_t *e) );
_PROTOTYPE( PRIVATE void e1000_reset_hw, (e1000_t *e) );
_PROTOTYPE( PRIVATE void e1000_writev_s, (message *mp, int from_int) );
_PROTOTYPE( PRIVATE void e1000_readv_s, (message *mp, int from_int) );
_PROTOTYPE( PRIVATE void e1000_getstat_s, (message *mp) );
_PROTOTYPE( PRIVATE void e1000_interrupt, (message *mp) );
_PROTOTYPE( PRIVATE int e1000_link_changed, (e1000_t *e) );
_PROTOTYPE( PRIVATE void e1000_stop, (e1000_t *e) );
_PROTOTYPE( PRIVATE uint32_t e1000_reg_read, (e1000_t *e, uint32_t reg) );
_PROTOTYPE( PRIVATE void e1000_reg_write, (e1000_t *e, uint32_t reg,
uint32_t value) );
_PROTOTYPE( PRIVATE void e1000_reg_set, (e1000_t *e, uint32_t reg,
uint32_t value) );
_PROTOTYPE( PRIVATE void e1000_reg_unset, (e1000_t *e, uint32_t reg,
uint32_t value) );
_PROTOTYPE( PRIVATE u16_t eeprom_eerd, (void *e, int reg) );
_PROTOTYPE( PRIVATE u16_t eeprom_ich, (void *e, int reg) );
_PROTOTYPE( PRIVATE int eeprom_ich_init, (e1000_t *e) );
_PROTOTYPE( PRIVATE int eeprom_ich_cycle, (const e1000_t *e, u32_t timeout) );
_PROTOTYPE( PRIVATE void reply, (e1000_t *e) );
_PROTOTYPE( PRIVATE void mess_reply, (message *req, message *reply) );
PRIVATE void e1000_init(message *mp);
PRIVATE void e1000_init_pci(void);
PRIVATE int e1000_probe(e1000_t *e, int skip);
PRIVATE int e1000_init_hw(e1000_t *e);
PRIVATE void e1000_init_addr(e1000_t *e);
PRIVATE void e1000_init_buf(e1000_t *e);
PRIVATE void e1000_reset_hw(e1000_t *e);
PRIVATE void e1000_writev_s(message *mp, int from_int);
PRIVATE void e1000_readv_s(message *mp, int from_int);
PRIVATE void e1000_getstat_s(message *mp);
PRIVATE void e1000_interrupt(message *mp);
PRIVATE int e1000_link_changed(e1000_t *e);
PRIVATE void e1000_stop(e1000_t *e);
PRIVATE uint32_t e1000_reg_read(e1000_t *e, uint32_t reg);
PRIVATE void e1000_reg_write(e1000_t *e, uint32_t reg, uint32_t value);
PRIVATE void e1000_reg_set(e1000_t *e, uint32_t reg, uint32_t value);
PRIVATE void e1000_reg_unset(e1000_t *e, uint32_t reg, uint32_t value);
PRIVATE u16_t eeprom_eerd(void *e, int reg);
PRIVATE u16_t eeprom_ich(void *e, int reg);
PRIVATE int eeprom_ich_init(e1000_t *e);
PRIVATE int eeprom_ich_cycle(const e1000_t *e, u32_t timeout);
PRIVATE void reply(e1000_t *e);
PRIVATE void mess_reply(message *req, message *reply);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* main *

6
drivers/filter/main.c
View File

@@ -73,9 +73,9 @@ static cp_grant_id_t grant_id; /* BDEV_GRANT */
static char *buf_array, *buffer; /* contiguous buffer */
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* carry *

60
drivers/floppy/floppy.c
View File

@@ -238,32 +238,30 @@ PRIVATE u8_t f_results[MAX_RESULTS];/* the controller can give lots of output */
*/
PRIVATE timer_t f_tmr_timeout; /* timer for various timeouts */
PRIVATE u32_t system_hz; /* system clock frequency */
FORWARD _PROTOTYPE( void f_expire_tmrs, (clock_t stamp) );
FORWARD _PROTOTYPE( void stop_motor, (timer_t *tp) );
FORWARD _PROTOTYPE( void f_timeout, (timer_t *tp) );
FORWARD void f_expire_tmrs(clock_t stamp);
FORWARD void stop_motor(timer_t *tp);
FORWARD void f_timeout(timer_t *tp);
FORWARD _PROTOTYPE( struct device *f_prepare, (dev_t device) );
FORWARD _PROTOTYPE( struct device *f_part, (dev_t minor) );
FORWARD _PROTOTYPE( void f_cleanup, (void) );
FORWARD _PROTOTYPE( ssize_t f_transfer, (dev_t minor, int do_write,
u64_t position, endpoint_t proc_nr, iovec_t *iov,
unsigned int nr_req, int flags) );
FORWARD _PROTOTYPE( int dma_setup, (int do_write) );
FORWARD _PROTOTYPE( void start_motor, (void) );
FORWARD _PROTOTYPE( int seek, (void) );
FORWARD _PROTOTYPE( int fdc_transfer, (int do_write) );
FORWARD _PROTOTYPE( int fdc_results, (void) );
FORWARD _PROTOTYPE( int fdc_command, (const u8_t *cmd, int len) );
FORWARD _PROTOTYPE( void fdc_out, (int val) );
FORWARD _PROTOTYPE( int recalibrate, (void) );
FORWARD _PROTOTYPE( void f_reset, (void) );
FORWARD _PROTOTYPE( int f_intr_wait, (void) );
FORWARD _PROTOTYPE( int read_id, (void) );
FORWARD _PROTOTYPE( int f_do_open, (dev_t minor, int access) );
FORWARD _PROTOTYPE( int f_do_close, (dev_t minor) );
FORWARD _PROTOTYPE( int test_read, (int density) );
FORWARD _PROTOTYPE( void f_geometry, (dev_t minor,
struct partition *entry) );
FORWARD struct device *f_prepare(dev_t device);
FORWARD struct device *f_part(dev_t minor);
FORWARD void f_cleanup(void);
FORWARD ssize_t f_transfer(dev_t minor, int do_write, u64_t position,
endpoint_t proc_nr, iovec_t *iov, unsigned int nr_req, int flags);
FORWARD int dma_setup(int do_write);
FORWARD void start_motor(void);
FORWARD int seek(void);
FORWARD int fdc_transfer(int do_write);
FORWARD int fdc_results(void);
FORWARD int fdc_command(const u8_t *cmd, int len);
FORWARD void fdc_out(int val);
FORWARD int recalibrate(void);
FORWARD void f_reset(void);
FORWARD int f_intr_wait(void);
FORWARD int read_id(void);
FORWARD int f_do_open(dev_t minor, int access);
FORWARD int f_do_close(dev_t minor);
FORWARD int test_read(int density);
FORWARD void f_geometry(dev_t minor, struct partition *entry);
/* Entry points to this driver. */
PRIVATE struct blockdriver f_dtab = {
@@ -285,12 +283,12 @@ static char *floppy_buf;
static phys_bytes floppy_buf_phys;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
EXTERN _PROTOTYPE( int sef_cb_lu_prepare, (int state) );
EXTERN _PROTOTYPE( int sef_cb_lu_state_isvalid, (int state) );
EXTERN _PROTOTYPE( void sef_cb_lu_state_dump, (int state) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
EXTERN int sef_cb_lu_prepare(int state);
EXTERN int sef_cb_lu_state_isvalid(int state);
EXTERN void sef_cb_lu_state_dump(int state);
PUBLIC int last_was_write;
/*===========================================================================*

74
drivers/fxp/fxp.c
View File

@@ -149,40 +149,40 @@ PRIVATE u32_t system_hz;
#define fxp_outb(port, offset, value) (do_outb((port) + (offset), (value)))
#define fxp_outl(port, offset, value) (do_outl((port) + (offset), (value)))
_PROTOTYPE( static void fxp_init, (message *mp) );
_PROTOTYPE( static void fxp_pci_conf, (void) );
_PROTOTYPE( static int fxp_probe, (fxp_t *fp, int skip) );
_PROTOTYPE( static void fxp_conf_hw, (fxp_t *fp) );
_PROTOTYPE( static void fxp_init_hw, (fxp_t *fp) );
_PROTOTYPE( static void fxp_init_buf, (fxp_t *fp) );
_PROTOTYPE( static void fxp_reset_hw, (fxp_t *fp) );
_PROTOTYPE( static void fxp_confaddr, (fxp_t *fp) );
_PROTOTYPE( static void fxp_rec_mode, (fxp_t *fp) );
_PROTOTYPE( static void fxp_writev_s, (const message *mp, int from_int) );
_PROTOTYPE( static void fxp_readv_s, (message *mp, int from_int) );
_PROTOTYPE( static void fxp_do_conf, (fxp_t *fp) );
_PROTOTYPE( static void fxp_cu_ptr_cmd, (fxp_t *fp, int cmd,
phys_bytes bus_addr, int check_idle) );
_PROTOTYPE( static void fxp_ru_ptr_cmd, (fxp_t *fp, int cmd,
phys_bytes bus_addr, int check_idle) );
_PROTOTYPE( static void fxp_restart_ru, (fxp_t *fp) );
_PROTOTYPE( static void fxp_getstat_s, (message *mp) );
_PROTOTYPE( static void fxp_handler, (fxp_t *fp) );
_PROTOTYPE( static void fxp_check_ints, (fxp_t *fp) );
_PROTOTYPE( static void fxp_watchdog_f, (timer_t *tp) );
_PROTOTYPE( static int fxp_link_changed, (fxp_t *fp) );
_PROTOTYPE( static void fxp_report_link, (fxp_t *fp) );
_PROTOTYPE( static void reply, (fxp_t *fp) );
_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
_PROTOTYPE( static u16_t eeprom_read, (fxp_t *fp, int reg) );
_PROTOTYPE( static void eeprom_addrsize, (fxp_t *fp) );
_PROTOTYPE( static u16_t mii_read, (fxp_t *fp, int reg) );
_PROTOTYPE( static u8_t do_inb, (port_t port) );
_PROTOTYPE( static u32_t do_inl, (port_t port) );
_PROTOTYPE( static void do_outb, (port_t port, u8_t v) );
_PROTOTYPE( static void do_outl, (port_t port, u32_t v) );
_PROTOTYPE( static void tell_dev, (vir_bytes start, size_t size,
int pci_bus, int pci_dev, int pci_func) );
static void fxp_init(message *mp);
static void fxp_pci_conf(void);
static int fxp_probe(fxp_t *fp, int skip);
static void fxp_conf_hw(fxp_t *fp);
static void fxp_init_hw(fxp_t *fp);
static void fxp_init_buf(fxp_t *fp);
static void fxp_reset_hw(fxp_t *fp);
static void fxp_confaddr(fxp_t *fp);
static void fxp_rec_mode(fxp_t *fp);
static void fxp_writev_s(const message *mp, int from_int);
static void fxp_readv_s(message *mp, int from_int);
static void fxp_do_conf(fxp_t *fp);
static void fxp_cu_ptr_cmd(fxp_t *fp, int cmd, phys_bytes bus_addr, int
check_idle);
static void fxp_ru_ptr_cmd(fxp_t *fp, int cmd, phys_bytes bus_addr, int
check_idle);
static void fxp_restart_ru(fxp_t *fp);
static void fxp_getstat_s(message *mp);
static void fxp_handler(fxp_t *fp);
static void fxp_check_ints(fxp_t *fp);
static void fxp_watchdog_f(timer_t *tp);
static int fxp_link_changed(fxp_t *fp);
static void fxp_report_link(fxp_t *fp);
static void reply(fxp_t *fp);
static void mess_reply(message *req, message *reply);
static u16_t eeprom_read(fxp_t *fp, int reg);
static void eeprom_addrsize(fxp_t *fp);
static u16_t mii_read(fxp_t *fp, int reg);
static u8_t do_inb(port_t port);
static u32_t do_inl(port_t port);
static void do_outb(port_t port, u8_t v);
static void do_outl(port_t port, u32_t v);
static void tell_dev(vir_bytes start, size_t size, int pci_bus, int
pci_dev, int pci_func);
PRIVATE void handle_hw_intr(void)
{
@@ -208,9 +208,9 @@ PRIVATE void handle_hw_intr(void)
}
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* main *

4
drivers/fxp/mii.h
View File

@@ -111,8 +111,8 @@ Definitions for the Media Independent (Ethernet) Interface
#define MII_ESTAT_RES 0x0FFF /* Reserved */
/* 0x10 ... 0x1F */ /* Vendor Specific */
_PROTOTYPE( void mii_print_stat_speed, (u16_t stat, u16_t extstat) );
_PROTOTYPE( void mii_print_techab, (u16_t techab) );
void mii_print_stat_speed(u16_t stat, u16_t extstat);
void mii_print_techab(u16_t techab);
#endif
/*

22
drivers/hello/hello.c
View File

@@ -8,20 +8,18 @@
/*
* Function prototypes for the hello driver.
*/
FORWARD _PROTOTYPE( int hello_open, (message *m) );
FORWARD _PROTOTYPE( int hello_close, (message *m) );
FORWARD _PROTOTYPE( struct device * hello_prepare, (dev_t device) );
FORWARD _PROTOTYPE( int hello_transfer, (endpoint_t endpt, int opcode,
u64_t position, iovec_t *iov,
unsigned int nr_req,
endpoint_t user_endpt,
unsigned int flags) );
FORWARD int hello_open(message *m);
FORWARD int hello_close(message *m);
FORWARD struct device * hello_prepare(dev_t device);
FORWARD int hello_transfer(endpoint_t endpt, int opcode, u64_t position,
iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
flags);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( int sef_cb_lu_state_save, (int) );
FORWARD _PROTOTYPE( int lu_state_restore, (void) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init(int type, sef_init_info_t *info);
FORWARD int sef_cb_lu_state_save(int);
FORWARD int lu_state_restore(void);
/* Entry points to the hello driver. */
PRIVATE struct chardriver hello_tab =

74
drivers/lance/lance.c
View File

@@ -80,47 +80,43 @@ ec_conf_t ec_conf[EC_CONF_NR]= /* Card addresses */
};
/* General */
_PROTOTYPE( static void do_init, (message *mp) );
_PROTOTYPE( static void ec_init, (ether_card_t *ec) );
_PROTOTYPE( static void ec_confaddr, (ether_card_t *ec) );
_PROTOTYPE( static void ec_reinit, (ether_card_t *ec) );
_PROTOTYPE( static void ec_check_ints, (ether_card_t *ec) );
_PROTOTYPE( static void conf_hw, (ether_card_t *ec) );
_PROTOTYPE( static void update_conf, (ether_card_t *ec, ec_conf_t *ecp) );
_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
_PROTOTYPE( static void do_int, (ether_card_t *ec) );
_PROTOTYPE( static void reply, (ether_card_t *ec) );
_PROTOTYPE( static void ec_reset, (ether_card_t *ec) );
_PROTOTYPE( static void ec_send, (ether_card_t *ec) );
_PROTOTYPE( static void ec_recv, (ether_card_t *ec) );
_PROTOTYPE( static void do_vwrite_s, (message *mp, int from_int) );
_PROTOTYPE( static void do_vread_s, (const message *mp) );
_PROTOTYPE( static void ec_user2nic,
(ether_card_t *dep, iovec_dat_t *iovp,
vir_bytes offset, int nic_addr,
vir_bytes count) );
_PROTOTYPE( static void ec_nic2user,
(ether_card_t *ec, int nic_addr,
iovec_dat_t *iovp, vir_bytes offset,
vir_bytes count) );
_PROTOTYPE( static int calc_iovec_size, (iovec_dat_t *iovp) );
_PROTOTYPE( static void ec_next_iovec, (iovec_dat_t *iovp) );
_PROTOTYPE( static void do_getstat_s, (message *mp) );
_PROTOTYPE( static void lance_stop, (ether_card_t *ec) );
static void do_init(message *mp);
static void ec_init(ether_card_t *ec);
static void ec_confaddr(ether_card_t *ec);
static void ec_reinit(ether_card_t *ec);
static void ec_check_ints(ether_card_t *ec);
static void conf_hw(ether_card_t *ec);
static void update_conf(ether_card_t *ec, ec_conf_t *ecp);
static void mess_reply(message *req, message *reply);
static void do_int(ether_card_t *ec);
static void reply(ether_card_t *ec);
static void ec_reset(ether_card_t *ec);
static void ec_send(ether_card_t *ec);
static void ec_recv(ether_card_t *ec);
static void do_vwrite_s(message *mp, int from_int);
static void do_vread_s(const message *mp);
static void ec_user2nic(ether_card_t *dep, iovec_dat_t *iovp, vir_bytes
offset, int nic_addr, vir_bytes count);
static void ec_nic2user(ether_card_t *ec, int nic_addr, iovec_dat_t
*iovp, vir_bytes offset, vir_bytes count);
static int calc_iovec_size(iovec_dat_t *iovp);
static void ec_next_iovec(iovec_dat_t *iovp);
static void do_getstat_s(message *mp);
static void lance_stop(ether_card_t *ec);
_PROTOTYPE( static void lance_dump, (void) );
_PROTOTYPE( static void getAddressing, (int devind, ether_card_t *ec) );
static void lance_dump(void);
static void getAddressing(int devind, ether_card_t *ec);
/* probe+init LANCE cards */
_PROTOTYPE( static int lance_probe, (ether_card_t *ec, int skip) );
_PROTOTYPE( static void lance_init_card, (ether_card_t *ec) );
static int lance_probe(ether_card_t *ec, int skip);
static void lance_init_card(ether_card_t *ec);
/* Accesses Lance Control and Status Registers */
_PROTOTYPE( static u8_t in_byte, (port_t port) );
_PROTOTYPE( static u16_t in_word, (port_t port) );
_PROTOTYPE( static void out_word, (port_t port, u16_t value) );
_PROTOTYPE( static u16_t read_csr, (port_t ioaddr, u16_t csrno) );
_PROTOTYPE( static void write_csr, (port_t ioaddr, u16_t csrno, u16_t value));
static u8_t in_byte(port_t port);
static u16_t in_word(port_t port);
static void out_word(port_t port, u16_t value);
static u16_t read_csr(port_t ioaddr, u16_t csrno);
static void write_csr(port_t ioaddr, u16_t csrno, u16_t value);
/* --- LANCE --- */
/* General */
@@ -249,9 +245,9 @@ static char isstored[TX_RING_SIZE]; /* Tx-slot in-use */
phys_bytes lance_buf_phys;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* main *

32
drivers/log/log.c
View File

@@ -22,16 +22,16 @@ PUBLIC struct logdevice logdevices[NR_DEVS];
PRIVATE struct device log_geom[NR_DEVS]; /* base and size of devices */
PRIVATE int log_device = -1; /* current device */
FORWARD _PROTOTYPE( struct device *log_prepare, (dev_t device) );
FORWARD _PROTOTYPE( int log_transfer, (endpoint_t endpt, int opcode,
u64_t position, iovec_t *iov, unsigned int nr_req,
endpoint_t user_endpt, unsigned int flags) );
FORWARD _PROTOTYPE( int log_do_open, (message *m_ptr) );
FORWARD _PROTOTYPE( int log_cancel, (message *m_ptr) );
FORWARD _PROTOTYPE( int log_select, (message *m_ptr) );
FORWARD _PROTOTYPE( int log_other, (message *m_ptr) );
FORWARD _PROTOTYPE( int subread, (struct logdevice *log, int count,
endpoint_t endpt, cp_grant_id_t grant, size_t) );
FORWARD struct device *log_prepare(dev_t device);
FORWARD int log_transfer(endpoint_t endpt, int opcode, u64_t position,
iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
flags);
FORWARD int log_do_open(message *m_ptr);
FORWARD int log_cancel(message *m_ptr);
FORWARD int log_select(message *m_ptr);
FORWARD int log_other(message *m_ptr);
FORWARD int subread(struct logdevice *log, int count, endpoint_t endpt,
cp_grant_id_t grant, size_t);
/* Entry points to this driver. */
PRIVATE struct chardriver log_dtab = {
@@ -48,12 +48,12 @@ PRIVATE struct chardriver log_dtab = {
};
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
EXTERN _PROTOTYPE( int sef_cb_lu_prepare, (int state) );
EXTERN _PROTOTYPE( int sef_cb_lu_state_isvalid, (int state) );
EXTERN _PROTOTYPE( void sef_cb_lu_state_dump, (int state) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
EXTERN int sef_cb_lu_prepare(int state);
EXTERN int sef_cb_lu_state_isvalid(int state);
EXTERN void sef_cb_lu_state_dump(int state);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* main *

4
drivers/log/log.h
View File

@@ -31,6 +31,6 @@ struct logdevice {
};
/* Function prototypes. */
_PROTOTYPE( void do_new_kmess, (void) );
_PROTOTYPE( void log_append, (char *buf, int len) );
void do_new_kmess(void);
void log_append(char *buf, int len);

31
drivers/memory/memory.c
View File

@@ -44,21 +44,20 @@ PRIVATE dev_t m_device; /* current minor character device */
PRIVATE int openct[NR_DEVS];
FORWARD _PROTOTYPE( struct device *m_prepare, (dev_t device) );
FORWARD _PROTOTYPE( int m_transfer, (endpoint_t endpt, int opcode,
u64_t position, iovec_t *iov, unsigned int nr_req,
endpoint_t user_endpt, unsigned int flags) );
FORWARD _PROTOTYPE( int m_do_open, (message *m_ptr) );
FORWARD _PROTOTYPE( int m_do_close, (message *m_ptr) );
FORWARD struct device *m_prepare(dev_t device);
FORWARD int m_transfer(endpoint_t endpt, int opcode, u64_t position,
iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
flags);
FORWARD int m_do_open(message *m_ptr);
FORWARD int m_do_close(message *m_ptr);
FORWARD _PROTOTYPE( struct device *m_block_part, (dev_t minor) );
FORWARD _PROTOTYPE( int m_block_transfer, (dev_t minor, int do_write,
u64_t position, endpoint_t endpt, iovec_t *iov,
unsigned int nr_req, int flags) );
FORWARD _PROTOTYPE( int m_block_open, (dev_t minor, int access) );
FORWARD _PROTOTYPE( int m_block_close, (dev_t minor) );
FORWARD _PROTOTYPE( int m_block_ioctl, (dev_t minor,
unsigned int request, endpoint_t endpt, cp_grant_id_t grant) );
FORWARD struct device *m_block_part(dev_t minor);
FORWARD int m_block_transfer(dev_t minor, int do_write, u64_t position,
endpoint_t endpt, iovec_t *iov, unsigned int nr_req, int flags);
FORWARD int m_block_open(dev_t minor, int access);
FORWARD int m_block_close(dev_t minor);
FORWARD int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t
endpt, cp_grant_id_t grant);
/* Entry points to the CHARACTER part of this driver. */
PRIVATE struct chardriver m_cdtab = {
@@ -98,8 +97,8 @@ PRIVATE char dev_zero[ZERO_BUF_SIZE];
((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
/*===========================================================================*
* main *

52
drivers/orinoco/hermes.h
View File

@@ -301,32 +301,28 @@ struct hermes_idstring
#define HERMES_RECLEN_TO_BYTES(n) ( ((n)-1) * 2 )
/* Function prototypes */
_PROTOTYPE (u16_t hermes_read_reg, (const hermes_t * hw, u16_t off));
_PROTOTYPE (void hermes_write_reg, (const hermes_t * hw, u16_t off,
u16_t val));
_PROTOTYPE (void hermes_struct_init, (hermes_t * hw, u32_t address,
int io_space, int reg_spacing));
_PROTOTYPE (int hermes_init, (hermes_t * hw));
_PROTOTYPE (int hermes_docmd_wait, (hermes_t * hw, u16_t cmd,
u16_t parm0, hermes_response_t * resp));
_PROTOTYPE (int hermes_allocate, (hermes_t * hw, u16_t size, u16_t * fid));
_PROTOTYPE (int hermes_bap_pread, (hermes_t * hw, int bap, void *buf,
unsigned len, u16_t id, u16_t offset));
_PROTOTYPE (int hermes_bap_pwrite, (hermes_t * hw, int bap,
const void *buf, unsigned len, u16_t id,
u16_t offset));
_PROTOTYPE (void hermes_read_words, (hermes_t * hw, int off, void *buf,
unsigned count));
_PROTOTYPE (int hermes_read_ltv, (hermes_t * hw, int bap, u16_t rid,
unsigned buflen, u16_t * length,
void *buf));
_PROTOTYPE (int hermes_write_ltv, (hermes_t * hw, int bap, u16_t rid,
u16_t length, const void *value));
_PROTOTYPE (int hermes_set_irqmask, (hermes_t * hw, u16_t events));
_PROTOTYPE (u16_t hermes_get_irqmask, (hermes_t * hw));
_PROTOTYPE (int hermes_read_wordrec, (hermes_t * hw, int bap, u16_t rid,
u16_t * word));
_PROTOTYPE (int hermes_write_wordrec, (hermes_t * hw, int bap, u16_t rid,
u16_t word));
_PROTOTYPE (int hermes_cor_reset, (hermes_t *hw));
u16_t hermes_read_reg(const hermes_t * hw, u16_t off);
void hermes_write_reg(const hermes_t * hw, u16_t off, u16_t val);
void hermes_struct_init(hermes_t * hw, u32_t address, int io_space, int
reg_spacing);
int hermes_init(hermes_t * hw);
int hermes_docmd_wait(hermes_t * hw, u16_t cmd, u16_t parm0,
hermes_response_t * resp);
int hermes_allocate(hermes_t * hw, u16_t size, u16_t * fid);
int hermes_bap_pread(hermes_t * hw, int bap, void *buf, unsigned len,
u16_t id, u16_t offset);
int hermes_bap_pwrite(hermes_t * hw, int bap, const void *buf, unsigned
len, u16_t id, u16_t offset);
void hermes_read_words(hermes_t * hw, int off, void *buf, unsigned
count);
int hermes_read_ltv(hermes_t * hw, int bap, u16_t rid, unsigned buflen,
u16_t * length, void *buf);
int hermes_write_ltv(hermes_t * hw, int bap, u16_t rid, u16_t length,
const void *value);
int hermes_set_irqmask(hermes_t * hw, u16_t events);
u16_t hermes_get_irqmask(hermes_t * hw);
int hermes_read_wordrec(hermes_t * hw, int bap, u16_t rid, u16_t *
word);
int hermes_write_wordrec(hermes_t * hw, int bap, u16_t rid, u16_t word);
int hermes_cor_reset(hermes_t *hw);
#endif /* _HERMES_H */

59
drivers/orinoco/orinoco.c
View File

@@ -129,33 +129,32 @@ struct {
#define BITRATE_TABLE_SIZE (sizeof(bitrate_table) / sizeof(bitrate_table[0]))
_PROTOTYPE (static void or_writev_s, (message * mp, int from_int));
_PROTOTYPE (static void or_readv_s, (message * mp, int from_int));
_PROTOTYPE (static void reply, (t_or * orp));
_PROTOTYPE (static int or_probe, (t_or *, int skip));
_PROTOTYPE (static void or_ev_info, (t_or *));
_PROTOTYPE (static void or_init, (message *));
_PROTOTYPE (static void or_pci_conf, (void));
_PROTOTYPE (static void or_init_struct, (t_or *));
_PROTOTYPE (static void map_hw_buffer, (t_or *));
_PROTOTYPE (static void or_init_hw, (t_or *));
_PROTOTYPE (static void or_check_ints, (t_or *));
_PROTOTYPE (static void or_writerids, (hermes_t *, t_or *));
_PROTOTYPE (static void or_readrids, (hermes_t *, t_or *));
_PROTOTYPE (static void or_rec_mode, (t_or *));
_PROTOTYPE (static void mess_reply, (message *, message *));
_PROTOTYPE (static u32_t or_get_bar, (int devind, t_or * orp));
_PROTOTYPE (static void or_getstat_s, (message * mp));
_PROTOTYPE (static void print_linkstatus, (t_or * orp, u16_t status));
_PROTOTYPE (static int or_get_recvd_packet, (t_or *orp, u16_t rxfid,
u8_t *databuf));
_PROTOTYPE (static void or_reset, (void));
_PROTOTYPE (static void or_watchdog_f, (timer_t *tp) );
_PROTOTYPE (static void setup_wepkey, (t_or *orp, char *wepkey0) );
_PROTOTYPE (static void do_hard_int, (void));
_PROTOTYPE (static void check_int_events, (void));
_PROTOTYPE (static void or_handler, (t_or *orp));
_PROTOTYPE (static void or_dump, (message *m));
static void or_writev_s(message * mp, int from_int);
static void or_readv_s(message * mp, int from_int);
static void reply(t_or * orp);
static int or_probe(t_or *, int skip);
static void or_ev_info(t_or *);
static void or_init(message *);
static void or_pci_conf(void);
static void or_init_struct(t_or *);
static void map_hw_buffer(t_or *);
static void or_init_hw(t_or *);
static void or_check_ints(t_or *);
static void or_writerids(hermes_t *, t_or *);
static void or_readrids(hermes_t *, t_or *);
static void or_rec_mode(t_or *);
static void mess_reply(message *, message *);
static u32_t or_get_bar(int devind, t_or * orp);
static void or_getstat_s(message * mp);
static void print_linkstatus(t_or * orp, u16_t status);
static int or_get_recvd_packet(t_or *orp, u16_t rxfid, u8_t *databuf);
static void or_reset(void);
static void or_watchdog_f(timer_t *tp);
static void setup_wepkey(t_or *orp, char *wepkey0);
static void do_hard_int(void);
static void check_int_events(void);
static void or_handler(t_or *orp);
static void or_dump(message *m);
/* The message used in the main loop is made global, so that rl_watchdog_f()
* can change its message type to fake an interrupt message.
@@ -166,9 +165,9 @@ PRIVATE int int_event_check; /* set to TRUE if events arrived */
PRIVATE u32_t system_hz;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*****************************************************************************
* main *

42
drivers/pci/main.c
View File

@@ -6,31 +6,31 @@ main.c
PUBLIC struct pci_acl pci_acl[NR_DRIVERS];
FORWARD _PROTOTYPE( void do_init, (message *mp) );
FORWARD _PROTOTYPE( void do_first_dev, (message *mp) );
FORWARD _PROTOTYPE( void do_next_dev, (message *mp) );
FORWARD _PROTOTYPE( void do_find_dev, (message *mp) );
FORWARD _PROTOTYPE( void do_ids, (message *mp) );
FORWARD _PROTOTYPE( void do_dev_name_s, (message *mp) );
FORWARD _PROTOTYPE( void do_slot_name_s, (message *mp) );
FORWARD _PROTOTYPE( void do_set_acl, (message *mp) );
FORWARD _PROTOTYPE( void do_del_acl, (message *mp) );
FORWARD _PROTOTYPE( void do_reserve, (message *mp) );
FORWARD _PROTOTYPE( void do_attr_r8, (message *mp) );
FORWARD _PROTOTYPE( void do_attr_r16, (message *mp) );
FORWARD _PROTOTYPE( void do_attr_r32, (message *mp) );
FORWARD _PROTOTYPE( void do_attr_w8, (message *mp) );
FORWARD _PROTOTYPE( void do_attr_w16, (message *mp) );
FORWARD _PROTOTYPE( void do_attr_w32, (message *mp) );
FORWARD _PROTOTYPE( void do_get_bar, (message *mp) );
FORWARD _PROTOTYPE( void do_rescan_bus, (message *mp) );
FORWARD _PROTOTYPE( void reply, (message *mp, int result) );
FORWARD _PROTOTYPE( struct rs_pci *find_acl, (int endpoint) );
FORWARD void do_init(message *mp);
FORWARD void do_first_dev(message *mp);
FORWARD void do_next_dev(message *mp);
FORWARD void do_find_dev(message *mp);
FORWARD void do_ids(message *mp);
FORWARD void do_dev_name_s(message *mp);
FORWARD void do_slot_name_s(message *mp);
FORWARD void do_set_acl(message *mp);
FORWARD void do_del_acl(message *mp);
FORWARD void do_reserve(message *mp);
FORWARD void do_attr_r8(message *mp);
FORWARD void do_attr_r16(message *mp);
FORWARD void do_attr_r32(message *mp);
FORWARD void do_attr_w8(message *mp);
FORWARD void do_attr_w16(message *mp);
FORWARD void do_attr_w32(message *mp);
FORWARD void do_get_bar(message *mp);
FORWARD void do_rescan_bus(message *mp);
FORWARD void reply(message *mp, int result);
FORWARD struct rs_pci *find_acl(int endpoint);
extern int debug;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD void sef_local_startup(void);
int main(void)
{

101
drivers/pci/pci.c
View File

@@ -92,63 +92,58 @@ EXTERN struct pci_acl pci_acl[NR_DRIVERS];
PRIVATE int nr_pcidev= 0;
FORWARD _PROTOTYPE( void pci_intel_init, (void) );
FORWARD _PROTOTYPE( void probe_bus, (int busind) );
FORWARD _PROTOTYPE( int is_duplicate, (u8_t busnr, u8_t dev, u8_t func) );
FORWARD _PROTOTYPE( void record_irq, (int devind) );
FORWARD _PROTOTYPE( void record_bars_normal, (int devind) );
FORWARD _PROTOTYPE( void record_bars_bridge, (int devind) );
FORWARD _PROTOTYPE( void record_bars_cardbus, (int devind) );
FORWARD _PROTOTYPE( void record_bars, (int devind, int last_reg) );
FORWARD _PROTOTYPE( int record_bar, (int devind, int bar_nr, int last) );
FORWARD _PROTOTYPE( void complete_bridges, (void) );
FORWARD _PROTOTYPE( void complete_bars, (void) );
FORWARD _PROTOTYPE( void update_bridge4dev_io, (int devind,
u32_t io_base, u32_t io_size) );
FORWARD _PROTOTYPE( int get_freebus, (void) );
FORWARD _PROTOTYPE( int do_isabridge, (int busind) );
FORWARD _PROTOTYPE( void do_pcibridge, (int busind) );
FORWARD _PROTOTYPE( int get_busind, (int busnr) );
FORWARD _PROTOTYPE( int do_piix, (int devind) );
FORWARD _PROTOTYPE( int do_amd_isabr, (int devind) );
FORWARD _PROTOTYPE( int do_sis_isabr, (int devind) );
FORWARD _PROTOTYPE( int do_via_isabr, (int devind) );
FORWARD void pci_intel_init(void);
FORWARD void probe_bus(int busind);
FORWARD int is_duplicate(u8_t busnr, u8_t dev, u8_t func);
FORWARD void record_irq(int devind);
FORWARD void record_bars_normal(int devind);
FORWARD void record_bars_bridge(int devind);
FORWARD void record_bars_cardbus(int devind);
FORWARD void record_bars(int devind, int last_reg);
FORWARD int record_bar(int devind, int bar_nr, int last);
FORWARD void complete_bridges(void);
FORWARD void complete_bars(void);
FORWARD void update_bridge4dev_io(int devind, u32_t io_base, u32_t
io_size);
FORWARD int get_freebus(void);
FORWARD int do_isabridge(int busind);
FORWARD void do_pcibridge(int busind);
FORWARD int get_busind(int busnr);
FORWARD int do_piix(int devind);
FORWARD int do_amd_isabr(int devind);
FORWARD int do_sis_isabr(int devind);
FORWARD int do_via_isabr(int devind);
#if 0
FORWARD _PROTOTYPE( void report_vga, (int devind) );
FORWARD void report_vga(int devind);
#endif
FORWARD _PROTOTYPE( char *pci_vid_name, (u16_t vid) );
FORWARD _PROTOTYPE( char *pci_baseclass_name, (u8_t baseclass) );
FORWARD _PROTOTYPE( char *pci_subclass_name, (u8_t baseclass,
u8_t subclass, u8_t infclass) );
FORWARD _PROTOTYPE( void ntostr, (unsigned n, char **str, char *end) );
FORWARD char *pci_vid_name(u16_t vid);
FORWARD char *pci_baseclass_name(u8_t baseclass);
FORWARD char *pci_subclass_name(u8_t baseclass, u8_t subclass, u8_t
infclass);
FORWARD void ntostr(unsigned n, char **str, char *end);
FORWARD _PROTOTYPE( u8_t pci_attr_r8_u, (int devind, int port) );
FORWARD _PROTOTYPE( u32_t pci_attr_r32_u, (int devind, int port) );
FORWARD u8_t pci_attr_r8_u(int devind, int port);
FORWARD u32_t pci_attr_r32_u(int devind, int port);
FORWARD _PROTOTYPE( u16_t pci_attr_rsts, (int devind) );
FORWARD _PROTOTYPE( void pci_attr_wsts, (int devind, u16_t value) );
FORWARD _PROTOTYPE( u16_t pcibr_std_rsts, (int busind) );
FORWARD _PROTOTYPE( void pcibr_std_wsts, (int busind, u16_t value) );
FORWARD _PROTOTYPE( u16_t pcibr_cb_rsts, (int busind) );
FORWARD _PROTOTYPE( void pcibr_cb_wsts, (int busind, u16_t value) );
FORWARD _PROTOTYPE( u16_t pcibr_via_rsts, (int busind) );
FORWARD _PROTOTYPE( void pcibr_via_wsts, (int busind, u16_t value) );
FORWARD _PROTOTYPE( u8_t pcii_rreg8, (int busind, int devind, int port) );
FORWARD _PROTOTYPE( u16_t pcii_rreg16, (int busind, int devind,
int port) );
FORWARD _PROTOTYPE( u32_t pcii_rreg32, (int busind, int devind,
int port) );
FORWARD _PROTOTYPE( void pcii_wreg8, (int busind, int devind, int port,
u8_t value) );
FORWARD _PROTOTYPE( void pcii_wreg16, (int busind, int devind, int port,
u16_t value) );
FORWARD _PROTOTYPE( void pcii_wreg32, (int busind, int devind, int port,
u32_t value) );
FORWARD _PROTOTYPE( u16_t pcii_rsts, (int busind) );
FORWARD _PROTOTYPE( void pcii_wsts, (int busind, u16_t value) );
FORWARD _PROTOTYPE( void print_capabilities, (int devind) );
FORWARD _PROTOTYPE( int visible, (struct rs_pci *aclp, int devind) );
FORWARD _PROTOTYPE( void print_hyper_cap, (int devind, u8_t capptr) );
FORWARD u16_t pci_attr_rsts(int devind);
FORWARD void pci_attr_wsts(int devind, u16_t value);
FORWARD u16_t pcibr_std_rsts(int busind);
FORWARD void pcibr_std_wsts(int busind, u16_t value);
FORWARD u16_t pcibr_cb_rsts(int busind);
FORWARD void pcibr_cb_wsts(int busind, u16_t value);
FORWARD u16_t pcibr_via_rsts(int busind);
FORWARD void pcibr_via_wsts(int busind, u16_t value);
FORWARD u8_t pcii_rreg8(int busind, int devind, int port);
FORWARD u16_t pcii_rreg16(int busind, int devind, int port);
FORWARD u32_t pcii_rreg32(int busind, int devind, int port);
FORWARD void pcii_wreg8(int busind, int devind, int port, u8_t value);
FORWARD void pcii_wreg16(int busind, int devind, int port, u16_t value);
FORWARD void pcii_wreg32(int busind, int devind, int port, u32_t value);
FORWARD u16_t pcii_rsts(int busind);
FORWARD void pcii_wsts(int busind, u16_t value);
FORWARD void print_capabilities(int devind);
FORWARD int visible(struct rs_pci *aclp, int devind);
FORWARD void print_hyper_cap(int devind, u8_t capptr);
PRIVATE struct machine machine;
PRIVATE endpoint_t acpi_ep;

41
drivers/pci/pci.h
View File

@@ -9,13 +9,13 @@ Created: Jan 2000 by Philip Homburg <philip@cs.vu.nl>
#include <minix/rs.h>
/* tempory functions: to be replaced later (see pci_intel.h) */
_PROTOTYPE( unsigned pci_inb, (u16_t port) );
_PROTOTYPE( unsigned pci_inw, (u16_t port) );
_PROTOTYPE( unsigned pci_inl, (u16_t port) );
unsigned pci_inb(u16_t port);
unsigned pci_inw(u16_t port);
unsigned pci_inl(u16_t port);
_PROTOTYPE( void pci_outb, (u16_t port, u8_t value) );
_PROTOTYPE( void pci_outw, (u16_t port, u16_t value) );
_PROTOTYPE( void pci_outl, (u16_t port, u32_t value) );
void pci_outb(u16_t port, u8_t value);
void pci_outw(u16_t port, u16_t value);
void pci_outl(u16_t port, u32_t value);
struct pci_vendor
{
@@ -94,22 +94,21 @@ extern struct pci_isabridge pci_isabridge[];
extern struct pci_pcibridge pci_pcibridge[];
/* Function prototypes. */
_PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
_PROTOTYPE( int map_service, (struct rprocpub *rpub) );
_PROTOTYPE( int pci_reserve_a, (int devind, endpoint_t proc,
struct rs_pci *aclp) );
_PROTOTYPE( void pci_release, (endpoint_t proc) );
_PROTOTYPE( int pci_first_dev_a, (struct rs_pci *aclp, int *devindp,
u16_t *vidp, u16_t *didp) );
_PROTOTYPE( int pci_next_dev_a, (struct rs_pci *aclp, int *devindp,
u16_t *vidp, u16_t *didp) );
int sef_cb_init_fresh(int type, sef_init_info_t *info);
int map_service(struct rprocpub *rpub);
int pci_reserve_a(int devind, endpoint_t proc, struct rs_pci *aclp);
void pci_release(endpoint_t proc);
int pci_first_dev_a(struct rs_pci *aclp, int *devindp, u16_t *vidp,
u16_t *didp);
int pci_next_dev_a(struct rs_pci *aclp, int *devindp, u16_t *vidp, u16_t
*didp);
_PROTOTYPE( int pci_attr_r8_s, (int devind, int port, u8_t *vp) );
_PROTOTYPE( int pci_attr_r32_s, (int devind, int port, u32_t *vp) );
_PROTOTYPE( int pci_get_bar_s, (int devind, int port, u32_t *base,
u32_t *size, int *ioflag) );
_PROTOTYPE( int pci_slot_name_s, (int devind, char **cpp) );
_PROTOTYPE( int pci_ids_s, (int devind, u16_t *vidp, u16_t *didp) );
int pci_attr_r8_s(int devind, int port, u8_t *vp);
int pci_attr_r32_s(int devind, int port, u32_t *vp);
int pci_get_bar_s(int devind, int port, u32_t *base, u32_t *size, int
*ioflag);
int pci_slot_name_s(int devind, char **cpp);
int pci_ids_s(int devind, u16_t *vidp, u16_t *didp);
/*
* $PchId: pci.h,v 1.4 2001/12/06 20:21:22 philip Exp $

28
drivers/printer/printer.c
View File

@@ -102,22 +102,22 @@ PRIVATE vir_bytes user_vir_d; /* offset in user buf */
PUBLIC int writing; /* nonzero while write is in progress */
PRIVATE int irq_hook_id; /* id of irq hook at kernel */
FORWARD _PROTOTYPE( void do_cancel, (message *m_ptr) );
FORWARD _PROTOTYPE( void output_done, (void) );
FORWARD _PROTOTYPE( void do_write, (message *m_ptr) );
FORWARD _PROTOTYPE( void do_status, (message *m_ptr) );
FORWARD _PROTOTYPE( void prepare_output, (void) );
FORWARD _PROTOTYPE( int do_probe, (void) );
FORWARD _PROTOTYPE( void do_initialize, (void) );
FORWARD _PROTOTYPE( void reply, (int code,int replyee,int proc,int status));
FORWARD _PROTOTYPE( void do_printer_output, (void) );
FORWARD void do_cancel(message *m_ptr);
FORWARD void output_done(void);
FORWARD void do_write(message *m_ptr);
FORWARD void do_status(message *m_ptr);
FORWARD void prepare_output(void);
FORWARD int do_probe(void);
FORWARD void do_initialize(void);
FORWARD void reply(int code,int replyee,int proc,int status);
FORWARD void do_printer_output(void);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
EXTERN _PROTOTYPE( int sef_cb_lu_prepare, (int state) );
EXTERN _PROTOTYPE( int sef_cb_lu_state_isvalid, (int state) );
EXTERN _PROTOTYPE( void sef_cb_lu_state_dump, (int state) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
EXTERN int sef_cb_lu_prepare(int state);
EXTERN int sef_cb_lu_state_isvalid(int state);
EXTERN void sef_cb_lu_state_dump(int state);
PUBLIC int is_status_msg_expected = FALSE;
/*===========================================================================*

19
drivers/random/main.c
View File

@@ -20,14 +20,13 @@ PRIVATE dev_t m_device; /* current device */
extern int errno; /* error number for PM calls */
FORWARD _PROTOTYPE( struct device *r_prepare, (dev_t device) );
FORWARD _PROTOTYPE( int r_transfer, (endpoint_t endpt, int opcode,
u64_t position, iovec_t *iov, unsigned int nr_req,
endpoint_t user_endpt, unsigned int flags) );
FORWARD _PROTOTYPE( int r_do_open, (message *m_ptr) );
FORWARD _PROTOTYPE( void r_random, (message *m_ptr) );
FORWARD _PROTOTYPE( void r_updatebin, (int source,
struct k_randomness_bin *rb) );
FORWARD struct device *r_prepare(dev_t device);
FORWARD int r_transfer(endpoint_t endpt, int opcode, u64_t position,
iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
flags);
FORWARD int r_do_open(message *m_ptr);
FORWARD void r_random(message *m_ptr);
FORWARD void r_updatebin(int source, struct k_randomness_bin *rb);
/* Entry points to this driver. */
PRIVATE struct chardriver r_dtab = {
@@ -48,8 +47,8 @@ PRIVATE struct chardriver r_dtab = {
PRIVATE char random_buf[RANDOM_BUF_SIZE];
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
/*===========================================================================*
* main *

7
drivers/random/random.c
View File

@@ -34,10 +34,9 @@ PRIVATE u8_t random_key[2*AES_BLOCKSIZE];
PRIVATE u32_t count_lo, count_hi;
PRIVATE u32_t reseed_count;
FORWARD _PROTOTYPE( void add_sample, (int source, unsigned long sample) );
FORWARD _PROTOTYPE( void data_block, (rd_keyinstance *keyp,
void *data) );
FORWARD _PROTOTYPE( void reseed, (void) );
FORWARD void add_sample(int source, unsigned long sample);
FORWARD void data_block(rd_keyinstance *keyp, void *data);
FORWARD void reseed(void);
PUBLIC void random_init()
{

10
drivers/random/random.h
View File

@@ -9,8 +9,8 @@ Public interface to the random number generator
#define RANDOM_SOURCES_INTERNAL 1
#define TOTAL_SOURCES (RANDOM_SOURCES+RANDOM_SOURCES_INTERNAL)
_PROTOTYPE( void random_init, (void) );
_PROTOTYPE( int random_isseeded, (void) );
_PROTOTYPE( void random_update, (int source, rand_t *buf, int count) );
_PROTOTYPE( void random_getbytes, (void *buf, size_t size) );
_PROTOTYPE( void random_putbytes, (void *buf, size_t size) );
void random_init(void);
int random_isseeded(void);
void random_update(int source, rand_t *buf, int count);
void random_getbytes(void *buf, size_t size);
void random_putbytes(void *buf, size_t size);

2
drivers/readclock/readclock.c
View File

@@ -83,7 +83,7 @@ int dec_to_bcd(int n);
void usage(void);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD void sef_local_startup(void);
int main(int argc, char **argv)
{

79
drivers/rtl8139/rtl8139.c
View File

@@ -64,37 +64,36 @@ static void my_outl(u16_t port, u32_t value) {
#define rl_outw(port, offset, value) (my_outw((port) + (offset), (value)))
#define rl_outl(port, offset, value) (my_outl((port) + (offset), (value)))
_PROTOTYPE( static void rl_init, (message *mp) );
_PROTOTYPE( static void rl_pci_conf, (void) );
_PROTOTYPE( static int rl_probe, (re_t *rep, int skip) );
_PROTOTYPE( static void rl_conf_hw, (re_t *rep) );
_PROTOTYPE( static void rl_init_buf, (re_t *rep) );
_PROTOTYPE( static void rl_init_hw, (re_t *rep) );
_PROTOTYPE( static void rl_reset_hw, (re_t *rep) );
_PROTOTYPE( static void rl_confaddr, (re_t *rep) );
_PROTOTYPE( static void rl_rec_mode, (re_t *rep) );
_PROTOTYPE( static void rl_readv_s, (const message *mp, int from_int) );
_PROTOTYPE( static void rl_writev_s, (const message *mp, int from_int) );
_PROTOTYPE( static void rl_check_ints, (re_t *rep) );
_PROTOTYPE( static void rl_report_link, (re_t *rep) );
_PROTOTYPE( static void mii_print_techab, (u16_t techab) );
_PROTOTYPE( static void mii_print_stat_speed, (u16_t stat,
u16_t extstat) );
_PROTOTYPE( static void rl_clear_rx, (re_t *rep) );
_PROTOTYPE( static void rl_do_reset, (re_t *rep) );
_PROTOTYPE( static void rl_getstat_s, (message *mp) );
_PROTOTYPE( static void reply, (re_t *rep) );
_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
_PROTOTYPE( static void check_int_events, (void) );
_PROTOTYPE( static void do_hard_int, (void) );
_PROTOTYPE( static void rtl8139_dump, (message *m) );
static void rl_init(message *mp);
static void rl_pci_conf(void);
static int rl_probe(re_t *rep, int skip);
static void rl_conf_hw(re_t *rep);
static void rl_init_buf(re_t *rep);
static void rl_init_hw(re_t *rep);
static void rl_reset_hw(re_t *rep);
static void rl_confaddr(re_t *rep);
static void rl_rec_mode(re_t *rep);
static void rl_readv_s(const message *mp, int from_int);
static void rl_writev_s(const message *mp, int from_int);
static void rl_check_ints(re_t *rep);
static void rl_report_link(re_t *rep);
static void mii_print_techab(u16_t techab);
static void mii_print_stat_speed(u16_t stat, u16_t extstat);
static void rl_clear_rx(re_t *rep);
static void rl_do_reset(re_t *rep);
static void rl_getstat_s(message *mp);
static void reply(re_t *rep);
static void mess_reply(message *req, message *reply);
static void check_int_events(void);
static void do_hard_int(void);
static void rtl8139_dump(message *m);
#if 0
_PROTOTYPE( static void dump_phy, (re_t *rep) );
static void dump_phy(re_t *rep);
#endif
_PROTOTYPE( static int rl_handler, (re_t *rep) );
_PROTOTYPE( static void rl_watchdog_f, (timer_t *tp) );
_PROTOTYPE( static void tell_dev, (vir_bytes start, size_t size,
int pci_bus, int pci_dev, int pci_func) );
static int rl_handler(re_t *rep);
static void rl_watchdog_f(timer_t *tp);
static void tell_dev(vir_bytes start, size_t size, int pci_bus, int
pci_dev, int pci_func);
/* The message used in the main loop is made global, so that rl_watchdog_f()
* can change its message type to fake an interrupt message.
@@ -105,12 +104,12 @@ PRIVATE int int_event_check; /* set to TRUE if events arrived */
PRIVATE u32_t system_hz;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
EXTERN _PROTOTYPE( int sef_cb_lu_prepare, (int state) );
EXTERN _PROTOTYPE( int sef_cb_lu_state_isvalid, (int state) );
EXTERN _PROTOTYPE( void sef_cb_lu_state_dump, (int state) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
EXTERN int sef_cb_lu_prepare(int state);
EXTERN int sef_cb_lu_state_isvalid(int state);
EXTERN void sef_cb_lu_state_dump(int state);
/*===========================================================================*
* main *
@@ -2008,11 +2007,11 @@ timer_t *tp;
#if 0
_PROTOTYPE( static void rtl_init, (struct dpeth *dep) );
_PROTOTYPE( static u16_t get_ee_word, (dpeth_t *dep, int a) );
_PROTOTYPE( static void ee_wen, (dpeth_t *dep) );
_PROTOTYPE( static void set_ee_word, (dpeth_t *dep, int a, u16_t w) );
_PROTOTYPE( static void ee_wds, (dpeth_t *dep) );
static void rtl_init(struct dpeth *dep);
static u16_t get_ee_word(dpeth_t *dep, int a);
static void ee_wen(dpeth_t *dep);
static void set_ee_word(dpeth_t *dep, int a, u16_t w);
static void ee_wds(dpeth_t *dep);
static void rtl_init(dep)
dpeth_t *dep;

50
drivers/rtl8169/rtl8169.c
View File

@@ -205,28 +205,28 @@ static void my_outl(u16_t port, u32_t value)
#define rl_outw(port, offset, value) (my_outw((port) + (offset), (value)))
#define rl_outl(port, offset, value) (my_outl((port) + (offset), (value)))
_PROTOTYPE( static void rl_init, (message *mp) );
_PROTOTYPE( static void rl_pci_conf, (void) );
_PROTOTYPE( static int rl_probe, (re_t *rep, int skip) );
_PROTOTYPE( static void rl_conf_hw, (re_t *rep) );
_PROTOTYPE( static void rl_init_buf, (re_t *rep) );
_PROTOTYPE( static void rl_init_hw, (re_t *rep) );
_PROTOTYPE( static void rl_reset_hw, (re_t *rep) );
_PROTOTYPE( static void rl_confaddr, (re_t *rep) );
_PROTOTYPE( static void rl_rec_mode, (re_t *rep) );
_PROTOTYPE( static void rl_readv_s, (const message *mp, int from_int) );
_PROTOTYPE( static void rl_writev_s, (const message *mp, int from_int) );
_PROTOTYPE( static void rl_check_ints, (re_t *rep) );
_PROTOTYPE( static void rl_report_link, (re_t *rep) );
_PROTOTYPE( static void rl_do_reset, (re_t *rep) );
_PROTOTYPE( static void rl_getstat_s, (message *mp) );
_PROTOTYPE( static void reply, (re_t *rep) );
_PROTOTYPE( static void mess_reply, (message *req, message *reply) );
_PROTOTYPE( static void check_int_events, (void) );
_PROTOTYPE( static void do_hard_int, (void) );
_PROTOTYPE( static void dump_phy, (const re_t *rep) );
_PROTOTYPE( static void rl_handler, (re_t *rep) );
_PROTOTYPE( static void rl_watchdog_f, (timer_t *tp) );
static void rl_init(message *mp);
static void rl_pci_conf(void);
static int rl_probe(re_t *rep, int skip);
static void rl_conf_hw(re_t *rep);
static void rl_init_buf(re_t *rep);
static void rl_init_hw(re_t *rep);
static void rl_reset_hw(re_t *rep);
static void rl_confaddr(re_t *rep);
static void rl_rec_mode(re_t *rep);
static void rl_readv_s(const message *mp, int from_int);
static void rl_writev_s(const message *mp, int from_int);
static void rl_check_ints(re_t *rep);
static void rl_report_link(re_t *rep);
static void rl_do_reset(re_t *rep);
static void rl_getstat_s(message *mp);
static void reply(re_t *rep);
static void mess_reply(message *req, message *reply);
static void check_int_events(void);
static void do_hard_int(void);
static void dump_phy(const re_t *rep);
static void rl_handler(re_t *rep);
static void rl_watchdog_f(timer_t *tp);
/*
* The message used in the main loop is made global, so that rl_watchdog_f()
@@ -238,9 +238,9 @@ PRIVATE int int_event_check; /* set to TRUE if events arrived */
u32_t system_hz;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* main *

10
drivers/ti1225/ti1225.c
View File

@@ -31,13 +31,13 @@ PRIVATE struct port
PRIVATE int instance;
PRIVATE int debug;
FORWARD _PROTOTYPE( int hw_probe, (int skip) );
FORWARD _PROTOTYPE( void hw_init, (struct port *pp, int devind) );
FORWARD _PROTOTYPE( void do_int, (struct port *pp) );
FORWARD int hw_probe(int skip);
FORWARD void hw_init(struct port *pp, int devind);
FORWARD void do_int(struct port *pp);
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
/*===========================================================================*
* main *

38
drivers/tty/console.c
View File

@@ -118,27 +118,27 @@ struct sequence {
unsigned char value;
};
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 cons_putk, (int c) );
FORWARD _PROTOTYPE( void beep, (void) );
FORWARD _PROTOTYPE( void do_escape, (console_t *cons, int c) );
FORWARD _PROTOTYPE( void flush, (console_t *cons) );
FORWARD _PROTOTYPE( void parse_escape, (console_t *cons, int c) );
FORWARD _PROTOTYPE( void scroll_screen, (console_t *cons, int dir) );
FORWARD _PROTOTYPE( void set_6845, (int reg, unsigned val) );
FORWARD _PROTOTYPE( void stop_beep, (timer_t *tmrp) );
FORWARD _PROTOTYPE( void cons_org0, (void) );
FORWARD _PROTOTYPE( void disable_console, (void) );
FORWARD _PROTOTYPE( void reenable_console, (void) );
FORWARD _PROTOTYPE( int ga_program, (struct sequence *seq) );
FORWARD _PROTOTYPE( int cons_ioctl, (tty_t *tp, int) );
FORWARD _PROTOTYPE( void mem_vid_copy, (vir_bytes src, int dst, int count) );
FORWARD _PROTOTYPE( void vid_vid_copy, (int src, int dst, int count) );
FORWARD int cons_write(struct tty *tp, int try);
FORWARD void cons_echo(tty_t *tp, int c);
FORWARD void out_char(console_t *cons, int c);
FORWARD void cons_putk(int c);
FORWARD void beep(void);
FORWARD void do_escape(console_t *cons, int c);
FORWARD void flush(console_t *cons);
FORWARD void parse_escape(console_t *cons, int c);
FORWARD void scroll_screen(console_t *cons, int dir);
FORWARD void set_6845(int reg, unsigned val);
FORWARD void stop_beep(timer_t *tmrp);
FORWARD void cons_org0(void);
FORWARD void disable_console(void);
FORWARD void reenable_console(void);
FORWARD int ga_program(struct sequence *seq);
FORWARD int cons_ioctl(tty_t *tp, int);
FORWARD void mem_vid_copy(vir_bytes src, int dst, int count);
FORWARD void vid_vid_copy(int src, int dst, int count);
#if 0
FORWARD _PROTOTYPE( void get_6845, (int reg, unsigned *val) );
FORWARD void get_6845(int reg, unsigned *val);
#endif
/*===========================================================================*

32
drivers/tty/keyboard.c
View File

@@ -153,22 +153,22 @@ PRIVATE long sticky_alt_mode = 0;
PRIVATE long debug_fkeys = 1;
PRIVATE timer_t tmr_kbd_wd;
FORWARD _PROTOTYPE( void handle_req, (struct kbd *kbdp, message *m) );
FORWARD _PROTOTYPE( int handle_status, (struct kbd *kbdp, message *m) );
FORWARD _PROTOTYPE( void kbc_cmd0, (int cmd) );
FORWARD _PROTOTYPE( void kbc_cmd1, (int cmd, int data) );
FORWARD _PROTOTYPE( int kbc_read, (void) );
FORWARD _PROTOTYPE( void kbd_send, (void) );
FORWARD _PROTOTYPE( int kb_ack, (void) );
FORWARD _PROTOTYPE( int kb_wait, (void) );
FORWARD _PROTOTYPE( int func_key, (int scode) );
FORWARD _PROTOTYPE( int scan_keyboard, (unsigned char *bp, int *isauxp) );
FORWARD _PROTOTYPE( unsigned make_break, (int scode) );
FORWARD _PROTOTYPE( void set_leds, (void) );
FORWARD _PROTOTYPE( void show_key_mappings, (void) );
FORWARD _PROTOTYPE( int kb_read, (struct tty *tp, int try) );
FORWARD _PROTOTYPE( unsigned map_key, (int scode) );
FORWARD _PROTOTYPE( void kbd_watchdog, (timer_t *tmrp) );
FORWARD void handle_req(struct kbd *kbdp, message *m);
FORWARD int handle_status(struct kbd *kbdp, message *m);
FORWARD void kbc_cmd0(int cmd);
FORWARD void kbc_cmd1(int cmd, int data);
FORWARD int kbc_read(void);
FORWARD void kbd_send(void);
FORWARD int kb_ack(void);
FORWARD int kb_wait(void);
FORWARD int func_key(int scode);
FORWARD int scan_keyboard(unsigned char *bp, int *isauxp);
FORWARD unsigned make_break(int scode);
FORWARD void set_leds(void);
FORWARD void show_key_mappings(void);
FORWARD int kb_read(struct tty *tp, int try);
FORWARD unsigned map_key(int scode);
FORWARD void kbd_watchdog(timer_t *tmrp);
int micro_delay(u32_t usecs)
{

18
drivers/tty/pty.c
View File

@@ -67,15 +67,15 @@ typedef struct pty {
PRIVATE pty_t pty_table[NR_PTYS]; /* PTY bookkeeping */
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( 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) );
FORWARD _PROTOTYPE( int pty_select, (tty_t *tp, message *m) );
FORWARD int pty_write(tty_t *tp, int try);
FORWARD void pty_echo(tty_t *tp, int c);
FORWARD void pty_start(pty_t *pp);
FORWARD void pty_finish(pty_t *pp);
FORWARD int pty_read(tty_t *tp, int try);
FORWARD int pty_close(tty_t *tp, int try);
FORWARD int pty_icancel(tty_t *tp, int try);
FORWARD int pty_ocancel(tty_t *tp, int try);
FORWARD int pty_select(tty_t *tp, message *m);
/*===========================================================================*
* do_pty *

30
drivers/tty/rs232.c
View File

@@ -178,21 +178,21 @@ PRIVATE port_t addr_8250[] = {
};
#endif
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( int rs_write, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( void rs_echo, (tty_t *tp, int c) );
FORWARD _PROTOTYPE( int rs_ioctl, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( void rs_config, (rs232_t *rs) );
FORWARD _PROTOTYPE( int rs_read, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( int rs_icancel, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( int rs_ocancel, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( void rs_ostart, (rs232_t *rs) );
FORWARD _PROTOTYPE( int rs_break, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( int rs_close, (tty_t *tp, int try) );
FORWARD _PROTOTYPE( void out_int, (rs232_t *rs) );
FORWARD _PROTOTYPE( void rs232_handler, (rs232_t *rs) );
FORWARD void in_int(rs232_t *rs);
FORWARD void line_int(rs232_t *rs);
FORWARD void modem_int(rs232_t *rs);
FORWARD int rs_write(tty_t *tp, int try);
FORWARD void rs_echo(tty_t *tp, int c);
FORWARD int rs_ioctl(tty_t *tp, int try);
FORWARD void rs_config(rs232_t *rs);
FORWARD int rs_read(tty_t *tp, int try);
FORWARD int rs_icancel(tty_t *tp, int try);
FORWARD int rs_ocancel(tty_t *tp, int try);
FORWARD void rs_ostart(rs232_t *rs);
FORWARD int rs_break(tty_t *tp, int try);
FORWARD int rs_close(tty_t *tp, int try);
FORWARD void out_int(rs232_t *rs);
FORWARD void rs232_handler(rs232_t *rs);
/* XXX */
PRIVATE void lock(void) {}

44
drivers/tty/tty.c
View File

@@ -101,25 +101,25 @@ unsigned long rs_irq_set = 0;
struct kmessages kmess;
FORWARD _PROTOTYPE( void tty_timed_out, (timer_t *tp) );
FORWARD _PROTOTYPE( void settimer, (tty_t *tty_ptr, int enable) );
FORWARD _PROTOTYPE( void do_cancel, (tty_t *tp, message *m_ptr) );
FORWARD _PROTOTYPE( void do_ioctl, (tty_t *tp, message *m_ptr) );
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 do_status, (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) );
FORWARD _PROTOTYPE( int back_over, (tty_t *tp) );
FORWARD _PROTOTYPE( void reprint, (tty_t *tp) );
FORWARD _PROTOTYPE( void dev_ioctl, (tty_t *tp) );
FORWARD _PROTOTYPE( void setattr, (tty_t *tp) );
FORWARD _PROTOTYPE( void tty_icancel, (tty_t *tp) );
FORWARD _PROTOTYPE( void tty_init, (void) );
FORWARD void tty_timed_out(timer_t *tp);
FORWARD void settimer(tty_t *tty_ptr, int enable);
FORWARD void do_cancel(tty_t *tp, message *m_ptr);
FORWARD void do_ioctl(tty_t *tp, message *m_ptr);
FORWARD void do_open(tty_t *tp, message *m_ptr);
FORWARD void do_close(tty_t *tp, message *m_ptr);
FORWARD void do_read(tty_t *tp, message *m_ptr);
FORWARD void do_write(tty_t *tp, message *m_ptr);
FORWARD void do_select(tty_t *tp, message *m_ptr);
FORWARD void do_status(message *m_ptr);
FORWARD void in_transfer(tty_t *tp);
FORWARD int tty_echo(tty_t *tp, int ch);
FORWARD void rawecho(tty_t *tp, int ch);
FORWARD int back_over(tty_t *tp);
FORWARD void reprint(tty_t *tp);
FORWARD void dev_ioctl(tty_t *tp);
FORWARD void setattr(tty_t *tp);
FORWARD void tty_icancel(tty_t *tp);
FORWARD void tty_init(void);
/* Default attributes. */
PRIVATE struct termios termios_defaults = {
@@ -139,9 +139,9 @@ PUBLIC struct machine machine; /* kernel environment variables */
PUBLIC u32_t system_hz;
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
FORWARD _PROTOTYPE( int sef_cb_init_fresh, (int type, sef_init_info_t *info) );
FORWARD _PROTOTYPE( void sef_cb_signal_handler, (int signo) );
FORWARD void sef_local_startup(void);
FORWARD int sef_cb_init_fresh(int type, sef_init_info_t *info);
FORWARD void sef_cb_signal_handler(int signo);
/*===========================================================================*
* tty_task *

75
drivers/tty/tty.h
View File

@@ -29,8 +29,8 @@
#define O_NONBLOCK 04000
struct tty;
typedef _PROTOTYPE( int (*devfun_t), (struct tty *tp, int try_only) );
typedef _PROTOTYPE( void (*devfunarg_t), (struct tty *tp, int c) );
typedef int(*devfun_t) (struct tty *tp, int try_only);
typedef void(*devfunarg_t) (struct tty *tp, int c);
typedef struct tty {
int tty_events; /* set when TTY should inspect this line */
@@ -137,52 +137,51 @@ extern struct kmessages kmess;
/* Function prototypes for TTY driver. */
/* tty.c */
_PROTOTYPE( void handle_events, (struct tty *tp) );
_PROTOTYPE( void sigchar, (struct tty *tp, int sig, int mayflush) );
_PROTOTYPE( void tty_task, (void) );
_PROTOTYPE( int in_process, (struct tty *tp, char *buf, int count,
int scode) );
_PROTOTYPE( void out_process, (struct tty *tp, char *bstart, char *bpos,
char *bend, int *icount, int *ocount) );
_PROTOTYPE( void tty_wakeup, (clock_t now) );
void handle_events(struct tty *tp);
void sigchar(struct tty *tp, int sig, int mayflush);
void tty_task(void);
int in_process(struct tty *tp, char *buf, int count, int scode);
void out_process(struct tty *tp, char *bstart, char *bpos, char *bend,
int *icount, int *ocount);
void tty_wakeup(clock_t now);
#define tty_reply(c, r, p, s) tty_reply_f(__FILE__, __LINE__, (c), (r), (p), (s))
_PROTOTYPE( void tty_reply_f, (char *f, int l, int code, int replyee, int proc_nr,
int status) );
_PROTOTYPE( int select_try, (struct tty *tp, int ops) );
_PROTOTYPE( int select_retry, (struct tty *tp) );
void tty_reply_f(char *f, int l, int code, int replyee, int proc_nr, int
status);
int select_try(struct tty *tp, int ops);
int select_retry(struct tty *tp);
/* rs232.c */
_PROTOTYPE( void rs_init, (struct tty *tp) );
_PROTOTYPE( void rs_interrupt, (message *m) );
void rs_init(struct tty *tp);
void rs_interrupt(message *m);
#if (CHIP == INTEL)
/* console.c */
_PROTOTYPE( void kputc, (int c) );
_PROTOTYPE( void cons_stop, (void) );
_PROTOTYPE( void do_new_kmess, (void) );
_PROTOTYPE( void scr_init, (struct tty *tp) );
_PROTOTYPE( void toggle_scroll, (void) );
_PROTOTYPE( int con_loadfont, (message *m) );
_PROTOTYPE( void select_console, (int cons_line) );
_PROTOTYPE( void beep_x, ( unsigned freq, clock_t dur) );
_PROTOTYPE( void do_video, (message *m) );
void kputc(int c);
void cons_stop(void);
void do_new_kmess(void);
void scr_init(struct tty *tp);
void toggle_scroll(void);
int con_loadfont(message *m);
void select_console(int cons_line);
void beep_x( unsigned freq, clock_t dur);
void do_video(message *m);
/* keyboard.c */
_PROTOTYPE( void kb_init, (struct tty *tp) );
_PROTOTYPE( void kb_init_once, (void) );
_PROTOTYPE( int kbd_loadmap, (message *m) );
_PROTOTYPE( void do_fkey_ctl, (message *m) );
_PROTOTYPE( void kbd_interrupt, (message *m) );
_PROTOTYPE( void do_kbd, (message *m) );
_PROTOTYPE( void do_kb_inject, (message *m) );
_PROTOTYPE( void do_kbdaux, (message *m) );
_PROTOTYPE( int kbd_status, (message *m_ptr) );
void kb_init(struct tty *tp);
void kb_init_once(void);
int kbd_loadmap(message *m);
void do_fkey_ctl(message *m);
void kbd_interrupt(message *m);
void do_kbd(message *m);
void do_kb_inject(message *m);
void do_kbdaux(message *m);
int kbd_status(message *m_ptr);
/* pty.c */
_PROTOTYPE( void do_pty, (struct tty *tp, message *m_ptr) );
_PROTOTYPE( void pty_init, (struct tty *tp) );
_PROTOTYPE( void select_retry_pty, (struct tty *tp) );
_PROTOTYPE( int pty_status, (message *m_ptr) );
void do_pty(struct tty *tp, message *m_ptr);
void pty_init(struct tty *tp);
void select_retry_pty(struct tty *tp);
int pty_status(message *m_ptr);
#endif /* (CHIP == INTEL) */