d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove __P.

Browse Source
This commit is contained in:
Alfred Perlstein 2002-03-20 02:08:01 +00:00
parent c605e9e62f
commit e51a25f850
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=92739
152 changed files with 2144 additions and 2198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/dev/acpica/acpivar.h
View File

@ -297,7 +297,7 @@ extern UINT32 acpi_eventhandler_sleep_button_for_wakeup(void *context);
#define ACPI_EVENT_PRI_DEFAULT 10000
#define ACPI_EVENT_PRI_LAST 20000
typedef void (*acpi_event_handler_t) __P((void *, int));
typedef void (*acpi_event_handler_t)(void *, int);
EVENTHANDLER_DECLARE(acpi_sleep_event, acpi_event_handler_t);
EVENTHANDLER_DECLARE(acpi_wakeup_event, acpi_event_handler_t);

40
sys/dev/aic/aic.c
View File

@ -45,26 +45,26 @@
#include <dev/aic/aic6360reg.h>
#include <dev/aic/aicvar.h>
static void aic_action __P((struct cam_sim *sim, union ccb *ccb));
static void aic_execute_scb __P((void *arg, bus_dma_segment_t *dm_segs,
int nseg, int error));
static void aic_start __P((struct aic_softc *aic));
static void aic_select __P((struct aic_softc *aic));
static void aic_selected __P((struct aic_softc *aic));
static void aic_reselected __P((struct aic_softc *aic));
static void aic_reconnect __P((struct aic_softc *aic, int tag));
static void aic_cmd __P((struct aic_softc *aic));
static void aic_msgin __P((struct aic_softc *aic));
static void aic_handle_msgin __P((struct aic_softc *aic));
static void aic_msgout __P((struct aic_softc *aic));
static void aic_datain __P((struct aic_softc *aic));
static void aic_dataout __P((struct aic_softc *aic));
static void aic_done __P((struct aic_softc *aic, struct aic_scb *scb));
static void aic_poll __P((struct cam_sim *sim));
static void aic_timeout __P((void *arg));
static void aic_scsi_reset __P((struct aic_softc *aic));
static void aic_chip_reset __P((struct aic_softc *aic));
static void aic_reset __P((struct aic_softc *aic, int initiate_reset));
static void aic_action(struct cam_sim *sim, union ccb *ccb);
static void aic_execute_scb(void *arg, bus_dma_segment_t *dm_segs,
int nseg, int error);
static void aic_start(struct aic_softc *aic);
static void aic_select(struct aic_softc *aic);
static void aic_selected(struct aic_softc *aic);
static void aic_reselected(struct aic_softc *aic);
static void aic_reconnect(struct aic_softc *aic, int tag);
static void aic_cmd(struct aic_softc *aic);
static void aic_msgin(struct aic_softc *aic);
static void aic_handle_msgin(struct aic_softc *aic);
static void aic_msgout(struct aic_softc *aic);
static void aic_datain(struct aic_softc *aic);
static void aic_dataout(struct aic_softc *aic);
static void aic_done(struct aic_softc *aic, struct aic_scb *scb);
static void aic_poll(struct cam_sim *sim);
static void aic_timeout(void *arg);
static void aic_scsi_reset(struct aic_softc *aic);
static void aic_chip_reset(struct aic_softc *aic);
static void aic_reset(struct aic_softc *aic, int initiate_reset);
devclass_t aic_devclass;

8
sys/dev/aic/aic_cbus.c
View File

@ -48,10 +48,10 @@ struct aic_isa_softc {
void *sc_ih;
};
static int aic_isa_alloc_resources __P((device_t));
static void aic_isa_release_resources __P((device_t));
static int aic_isa_probe __P((device_t));
static int aic_isa_attach __P((device_t));
static int aic_isa_alloc_resources(device_t);
static void aic_isa_release_resources(device_t);
static int aic_isa_probe(device_t);
static int aic_isa_attach(device_t);
#ifdef PC98
static u_int aic_isa_ports[] = { 0x1840 };

8
sys/dev/aic/aic_isa.c
View File

@ -48,10 +48,10 @@ struct aic_isa_softc {
void *sc_ih;
};
static int aic_isa_alloc_resources __P((device_t));
static void aic_isa_release_resources __P((device_t));
static int aic_isa_probe __P((device_t));
static int aic_isa_attach __P((device_t));
static int aic_isa_alloc_resources(device_t);
static void aic_isa_release_resources(device_t);
static int aic_isa_probe(device_t);
static int aic_isa_attach(device_t);
static u_int aic_isa_ports[] = { 0x340, 0x140 };
#define AIC_ISA_NUMPORTS (sizeof(aic_isa_ports) / sizeof(aic_isa_ports[0]))

8
sys/dev/aic/aicvar.h
View File

@ -153,7 +153,7 @@ struct aic_softc {
bus_space_write_multi_4((aic)->tag, (aic)->bsh, (port), \
(u_int32_t *)(addr), (count))
extern int aic_probe __P((struct aic_softc *));
extern int aic_attach __P((struct aic_softc *));
extern int aic_detach __P((struct aic_softc *));
extern void aic_intr __P((void *));
extern int aic_probe(struct aic_softc *);
extern int aic_attach(struct aic_softc *);
extern int aic_detach(struct aic_softc *);
extern void aic_intr(void *);

72
sys/dev/an/if_an.c
View File

@ -136,54 +136,52 @@ static const char rcsid[] =
#endif
/* These are global because we need them in sys/pci/if_an_p.c. */
static void an_reset __P((struct an_softc *));
static int an_ioctl __P((struct ifnet *, u_long, caddr_t));
static void an_init __P((void *));
static int an_init_tx_ring __P((struct an_softc *));
static void an_start __P((struct ifnet *));
static void an_watchdog __P((struct ifnet *));
static void an_rxeof __P((struct an_softc *));
static void an_txeof __P((struct an_softc *, int));
static void an_reset (struct an_softc *);
static int an_ioctl (struct ifnet *, u_long, caddr_t);
static void an_init (void *);
static int an_init_tx_ring (struct an_softc *);
static void an_start (struct ifnet *);
static void an_watchdog (struct ifnet *);
static void an_rxeof (struct an_softc *);
static void an_txeof (struct an_softc *, int);
static void an_promisc __P((struct an_softc *, int));
static int an_cmd __P((struct an_softc *, int, int));
static int an_read_record __P((struct an_softc *, struct an_ltv_gen *));
static int an_write_record __P((struct an_softc *, struct an_ltv_gen *));
static int an_read_data __P((struct an_softc *, int,
int, caddr_t, int));
static int an_write_data __P((struct an_softc *, int,
int, caddr_t, int));
static int an_seek __P((struct an_softc *, int, int, int));
static int an_alloc_nicmem __P((struct an_softc *, int, int *));
static void an_stats_update __P((void *));
static void an_setdef __P((struct an_softc *, struct an_req *));
static void an_promisc (struct an_softc *, int);
static int an_cmd (struct an_softc *, int, int);
static int an_read_record (struct an_softc *, struct an_ltv_gen *);
static int an_write_record (struct an_softc *, struct an_ltv_gen *);
static int an_read_data (struct an_softc *, int, int, caddr_t, int);
static int an_write_data (struct an_softc *, int, int, caddr_t, int);
static int an_seek (struct an_softc *, int, int, int);
static int an_alloc_nicmem (struct an_softc *, int, int *);
static void an_stats_update (void *);
static void an_setdef (struct an_softc *, struct an_req *);
#ifdef ANCACHE
static void an_cache_store __P((struct an_softc *, struct ether_header *,
struct mbuf *, unsigned short));
static void an_cache_store (struct an_softc *, struct ether_header *,
struct mbuf *, unsigned short);
#endif
/* function definitions for use with the Cisco's Linux configuration
utilities
*/
static int readrids __P((struct ifnet*, struct aironet_ioctl*));
static int writerids __P((struct ifnet*, struct aironet_ioctl*));
static int flashcard __P((struct ifnet*, struct aironet_ioctl*));
static int readrids(struct ifnet*, struct aironet_ioctl*);
static int writerids(struct ifnet*, struct aironet_ioctl*);
static int flashcard(struct ifnet*, struct aironet_ioctl*);
static int cmdreset __P((struct ifnet *));
static int setflashmode __P((struct ifnet *));
static int flashgchar __P((struct ifnet *,int,int));
static int flashpchar __P((struct ifnet *,int,int));
static int flashputbuf __P((struct ifnet *));
static int flashrestart __P((struct ifnet *));
static int WaitBusy __P((struct ifnet *, int));
static int unstickbusy __P((struct ifnet *));
static int cmdreset(struct ifnet *);
static int setflashmode(struct ifnet *);
static int flashgchar(struct ifnet *,int,int);
static int flashpchar(struct ifnet *,int,int);
static int flashputbuf(struct ifnet *);
static int flashrestart(struct ifnet *);
static int WaitBusy(struct ifnet *, int);
static int unstickbusy(struct ifnet *);
static void an_dump_record __P((struct an_softc *,struct an_ltv_gen *,
char *));
static void an_dump_record (struct an_softc *,struct an_ltv_gen *,
char *);
static int an_media_change __P((struct ifnet *));
static void an_media_status __P((struct ifnet *, struct ifmediareq *));
static int an_media_change (struct ifnet *);
static void an_media_status (struct ifnet *, struct ifmediareq *);
static int an_dump = 0;

6
sys/dev/an/if_an_isa.c
View File

@ -81,9 +81,9 @@ static struct isa_pnp_id an_ids[] = {
{ 0, NULL }
};
static int an_probe_isa __P((device_t));
static int an_attach_isa __P((device_t));
static int an_detach_isa __P((device_t));
static int an_probe_isa (device_t);
static int an_attach_isa (device_t);
static int an_detach_isa (device_t);
static int
an_probe_isa(dev)

6
sys/dev/an/if_an_pci.c
View File

@ -112,9 +112,9 @@ static struct an_type an_devs[] = {
{ 0, 0, NULL }
};
static int an_probe_pci __P((device_t));
static int an_attach_pci __P((device_t));
static int an_detach_pci __P((device_t));
static int an_probe_pci (device_t);
static int an_attach_pci (device_t);
static int an_detach_pci (device_t);
static int
an_probe_pci(device_t dev)

16
sys/dev/an/if_anreg.h
View File

@ -368,14 +368,14 @@ struct an_softc {
#define AN_LOCK(_sc) mtx_lock(&(_sc)->an_mtx)
#define AN_UNLOCK(_sc) mtx_unlock(&(_sc)->an_mtx)
void an_release_resources __P((device_t));
int an_alloc_port __P((device_t, int, int));
int an_alloc_memory __P((device_t, int, int));
int an_alloc_irq __P((device_t, int, int));
int an_probe __P((device_t));
void an_shutdown __P((device_t));
int an_attach __P((struct an_softc *, int, int));
void an_stop __P((struct an_softc *));
void an_release_resources (device_t);
int an_alloc_port (device_t, int, int);
int an_alloc_memory (device_t, int, int);
int an_alloc_irq (device_t, int, int);
int an_probe (device_t);
void an_shutdown (device_t);
int an_attach (struct an_softc *, int, int);
void an_stop (struct an_softc *);
driver_intr_t an_intr;

64
sys/dev/asr/asr.c
View File

@ -443,48 +443,48 @@ STATIC Asr_softc_t * Asr_softc;
#define ATTACH_RETURN(retval) return
#endif
/* I2O HDM interface */
STATIC PROBE_RET asr_probe __P((PROBE_ARGS));
STATIC ATTACH_RET asr_attach __P((ATTACH_ARGS));
STATIC PROBE_RET asr_probe(PROBE_ARGS);
STATIC ATTACH_RET asr_attach(ATTACH_ARGS);
/* DOMINO placeholder */
STATIC PROBE_RET domino_probe __P((PROBE_ARGS));
STATIC ATTACH_RET domino_attach __P((ATTACH_ARGS));
STATIC PROBE_RET domino_probe(PROBE_ARGS);
STATIC ATTACH_RET domino_attach(ATTACH_ARGS);
/* MODE0 adapter placeholder */
STATIC PROBE_RET mode0_probe __P((PROBE_ARGS));
STATIC ATTACH_RET mode0_attach __P((ATTACH_ARGS));
STATIC PROBE_RET mode0_probe(PROBE_ARGS);
STATIC ATTACH_RET mode0_attach(ATTACH_ARGS);
STATIC Asr_softc_t * ASR_get_sc __P((
IN dev_t dev));
STATIC int asr_ioctl __P((
STATIC Asr_softc_t * ASR_get_sc(
IN dev_t dev);
STATIC int asr_ioctl(
IN dev_t dev,
IN u_long cmd,
INOUT caddr_t data,
int flag,
struct thread * td));
STATIC int asr_open __P((
struct thread * td);
STATIC int asr_open(
IN dev_t dev,
int32_t flags,
int32_t ifmt,
IN struct thread * td));
STATIC int asr_close __P((
IN struct thread * td);
STATIC int asr_close(
dev_t dev,
int flags,
int ifmt,
struct thread * td));
STATIC int asr_intr __P((
IN Asr_softc_t * sc));
STATIC void asr_timeout __P((
INOUT void * arg));
STATIC int ASR_init __P((
IN Asr_softc_t * sc));
STATIC INLINE int ASR_acquireLct __P((
INOUT Asr_softc_t * sc));
STATIC INLINE int ASR_acquireHrt __P((
INOUT Asr_softc_t * sc));
STATIC void asr_action __P((
struct thread * td);
STATIC int asr_intr(
IN Asr_softc_t * sc);
STATIC void asr_timeout(
INOUT void * arg);
STATIC int ASR_init(
IN Asr_softc_t * sc);
STATIC INLINE int ASR_acquireLct(
INOUT Asr_softc_t * sc);
STATIC INLINE int ASR_acquireHrt(
INOUT Asr_softc_t * sc);
STATIC void asr_action(
IN struct cam_sim * sim,
IN union ccb * ccb));
STATIC void asr_poll __P((
IN struct cam_sim * sim));
IN union ccb * ccb);
STATIC void asr_poll(
IN struct cam_sim * sim);
/*
* Here is the auto-probe structure used to nest our tests appropriately
@ -593,8 +593,8 @@ STATIC struct cdevsw asr_cdevsw = {
};
#ifdef ASR_MEASURE_PERFORMANCE
STATIC u_int32_t asr_time_delta __P((IN struct timeval start,
IN struct timeval end));
STATIC u_int32_t asr_time_delta(IN struct timeval start,
IN struct timeval end);
#endif
#ifdef ASR_VERY_BROKEN
@ -942,9 +942,9 @@ ASR_prstring (
/*
* Prototypes
*/
STATIC INLINE int ASR_queue __P((
STATIC INLINE int ASR_queue(
IN Asr_softc_t * sc,
IN PI2O_MESSAGE_FRAME Message));
IN PI2O_MESSAGE_FRAME Message);
/*
* Send a message synchronously and without Interrupt to a ccb.
*/

34
sys/dev/awi/am79c930.c
View File

@ -88,27 +88,27 @@
#define AM930_DELAY(x) /*nothing*/
void am79c930_regdump __P((struct am79c930_softc *sc));
void am79c930_regdump(struct am79c930_softc *sc);
static void io_write_1 __P((struct am79c930_softc *, u_int32_t, u_int8_t));
static void io_write_2 __P((struct am79c930_softc *, u_int32_t, u_int16_t));
static void io_write_4 __P((struct am79c930_softc *, u_int32_t, u_int32_t));
static void io_write_bytes __P((struct am79c930_softc *, u_int32_t, u_int8_t *, size_t));
static void io_write_1(struct am79c930_softc *, u_int32_t, u_int8_t);
static void io_write_2(struct am79c930_softc *, u_int32_t, u_int16_t);
static void io_write_4(struct am79c930_softc *, u_int32_t, u_int32_t);
static void io_write_bytes(struct am79c930_softc *, u_int32_t, u_int8_t *, size_t);
static u_int8_t io_read_1 __P((struct am79c930_softc *, u_int32_t));
static u_int16_t io_read_2 __P((struct am79c930_softc *, u_int32_t));
static u_int32_t io_read_4 __P((struct am79c930_softc *, u_int32_t));
static void io_read_bytes __P((struct am79c930_softc *, u_int32_t, u_int8_t *, size_t));
static u_int8_t io_read_1(struct am79c930_softc *, u_int32_t);
static u_int16_t io_read_2(struct am79c930_softc *, u_int32_t);
static u_int32_t io_read_4(struct am79c930_softc *, u_int32_t);
static void io_read_bytes(struct am79c930_softc *, u_int32_t, u_int8_t *, size_t);
static void mem_write_1 __P((struct am79c930_softc *, u_int32_t, u_int8_t));
static void mem_write_2 __P((struct am79c930_softc *, u_int32_t, u_int16_t));
static void mem_write_4 __P((struct am79c930_softc *, u_int32_t, u_int32_t));
static void mem_write_bytes __P((struct am79c930_softc *, u_int32_t, u_int8_t *, size_t));
static void mem_write_1(struct am79c930_softc *, u_int32_t, u_int8_t);
static void mem_write_2(struct am79c930_softc *, u_int32_t, u_int16_t);
static void mem_write_4(struct am79c930_softc *, u_int32_t, u_int32_t);
static void mem_write_bytes(struct am79c930_softc *, u_int32_t, u_int8_t *, size_t);
static u_int8_t mem_read_1 __P((struct am79c930_softc *, u_int32_t));
static u_int16_t mem_read_2 __P((struct am79c930_softc *, u_int32_t));
static u_int32_t mem_read_4 __P((struct am79c930_softc *, u_int32_t));
static void mem_read_bytes __P((struct am79c930_softc *, u_int32_t, u_int8_t *, size_t));
static u_int8_t mem_read_1(struct am79c930_softc *, u_int32_t);
static u_int16_t mem_read_2(struct am79c930_softc *, u_int32_t);
static u_int32_t mem_read_4(struct am79c930_softc *, u_int32_t);
static void mem_read_bytes(struct am79c930_softc *, u_int32_t, u_int8_t *, size_t);
static struct am79c930_ops iospace_ops = {
io_write_1,

24
sys/dev/awi/am79c930var.h
View File

@ -55,23 +55,23 @@ struct am79c930_softc
struct am79c930_ops
{
void (*write_1) __P((struct am79c930_softc *, u_int32_t, u_int8_t));
void (*write_2) __P((struct am79c930_softc *, u_int32_t, u_int16_t));
void (*write_4) __P((struct am79c930_softc *, u_int32_t, u_int32_t));
void (*write_bytes) __P((struct am79c930_softc *, u_int32_t, u_int8_t *, size_t));
void (*write_1)(struct am79c930_softc *, u_int32_t, u_int8_t);
void (*write_2)(struct am79c930_softc *, u_int32_t, u_int16_t);
void (*write_4)(struct am79c930_softc *, u_int32_t, u_int32_t);
void (*write_bytes)(struct am79c930_softc *, u_int32_t, u_int8_t *, size_t);
u_int8_t (*read_1) __P((struct am79c930_softc *, u_int32_t));
u_int16_t (*read_2) __P((struct am79c930_softc *, u_int32_t));
u_int32_t (*read_4) __P((struct am79c930_softc *, u_int32_t));
void (*read_bytes) __P((struct am79c930_softc *, u_int32_t, u_int8_t *, size_t));
u_int8_t (*read_1)(struct am79c930_softc *, u_int32_t);
u_int16_t (*read_2)(struct am79c930_softc *, u_int32_t);
u_int32_t (*read_4)(struct am79c930_softc *, u_int32_t);
void (*read_bytes)(struct am79c930_softc *, u_int32_t, u_int8_t *, size_t);
};
void am79c930_chip_init __P((struct am79c930_softc *sc, int));
void am79c930_chip_init(struct am79c930_softc *sc, int);
void am79c930_gcr_setbits __P((struct am79c930_softc *sc, u_int8_t bits));
void am79c930_gcr_clearbits __P((struct am79c930_softc *sc, u_int8_t bits));
void am79c930_gcr_setbits(struct am79c930_softc *sc, u_int8_t bits);
void am79c930_gcr_clearbits(struct am79c930_softc *sc, u_int8_t bits);
u_int8_t am79c930_gcr_read __P((struct am79c930_softc *sc));
u_int8_t am79c930_gcr_read(struct am79c930_softc *sc);
#define am79c930_hard_reset(sc) am79c930_gcr_setbits(sc, AM79C930_GCR_CORESET)
#define am79c930_hard_reset_off(sc) am79c930_gcr_clearbits(sc, AM79C930_GCR_CORESET)

84
sys/dev/awi/awi.c
View File

@ -160,51 +160,51 @@
#include <dev/awi/awivar.h>
#endif
static int awi_ioctl __P((struct ifnet *ifp, u_long cmd, caddr_t data));
static int awi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
#ifdef IFM_IEEE80211
static int awi_media_rate2opt __P((struct awi_softc *sc, int rate));
static int awi_media_opt2rate __P((struct awi_softc *sc, int opt));
static int awi_media_change __P((struct ifnet *ifp));
static void awi_media_status __P((struct ifnet *ifp, struct ifmediareq *imr));
static int awi_media_rate2opt(struct awi_softc *sc, int rate);
static int awi_media_opt2rate(struct awi_softc *sc, int opt);
static int awi_media_change(struct ifnet *ifp);
static void awi_media_status(struct ifnet *ifp, struct ifmediareq *imr);
#endif
static void awi_watchdog __P((struct ifnet *ifp));
static void awi_start __P((struct ifnet *ifp));
static void awi_txint __P((struct awi_softc *sc));
static struct mbuf * awi_fix_txhdr __P((struct awi_softc *sc, struct mbuf *m0));
static struct mbuf * awi_fix_rxhdr __P((struct awi_softc *sc, struct mbuf *m0));
static void awi_input __P((struct awi_softc *sc, struct mbuf *m, u_int32_t rxts, u_int8_t rssi));
static void awi_rxint __P((struct awi_softc *sc));
static struct mbuf * awi_devget __P((struct awi_softc *sc, u_int32_t off, u_int16_t len));
static int awi_init_hw __P((struct awi_softc *sc));
static int awi_init_mibs __P((struct awi_softc *sc));
static int awi_init_txrx __P((struct awi_softc *sc));
static void awi_stop_txrx __P((struct awi_softc *sc));
static int awi_start_scan __P((struct awi_softc *sc));
static int awi_next_scan __P((struct awi_softc *sc));
static void awi_stop_scan __P((struct awi_softc *sc));
static void awi_recv_beacon __P((struct awi_softc *sc, struct mbuf *m0, u_int32_t rxts, u_int8_t rssi));
static int awi_set_ss __P((struct awi_softc *sc));
static void awi_try_sync __P((struct awi_softc *sc));
static void awi_sync_done __P((struct awi_softc *sc));
static void awi_send_deauth __P((struct awi_softc *sc));
static void awi_send_auth __P((struct awi_softc *sc, int seq));
static void awi_recv_auth __P((struct awi_softc *sc, struct mbuf *m0));
static void awi_send_asreq __P((struct awi_softc *sc, int reassoc));
static void awi_recv_asresp __P((struct awi_softc *sc, struct mbuf *m0));
static int awi_mib __P((struct awi_softc *sc, u_int8_t cmd, u_int8_t mib));
static int awi_cmd_scan __P((struct awi_softc *sc));
static int awi_cmd __P((struct awi_softc *sc, u_int8_t cmd));
static void awi_cmd_done __P((struct awi_softc *sc));
static int awi_next_txd __P((struct awi_softc *sc, int len, u_int32_t *framep, u_int32_t*ntxdp));
static int awi_lock __P((struct awi_softc *sc));
static void awi_unlock __P((struct awi_softc *sc));
static int awi_intr_lock __P((struct awi_softc *sc));
static void awi_intr_unlock __P((struct awi_softc *sc));
static int awi_cmd_wait __P((struct awi_softc *sc));
static void awi_print_essid __P((u_int8_t *essid));
static void awi_watchdog(struct ifnet *ifp);
static void awi_start(struct ifnet *ifp);
static void awi_txint(struct awi_softc *sc);
static struct mbuf * awi_fix_txhdr(struct awi_softc *sc, struct mbuf *m0);
static struct mbuf * awi_fix_rxhdr(struct awi_softc *sc, struct mbuf *m0);
static void awi_input(struct awi_softc *sc, struct mbuf *m, u_int32_t rxts, u_int8_t rssi);
static void awi_rxint(struct awi_softc *sc);
static struct mbuf * awi_devget(struct awi_softc *sc, u_int32_t off, u_int16_t len);
static int awi_init_hw(struct awi_softc *sc);
static int awi_init_mibs(struct awi_softc *sc);
static int awi_init_txrx(struct awi_softc *sc);
static void awi_stop_txrx(struct awi_softc *sc);
static int awi_start_scan(struct awi_softc *sc);
static int awi_next_scan(struct awi_softc *sc);
static void awi_stop_scan(struct awi_softc *sc);
static void awi_recv_beacon(struct awi_softc *sc, struct mbuf *m0, u_int32_t rxts, u_int8_t rssi);
static int awi_set_ss(struct awi_softc *sc);
static void awi_try_sync(struct awi_softc *sc);
static void awi_sync_done(struct awi_softc *sc);
static void awi_send_deauth(struct awi_softc *sc);
static void awi_send_auth(struct awi_softc *sc, int seq);
static void awi_recv_auth(struct awi_softc *sc, struct mbuf *m0);
static void awi_send_asreq(struct awi_softc *sc, int reassoc);
static void awi_recv_asresp(struct awi_softc *sc, struct mbuf *m0);
static int awi_mib(struct awi_softc *sc, u_int8_t cmd, u_int8_t mib);
static int awi_cmd_scan(struct awi_softc *sc);
static int awi_cmd(struct awi_softc *sc, u_int8_t cmd);
static void awi_cmd_done(struct awi_softc *sc);
static int awi_next_txd(struct awi_softc *sc, int len, u_int32_t *framep, u_int32_t*ntxdp);
static int awi_lock(struct awi_softc *sc);
static void awi_unlock(struct awi_softc *sc);
static int awi_intr_lock(struct awi_softc *sc);
static void awi_intr_unlock(struct awi_softc *sc);
static int awi_cmd_wait(struct awi_softc *sc);
static void awi_print_essid(u_int8_t *essid);
#ifdef AWI_DEBUG
static void awi_dump_pkt __P((struct awi_softc *sc, struct mbuf *m, int rssi));
static void awi_dump_pkt(struct awi_softc *sc, struct mbuf *m, int rssi);
int awi_verbose = 0;
int awi_dump = 0;
#define AWI_DUMP_MASK(fc0) (1 << (((fc0) & IEEE80211_FC0_SUBTYPE_MASK) >> 4))
@ -241,7 +241,7 @@ devclass_t awi_devclass;
#endif
/* NetBSD compatible functions */
static char * ether_sprintf __P((u_int8_t *));
static char * ether_sprintf(u_int8_t *);
static char *
ether_sprintf(enaddr)

10
sys/dev/awi/awi_wep.c
View File

@ -116,12 +116,12 @@ arc4_encrypt(void *ctx, u_int8_t *dst, u_int8_t *src, int len)
}
#endif
static void awi_crc_init __P((void));
static u_int32_t awi_crc_update __P((u_int32_t crc, u_int8_t *buf, int len));
static void awi_crc_init(void);
static u_int32_t awi_crc_update(u_int32_t crc, u_int8_t *buf, int len);
static int awi_null_ctxlen __P((void));
static void awi_null_setkey __P((void *ctx, u_int8_t *key, int keylen));
static void awi_null_copy __P((void *ctx, u_int8_t *dst, u_int8_t *src, int len));
static int awi_null_ctxlen(void);
static void awi_null_setkey(void *ctx, u_int8_t *key, int keylen);
static void awi_null_copy(void *ctx, u_int8_t *dst, u_int8_t *src, int len);
/* XXX: the order should be known to wiconfig/user */

4
sys/dev/awi/awi_wicfg.c
View File

@ -91,8 +91,8 @@
#include <dev/awi/awivar.h>
#endif
static int awi_cfgget __P((struct ifnet *ifp, u_long cmd, caddr_t data));
static int awi_cfgset __P((struct ifnet *ifp, u_long cmd, caddr_t data));
static int awi_cfgget(struct ifnet *ifp, u_long cmd, caddr_t data);
static int awi_cfgset(struct ifnet *ifp, u_long cmd, caddr_t data);
int
awi_wicfg(ifp, cmd, data)

46
sys/dev/awi/awivar.h
View File

@ -81,10 +81,10 @@ struct awi_bss
struct awi_wep_algo {
char *awa_name;
int (*awa_ctxlen) __P((void));
void (*awa_setkey) __P((void *, u_char *, int));
void (*awa_encrypt) __P((void *, u_char *, u_char *, int));
void (*awa_decrypt) __P((void *, u_char *, u_char *, int));
int (*awa_ctxlen)(void);
void (*awa_setkey)(void *, u_char *, int);
void (*awa_encrypt)(void *, u_char *, u_char *, int);
void (*awa_decrypt)(void *, u_char *, u_char *, int);
};
struct awi_softc
@ -106,8 +106,8 @@ struct awi_softc
#endif
struct am79c930_softc sc_chip;
struct ifnet *sc_ifp;
int (*sc_enable) __P((struct awi_softc *));
void (*sc_disable) __P((struct awi_softc *));
int (*sc_enable)(struct awi_softc *);
void (*sc_disable)(struct awi_softc *);
struct ifmedia sc_media;
enum awi_status sc_status;
@ -199,24 +199,24 @@ struct awi_softc
#define AWI_80211_RATE(rate) (((rate) & 0x7f) * 5)
int awi_attach __P((struct awi_softc *));
int awi_intr __P((void *));
void awi_reset __P((struct awi_softc *));
int awi_attach(struct awi_softc *);
int awi_intr(void *);
void awi_reset(struct awi_softc *);
#ifdef __NetBSD__
int awi_activate __P((struct device *, enum devact));
int awi_detach __P((struct awi_softc *));
void awi_power __P((struct awi_softc *, int));
int awi_activate(struct device *, enum devact);
int awi_detach(struct awi_softc *);
void awi_power(struct awi_softc *, int);
#endif
void awi_stop __P((struct awi_softc *sc));
int awi_init __P((struct awi_softc *sc));
int awi_init_region __P((struct awi_softc *));
int awi_wicfg __P((struct ifnet *, u_long, caddr_t));
void awi_stop(struct awi_softc *sc);
int awi_init(struct awi_softc *sc);
int awi_init_region(struct awi_softc *);
int awi_wicfg(struct ifnet *, u_long, caddr_t);
int awi_wep_setnwkey __P((struct awi_softc *, struct ieee80211_nwkey *));
int awi_wep_getnwkey __P((struct awi_softc *, struct ieee80211_nwkey *));
int awi_wep_getalgo __P((struct awi_softc *));
int awi_wep_setalgo __P((struct awi_softc *, int));
int awi_wep_setkey __P((struct awi_softc *, int, unsigned char *, int));
int awi_wep_getkey __P((struct awi_softc *, int, unsigned char *, int *));
struct mbuf *awi_wep_encrypt __P((struct awi_softc *, struct mbuf *, int));
int awi_wep_setnwkey(struct awi_softc *, struct ieee80211_nwkey *);
int awi_wep_getnwkey(struct awi_softc *, struct ieee80211_nwkey *);
int awi_wep_getalgo(struct awi_softc *);
int awi_wep_setalgo(struct awi_softc *, int);
int awi_wep_setkey(struct awi_softc *, int, unsigned char *, int);
int awi_wep_getkey(struct awi_softc *, int, unsigned char *, int *);
struct mbuf *awi_wep_encrypt(struct awi_softc *, struct mbuf *, int);

102
sys/dev/bge/if_bge.c
View File

@ -148,75 +148,73 @@ static struct bge_type bge_devs[] = {
{ 0, 0, NULL }
};
static int bge_probe __P((device_t));
static int bge_attach __P((device_t));
static int bge_detach __P((device_t));
static int bge_probe (device_t);
static int bge_attach (device_t);
static int bge_detach (device_t);
static void bge_release_resources
__P((struct bge_softc *));
static void bge_txeof __P((struct bge_softc *));
static void bge_rxeof __P((struct bge_softc *));
(struct bge_softc *);
static void bge_txeof (struct bge_softc *);
static void bge_rxeof (struct bge_softc *);
static void bge_tick __P((void *));
static void bge_stats_update __P((struct bge_softc *));
static int bge_encap __P((struct bge_softc *, struct mbuf *,
u_int32_t *));
static void bge_tick (void *);
static void bge_stats_update (struct bge_softc *);
static int bge_encap (struct bge_softc *, struct mbuf *,
u_int32_t *);
static void bge_intr __P((void *));
static void bge_start __P((struct ifnet *));
static int bge_ioctl __P((struct ifnet *, u_long, caddr_t));
static void bge_init __P((void *));
static void bge_stop __P((struct bge_softc *));
static void bge_watchdog __P((struct ifnet *));
static void bge_shutdown __P((device_t));
static int bge_ifmedia_upd __P((struct ifnet *));
static void bge_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
static void bge_intr (void *);
static void bge_start (struct ifnet *);
static int bge_ioctl (struct ifnet *, u_long, caddr_t);
static void bge_init (void *);
static void bge_stop (struct bge_softc *);
static void bge_watchdog (struct ifnet *);
static void bge_shutdown (device_t);
static int bge_ifmedia_upd (struct ifnet *);
static void bge_ifmedia_sts (struct ifnet *, struct ifmediareq *);
static u_int8_t bge_eeprom_getbyte __P((struct bge_softc *,
int, u_int8_t *));
static int bge_read_eeprom __P((struct bge_softc *, caddr_t, int, int));
static u_int8_t bge_eeprom_getbyte (struct bge_softc *, int, u_int8_t *);
static int bge_read_eeprom (struct bge_softc *, caddr_t, int, int);
static u_int32_t bge_crc __P((caddr_t));
static void bge_setmulti __P((struct bge_softc *));
static u_int32_t bge_crc (caddr_t);
static void bge_setmulti (struct bge_softc *);
static void bge_handle_events __P((struct bge_softc *));
static int bge_alloc_jumbo_mem __P((struct bge_softc *));
static void bge_free_jumbo_mem __P((struct bge_softc *));
static void *bge_jalloc __P((struct bge_softc *));
static void bge_jfree __P((caddr_t, void *));
static int bge_newbuf_std __P((struct bge_softc *, int, struct mbuf *));
static int bge_newbuf_jumbo __P((struct bge_softc *, int, struct mbuf *));
static int bge_init_rx_ring_std __P((struct bge_softc *));
static void bge_free_rx_ring_std __P((struct bge_softc *));
static int bge_init_rx_ring_jumbo __P((struct bge_softc *));
static void bge_free_rx_ring_jumbo __P((struct bge_softc *));
static void bge_free_tx_ring __P((struct bge_softc *));
static int bge_init_tx_ring __P((struct bge_softc *));
static void bge_handle_events (struct bge_softc *);
static int bge_alloc_jumbo_mem (struct bge_softc *);
static void bge_free_jumbo_mem (struct bge_softc *);
static void *bge_jalloc (struct bge_softc *);
static void bge_jfree (caddr_t, void *);
static int bge_newbuf_std (struct bge_softc *, int, struct mbuf *);
static int bge_newbuf_jumbo (struct bge_softc *, int, struct mbuf *);
static int bge_init_rx_ring_std (struct bge_softc *);
static void bge_free_rx_ring_std (struct bge_softc *);
static int bge_init_rx_ring_jumbo (struct bge_softc *);
static void bge_free_rx_ring_jumbo (struct bge_softc *);
static void bge_free_tx_ring (struct bge_softc *);
static int bge_init_tx_ring (struct bge_softc *);
static int bge_chipinit __P((struct bge_softc *));
static int bge_blockinit __P((struct bge_softc *));
static int bge_chipinit (struct bge_softc *);
static int bge_blockinit (struct bge_softc *);
#ifdef notdef
static u_int8_t bge_vpd_readbyte __P((struct bge_softc *, int));
static void bge_vpd_read_res __P((struct bge_softc *,
struct vpd_res *, int));
static void bge_vpd_read __P((struct bge_softc *));
static u_int8_t bge_vpd_readbyte(struct bge_softc *, int);
static void bge_vpd_read_res (struct bge_softc *, struct vpd_res *, int);
static void bge_vpd_read (struct bge_softc *);
#endif
static u_int32_t bge_readmem_ind
__P((struct bge_softc *, int));
static void bge_writemem_ind __P((struct bge_softc *, int, int));
(struct bge_softc *, int);
static void bge_writemem_ind (struct bge_softc *, int, int);
#ifdef notdef
static u_int32_t bge_readreg_ind
__P((struct bge_softc *, int));
(struct bge_softc *, int);
#endif
static void bge_writereg_ind __P((struct bge_softc *, int, int));
static void bge_writereg_ind (struct bge_softc *, int, int);
static int bge_miibus_readreg __P((device_t, int, int));
static int bge_miibus_writereg __P((device_t, int, int, int));
static void bge_miibus_statchg __P((device_t));
static int bge_miibus_readreg (device_t, int, int);
static int bge_miibus_writereg (device_t, int, int, int);
static void bge_miibus_statchg (device_t);
static void bge_reset __P((struct bge_softc *));
static void bge_phy_hack __P((struct bge_softc *));
static void bge_reset (struct bge_softc *);
static void bge_phy_hack (struct bge_softc *);
static device_method_t bge_methods[] = {
/* Device interface */

6
sys/dev/bktr/bktr_os.c
View File

@ -1290,11 +1290,11 @@ vm_offset_t vm_page_alloc_contig(vm_offset_t, vm_offset_t,
vm_offset_t, vm_offset_t);
#if defined(__OpenBSD__)
static int bktr_probe __P((struct device *, void *, void *));
static int bktr_probe(struct device *, void *, void *);
#else
static int bktr_probe __P((struct device *, struct cfdata *, void *));
static int bktr_probe(struct device *, struct cfdata *, void *);
#endif
static void bktr_attach __P((struct device *, struct device *, void *));
static void bktr_attach(struct device *, struct device *, void *);
struct cfattach bktr_ca = {
sizeof(struct bktr_softc), bktr_probe, bktr_attach

4
sys/dev/cm/if_cm_isa.c
View File

@ -52,8 +52,8 @@
#include <dev/cm/smc90cx6var.h>
static int cm_isa_probe __P((device_t));
static int cm_isa_attach __P((device_t));
static int cm_isa_probe (device_t);
static int cm_isa_attach (device_t);
static int
cm_isa_probe(dev)

16
sys/dev/cm/smc90cx6.c
View File

@ -146,13 +146,13 @@ devclass_t cm_devclass;
* #define fill(i) get mbuf && copy mbuf to chip(i)
*/
void cm_init __P((void *));
void cm_reset __P((struct cm_softc *));
void cm_start __P((struct ifnet *));
int cm_ioctl __P((struct ifnet *, unsigned long, caddr_t));
void cm_watchdog __P((struct ifnet *));
void cm_srint __P((void *vsc));
static void cm_tint __P((struct cm_softc *, int));
void cm_init(void *);
void cm_reset(struct cm_softc *);
void cm_start(struct ifnet *);
int cm_ioctl(struct ifnet *, unsigned long, caddr_t);
void cm_watchdog(struct ifnet *);
void cm_srint(void *vsc);
static void cm_tint(struct cm_softc *, int);
void cm_reconwatch(void *);
int
@ -336,7 +336,7 @@ cm_attach(sc, unit)
#ifdef CMSOFTCOPY
sc->sc_rxcookie = softintr_establish(IPL_SOFTNET, cm_srint, sc);
sc->sc_txcookie = softintr_establish(IPL_SOFTNET,
(void (*) __P((void *)))cm_start, ifp);
(void (*)(void *))cm_start, ifp);
#endif
#if __FreeBSD_version < 500000

16
sys/dev/cm/smc90cx6var.h
View File

@ -87,16 +87,16 @@ struct cm_softc {
u_char sc_retransmits[2]; /* unused at the moment */
};
int cm_attach __P((struct cm_softc *, int unit));
void cmintr __P((void *));
int cm_attach(struct cm_softc *, int unit);
void cmintr(void *);
int cm_probe __P((device_t dev));
void cm_stop __P((struct cm_softc *sc));
int cm_probe(device_t dev);
void cm_stop(struct cm_softc *sc);
int cm_alloc_port __P((device_t dev, int rid, int size));
int cm_alloc_memory __P((device_t dev, int rid, int size));
int cm_alloc_irq __P((device_t dev, int rid));
void cm_release_resources __P((device_t dev));
int cm_alloc_port(device_t dev, int rid, int size);
int cm_alloc_memory(device_t dev, int rid, int size);
int cm_alloc_irq(device_t dev, int rid);
void cm_release_resources(device_t dev);
extern devclass_t cm_devclass;

60
sys/dev/cnw/if_cnw.c
View File

@ -184,11 +184,11 @@ int cnw_skey = CNW_SCRAMBLEKEY; /* Scramble key */
*/
#define MEMORY_MAPPED
int cnw_match __P((struct device *, struct cfdata *, void *));
void cnw_attach __P((struct device *, struct device *, void *));
int cnw_detach __P((struct device *, int));
int cnw_match(struct device *, struct cfdata *, void *);
void cnw_attach(struct device *, struct device *, void *);
int cnw_detach(struct device *, int);
int cnw_activate __P((struct device *, enum devact));
int cnw_activate(struct device *, enum devact);
struct cnw_softc {
struct device sc_dev; /* Device glue (must be first) */
@ -309,15 +309,15 @@ struct cnw_softc {
};
static void cnw_freebsd_init __P((void *));
static void cnw_stop __P((struct cnw_softc *));
static void cnw_freebsd_init (void *);
static void cnw_stop (struct cnw_softc *);
static int cnw_pccard_probe __P((device_t));
static int cnw_pccard_attach __P((device_t));
static int cnw_pccard_detach __P((device_t));
static void cnw_shutdown __P((device_t));
static int cnw_alloc __P((device_t));
static void cnw_free __P((device_t));
static int cnw_pccard_probe (device_t);
static int cnw_pccard_attach (device_t);
static int cnw_pccard_detach (device_t);
static void cnw_shutdown (device_t);
static int cnw_alloc (device_t);
static void cnw_free (device_t);
static device_method_t cnw_pccard_methods[] = {
/* Device interface */
@ -341,33 +341,33 @@ DRIVER_MODULE(if_cnw, pccard, cnw_pccard_driver, cnw_pccard_devclass, 0, 0);
#endif /* !defined(__FreeBSD__) */
void cnw_reset __P((struct cnw_softc *));
void cnw_init __P((struct cnw_softc *));
void cnw_reset(struct cnw_softc *);
void cnw_init(struct cnw_softc *);
#if !defined(__FreeBSD__)
int cnw_enable __P((struct cnw_softc *sc));
void cnw_disable __P((struct cnw_softc *sc));
void cnw_config __P((struct cnw_softc *sc, u_int8_t *));
int cnw_enable(struct cnw_softc *sc);
void cnw_disable(struct cnw_softc *sc);
void cnw_config(struct cnw_softc *sc, u_int8_t *);
#endif
void cnw_start __P((struct ifnet *));
void cnw_transmit __P((struct cnw_softc *, struct mbuf *));
struct mbuf *cnw_read __P((struct cnw_softc *));
void cnw_recv __P((struct cnw_softc *));
void cnw_start(struct ifnet *);
void cnw_transmit(struct cnw_softc *, struct mbuf *);
struct mbuf *cnw_read(struct cnw_softc *);
void cnw_recv(struct cnw_softc *);
#if !defined(__FreeBSD__)
int cnw_intr __P((void *arg));
int cnw_intr(void *arg);
#else
void cnw_intr __P((void *arg));
void cnw_intr(void *arg);
#endif
int cnw_ioctl __P((struct ifnet *, u_long, caddr_t));
void cnw_watchdog __P((struct ifnet *));
static int cnw_setdomain __P((struct cnw_softc *, int));
static int cnw_setkey __P((struct cnw_softc *, int));
int cnw_ioctl(struct ifnet *, u_long, caddr_t);
void cnw_watchdog(struct ifnet *);
static int cnw_setdomain(struct cnw_softc *, int);
static int cnw_setkey(struct cnw_softc *, int);
/* ---------------------------------------------------------------- */
/* Help routines */
static int wait_WOC __P((struct cnw_softc *, int));
static int read16 __P((struct cnw_softc *, int));
static int cnw_cmd __P((struct cnw_softc *, int, int, int, int));
static int wait_WOC(struct cnw_softc *, int);
static int read16(struct cnw_softc *, int);
static int cnw_cmd(struct cnw_softc *, int, int, int, int);
/*
* Wait until the WOC (Write Operation Complete) bit in the

24
sys/dev/ct/bshw_machdep.c
View File

@ -210,9 +210,9 @@ bshw_read_settings(chp, bs)
#define SF_ABORT 0x08
#define SF_RDY 0x10
static __inline void bshw_lc_smit_start __P((struct ct_softc *, int, u_int));
static __inline void bshw_lc_smit_stop __P((struct ct_softc *));
static int bshw_lc_smit_fstat __P((struct ct_softc *, int, int));
static __inline void bshw_lc_smit_start(struct ct_softc *, int, u_int);
static __inline void bshw_lc_smit_stop(struct ct_softc *);
static int bshw_lc_smit_fstat(struct ct_softc *, int, int);
static __inline void
bshw_lc_smit_stop(ct)
@ -422,9 +422,9 @@ bshw_smit_xfer_start(ct)
* DMA TRANSFER (BS)
*********************************************************/
static __inline void bshw_dma_write_1 \
__P((struct ct_bus_access_handle *, bus_addr_t, u_int8_t));
static void bshw_dmastart __P((struct ct_softc *));
static void bshw_dmadone __P((struct ct_softc *));
(struct ct_bus_access_handle *, bus_addr_t, u_int8_t);
static void bshw_dmastart(struct ct_softc *);
static void bshw_dmadone(struct ct_softc *);
int
bshw_dma_xfer_start(ct)
@ -631,12 +631,12 @@ bshw_dmadone(ct)
/**********************************************
* VENDOR UNIQUE DMA FUNCS
**********************************************/
static int bshw_dma_init_sc98 __P((struct ct_softc *));
static void bshw_dma_start_sc98 __P((struct ct_softc *));
static void bshw_dma_stop_sc98 __P((struct ct_softc *));
static int bshw_dma_init_texa __P((struct ct_softc *));
static void bshw_dma_start_elecom __P((struct ct_softc *));
static void bshw_dma_stop_elecom __P((struct ct_softc *));
static int bshw_dma_init_sc98(struct ct_softc *);
static void bshw_dma_start_sc98(struct ct_softc *);
static void bshw_dma_stop_sc98(struct ct_softc *);
static int bshw_dma_init_texa(struct ct_softc *);
static void bshw_dma_start_elecom(struct ct_softc *);
static void bshw_dma_stop_elecom(struct ct_softc *);
static int
bshw_dma_init_texa(ct)

24
sys/dev/ct/bshwvar.h
View File

@ -48,9 +48,9 @@ struct bshw {
u_int hw_flags;
u_int hw_sregaddr;
int ((*hw_dma_init) __P((struct ct_softc *)));
void ((*hw_dma_start) __P((struct ct_softc *)));
void ((*hw_dma_stop) __P((struct ct_softc *)));
int ((*hw_dma_init)(struct ct_softc *));
void ((*hw_dma_start)(struct ct_softc *));
void ((*hw_dma_stop)(struct ct_softc *));
};
struct bshw_softc {
@ -80,17 +80,17 @@ struct bshw_softc {
/* hardware */
struct bshw *sc_hw;
void ((*sc_dmasync_before)) __P((struct ct_softc *));
void ((*sc_dmasync_after)) __P((struct ct_softc *));
void ((*sc_dmasync_before))(struct ct_softc *);
void ((*sc_dmasync_after))(struct ct_softc *);
};
void bshw_synch_setup __P((struct ct_softc *, struct targ_info *));
void bshw_bus_reset __P((struct ct_softc *));
int bshw_read_settings __P((struct ct_bus_access_handle *, struct bshw_softc *));
int bshw_smit_xfer_start __P((struct ct_softc *));
void bshw_smit_xfer_stop __P((struct ct_softc *));
int bshw_dma_xfer_start __P((struct ct_softc *));
void bshw_dma_xfer_stop __P((struct ct_softc *));
void bshw_synch_setup(struct ct_softc *, struct targ_info *);
void bshw_bus_reset(struct ct_softc *);
int bshw_read_settings(struct ct_bus_access_handle *, struct bshw_softc *);
int bshw_smit_xfer_start(struct ct_softc *);
void bshw_smit_xfer_stop(struct ct_softc *);
int bshw_dma_xfer_start(struct ct_softc *);
void bshw_dma_xfer_stop(struct ct_softc *);
extern struct dvcfg_hwsel bshw_hwsel;
#endif /* !_BSHWVAR_H_ */

38
sys/dev/ct/ct.c
View File

@ -149,25 +149,25 @@ extern struct cfdriver ct_cd;
/*****************************************************************
* Interface functions
*****************************************************************/
static int ct_xfer __P((struct ct_softc *, u_int8_t *, int, int, u_int *));
static void ct_io_xfer __P((struct ct_softc *));
static int ct_reselected __P((struct ct_softc *, u_int8_t));
static void ct_phase_error __P((struct ct_softc *, u_int8_t));
static int ct_start_selection __P((struct ct_softc *, struct slccb *));
static int ct_msg __P((struct ct_softc *, struct targ_info *, u_int));
static int ct_world_start __P((struct ct_softc *, int));
static __inline void cthw_phase_bypass __P((struct ct_softc *, u_int8_t));
static int cthw_chip_reset __P((struct ct_bus_access_handle *, int *, int, int));
static void cthw_bus_reset __P((struct ct_softc *));
static int ct_ccb_nexus_establish __P((struct ct_softc *));
static int ct_lun_nexus_establish __P((struct ct_softc *));
static int ct_target_nexus_establish __P((struct ct_softc *, int, int));
static void cthw_attention __P((struct ct_softc *));
static int ct_targ_init __P((struct ct_softc *, struct targ_info *, int));
static int ct_unbusy __P((struct ct_softc *));
static void ct_attention __P((struct ct_softc *));
static struct ct_synch_data *ct_make_synch_table __P((struct ct_softc *));
static int ct_catch_intr __P((struct ct_softc *));
static int ct_xfer(struct ct_softc *, u_int8_t *, int, int, u_int *);
static void ct_io_xfer(struct ct_softc *);
static int ct_reselected(struct ct_softc *, u_int8_t);
static void ct_phase_error(struct ct_softc *, u_int8_t);
static int ct_start_selection(struct ct_softc *, struct slccb *);
static int ct_msg(struct ct_softc *, struct targ_info *, u_int);
static int ct_world_start(struct ct_softc *, int);
static __inline void cthw_phase_bypass(struct ct_softc *, u_int8_t);
static int cthw_chip_reset(struct ct_bus_access_handle *, int *, int, int);
static void cthw_bus_reset(struct ct_softc *);
static int ct_ccb_nexus_establish(struct ct_softc *);
static int ct_lun_nexus_establish(struct ct_softc *);
static int ct_target_nexus_establish(struct ct_softc *, int, int);
static void cthw_attention(struct ct_softc *);
static int ct_targ_init(struct ct_softc *, struct targ_info *, int);
static int ct_unbusy(struct ct_softc *);
static void ct_attention(struct ct_softc *);
static struct ct_synch_data *ct_make_synch_table(struct ct_softc *);
static int ct_catch_intr(struct ct_softc *);
struct scsi_low_funcs ct_funcs = {
SC_LOW_INIT_T ct_world_start,

6
sys/dev/ct/ct_isa.c
View File

@ -101,9 +101,9 @@ static int ct_space_map(device_t, struct bshw *,
static void ct_space_unmap(device_t, struct ct_softc *);
static struct bshw *ct_find_hw(device_t);
static void ct_dmamap(void *, bus_dma_segment_t *, int, int);
static void ct_isa_bus_access_weight __P((struct ct_bus_access_handle *));
static void ct_isa_dmasync_before __P((struct ct_softc *));
static void ct_isa_dmasync_after __P((struct ct_softc *));
static void ct_isa_bus_access_weight(struct ct_bus_access_handle *);
static void ct_isa_dmasync_before(struct ct_softc *);
static void ct_isa_dmasync_after(struct ct_softc *);
struct ct_isa_softc {
struct ct_softc sc_ct;

16
sys/dev/ct/ct_machdep.h
View File

@ -73,21 +73,21 @@
* All port accesses primitive methods
*/
static __inline u_int8_t ct_stat_read_1
__P((struct ct_bus_access_handle *));
(struct ct_bus_access_handle *);
static __inline u_int8_t ct_cmdp_read_1
__P((struct ct_bus_access_handle *));
(struct ct_bus_access_handle *);
static __inline void ct_cmdp_write_1
__P((struct ct_bus_access_handle *, u_int8_t));
(struct ct_bus_access_handle *, u_int8_t);
static __inline u_int8_t ct_cr_read_1
__P((struct ct_bus_access_handle *, bus_addr_t));
(struct ct_bus_access_handle *, bus_addr_t);
static __inline void ct_cr_write_1
__P((struct ct_bus_access_handle *, bus_addr_t, u_int8_t));
(struct ct_bus_access_handle *, bus_addr_t, u_int8_t);
static __inline void ct_write_cmds
__P((struct ct_bus_access_handle *, u_int8_t *, int));
(struct ct_bus_access_handle *, u_int8_t *, int);
static __inline u_int cthw_get_count
__P((struct ct_bus_access_handle *));
(struct ct_bus_access_handle *);
static __inline void cthw_set_count
__P((struct ct_bus_access_handle *, u_int));
(struct ct_bus_access_handle *, u_int);
static __inline u_int8_t
ct_stat_read_1(chp)

22
sys/dev/ct/ctvar.h
View File

@ -54,7 +54,7 @@ struct ct_bus_access_handle {
bus_space_handle_t ch_datah;
bus_space_handle_t ch_memh;
void (*ch_bus_weight) __P((struct ct_bus_access_handle *));
void (*ch_bus_weight)(struct ct_bus_access_handle *);
#ifdef CT_USE_RELOCATE_OFFSET
bus_addr_t ch_offset[4];
@ -118,12 +118,12 @@ struct ct_softc {
* Machdep stuff.
*/
void *ct_hw; /* point to bshw_softc etc ... */
int (*ct_dma_xfer_start) __P((struct ct_softc *));
int (*ct_pio_xfer_start) __P((struct ct_softc *));
void (*ct_dma_xfer_stop) __P((struct ct_softc *));
void (*ct_pio_xfer_stop) __P((struct ct_softc *));
void (*ct_bus_reset) __P((struct ct_softc *));
void (*ct_synch_setup) __P((struct ct_softc *, struct targ_info *));
int (*ct_dma_xfer_start)(struct ct_softc *);
int (*ct_pio_xfer_start)(struct ct_softc *);
void (*ct_dma_xfer_stop)(struct ct_softc *);
void (*ct_pio_xfer_stop)(struct ct_softc *);
void (*ct_bus_reset)(struct ct_softc *);
void (*ct_synch_setup)(struct ct_softc *, struct targ_info *);
};
/*****************************************************************
@ -138,8 +138,8 @@ struct ct_targ_info {
/*****************************************************************
* PROTO
*****************************************************************/
int ctprobesubr __P((struct ct_bus_access_handle *, u_int, int, u_int, int *));
void ctattachsubr __P((struct ct_softc *));
int ctprint __P((void *, const char *));
int ctintr __P((void *));
int ctprobesubr(struct ct_bus_access_handle *, u_int, int, u_int, int *);
void ctattachsubr(struct ct_softc *);
int ctprint(void *, const char *);
int ctintr(void *);
#endif /* !_CTVAR_H_ */

4
sys/dev/cy/cy_pci.c
View File

@ -68,8 +68,8 @@
extern int cyattach_common(void *, int); /* Not exactly correct */
extern void cyintr(int);
static int cy_pci_attach __P((device_t dev));
static int cy_pci_probe __P((device_t dev));
static int cy_pci_attach(device_t dev);
static int cy_pci_probe(device_t dev);
static device_method_t cy_pci_methods[] = {
/* Device interface. */

14
sys/dev/dc/dcphy.c
View File

@ -93,9 +93,9 @@ static const char rcsid[] =
*/
#define COMPAQ_PRESARIO_ID 0xb0bb0e11
static int dcphy_probe __P((device_t));
static int dcphy_attach __P((device_t));
static int dcphy_detach __P((device_t));
static int dcphy_probe (device_t);
static int dcphy_attach (device_t);
static int dcphy_detach (device_t);
static device_method_t dcphy_methods[] = {
/* device interface */
@ -116,10 +116,10 @@ static driver_t dcphy_driver = {
DRIVER_MODULE(dcphy, miibus, dcphy_driver, dcphy_devclass, 0, 0);
static int dcphy_service __P((struct mii_softc *, struct mii_data *, int));
static void dcphy_status __P((struct mii_softc *));
static void dcphy_reset __P((struct mii_softc *));
static int dcphy_auto __P((struct mii_softc *, int));
static int dcphy_service(struct mii_softc *, struct mii_data *, int);
static void dcphy_status(struct mii_softc *);
static void dcphy_reset(struct mii_softc *);
static int dcphy_auto(struct mii_softc *, int);
static int dcphy_probe(dev)
device_t dev;

117
sys/dev/dc/if_dc.c
View File

@ -195,75 +195,70 @@ static struct dc_type dc_devs[] = {
{ 0, 0, NULL }
};
static int dc_probe __P((device_t));
static int dc_attach __P((device_t));
static int dc_detach __P((device_t));
static void dc_acpi __P((device_t));
static struct dc_type *dc_devtype __P((device_t));
static int dc_newbuf __P((struct dc_softc *, int, struct mbuf *));
static int dc_encap __P((struct dc_softc *, struct mbuf *,
u_int32_t *));
static int dc_coal __P((struct dc_softc *, struct mbuf **));
static void dc_pnic_rx_bug_war __P((struct dc_softc *, int));
static int dc_rx_resync __P((struct dc_softc *));
static void dc_rxeof __P((struct dc_softc *));
static void dc_txeof __P((struct dc_softc *));
static void dc_tick __P((void *));
static void dc_tx_underrun __P((struct dc_softc *));
static void dc_intr __P((void *));
static void dc_start __P((struct ifnet *));
static int dc_ioctl __P((struct ifnet *, u_long, caddr_t));
static void dc_init __P((void *));
static void dc_stop __P((struct dc_softc *));
static void dc_watchdog __P((struct ifnet *));
static void dc_shutdown __P((device_t));
static int dc_ifmedia_upd __P((struct ifnet *));
static void dc_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
static int dc_probe (device_t);
static int dc_attach (device_t);
static int dc_detach (device_t);
static void dc_acpi (device_t);
static struct dc_type *dc_devtype (device_t);
static int dc_newbuf (struct dc_softc *, int, struct mbuf *);
static int dc_encap (struct dc_softc *, struct mbuf *, u_int32_t *);
static int dc_coal (struct dc_softc *, struct mbuf **);
static void dc_pnic_rx_bug_war (struct dc_softc *, int);
static int dc_rx_resync (struct dc_softc *);
static void dc_rxeof (struct dc_softc *);
static void dc_txeof (struct dc_softc *);
static void dc_tick (void *);
static void dc_tx_underrun (struct dc_softc *);
static void dc_intr (void *);
static void dc_start (struct ifnet *);
static int dc_ioctl (struct ifnet *, u_long, caddr_t);
static void dc_init (void *);
static void dc_stop (struct dc_softc *);
static void dc_watchdog (struct ifnet *);
static void dc_shutdown (device_t);
static int dc_ifmedia_upd (struct ifnet *);
static void dc_ifmedia_sts (struct ifnet *, struct ifmediareq *);
static void dc_delay __P((struct dc_softc *));
static void dc_eeprom_idle __P((struct dc_softc *));
static void dc_eeprom_putbyte __P((struct dc_softc *, int));
static void dc_eeprom_getword __P((struct dc_softc *, int, u_int16_t *));
static void dc_delay (struct dc_softc *);
static void dc_eeprom_idle (struct dc_softc *);
static void dc_eeprom_putbyte (struct dc_softc *, int);
static void dc_eeprom_getword (struct dc_softc *, int, u_int16_t *);
static void dc_eeprom_getword_pnic
__P((struct dc_softc *, int, u_int16_t *));
(struct dc_softc *, int, u_int16_t *);
static void dc_eeprom_getword_xircom
__P((struct dc_softc *, int, u_int16_t *));
static void dc_read_eeprom __P((struct dc_softc *, caddr_t, int,
int, int));
(struct dc_softc *, int, u_int16_t *);
static void dc_read_eeprom (struct dc_softc *, caddr_t, int, int, int);
static void dc_mii_writebit __P((struct dc_softc *, int));
static int dc_mii_readbit __P((struct dc_softc *));
static void dc_mii_sync __P((struct dc_softc *));
static void dc_mii_send __P((struct dc_softc *, u_int32_t, int));
static int dc_mii_readreg __P((struct dc_softc *, struct dc_mii_frame *));
static int dc_mii_writereg __P((struct dc_softc *, struct dc_mii_frame *));
static int dc_miibus_readreg __P((device_t, int, int));
static int dc_miibus_writereg __P((device_t, int, int, int));
static void dc_miibus_statchg __P((device_t));
static void dc_miibus_mediainit __P((device_t));
static void dc_mii_writebit (struct dc_softc *, int);
static int dc_mii_readbit (struct dc_softc *);
static void dc_mii_sync (struct dc_softc *);
static void dc_mii_send (struct dc_softc *, u_int32_t, int);
static int dc_mii_readreg (struct dc_softc *, struct dc_mii_frame *);
static int dc_mii_writereg (struct dc_softc *, struct dc_mii_frame *);
static int dc_miibus_readreg (device_t, int, int);
static int dc_miibus_writereg (device_t, int, int, int);
static void dc_miibus_statchg (device_t);
static void dc_miibus_mediainit (device_t);
static void dc_setcfg __P((struct dc_softc *, int));
static u_int32_t dc_crc_le __P((struct dc_softc *, caddr_t));
static u_int32_t dc_crc_be __P((caddr_t));
static void dc_setfilt_21143 __P((struct dc_softc *));
static void dc_setfilt_asix __P((struct dc_softc *));
static void dc_setfilt_admtek __P((struct dc_softc *));
static void dc_setfilt_xircom __P((struct dc_softc *));
static void dc_setcfg (struct dc_softc *, int);
static u_int32_t dc_crc_le (struct dc_softc *, caddr_t);
static u_int32_t dc_crc_be (caddr_t);
static void dc_setfilt_21143 (struct dc_softc *);
static void dc_setfilt_asix (struct dc_softc *);
static void dc_setfilt_admtek (struct dc_softc *);
static void dc_setfilt_xircom (struct dc_softc *);
static void dc_setfilt __P((struct dc_softc *));
static void dc_setfilt (struct dc_softc *);
static void dc_reset __P((struct dc_softc *));
static int dc_list_rx_init __P((struct dc_softc *));
static int dc_list_tx_init __P((struct dc_softc *));
static void dc_reset (struct dc_softc *);
static int dc_list_rx_init (struct dc_softc *);
static int dc_list_tx_init (struct dc_softc *);
static void dc_parse_21143_srom __P((struct dc_softc *));
static void dc_decode_leaf_sia __P((struct dc_softc *,
struct dc_eblock_sia *));
static void dc_decode_leaf_mii __P((struct dc_softc *,
struct dc_eblock_mii *));
static void dc_decode_leaf_sym __P((struct dc_softc *,
struct dc_eblock_sym *));
static void dc_apply_fixup __P((struct dc_softc *, int));
static void dc_parse_21143_srom (struct dc_softc *);
static void dc_decode_leaf_sia (struct dc_softc *, struct dc_eblock_sia *);
static void dc_decode_leaf_mii (struct dc_softc *, struct dc_eblock_mii *);
static void dc_decode_leaf_sym (struct dc_softc *, struct dc_eblock_sym *);
static void dc_apply_fixup (struct dc_softc *, int);
#ifdef DC_USEIOSPACE
#define DC_RES SYS_RES_IOPORT

10
sys/dev/dc/pnphy.c
View File

@ -80,9 +80,9 @@ static const char rcsid[] =
CSR_WRITE_4(sc, reg, \
CSR_READ_4(sc, reg) & ~x)
static int pnphy_probe __P((device_t));
static int pnphy_attach __P((device_t));
static int pnphy_detach __P((device_t));
static int pnphy_probe (device_t);
static int pnphy_attach (device_t);
static int pnphy_detach (device_t);
static device_method_t pnphy_methods[] = {
/* device interface */
@ -103,8 +103,8 @@ static driver_t pnphy_driver = {
DRIVER_MODULE(pnphy, miibus, pnphy_driver, pnphy_devclass, 0, 0);
static int pnphy_service __P((struct mii_softc *, struct mii_data *, int));
static void pnphy_status __P((struct mii_softc *));
static int pnphy_service(struct mii_softc *, struct mii_data *, int);
static void pnphy_status(struct mii_softc *);
static int pnphy_probe(dev)
device_t dev;

32
sys/dev/dgb/dgb.c
View File

@ -204,28 +204,28 @@ static struct tty dgb_tty[NDGBPORTS];
*/
/* Interrupt handling entry points. */
static void dgbpoll __P((void *unit_c));
static void dgbpoll (void *unit_c);
/* Device switch entry points. */
#define dgbreset noreset
#define dgbmmap nommap
#define dgbstrategy nostrategy
static int dgbattach __P((struct isa_device *dev));
static int dgbprobe __P((struct isa_device *dev));
static int dgbattach (struct isa_device *dev);
static int dgbprobe (struct isa_device *dev);
static void fepcmd(struct dgb_p *port, unsigned cmd, unsigned op1, unsigned op2,
unsigned ncmds, unsigned bytecmd);
static void dgbstart __P((struct tty *tp));
static void dgbstop __P((struct tty *tp, int rw));
static int dgbparam __P((struct tty *tp, struct termios *t));
static void dgbhardclose __P((struct dgb_p *port));
static void dgb_drain_or_flush __P((struct dgb_p *port));
static int dgbdrain __P((struct dgb_p *port));
static void dgb_pause __P((void *chan));
static void wakeflush __P((void *p));
static void disc_optim __P((struct tty *tp, struct termios *t));
static void dgbstart (struct tty *tp);
static void dgbstop (struct tty *tp, int rw);
static int dgbparam (struct tty *tp, struct termios *t);
static void dgbhardclose (struct dgb_p *port);
static void dgb_drain_or_flush (struct dgb_p *port);
static int dgbdrain (struct dgb_p *port);
static void dgb_pause (void *chan);
static void wakeflush (void *p);
static void disc_optim (struct tty *tp, struct termios *t);
struct isa_driver dgbdriver = {
@ -339,10 +339,10 @@ static int dgbdebug=0;
SYSCTL_INT(_debug, OID_AUTO, dgb_debug, CTLFLAG_RW, &dgbdebug, 0, "");
#endif
static __inline int setwin __P((struct dgb_softc *sc, unsigned addr));
static __inline int setinitwin __P((struct dgb_softc *sc, unsigned addr));
static __inline void hidewin __P((struct dgb_softc *sc));
static __inline void towin __P((struct dgb_softc *sc, int win));
static __inline int setwin(struct dgb_softc *sc, unsigned addr);
static __inline int setinitwin(struct dgb_softc *sc, unsigned addr);
static __inline void hidewin(struct dgb_softc *sc);
static __inline void towin(struct dgb_softc *sc, int win);
/*Helg: to allow recursive dgb...() calls */
typedef struct

44
sys/dev/ed/if_ed.c
View File

@ -75,37 +75,35 @@
devclass_t ed_devclass;
static void ed_init __P((void *));
static int ed_ioctl __P((struct ifnet *, u_long, caddr_t));
static void ed_start __P((struct ifnet *));
static void ed_reset __P((struct ifnet *));
static void ed_watchdog __P((struct ifnet *));
static void ed_init (void *);
static int ed_ioctl (struct ifnet *, u_long, caddr_t);
static void ed_start (struct ifnet *);
static void ed_reset (struct ifnet *);
static void ed_watchdog (struct ifnet *);
#ifndef ED_NO_MIIBUS
static void ed_tick __P((void *));
static void ed_tick (void *);
#endif
static void ds_getmcaf __P((struct ed_softc *, u_int32_t *));
static void ds_getmcaf (struct ed_softc *, u_int32_t *);
static void ed_get_packet __P((struct ed_softc *, char *, /* u_short */ int));
static void ed_get_packet (struct ed_softc *, char *, /* u_short */ int);
static __inline void ed_rint __P((struct ed_softc *));
static __inline void ed_xmit __P((struct ed_softc *));
static __inline char * ed_ring_copy __P((struct ed_softc *, char *, char *,
/* u_short */ int));
static void ed_hpp_set_physical_link __P((struct ed_softc *));
static void ed_hpp_readmem __P((struct ed_softc *, int, unsigned char *,
/* u_short */ int));
static void ed_hpp_writemem __P((struct ed_softc *, unsigned char *,
/* u_short */ int, /* u_short */ int));
static u_short ed_hpp_write_mbufs __P((struct ed_softc *, struct mbuf *,
int));
static __inline void ed_rint (struct ed_softc *);
static __inline void ed_xmit (struct ed_softc *);
static __inline char * ed_ring_copy(struct ed_softc *, char *, char *,
/* u_short */ int);
static void ed_hpp_set_physical_link(struct ed_softc *);
static void ed_hpp_readmem (struct ed_softc *, int, unsigned char *,
/* u_short */ int);
static void ed_hpp_writemem (struct ed_softc *, unsigned char *,
/* u_short */ int, /* u_short */ int);
static u_short ed_hpp_write_mbufs(struct ed_softc *, struct mbuf *, int);
static u_short ed_pio_write_mbufs __P((struct ed_softc *, struct mbuf *,
int));
static u_short ed_pio_write_mbufs(struct ed_softc *, struct mbuf *, int);
static void ed_setrcr __P((struct ed_softc *));
static void ed_setrcr (struct ed_softc *);
static u_int32_t ds_crc __P((u_char *ep));
static u_int32_t ds_crc (u_char *ep);
/*
* Interrupt conversion table for WD/SMC ASIC/83C584

34
sys/dev/ed/if_ed_cbus.c
View File

@ -54,25 +54,25 @@
#include <dev/ed/if_edreg.h>
#include <dev/ed/if_ed98.h>
static int ed98_alloc_port __P((device_t, int));
static int ed98_alloc_memory __P((device_t, int));
static int ed_pio_testmem __P((struct ed_softc *, int, int, int));
static int ed_probe_SIC98 __P((device_t, int, int));
static int ed_probe_CNET98 __P((device_t, int, int));
static int ed_probe_CNET98EL __P((device_t, int, int));
static int ed_probe_NEC77 __P((device_t, int, int));
static int ed_probe_NW98X __P((device_t, int, int));
static int ed_probe_SB98 __P((device_t, int, int));
static int ed_probe_EZ98 __P((device_t, int, int));
static int ed98_probe_Novell __P((device_t, int, int));
static int ed98_probe_generic8390 __P((struct ed_softc *));
static void ed_reset_CNET98 __P((struct ed_softc *, int));
static void ed_winsel_CNET98 __P((struct ed_softc *, u_short));
static void ed_get_SB98 __P((struct ed_softc *));
static int ed98_alloc_port (device_t, int);
static int ed98_alloc_memory (device_t, int);
static int ed_pio_testmem (struct ed_softc *, int, int, int);
static int ed_probe_SIC98 (device_t, int, int);
static int ed_probe_CNET98 (device_t, int, int);
static int ed_probe_CNET98EL (device_t, int, int);
static int ed_probe_NEC77 (device_t, int, int);
static int ed_probe_NW98X (device_t, int, int);
static int ed_probe_SB98 (device_t, int, int);
static int ed_probe_EZ98 (device_t, int, int);
static int ed98_probe_Novell (device_t, int, int);
static int ed98_probe_generic8390 (struct ed_softc *);
static void ed_reset_CNET98 (struct ed_softc *, int);
static void ed_winsel_CNET98 (struct ed_softc *, u_short);
static void ed_get_SB98 (struct ed_softc *);
#endif
static int ed_isa_probe __P((device_t));
static int ed_isa_attach __P((device_t));
static int ed_isa_probe (device_t);
static int ed_isa_attach (device_t);
static struct isa_pnp_id ed_ids[] = {
#ifdef PC98

4
sys/dev/ed/if_ed_isa.c
View File

@ -44,8 +44,8 @@
#include <dev/ed/if_edvar.h>
static int ed_isa_probe __P((device_t));
static int ed_isa_attach __P((device_t));
static int ed_isa_probe (device_t);
static int ed_isa_attach (device_t);
static struct isa_pnp_id ed_ids[] = {
{ 0x1684a34d, NULL }, /* SMC8416 */

4
sys/dev/ed/if_ed_pci.c
View File

@ -58,8 +58,8 @@ static struct _pcsid
{ 0x00000000, NULL }
};
static int ed_pci_probe __P((device_t));
static int ed_pci_attach __P((device_t));
static int ed_pci_probe (device_t);
static int ed_pci_attach (device_t);
static int
ed_pci_probe (device_t dev)

48
sys/dev/ed/if_edvar.h
View File

@ -50,8 +50,8 @@ struct ed_softc {
struct resource* irq_res; /* resource for irq */
void* irq_handle; /* handle for irq handler */
device_t miibus; /* MII bus for cards with MII. */
void (*mii_writebits)__P((struct ed_softc *, u_int, int));
u_int (*mii_readbits)__P((struct ed_softc *, int));
void (*mii_writebits)(struct ed_softc *, u_int, int);
u_int (*mii_readbits)(struct ed_softc *, int);
struct callout_handle tick_ch; /* Callout handle for ed_tick */
int nic_offset; /* NIC (DS8390) I/O bus address offset */
@ -190,31 +190,31 @@ struct ed_softc {
rman_get_bushandle((sc)->port_res), \
(sc)->asic_offset + (port), (u_int32_t *)(addr), (count))
void ed_release_resources __P((device_t));
int ed_alloc_port __P((device_t, int, int));
int ed_alloc_memory __P((device_t, int, int));
int ed_alloc_irq __P((device_t, int, int));
void ed_release_resources (device_t);
int ed_alloc_port (device_t, int, int);
int ed_alloc_memory (device_t, int, int);
int ed_alloc_irq (device_t, int, int);
int ed_probe_generic8390 __P((struct ed_softc *));
int ed_probe_WD80x3 __P((device_t, int, int));
int ed_probe_WD80x3_generic __P((device_t, int, unsigned short *[]));
int ed_probe_3Com __P((device_t, int, int));
int ed_probe_Novell __P((device_t, int, int));
int ed_probe_Novell_generic __P((device_t, int));
int ed_probe_HP_pclanp __P((device_t, int, int));
int ed_probe_generic8390 (struct ed_softc *);
int ed_probe_WD80x3 (device_t, int, int);
int ed_probe_WD80x3_generic (device_t, int, unsigned short *[]);
int ed_probe_3Com (device_t, int, int);
int ed_probe_Novell (device_t, int, int);
int ed_probe_Novell_generic (device_t, int);
int ed_probe_HP_pclanp (device_t, int, int);
int ed_attach __P((struct ed_softc *, int, int));
void ed_stop __P((struct ed_softc *));
void ed_pio_readmem __P((struct ed_softc *, int, unsigned char *,
unsigned short));
void ed_pio_writemem __P((struct ed_softc *, char *,
unsigned short, unsigned short));
int ed_attach (struct ed_softc *, int, int);
void ed_stop (struct ed_softc *);
void ed_pio_readmem (struct ed_softc *, int, unsigned char *,
unsigned short);
void ed_pio_writemem (struct ed_softc *, char *,
unsigned short, unsigned short);
#ifndef ED_NO_MIIBUS
int ed_miibus_readreg __P((device_t, int, int));
void ed_miibus_writereg __P((device_t, int, int, int));
int ed_ifmedia_upd __P((struct ifnet *));
void ed_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
void ed_child_detached __P((device_t, device_t));
int ed_miibus_readreg (device_t, int, int);
void ed_miibus_writereg (device_t, int, int, int);
int ed_ifmedia_upd (struct ifnet *);
void ed_ifmedia_sts (struct ifnet *, struct ifmediareq *);
void ed_child_detached (device_t, device_t);
#endif
driver_intr_t edintr;

6
sys/dev/eisa/eisaconf.h
View File

@ -78,14 +78,14 @@ EISA_ACCESSOR(slot, SLOT, int)
EISA_ACCESSOR(id, ID, eisa_id_t)
EISA_ACCESSOR(irq, IRQ, eisa_id_t)
int eisa_add_intr __P((device_t, int, int));
int eisa_add_intr(device_t, int, int);
#define RESVADDR_NONE 0x00
#define RESVADDR_BITMASK 0x01 /* size is a mask of reserved
* bits at addr
*/
#define RESVADDR_RELOCATABLE 0x02
int eisa_add_iospace __P((device_t, u_long, u_long, int));
int eisa_add_mspace __P((device_t, u_long, u_long, int));
int eisa_add_iospace(device_t, u_long, u_long, int);
int eisa_add_mspace(device_t, u_long, u_long, int);
#endif /* _I386_EISA_EISACONF_H_ */

85
sys/dev/em/if_em.c
View File

@ -91,53 +91,52 @@ static char *em_strings[] = {
/*********************************************************************
* Function prototypes
*********************************************************************/
static int em_probe __P((device_t));
static int em_attach __P((device_t));
static int em_detach __P((device_t));
static int em_shutdown __P((device_t));
static void em_intr __P((void *));
static void em_start __P((struct ifnet *));
static int em_ioctl __P((struct ifnet *, IOCTL_CMD_TYPE, caddr_t));
static void em_watchdog __P((struct ifnet *));
static void em_init __P((void *));
static void em_stop __P((void *));
static void em_media_status __P((struct ifnet *, struct ifmediareq *));
static int em_media_change __P((struct ifnet *));
static void em_identify_hardware __P((struct adapter *));
static int em_allocate_pci_resources __P((struct adapter *));
static void em_free_pci_resources __P((struct adapter *));
static void em_local_timer __P((void *));
static int em_hardware_init __P((struct adapter *));
static void em_read_mac_address __P((struct adapter *, u_int8_t *));
static void em_setup_interface __P((device_t, struct adapter *));
static int em_setup_transmit_structures __P((struct adapter *));
static void em_initialize_transmit_unit __P((struct adapter *));
static int em_setup_receive_structures __P((struct adapter *));
static void em_initialize_receive_unit __P((struct adapter *));
static void EnableInterrupts __P((struct adapter *));
static void DisableInterrupts __P((struct adapter *));
static void em_free_transmit_structures __P((struct adapter *));
static void em_free_receive_structures __P((struct adapter *));
static void em_update_stats_counters __P((struct adapter *));
static void em_clean_transmit_interrupts __P((struct adapter *));
static int em_allocate_receive_structures __P((struct adapter *));
static int em_allocate_transmit_structures __P((struct adapter *));
static void em_process_receive_interrupts __P((struct adapter *));
static void em_receive_checksum __P((struct adapter *,
static int em_probe(device_t);
static int em_attach(device_t);
static int em_detach(device_t);
static int em_shutdown(device_t);
static void em_intr(void *);
static void em_start(struct ifnet *);
static int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t);
static void em_watchdog(struct ifnet *);
static void em_init(void *);
static void em_stop(void *);
static void em_media_status(struct ifnet *, struct ifmediareq *);
static int em_media_change(struct ifnet *);
static void em_identify_hardware(struct adapter *);
static int em_allocate_pci_resources(struct adapter *);
static void em_free_pci_resources(struct adapter *);
static void em_local_timer(void *);
static int em_hardware_init(struct adapter *);
static void em_read_mac_address(struct adapter *, u_int8_t *);
static void em_setup_interface(device_t, struct adapter *);
static int em_setup_transmit_structures(struct adapter *);
static void em_initialize_transmit_unit(struct adapter *);
static int em_setup_receive_structures(struct adapter *);
static void em_initialize_receive_unit(struct adapter *);
static void EnableInterrupts(struct adapter *);
static void DisableInterrupts(struct adapter *);
static void em_free_transmit_structures(struct adapter *);
static void em_free_receive_structures(struct adapter *);
static void em_update_stats_counters(struct adapter *);
static void em_clean_transmit_interrupts(struct adapter *);
static int em_allocate_receive_structures(struct adapter *);
static int em_allocate_transmit_structures(struct adapter *);
static void em_process_receive_interrupts(struct adapter *);
static void em_receive_checksum(struct adapter *,
struct em_rx_desc * RxDescriptor,
struct mbuf *));
static void em_transmit_checksum_setup __P((struct adapter *,
struct mbuf *);
static void em_transmit_checksum_setup(struct adapter *,
struct mbuf *,
struct em_tx_buffer *,
u_int32_t *,
u_int32_t *));
static void em_set_promisc __P((struct adapter *));
static void em_disable_promisc __P((struct adapter *));
static void em_set_multi __P((struct adapter *));
static void em_print_hw_stats __P((struct adapter *));
static void em_print_link_status __P((struct adapter *));
static int em_get_buf __P((struct em_rx_buffer *, struct adapter *,
struct mbuf *));
u_int32_t *);
static void em_set_promisc(struct adapter *);
static void em_disable_promisc(struct adapter *);
static void em_set_multi(struct adapter *);
static void em_print_hw_stats(struct adapter *);
static void em_print_link_status(struct adapter *);
static int em_get_buf(struct em_rx_buffer *, struct adapter *, struct mbuf *);
/*********************************************************************
* FreeBSD Device Interface Entry Points
*********************************************************************/

14
sys/dev/en/if_en_pci.c
View File

@ -67,10 +67,10 @@
* prototypes
*/
static int en_pci_probe __P((device_t));
static int en_pci_attach __P((device_t));
static int en_pci_detach __P((device_t));
static int en_pci_shutdown __P((device_t));
static int en_pci_probe(device_t);
static int en_pci_attach(device_t);
static int en_pci_detach(device_t);
static int en_pci_shutdown(device_t);
/*
* local structures
@ -87,10 +87,10 @@ struct en_pci_softc {
};
#if !defined(MIDWAY_ENIONLY)
static void eni_get_macaddr __P((device_t, struct en_pci_softc *));
static void eni_get_macaddr(device_t, struct en_pci_softc *);
#endif
#if !defined(MIDWAY_ADPONLY)
static void adp_get_macaddr __P((struct en_pci_softc *));
static void adp_get_macaddr(struct en_pci_softc *);
#endif
/*
@ -136,7 +136,7 @@ static void adp_get_macaddr __P((struct en_pci_softc *));
#if !defined(MIDWAY_ENIONLY)
static void adp_busreset __P((void *));
static void adp_busreset(void *);
/*
* bus specific reset function [ADP only!]

54
sys/dev/en/midway.c
View File

@ -265,36 +265,34 @@ static struct en_dmatab *en_dmaplan = en_dma_planB;
* prototypes
*/
STATIC INLINE int en_b2sz __P((int)) __attribute__ ((unused));
STATIC INLINE int en_b2sz(int) __attribute__ ((unused));
#ifdef EN_DDBHOOK
int en_dump __P((int,int));
int en_dumpmem __P((int,int,int));
int en_dump(int,int);
int en_dumpmem(int,int,int);
#endif
STATIC void en_dmaprobe __P((struct en_softc *));
STATIC int en_dmaprobe_doit __P((struct en_softc *, u_int8_t *,
u_int8_t *, int));
STATIC INLINE int en_dqneed __P((struct en_softc *, caddr_t, u_int,
u_int)) __attribute__ ((unused));
STATIC void en_init __P((struct en_softc *));
STATIC int en_ioctl __P((struct ifnet *, EN_IOCTL_CMDT, caddr_t));
STATIC INLINE int en_k2sz __P((int)) __attribute__ ((unused));
STATIC void en_loadvc __P((struct en_softc *, int));
STATIC int en_mfix __P((struct en_softc *, struct mbuf **,
struct mbuf *));
STATIC INLINE struct mbuf *en_mget __P((struct en_softc *, u_int,
u_int *)) __attribute__ ((unused));
STATIC INLINE u_int32_t en_read __P((struct en_softc *,
u_int32_t)) __attribute__ ((unused));
STATIC int en_rxctl __P((struct en_softc *, struct atm_pseudoioctl *,
int));
STATIC void en_txdma __P((struct en_softc *, int));
STATIC void en_txlaunch __P((struct en_softc *, int,
struct en_launch *));
STATIC void en_service __P((struct en_softc *));
STATIC void en_start __P((struct ifnet *));
STATIC INLINE int en_sz2b __P((int)) __attribute__ ((unused));
STATIC INLINE void en_write __P((struct en_softc *, u_int32_t,
u_int32_t)) __attribute__ ((unused));
STATIC void en_dmaprobe(struct en_softc *);
STATIC int en_dmaprobe_doit(struct en_softc *, u_int8_t *,
u_int8_t *, int);
STATIC INLINE int en_dqneed(struct en_softc *, caddr_t, u_int,
u_int) __attribute__ ((unused));
STATIC void en_init(struct en_softc *);
STATIC int en_ioctl(struct ifnet *, EN_IOCTL_CMDT, caddr_t);
STATIC INLINE int en_k2sz(int) __attribute__ ((unused));
STATIC void en_loadvc(struct en_softc *, int);
STATIC int en_mfix(struct en_softc *, struct mbuf **, struct mbuf *);
STATIC INLINE struct mbuf *en_mget(struct en_softc *, u_int,
u_int *) __attribute__ ((unused));
STATIC INLINE u_int32_t en_read(struct en_softc *,
u_int32_t) __attribute__ ((unused));
STATIC int en_rxctl(struct en_softc *, struct atm_pseudoioctl *, int);
STATIC void en_txdma(struct en_softc *, int);
STATIC void en_txlaunch(struct en_softc *, int,
struct en_launch *);
STATIC void en_service(struct en_softc *);
STATIC void en_start(struct ifnet *);
STATIC INLINE int en_sz2b(int) __attribute__ ((unused));
STATIC INLINE void en_write(struct en_softc *, u_int32_t,
u_int32_t) __attribute__ ((unused));
/*
* macros/inline

8
sys/dev/en/midwayvar.h
View File

@ -97,7 +97,7 @@ struct en_softc {
bus_space_tag_t en_memt; /* for EN_READ/EN_WRITE */
bus_space_handle_t en_base; /* base of en card */
bus_size_t en_obmemsz; /* size of en card (bytes) */
void (*en_busreset) __P((void *));
void (*en_busreset)(void *);
/* bus specific reset function */
/* serv list */
@ -195,6 +195,6 @@ struct en_softc {
* exported functions
*/
void en_attach __P((struct en_softc *));
EN_INTR_TYPE en_intr __P((void *));
void en_reset __P((struct en_softc *));
void en_attach(struct en_softc *);
EN_INTR_TYPE en_intr(void *);
void en_reset(struct en_softc *);

18
sys/dev/ep/if_ep.c
View File

@ -95,18 +95,18 @@ static int ep_media2if_media[] =
{ IFM_10_T, IFM_10_5, IFM_NONE, IFM_10_2, IFM_NONE };
/* if functions */
static void ep_if_init __P((void *));
static int ep_if_ioctl __P((struct ifnet *, u_long, caddr_t));
static void ep_if_start __P((struct ifnet *));
static void ep_if_watchdog __P((struct ifnet *));
static void ep_if_init (void *);
static int ep_if_ioctl (struct ifnet *, u_long, caddr_t);
static void ep_if_start (struct ifnet *);
static void ep_if_watchdog (struct ifnet *);
/* if_media functions */
static int ep_ifmedia_upd __P((struct ifnet *));
static void ep_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
static int ep_ifmedia_upd (struct ifnet *);
static void ep_ifmedia_sts (struct ifnet *, struct ifmediareq *);
static void epstop __P((struct ep_softc *));
static void epread __P((struct ep_softc *));
static int eeprom_rdy __P((struct ep_softc *));
static void epstop (struct ep_softc *);
static void epread (struct ep_softc *);
static int eeprom_rdy (struct ep_softc *);
#define EP_FTST(sc, f) (sc->stat & (f))
#define EP_FSET(sc, f) (sc->stat |= (f))

2
sys/dev/ep/if_ep_eisa.c
View File

@ -70,7 +70,7 @@
#define TRANS_AUI 0x4000
#define TRANS_BNC 0xc000
static const char *ep_match __P((eisa_id_t type));
static const char *ep_match(eisa_id_t type);
static const char*
ep_match(eisa_id_t type)

20
sys/dev/ex/if_ex.c
View File

@ -91,21 +91,21 @@ u_char plus_ee2irqmap[] =
{ 3, 4, 5, 7, 9, 10, 11, 12 };
/* Network Interface Functions */
static void ex_init __P((void *));
static void ex_start __P((struct ifnet *));
static int ex_ioctl __P((struct ifnet *, u_long, caddr_t));
static void ex_watchdog __P((struct ifnet *));
static void ex_init (void *);
static void ex_start (struct ifnet *);
static int ex_ioctl (struct ifnet *, u_long, caddr_t);
static void ex_watchdog (struct ifnet *);
/* ifmedia Functions */
static int ex_ifmedia_upd __P((struct ifnet *));
static void ex_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
static int ex_ifmedia_upd (struct ifnet *);
static void ex_ifmedia_sts (struct ifnet *, struct ifmediareq *);
static int ex_get_media __P((u_int32_t iobase));
static int ex_get_media (u_int32_t iobase);
static void ex_reset __P((struct ex_softc *));
static void ex_reset (struct ex_softc *);
static void ex_tx_intr __P((struct ex_softc *));
static void ex_rx_intr __P((struct ex_softc *));
static void ex_tx_intr (struct ex_softc *);
static void ex_rx_intr (struct ex_softc *);
int
look_for_card (u_int32_t iobase)

6
sys/dev/ex/if_ex_isa.c
View File

@ -50,9 +50,9 @@
#include <dev/ex/if_exvar.h>
/* Bus Front End Functions */
static void ex_isa_identify __P((driver_t *, device_t));
static int ex_isa_probe __P((device_t));
static int ex_isa_attach __P((device_t));
static void ex_isa_identify (driver_t *, device_t);
static int ex_isa_probe (device_t);
static int ex_isa_attach (device_t);
#if 0
static void ex_pnp_wakeup (void *);

6
sys/dev/ex/if_ex_pccard.c
View File

@ -49,9 +49,9 @@
#include <dev/pccard/pccardvar.h>
/* Bus Front End Functions */
static int ex_pccard_probe __P((device_t));
static int ex_pccard_attach __P((device_t));
static int ex_pccard_detach __P((device_t));
static int ex_pccard_probe (device_t);
static int ex_pccard_attach (device_t);
static int ex_pccard_detach (device_t);
static device_method_t ex_pccard_methods[] = {
/* Device interface */

64
sys/dev/gem/if_gem.c
View File

@ -60,41 +60,39 @@
#define TRIES 10000
static void gem_start __P((struct ifnet *));
static void gem_stop __P((struct ifnet *, int));
static int gem_ioctl __P((struct ifnet *, u_long, caddr_t));
static void gem_cddma_callback __P((void *, bus_dma_segment_t *, int, int));
static void gem_rxdma_callback __P((void *, bus_dma_segment_t *, int, int));
static void gem_txdma_callback __P((void *, bus_dma_segment_t *, int, int));
static void gem_tick __P((void *));
static void gem_watchdog __P((struct ifnet *));
static void gem_init __P((void *));
static void gem_init_regs __P((struct gem_softc *sc));
static int gem_ringsize __P((int sz));
static int gem_meminit __P((struct gem_softc *));
static int gem_dmamap_load_mbuf __P((struct gem_softc *, struct mbuf *,
bus_dmamap_callback_t *, struct gem_txjob *, int));
static void gem_dmamap_unload_mbuf __P((struct gem_softc *,
struct gem_txjob *));
static void gem_dmamap_commit_mbuf __P((struct gem_softc *,
struct gem_txjob *));
static void gem_mifinit __P((struct gem_softc *));
static int gem_bitwait __P((struct gem_softc *sc, bus_addr_t r,
u_int32_t clr, u_int32_t set));
static int gem_reset_rx __P((struct gem_softc *));
static int gem_reset_tx __P((struct gem_softc *));
static int gem_disable_rx __P((struct gem_softc *));
static int gem_disable_tx __P((struct gem_softc *));
static void gem_rxdrain __P((struct gem_softc *));
static int gem_add_rxbuf __P((struct gem_softc *, int));
static void gem_setladrf __P((struct gem_softc *));
static void gem_start(struct ifnet *);
static void gem_stop(struct ifnet *, int);
static int gem_ioctl(struct ifnet *, u_long, caddr_t);
static void gem_cddma_callback(void *, bus_dma_segment_t *, int, int);
static void gem_rxdma_callback(void *, bus_dma_segment_t *, int, int);
static void gem_txdma_callback(void *, bus_dma_segment_t *, int, int);
static void gem_tick(void *);
static void gem_watchdog(struct ifnet *);
static void gem_init(void *);
static void gem_init_regs(struct gem_softc *sc);
static int gem_ringsize(int sz);
static int gem_meminit(struct gem_softc *);
static int gem_dmamap_load_mbuf(struct gem_softc *, struct mbuf *,
bus_dmamap_callback_t *, struct gem_txjob *, int);
static void gem_dmamap_unload_mbuf(struct gem_softc *, struct gem_txjob *);
static void gem_dmamap_commit_mbuf(struct gem_softc *, struct gem_txjob *);
static void gem_mifinit(struct gem_softc *);
static int gem_bitwait(struct gem_softc *sc, bus_addr_t r,
u_int32_t clr, u_int32_t set);
static int gem_reset_rx(struct gem_softc *);
static int gem_reset_tx(struct gem_softc *);
static int gem_disable_rx(struct gem_softc *);
static int gem_disable_tx(struct gem_softc *);
static void gem_rxdrain(struct gem_softc *);
static int gem_add_rxbuf(struct gem_softc *, int);
static void gem_setladrf(struct gem_softc *);
struct mbuf *gem_get __P((struct gem_softc *, int, int));
static void gem_eint __P((struct gem_softc *, u_int));
static void gem_rint __P((struct gem_softc *));
static void gem_tint __P((struct gem_softc *));
struct mbuf *gem_get(struct gem_softc *, int, int);
static void gem_eint(struct gem_softc *, u_int);
static void gem_rint(struct gem_softc *);
static void gem_tint(struct gem_softc *);
#ifdef notyet
static void gem_power __P((int, void *));
static void gem_power(int, void *);
#endif
devclass_t gem_devclass;

4
sys/dev/gem/if_gem_pci.c
View File

@ -75,8 +75,8 @@ struct gem_pci_softc {
void *gsc_ih;
};
static int gem_pci_probe __P((device_t));
static int gem_pci_attach __P((device_t));
static int gem_pci_probe(device_t);
static int gem_pci_attach(device_t);
static device_method_t gem_pci_methods[] = {

22
sys/dev/gem/if_gemvar.h
View File

@ -182,8 +182,8 @@ struct gem_softc {
int sc_flags;
/* Special hardware hooks */
void (*sc_hwreset) __P((struct gem_softc *));
void (*sc_hwinit) __P((struct gem_softc *));
void (*sc_hwreset)(struct gem_softc *);
void (*sc_hwinit)(struct gem_softc *);
};
#define GEM_DMA_READ(sc, v) (((sc)->sc_pci) ? le64toh(v) : be64toh(v))
@ -222,19 +222,19 @@ do { \
#ifdef _KERNEL
extern devclass_t gem_devclass;
int gem_attach __P((struct gem_softc *));
int gem_detach __P((struct gem_softc *));
void gem_intr __P((void *));
int gem_attach(struct gem_softc *);
int gem_detach(struct gem_softc *);
void gem_intr(void *);
int gem_mediachange __P((struct ifnet *));
void gem_mediastatus __P((struct ifnet *, struct ifmediareq *));
int gem_mediachange(struct ifnet *);
void gem_mediastatus(struct ifnet *, struct ifmediareq *);
void gem_reset __P((struct gem_softc *));
void gem_reset(struct gem_softc *);
/* MII methods & callbacks */
int gem_mii_readreg __P((device_t, int, int));
int gem_mii_writereg __P((device_t, int, int, int));
void gem_mii_statchg __P((device_t));
int gem_mii_readreg(device_t, int, int);
int gem_mii_writereg(device_t, int, int, int);
void gem_mii_statchg(device_t);
#endif /* _KERNEL */

16
sys/dev/hea/eni.c
View File

@ -73,17 +73,17 @@ __RCSID("@(#) $FreeBSD$");
/*
* Typedef local functions
*/
static const char *eni_pci_probe __P((pcici_t, pcidi_t));
static void eni_pci_attach __P((pcici_t, int));
static int eni_get_ack __P((Eni_unit *));
static int eni_get_sebyte __P((Eni_unit *));
static void eni_read_seeprom __P((Eni_unit *));
static const char *eni_pci_probe(pcici_t, pcidi_t);
static void eni_pci_attach(pcici_t, int);
static int eni_get_ack(Eni_unit *);
static int eni_get_sebyte(Eni_unit *);
static void eni_read_seeprom(Eni_unit *);
#if BSD < 199506
static int eni_pci_shutdown __P((struct kern_devconf *, int));
static int eni_pci_shutdown(struct kern_devconf *, int);
#else
static void eni_pci_shutdown __P((void *, int));
static void eni_pci_shutdown(void *, int);
#endif
static void eni_pci_reset __P((Eni_unit *));
static void eni_pci_reset(Eni_unit *);
/*
* Used by kernel to return number of claimed devices

2
sys/dev/hea/eni_buffer.c
View File

@ -54,7 +54,7 @@
__RCSID("@(#) $FreeBSD$");
#endif
static int eni_test_memory __P((Eni_unit *));
static int eni_test_memory(Eni_unit *);
/*
* The host is going to manage (that is, allocate and free) buffers

2
sys/dev/hea/eni_if.c
View File

@ -61,7 +61,7 @@
__RCSID("@(#) $FreeBSD$");
#endif
static void eni_get_stats __P((Eni_unit *));
static void eni_get_stats(Eni_unit *);
/*
* SUNI statistics counters take one of three forms:

2
sys/dev/hea/eni_intr.c
View File

@ -56,7 +56,7 @@
__RCSID("@(#) $FreeBSD$");
#endif
static void eni_suni_intr __P((Eni_unit *));
static void eni_suni_intr(Eni_unit *);
/*
* SUNI Interrupt processing

2
sys/dev/hea/eni_receive.c
View File

@ -64,7 +64,7 @@
__RCSID("@(#) $FreeBSD$");
#endif
static void eni_recv_stack __P((void *, KBuffer *));
static void eni_recv_stack(void *, KBuffer *);
#ifdef DIAGNOSTIC
extern int eni_pdu_print;

32
sys/dev/hea/eni_var.h
View File

@ -42,37 +42,37 @@
* Global function declarations
*/
/* eni_buffer.c */
int eni_init_memory __P((Eni_unit *));
caddr_t eni_allocate_buffer __P((Eni_unit *, u_long *));
void eni_free_buffer __P((Eni_unit *, caddr_t));
int eni_init_memory(Eni_unit *);
caddr_t eni_allocate_buffer(Eni_unit *, u_long *);
void eni_free_buffer(Eni_unit *, caddr_t);
/* eni_if.c */
int eni_atm_ioctl __P((int, caddr_t, caddr_t));
void eni_zero_stats __P((Eni_unit *));
int eni_atm_ioctl(int, caddr_t, caddr_t);
void eni_zero_stats(Eni_unit *);
/* eni_init.c */
int eni_init __P((Eni_unit *));
int eni_init(Eni_unit *);
/* eni_intr.c */
#if defined(BSD) && BSD < 199506
int eni_intr __P((void *));
int eni_intr(void *);
#else
void eni_intr __P((void *));
void eni_intr(void *);
#endif
/* eni_receive.c */
void eni_do_service __P((Eni_unit *));
void eni_recv_drain __P((Eni_unit *));
void eni_do_service(Eni_unit *);
void eni_recv_drain(Eni_unit *);
/* eni_transmit.c */
int eni_set_dma __P((Eni_unit *, int, u_long *, int, long *, int, u_long, int ));
void eni_output __P((Cmn_unit *, Cmn_vcc *, KBuffer *));
void eni_xmit_drain __P((Eni_unit *));
int eni_set_dma(Eni_unit *, int, u_long *, int, long *, int, u_long, int );
void eni_output(Cmn_unit *, Cmn_vcc *, KBuffer *);
void eni_xmit_drain(Eni_unit *);
/* eni_vcm.c */
int eni_instvcc __P((Cmn_unit *, Cmn_vcc *));
int eni_openvcc __P((Cmn_unit *, Cmn_vcc *));
int eni_closevcc __P((Cmn_unit *, Cmn_vcc *));
int eni_instvcc(Cmn_unit *, Cmn_vcc *);
int eni_openvcc(Cmn_unit *, Cmn_vcc *);
int eni_closevcc(Cmn_unit *, Cmn_vcc *);
/*
* Global variable declarations

6
sys/dev/hfa/fore_buffer.c
View File

@ -71,9 +71,9 @@ __RCSID("@(#) $FreeBSD$");
/*
* Local functions
*/
static void fore_buf_drain __P((Fore_unit *));
static void fore_buf_supply_1s __P((Fore_unit *));
static void fore_buf_supply_1l __P((Fore_unit *));
static void fore_buf_drain(Fore_unit *);
static void fore_buf_supply_1s(Fore_unit *);
static void fore_buf_supply_1l(Fore_unit *);
/*

56
sys/dev/hfa/fore_include.h
View File

@ -42,56 +42,56 @@
* Global function declarations
*/
/* fore_buffer.c */
int fore_buf_allocate __P((Fore_unit *));
void fore_buf_initialize __P((Fore_unit *));
void fore_buf_supply __P((Fore_unit *));
void fore_buf_free __P((Fore_unit *));
int fore_buf_allocate(Fore_unit *);
void fore_buf_initialize(Fore_unit *);
void fore_buf_supply(Fore_unit *);
void fore_buf_free(Fore_unit *);
/* fore_command.c */
int fore_cmd_allocate __P((Fore_unit *));
void fore_cmd_initialize __P((Fore_unit *));
void fore_cmd_drain __P((Fore_unit *));
void fore_cmd_free __P((Fore_unit *));
int fore_cmd_allocate(Fore_unit *);
void fore_cmd_initialize(Fore_unit *);
void fore_cmd_drain(Fore_unit *);
void fore_cmd_free(Fore_unit *);
/* fore_if.c */
int fore_atm_ioctl __P((int, caddr_t, caddr_t));
void fore_interface_free __P((Fore_unit *));
int fore_atm_ioctl(int, caddr_t, caddr_t);
void fore_interface_free(Fore_unit *);
/* fore_init.c */
void fore_initialize __P((Fore_unit *));
void fore_initialize_complete __P((Fore_unit *));
void fore_initialize(Fore_unit *);
void fore_initialize_complete(Fore_unit *);
/* fore_intr.c */
void fore_intr __P((void *));
void fore_watchdog __P((Fore_unit *));
void fore_intr(void *);
void fore_watchdog(Fore_unit *);
/* fore_load.c */
/* fore_output.c */
void fore_output __P((Cmn_unit *, Cmn_vcc *, KBuffer *));
void fore_output(Cmn_unit *, Cmn_vcc *, KBuffer *);
/* fore_receive.c */
int fore_recv_allocate __P((Fore_unit *));
void fore_recv_initialize __P((Fore_unit *));
void fore_recv_drain __P((Fore_unit *));
void fore_recv_free __P((Fore_unit *));
int fore_recv_allocate(Fore_unit *);
void fore_recv_initialize(Fore_unit *);
void fore_recv_drain(Fore_unit *);
void fore_recv_free(Fore_unit *);
/* fore_stats.c */
int fore_get_stats __P((Fore_unit *));
int fore_get_stats(Fore_unit *);
/* fore_timer.c */
void fore_timeout __P((struct atm_time *));
void fore_timeout(struct atm_time *);
/* fore_transmit.c */
int fore_xmit_allocate __P((Fore_unit *));
void fore_xmit_initialize __P((Fore_unit *));
void fore_xmit_drain __P((Fore_unit *));
void fore_xmit_free __P((Fore_unit *));
int fore_xmit_allocate(Fore_unit *);
void fore_xmit_initialize(Fore_unit *);
void fore_xmit_drain(Fore_unit *);
void fore_xmit_free(Fore_unit *);
/* fore_vcm.c */
int fore_instvcc __P((Cmn_unit *, Cmn_vcc *));
int fore_openvcc __P((Cmn_unit *, Cmn_vcc *));
int fore_closevcc __P((Cmn_unit *, Cmn_vcc *));
int fore_instvcc(Cmn_unit *, Cmn_vcc *);
int fore_openvcc(Cmn_unit *, Cmn_vcc *);
int fore_closevcc(Cmn_unit *, Cmn_vcc *);
/*

4
sys/dev/hfa/fore_init.c
View File

@ -70,7 +70,7 @@ __RCSID("@(#) $FreeBSD$");
/*
* Local functions
*/
static void fore_get_prom __P((Fore_unit *));
static void fore_get_prom(Fore_unit *);
/*
@ -105,7 +105,7 @@ fore_initialize(fup)
* Try again later
*/
fup->fu_thandle =
timeout((KTimeout_ret(*) __P((void *)))fore_initialize,
timeout((KTimeout_ret(*)(void *))fore_initialize,
(void *)fup, hz);
return;
} else

14
sys/dev/hfa/fore_load.c
View File

@ -74,12 +74,12 @@ __RCSID("@(#) $FreeBSD$");
/*
* Local functions
*/
static int fore_start __P((void));
static const char * fore_pci_probe __P((pcici_t, pcidi_t));
static void fore_pci_attach __P((pcici_t, int));
static void fore_pci_shutdown __P((void *, int));
static void fore_unattach __P((Fore_unit *));
static void fore_reset __P((Fore_unit *));
static int fore_start(void);
static const char * fore_pci_probe(pcici_t, pcidi_t);
static void fore_pci_attach(pcici_t, int);
static void fore_pci_shutdown(void *, int);
static void fore_unattach(Fore_unit *);
static void fore_reset(Fore_unit *);
#ifndef COMPAT_OLDPCI
#error "The fore device requires the old pci compatibility shims"
@ -461,7 +461,7 @@ fore_unattach(fup)
/*
* Remove any pending timeout()'s
*/
(void)untimeout((KTimeout_ret(*) __P((void *)))fore_initialize,
(void)untimeout((KTimeout_ret(*)(void *))fore_initialize,
(void *)fup, fup->fu_thandle);

6
sys/dev/hfa/fore_output.c
View File

@ -71,9 +71,9 @@ __RCSID("@(#) $FreeBSD$");
/*
* Local functions
*/
static KBuffer * fore_xmit_segment __P((Fore_unit *, KBuffer *,
H_xmit_queue *, int *, int *));
static void fore_seg_dma_free __P((H_xmit_queue *, KBuffer *, int));
static KBuffer * fore_xmit_segment(Fore_unit *, KBuffer *,
H_xmit_queue *, int *, int *);
static void fore_seg_dma_free(H_xmit_queue *, KBuffer *, int);
/*

2
sys/dev/hfa/fore_receive.c
View File

@ -71,7 +71,7 @@ __RCSID("@(#) $FreeBSD$");
/*
* Local functions
*/
static void fore_recv_stack __P((void *, KBuffer *));
static void fore_recv_stack(void *, KBuffer *);
/*

28
sys/dev/iir/iir.h
View File

@ -610,12 +610,12 @@ struct gdt_softc {
struct cam_sim *sims[GDT_MAXBUS];
struct cam_path *paths[GDT_MAXBUS];
void (*sc_copy_cmd) __P((struct gdt_softc *, struct gdt_ccb *));
u_int8_t (*sc_get_status) __P((struct gdt_softc *));
void (*sc_intr) __P((struct gdt_softc *, struct gdt_intr_ctx *));
void (*sc_release_event) __P((struct gdt_softc *));
void (*sc_set_sema0) __P((struct gdt_softc *));
int (*sc_test_busy) __P((struct gdt_softc *));
void (*sc_copy_cmd)(struct gdt_softc *, struct gdt_ccb *);
u_int8_t (*sc_get_status)(struct gdt_softc *);
void (*sc_intr)(struct gdt_softc *, struct gdt_intr_ctx *);
void (*sc_release_event)(struct gdt_softc *);
void (*sc_set_sema0)(struct gdt_softc *);
int (*sc_test_busy)(struct gdt_softc *);
TAILQ_ENTRY(gdt_softc) links;
};
@ -644,17 +644,17 @@ struct gdt_ccb {
};
int iir_init __P((struct gdt_softc *));
void iir_free __P((struct gdt_softc *));
void iir_attach __P((struct gdt_softc *));
void iir_intr __P((void *arg));
int iir_init(struct gdt_softc *);
void iir_free(struct gdt_softc *);
void iir_attach(struct gdt_softc *);
void iir_intr(void *arg);
#ifdef __GNUC__
/* These all require correctly aligned buffers */
static __inline__ void gdt_enc16 __P((u_int8_t *, u_int16_t));
static __inline__ void gdt_enc32 __P((u_int8_t *, u_int32_t));
static __inline__ u_int16_t gdt_dec16 __P((u_int8_t *));
static __inline__ u_int32_t gdt_dec32 __P((u_int8_t *));
static __inline__ void gdt_enc16(u_int8_t *, u_int16_t);
static __inline__ void gdt_enc32(u_int8_t *, u_int32_t);
static __inline__ u_int16_t gdt_dec16(u_int8_t *);
static __inline__ u_int32_t gdt_dec32(u_int8_t *);
static __inline__ void
gdt_enc16(addr, value)

18
sys/dev/iir/iir_pci.c
View File

@ -125,17 +125,17 @@
/* DPRAM struct. */
#define GDT_MPR_SZ (0x3000 - GDT_SRAM_SZ)
static int iir_pci_probe __P((device_t dev));
static int iir_pci_attach __P((device_t dev));
static int iir_pci_probe(device_t dev);
static int iir_pci_attach(device_t dev);
void gdt_pci_enable_intr __P((struct gdt_softc *));
void gdt_pci_enable_intr(struct gdt_softc *);
void gdt_mpr_copy_cmd __P((struct gdt_softc *, struct gdt_ccb *));
u_int8_t gdt_mpr_get_status __P((struct gdt_softc *));
void gdt_mpr_intr __P((struct gdt_softc *, struct gdt_intr_ctx *));
void gdt_mpr_release_event __P((struct gdt_softc *));
void gdt_mpr_set_sema0 __P((struct gdt_softc *));
int gdt_mpr_test_busy __P((struct gdt_softc *));
void gdt_mpr_copy_cmd(struct gdt_softc *, struct gdt_ccb *);
u_int8_t gdt_mpr_get_status(struct gdt_softc *);
void gdt_mpr_intr(struct gdt_softc *, struct gdt_intr_ctx *);
void gdt_mpr_release_event(struct gdt_softc *);
void gdt_mpr_set_sema0(struct gdt_softc *);
int gdt_mpr_test_busy(struct gdt_softc *);
static device_method_t iir_pci_methods[] = {
/* Device interface */

2
sys/dev/isp/isp_freebsd.h
View File

@ -71,7 +71,7 @@
#define HANDLE_LOOPSTATE_IN_OUTER_LAYERS 1
typedef void ispfwfunc __P((int, int, int, u_int16_t **));
typedef void ispfwfunc(int, int, int, u_int16_t **);
#ifdef ISP_TARGET_MODE
#define ISP_TARGET_FUNCTIONS 1

4
sys/dev/ispfw/ispfw.c
View File

@ -50,9 +50,9 @@
#define PCI_PRODUCT_QLOGIC_ISP2300 0x2300
#define PCI_PRODUCT_QLOGIC_ISP2312 0x2312
typedef void ispfwfunc __P((int, int, int, const u_int16_t **));
typedef void ispfwfunc(int, int, int, const u_int16_t **);
extern ispfwfunc *isp_get_firmware_p;
static void isp_get_firmware __P((int, int, int, const u_int16_t **));
static void isp_get_firmware(int, int, int, const u_int16_t **);
static int ncallers = 0;
static const u_int16_t ***callp = NULL;

69
sys/dev/lge/if_lge.c
View File

@ -125,47 +125,46 @@ static struct lge_type lge_devs[] = {
{ 0, 0, NULL }
};
static int lge_probe __P((device_t));
static int lge_attach __P((device_t));
static int lge_detach __P((device_t));
static int lge_probe (device_t);
static int lge_attach (device_t);
static int lge_detach (device_t);
static int lge_alloc_jumbo_mem __P((struct lge_softc *));
static void lge_free_jumbo_mem __P((struct lge_softc *));
static void *lge_jalloc __P((struct lge_softc *));
static void lge_jfree __P((caddr_t, void *));
static int lge_alloc_jumbo_mem (struct lge_softc *);
static void lge_free_jumbo_mem (struct lge_softc *);
static void *lge_jalloc (struct lge_softc *);
static void lge_jfree (caddr_t, void *);
static int lge_newbuf __P((struct lge_softc *,
static int lge_newbuf (struct lge_softc *,
struct lge_rx_desc *,
struct mbuf *));
static int lge_encap __P((struct lge_softc *,
struct mbuf *, u_int32_t *));
static void lge_rxeof __P((struct lge_softc *, int));
static void lge_rxeoc __P((struct lge_softc *));
static void lge_txeof __P((struct lge_softc *));
static void lge_intr __P((void *));
static void lge_tick __P((void *));
static void lge_start __P((struct ifnet *));
static int lge_ioctl __P((struct ifnet *, u_long, caddr_t));
static void lge_init __P((void *));
static void lge_stop __P((struct lge_softc *));
static void lge_watchdog __P((struct ifnet *));
static void lge_shutdown __P((device_t));
static int lge_ifmedia_upd __P((struct ifnet *));
static void lge_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
struct mbuf *);
static int lge_encap (struct lge_softc *,
struct mbuf *, u_int32_t *);
static void lge_rxeof (struct lge_softc *, int);
static void lge_rxeoc (struct lge_softc *);
static void lge_txeof (struct lge_softc *);
static void lge_intr (void *);
static void lge_tick (void *);
static void lge_start (struct ifnet *);
static int lge_ioctl (struct ifnet *, u_long, caddr_t);
static void lge_init (void *);
static void lge_stop (struct lge_softc *);
static void lge_watchdog (struct ifnet *);
static void lge_shutdown (device_t);
static int lge_ifmedia_upd (struct ifnet *);
static void lge_ifmedia_sts (struct ifnet *, struct ifmediareq *);
static void lge_eeprom_getword __P((struct lge_softc *, int, u_int16_t *));
static void lge_read_eeprom __P((struct lge_softc *, caddr_t, int,
int, int));
static void lge_eeprom_getword (struct lge_softc *, int, u_int16_t *);
static void lge_read_eeprom (struct lge_softc *, caddr_t, int, int, int);
static int lge_miibus_readreg __P((device_t, int, int));
static int lge_miibus_writereg __P((device_t, int, int, int));
static void lge_miibus_statchg __P((device_t));
static int lge_miibus_readreg (device_t, int, int);
static int lge_miibus_writereg (device_t, int, int, int);
static void lge_miibus_statchg (device_t);
static void lge_setmulti __P((struct lge_softc *));
static u_int32_t lge_crc __P((struct lge_softc *, caddr_t));
static void lge_reset __P((struct lge_softc *));
static int lge_list_rx_init __P((struct lge_softc *));
static int lge_list_tx_init __P((struct lge_softc *));
static void lge_setmulti (struct lge_softc *);
static u_int32_t lge_crc (struct lge_softc *, caddr_t);
static void lge_reset (struct lge_softc *);
static int lge_list_rx_init (struct lge_softc *);
static int lge_list_tx_init (struct lge_softc *);
#ifdef LGE_USEIOSPACE
#define LGE_RES SYS_RES_IOPORT

38
sys/dev/lnc/if_lnc.c
View File

@ -115,29 +115,29 @@ static char const * const ic_ident[] = {
"PCnet-Home",
};
static void lnc_setladrf __P((struct lnc_softc *sc));
static void lnc_reset __P((struct lnc_softc *sc));
static void lnc_free_mbufs __P((struct lnc_softc *sc));
static __inline int alloc_mbuf_cluster __P((struct lnc_softc *sc,
struct host_ring_entry *desc));
static __inline struct mbuf *chain_mbufs __P((struct lnc_softc *sc,
static void lnc_setladrf(struct lnc_softc *sc);
static void lnc_reset(struct lnc_softc *sc);
static void lnc_free_mbufs(struct lnc_softc *sc);
static __inline int alloc_mbuf_cluster(struct lnc_softc *sc,
struct host_ring_entry *desc);
static __inline struct mbuf *chain_mbufs(struct lnc_softc *sc,
int start_of_packet,
int pkt_len));
static __inline struct mbuf *mbuf_packet __P((struct lnc_softc *sc,
int pkt_len);
static __inline struct mbuf *mbuf_packet(struct lnc_softc *sc,
int start_of_packet,
int pkt_len));
static __inline void lnc_rint __P((struct lnc_softc *sc));
static __inline void lnc_tint __P((struct lnc_softc *sc));
int pkt_len);
static __inline void lnc_rint(struct lnc_softc *sc);
static __inline void lnc_tint(struct lnc_softc *sc);
static void lnc_init __P((void *));
static __inline int mbuf_to_buffer __P((struct mbuf *m, char *buffer));
static __inline struct mbuf *chain_to_cluster __P((struct mbuf *m));
static void lnc_start __P((struct ifnet *ifp));
static int lnc_ioctl __P((struct ifnet *ifp, u_long command, caddr_t data));
static void lnc_watchdog __P((struct ifnet *ifp));
static void lnc_init(void *);
static __inline int mbuf_to_buffer(struct mbuf *m, char *buffer);
static __inline struct mbuf *chain_to_cluster(struct mbuf *m);
static void lnc_start(struct ifnet *ifp);
static int lnc_ioctl(struct ifnet *ifp, u_long command, caddr_t data);
static void lnc_watchdog(struct ifnet *ifp);
#ifdef DEBUG
void lnc_dump_state __P((struct lnc_softc *sc));
void mbuf_dump_chain __P((struct mbuf *m));
void lnc_dump_state(struct lnc_softc *sc);
void mbuf_dump_chain(struct mbuf *m);
#endif
u_short

12
sys/dev/lnc/if_lncvar.h
View File

@ -252,13 +252,13 @@ struct host_ring_entry {
bus_space_write_2(sc->lnc_btag, sc->lnc_bhandle, (port), (val))
/* Functional declarations */
extern int lance_probe __P((struct lnc_softc *));
extern void lnc_release_resources __P((device_t));
extern int lnc_attach_common __P((device_t));
extern void lnc_stop __P((struct lnc_softc *));
extern int lance_probe(struct lnc_softc *);
extern void lnc_release_resources(device_t);
extern int lnc_attach_common(device_t);
extern void lnc_stop(struct lnc_softc *);
extern void write_csr __P((struct lnc_softc *, u_short, u_short));
extern u_short read_csr __P((struct lnc_softc *, u_short));
extern void write_csr(struct lnc_softc *, u_short, u_short);
extern u_short read_csr(struct lnc_softc *, u_short);
/* Variable declarations */
extern driver_intr_t lncintr;

12
sys/dev/mii/acphy.c
View File

@ -92,9 +92,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int acphy_probe __P((device_t));
static int acphy_attach __P((device_t));
static int acphy_detach __P((device_t));
static int acphy_probe (device_t);
static int acphy_attach (device_t);
static int acphy_detach (device_t);
static device_method_t acphy_methods[] = {
/* device interface */
@ -115,9 +115,9 @@ static driver_t acphy_driver = {
DRIVER_MODULE(acphy, miibus, acphy_driver, acphy_devclass, 0, 0);
static int acphy_service __P((struct mii_softc *, struct mii_data *, int));
static void acphy_reset __P((struct mii_softc *));
static void acphy_status __P((struct mii_softc *));
static int acphy_service(struct mii_softc *, struct mii_data *, int);
static void acphy_reset(struct mii_softc *);
static void acphy_status(struct mii_softc *);
static int acphy_probe(dev)
device_t dev;

10
sys/dev/mii/amphy.c
View File

@ -60,9 +60,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int amphy_probe __P((device_t));
static int amphy_attach __P((device_t));
static int amphy_detach __P((device_t));
static int amphy_probe (device_t);
static int amphy_attach (device_t);
static int amphy_detach (device_t);
static device_method_t amphy_methods[] = {
/* device interface */
@ -83,8 +83,8 @@ static driver_t amphy_driver = {
DRIVER_MODULE(amphy, miibus, amphy_driver, amphy_devclass, 0, 0);
static int amphy_service __P((struct mii_softc *, struct mii_data *, int));
static void amphy_status __P((struct mii_softc *));
static int amphy_service(struct mii_softc *, struct mii_data *, int);
static void amphy_status(struct mii_softc *);
static int amphy_probe(dev)
device_t dev;

10
sys/dev/mii/brgphy.c
View File

@ -62,9 +62,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int brgphy_probe __P((device_t));
static int brgphy_attach __P((device_t));
static int brgphy_detach __P((device_t));
static int brgphy_probe (device_t);
static int brgphy_attach (device_t);
static int brgphy_detach (device_t);
static device_method_t brgphy_methods[] = {
/* device interface */
@ -87,8 +87,8 @@ DRIVER_MODULE(brgphy, miibus, brgphy_driver, brgphy_devclass, 0, 0);
static int brgphy_service(struct mii_softc *, struct mii_data *, int);
static void brgphy_status(struct mii_softc *);
static int brgphy_mii_phy_auto __P((struct mii_softc *, int));
extern void mii_phy_auto_timeout __P((void *));
static int brgphy_mii_phy_auto(struct mii_softc *, int);
extern void mii_phy_auto_timeout(void *);
static int brgphy_probe(dev)
device_t dev;

14
sys/dev/mii/dcphy.c
View File

@ -93,9 +93,9 @@ static const char rcsid[] =
*/
#define COMPAQ_PRESARIO_ID 0xb0bb0e11
static int dcphy_probe __P((device_t));
static int dcphy_attach __P((device_t));
static int dcphy_detach __P((device_t));
static int dcphy_probe (device_t);
static int dcphy_attach (device_t);
static int dcphy_detach (device_t);
static device_method_t dcphy_methods[] = {
/* device interface */
@ -116,10 +116,10 @@ static driver_t dcphy_driver = {
DRIVER_MODULE(dcphy, miibus, dcphy_driver, dcphy_devclass, 0, 0);
static int dcphy_service __P((struct mii_softc *, struct mii_data *, int));
static void dcphy_status __P((struct mii_softc *));
static void dcphy_reset __P((struct mii_softc *));
static int dcphy_auto __P((struct mii_softc *, int));
static int dcphy_service(struct mii_softc *, struct mii_data *, int);
static void dcphy_status(struct mii_softc *);
static void dcphy_reset(struct mii_softc *);
static int dcphy_auto(struct mii_softc *, int);
static int dcphy_probe(dev)
device_t dev;

10
sys/dev/mii/exphy.c
View File

@ -91,9 +91,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int exphy_probe __P((device_t));
static int exphy_attach __P((device_t));
static int exphy_detach __P((device_t));
static int exphy_probe (device_t);
static int exphy_attach (device_t);
static int exphy_detach (device_t);
static device_method_t exphy_methods[] = {
/* device interface */
@ -114,8 +114,8 @@ static driver_t exphy_driver = {
DRIVER_MODULE(xlphy, miibus, exphy_driver, exphy_devclass, 0, 0);
static int exphy_service __P((struct mii_softc *, struct mii_data *, int));
static void exphy_reset __P((struct mii_softc *));
static int exphy_service(struct mii_softc *, struct mii_data *, int);
static void exphy_reset(struct mii_softc *);
static int exphy_probe(dev)
device_t dev;

14
sys/dev/mii/lxtphy.c
View File

@ -96,9 +96,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int lxtphy_probe __P((device_t));
static int lxtphy_attach __P((device_t));
static int lxtphy_detach __P((device_t));
static int lxtphy_probe (device_t);
static int lxtphy_attach (device_t);
static int lxtphy_detach (device_t);
static device_method_t lxtphy_methods[] = {
/* device interface */
@ -119,10 +119,10 @@ static driver_t lxtphy_driver = {
DRIVER_MODULE(lxtphy, miibus, lxtphy_driver, lxtphy_devclass, 0, 0);
static int lxtphy_service __P((struct mii_softc *, struct mii_data *, int));
static void lxtphy_status __P((struct mii_softc *));
static void lxtphy_set_tp __P((struct mii_softc *));
static void lxtphy_set_fx __P((struct mii_softc *));
static int lxtphy_service(struct mii_softc *, struct mii_data *, int);
static void lxtphy_status(struct mii_softc *);
static void lxtphy_set_tp(struct mii_softc *);
static void lxtphy_set_fx(struct mii_softc *);
static int lxtphy_probe(dev)
device_t dev;

10
sys/dev/mii/mii.c
View File

@ -65,11 +65,11 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int miibus_readreg __P((device_t, int, int));
static int miibus_writereg __P((device_t, int, int, int));
static void miibus_statchg __P((device_t));
static void miibus_linkchg __P((device_t));
static void miibus_mediainit __P((device_t));
static int miibus_readreg (device_t, int, int);
static int miibus_writereg (device_t, int, int, int);
static void miibus_statchg (device_t);
static void miibus_linkchg (device_t);
static void miibus_mediainit (device_t);
static device_method_t miibus_methods[] = {
/* device interface */

2
sys/dev/mii/mii_physubr.c
View File

@ -63,7 +63,7 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
void mii_phy_auto_timeout __P((void *));
void mii_phy_auto_timeout(void *);
int
mii_phy_auto(mii, waitfor)

41
sys/dev/mii/miivar.h
View File

@ -56,9 +56,9 @@ struct mii_softc;
/*
* Callbacks from MII layer into network interface device driver.
*/
typedef int (*mii_readreg_t) __P((struct device *, int, int));
typedef void (*mii_writereg_t) __P((struct device *, int, int, int));
typedef void (*mii_statchg_t) __P((struct device *));
typedef int (*mii_readreg_t)(struct device *, int, int);
typedef void (*mii_writereg_t)(struct device *, int, int, int);
typedef void (*mii_statchg_t)(struct device *);
/*
* A network interface driver has one of these structures in its softc.
@ -96,7 +96,7 @@ typedef struct mii_data mii_data_t;
* This call is used by the MII layer to call into the PHY driver
* to perform a `service request'.
*/
typedef int (*mii_downcall_t) __P((struct mii_softc *, struct mii_data *, int));
typedef int (*mii_downcall_t)(struct mii_softc *, struct mii_data *, int);
/*
* Requests that can be made to the downcall.
@ -157,27 +157,26 @@ typedef struct mii_attach_args mii_attach_args_t;
extern devclass_t miibus_devclass;
extern driver_t miibus_driver;
int miibus_probe __P((device_t));
int miibus_attach __P((device_t));
int miibus_detach __P((device_t));
int miibus_probe(device_t);
int miibus_attach(device_t);
int miibus_detach(device_t);
int mii_anar __P((int));
int mii_mediachg __P((struct mii_data *));
void mii_tick __P((struct mii_data *));
void mii_pollstat __P((struct mii_data *));
int mii_phy_probe __P((device_t, device_t *,
ifm_change_cb_t, ifm_stat_cb_t));
void mii_add_media __P((struct mii_data *, int, int));
int mii_anar(int);
int mii_mediachg(struct mii_data *);
void mii_tick(struct mii_data *);
void mii_pollstat(struct mii_data *);
int mii_phy_probe(device_t, device_t *, ifm_change_cb_t, ifm_stat_cb_t);
void mii_add_media(struct mii_data *, int, int);
int mii_media_from_bmcr __P((int));
int mii_media_from_bmcr(int);
int mii_phy_auto __P((struct mii_softc *, int));
void mii_phy_auto_stop __P((struct mii_softc *));
void mii_phy_reset __P((struct mii_softc *));
void mii_phy_update __P((struct mii_softc *, int));
int mii_phy_tick __P((struct mii_softc *));
int mii_phy_auto(struct mii_softc *, int);
void mii_phy_auto_stop(struct mii_softc *);
void mii_phy_reset(struct mii_softc *);
void mii_phy_update(struct mii_softc *, int);
int mii_phy_tick(struct mii_softc *);
void ukphy_status __P((struct mii_softc *));
void ukphy_status(struct mii_softc *);
#endif /* _KERNEL */
#endif /* _DEV_MII_MIIVAR_H_ */

12
sys/dev/mii/mlphy.c
View File

@ -72,9 +72,9 @@ struct mlphy_softc {
int ml_linked;
};
static int mlphy_probe __P((device_t));
static int mlphy_attach __P((device_t));
static int mlphy_detach __P((device_t));
static int mlphy_probe (device_t);
static int mlphy_attach (device_t);
static int mlphy_detach (device_t);
static device_method_t mlphy_methods[] = {
/* device interface */
@ -95,9 +95,9 @@ static driver_t mlphy_driver = {
DRIVER_MODULE(mlphy, miibus, mlphy_driver, mlphy_devclass, 0, 0);
static int mlphy_service __P((struct mii_softc *, struct mii_data *, int));
static void mlphy_reset __P((struct mii_softc *));
static void mlphy_status __P((struct mii_softc *));
static int mlphy_service(struct mii_softc *, struct mii_data *, int);
static void mlphy_reset(struct mii_softc *);
static void mlphy_status(struct mii_softc *);
static int mlphy_probe(dev)
device_t dev;

14
sys/dev/mii/nsgphy.c
View File

@ -72,9 +72,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int nsgphy_probe __P((device_t));
static int nsgphy_attach __P((device_t));
static int nsgphy_detach __P((device_t));
static int nsgphy_probe (device_t);
static int nsgphy_attach (device_t);
static int nsgphy_detach (device_t);
static device_method_t nsgphy_methods[] = {
/* device interface */
@ -95,10 +95,10 @@ static driver_t nsgphy_driver = {
DRIVER_MODULE(nsgphy, miibus, nsgphy_driver, nsgphy_devclass, 0, 0);
static int nsgphy_service __P((struct mii_softc *, struct mii_data *,int));
static void nsgphy_status __P((struct mii_softc *));
static int nsgphy_mii_phy_auto __P((struct mii_softc *, int));
extern void mii_phy_auto_timeout __P((void *));
static int nsgphy_service(struct mii_softc *, struct mii_data *,int);
static void nsgphy_status(struct mii_softc *);
static int nsgphy_mii_phy_auto(struct mii_softc *, int);
extern void mii_phy_auto_timeout(void *);
static int nsgphy_probe(dev)
device_t dev;

10
sys/dev/mii/nsphy.c
View File

@ -95,9 +95,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int nsphy_probe __P((device_t));
static int nsphy_attach __P((device_t));
static int nsphy_detach __P((device_t));
static int nsphy_probe (device_t);
static int nsphy_attach (device_t);
static int nsphy_detach (device_t);
static device_method_t nsphy_methods[] = {
/* device interface */
@ -118,8 +118,8 @@ static driver_t nsphy_driver = {
DRIVER_MODULE(nsphy, miibus, nsphy_driver, nsphy_devclass, 0, 0);
static int nsphy_service __P((struct mii_softc *, struct mii_data *, int));
static void nsphy_status __P((struct mii_softc *));
static int nsphy_service(struct mii_softc *, struct mii_data *, int);
static void nsphy_status(struct mii_softc *);
static int nsphy_probe(dev)
device_t dev;

8
sys/dev/mii/pnaphy.c
View File

@ -66,9 +66,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int pnaphy_probe __P((device_t));
static int pnaphy_attach __P((device_t));
static int pnaphy_detach __P((device_t));
static int pnaphy_probe (device_t);
static int pnaphy_attach (device_t);
static int pnaphy_detach (device_t);
static device_method_t pnaphy_methods[] = {
/* device interface */
@ -89,7 +89,7 @@ static driver_t pnaphy_driver = {
DRIVER_MODULE(pnaphy, miibus, pnaphy_driver, pnaphy_devclass, 0, 0);
static int pnaphy_service __P((struct mii_softc *, struct mii_data *,int));
static int pnaphy_service(struct mii_softc *, struct mii_data *,int);
static int
pnaphy_probe(dev)

10
sys/dev/mii/pnphy.c
View File

@ -80,9 +80,9 @@ static const char rcsid[] =
CSR_WRITE_4(sc, reg, \
CSR_READ_4(sc, reg) & ~x)
static int pnphy_probe __P((device_t));
static int pnphy_attach __P((device_t));
static int pnphy_detach __P((device_t));
static int pnphy_probe (device_t);
static int pnphy_attach (device_t);
static int pnphy_detach (device_t);
static device_method_t pnphy_methods[] = {
/* device interface */
@ -103,8 +103,8 @@ static driver_t pnphy_driver = {
DRIVER_MODULE(pnphy, miibus, pnphy_driver, pnphy_devclass, 0, 0);
static int pnphy_service __P((struct mii_softc *, struct mii_data *, int));
static void pnphy_status __P((struct mii_softc *));
static int pnphy_service(struct mii_softc *, struct mii_data *, int);
static void pnphy_status(struct mii_softc *);
static int pnphy_probe(dev)
device_t dev;

12
sys/dev/mii/qsphy.c
View File

@ -96,9 +96,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int qsphy_probe __P((device_t));
static int qsphy_attach __P((device_t));
static int qsphy_detach __P((device_t));
static int qsphy_probe (device_t);
static int qsphy_attach (device_t);
static int qsphy_detach (device_t);
static device_method_t qsphy_methods[] = {
/* device interface */
@ -119,9 +119,9 @@ static driver_t qsphy_driver = {
DRIVER_MODULE(qsphy, miibus, qsphy_driver, qsphy_devclass, 0, 0);
static int qsphy_service __P((struct mii_softc *, struct mii_data *, int));
static void qsphy_reset __P((struct mii_softc *));
static void qsphy_status __P((struct mii_softc *));
static int qsphy_service(struct mii_softc *, struct mii_data *, int);
static void qsphy_reset(struct mii_softc *);
static void qsphy_status(struct mii_softc *);
static int qsphy_probe(dev)
device_t dev;

8
sys/dev/mii/rlphy.c
View File

@ -55,9 +55,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int rlphy_probe __P((device_t));
static int rlphy_attach __P((device_t));
static int rlphy_detach __P((device_t));
static int rlphy_probe (device_t);
static int rlphy_attach (device_t);
static int rlphy_detach (device_t);
static device_method_t rlphy_methods[] = {
/* device interface */
@ -78,7 +78,7 @@ static driver_t rlphy_driver = {
DRIVER_MODULE(rlphy, miibus, rlphy_driver, rlphy_devclass, 0, 0);
static int rlphy_service __P((struct mii_softc *, struct mii_data *, int));
static int rlphy_service(struct mii_softc *, struct mii_data *, int);
static int rlphy_probe(dev)
device_t dev;

10
sys/dev/mii/tdkphy.c
View File

@ -69,9 +69,9 @@ static const char rcsid[] =
"$Id: tdkphy.c,v 1.3 2000/10/14 06:20:56 jon Exp $";
#endif
static int tdkphy_probe __P((device_t));
static int tdkphy_attach __P((device_t));
static int tdkphy_detach __P((device_t));
static int tdkphy_probe (device_t);
static int tdkphy_attach (device_t);
static int tdkphy_detach (device_t);
static device_method_t tdkphy_methods[] = {
/* device interface */
@ -92,8 +92,8 @@ static driver_t tdkphy_driver = {
DRIVER_MODULE(tdkphy, miibus, tdkphy_driver, tdkphy_devclass, 0, 0);
static int tdkphy_service __P((struct mii_softc *, struct mii_data *, int));
static void tdkphy_status __P((struct mii_softc *));
static int tdkphy_service(struct mii_softc *, struct mii_data *, int);
static void tdkphy_status(struct mii_softc *);
static int
tdkphy_probe(device_t dev)

14
sys/dev/mii/tlphy.c
View File

@ -102,9 +102,9 @@ struct tlphy_softc {
int sc_need_acomp;
};
static int tlphy_probe __P((device_t));
static int tlphy_attach __P((device_t));
static int tlphy_detach __P((device_t));
static int tlphy_probe (device_t);
static int tlphy_attach (device_t);
static int tlphy_detach (device_t);
static device_method_t tlphy_methods[] = {
/* device interface */
@ -125,10 +125,10 @@ static driver_t tlphy_driver = {
DRIVER_MODULE(tlphy, miibus, tlphy_driver, tlphy_devclass, 0, 0);
static int tlphy_service __P((struct mii_softc *, struct mii_data *, int));
static int tlphy_auto __P((struct tlphy_softc *, int));
static void tlphy_acomp __P((struct tlphy_softc *));
static void tlphy_status __P((struct tlphy_softc *));
static int tlphy_service(struct mii_softc *, struct mii_data *, int);
static int tlphy_auto(struct tlphy_softc *, int);
static void tlphy_acomp(struct tlphy_softc *);
static void tlphy_status(struct tlphy_softc *);
static int tlphy_probe(dev)
device_t dev;

8
sys/dev/mii/ukphy.c
View File

@ -92,9 +92,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int ukphy_probe __P((device_t));
static int ukphy_attach __P((device_t));
static int ukphy_detach __P((device_t));
static int ukphy_probe (device_t);
static int ukphy_attach (device_t);
static int ukphy_detach (device_t);
static device_method_t ukphy_methods[] = {
/* device interface */
@ -115,7 +115,7 @@ static driver_t ukphy_driver = {
DRIVER_MODULE(ukphy, miibus, ukphy_driver, ukphy_devclass, 0, 0);
static int ukphy_service __P((struct mii_softc *, struct mii_data *, int));
static int ukphy_service(struct mii_softc *, struct mii_data *, int);
static int
ukphy_probe(dev)

14
sys/dev/mii/xmphy.c
View File

@ -62,9 +62,9 @@ static const char rcsid[] =
"$FreeBSD$";
#endif
static int xmphy_probe __P((device_t));
static int xmphy_attach __P((device_t));
static int xmphy_detach __P((device_t));
static int xmphy_probe (device_t);
static int xmphy_attach (device_t);
static int xmphy_detach (device_t);
static device_method_t xmphy_methods[] = {
/* device interface */
@ -85,10 +85,10 @@ static driver_t xmphy_driver = {
DRIVER_MODULE(xmphy, miibus, xmphy_driver, xmphy_devclass, 0, 0);
static int xmphy_service __P((struct mii_softc *, struct mii_data *, int));
static void xmphy_status __P((struct mii_softc *));
static int xmphy_mii_phy_auto __P((struct mii_softc *, int));
extern void mii_phy_auto_timeout __P((void *));
static int xmphy_service(struct mii_softc *, struct mii_data *, int);
static void xmphy_status(struct mii_softc *);
static int xmphy_mii_phy_auto(struct mii_softc *, int);
extern void mii_phy_auto_timeout(void *);
static int xmphy_probe(dev)
device_t dev;

52
sys/dev/ncv/ncr53c500.c
View File

@ -129,35 +129,35 @@ extern struct cfdriver ncv_cd;
* DECLARE
**************************************************************/
/* static */
static void ncv_pio_read __P((struct ncv_softc *, u_int8_t *, u_int));
static void ncv_pio_write __P((struct ncv_softc *, u_int8_t *, u_int));
static int ncv_msg __P((struct ncv_softc *, struct targ_info *, u_int));
static int ncv_reselected __P((struct ncv_softc *));
static int ncv_disconnected __P((struct ncv_softc *, struct targ_info *));
static void ncv_pio_read(struct ncv_softc *, u_int8_t *, u_int);
static void ncv_pio_write(struct ncv_softc *, u_int8_t *, u_int);
static int ncv_msg(struct ncv_softc *, struct targ_info *, u_int);
static int ncv_reselected(struct ncv_softc *);
static int ncv_disconnected(struct ncv_softc *, struct targ_info *);
static __inline void ncvhw_set_count __P((bus_space_tag_t, bus_space_handle_t, int));
static __inline u_int ncvhw_get_count __P((bus_space_tag_t, bus_space_handle_t));
static __inline void ncvhw_select_register_0 __P((bus_space_tag_t, bus_space_handle_t, struct ncv_hw *));
static __inline void ncvhw_select_register_1 __P((bus_space_tag_t, bus_space_handle_t, struct ncv_hw *));
static __inline void ncvhw_fpush __P((bus_space_tag_t, bus_space_handle_t, u_int8_t *, int));
static __inline void ncvhw_set_count(bus_space_tag_t, bus_space_handle_t, int);
static __inline u_int ncvhw_get_count(bus_space_tag_t, bus_space_handle_t);
static __inline void ncvhw_select_register_0(bus_space_tag_t, bus_space_handle_t, struct ncv_hw *);
static __inline void ncvhw_select_register_1(bus_space_tag_t, bus_space_handle_t, struct ncv_hw *);
static __inline void ncvhw_fpush(bus_space_tag_t, bus_space_handle_t, u_int8_t *, int);
static void ncv_pdma_end __P((struct ncv_softc *sc, struct targ_info *));
static int ncv_world_start __P((struct ncv_softc *, int));
static void ncvhw_bus_reset __P((struct ncv_softc *));
static void ncvhw_reset __P((bus_space_tag_t, bus_space_handle_t, struct ncv_hw *));
static int ncvhw_check __P((bus_space_tag_t, bus_space_handle_t, struct ncv_hw *));
static void ncvhw_init __P((bus_space_tag_t, bus_space_handle_t, struct ncv_hw *));
static int ncvhw_start_selection __P((struct ncv_softc *sc, struct slccb *));
static void ncvhw_attention __P((struct ncv_softc *));
static int ncv_ccb_nexus_establish __P((struct ncv_softc *));
static int ncv_lun_nexus_establish __P((struct ncv_softc *));
static int ncv_target_nexus_establish __P((struct ncv_softc *));
static int ncv_targ_init __P((struct ncv_softc *, struct targ_info *, int));
static int ncv_catch_intr __P((struct ncv_softc *));
static void ncv_pdma_end(struct ncv_softc *sc, struct targ_info *);
static int ncv_world_start(struct ncv_softc *, int);
static void ncvhw_bus_reset(struct ncv_softc *);
static void ncvhw_reset(bus_space_tag_t, bus_space_handle_t, struct ncv_hw *);
static int ncvhw_check(bus_space_tag_t, bus_space_handle_t, struct ncv_hw *);
static void ncvhw_init(bus_space_tag_t, bus_space_handle_t, struct ncv_hw *);
static int ncvhw_start_selection(struct ncv_softc *sc, struct slccb *);
static void ncvhw_attention(struct ncv_softc *);
static int ncv_ccb_nexus_establish(struct ncv_softc *);
static int ncv_lun_nexus_establish(struct ncv_softc *);
static int ncv_target_nexus_establish(struct ncv_softc *);
static int ncv_targ_init(struct ncv_softc *, struct targ_info *, int);
static int ncv_catch_intr(struct ncv_softc *);
#ifdef NCV_POWER_CONTROL
static int ncvhw_power __P((struct ncv_softc *, u_int));
static int ncvhw_power(struct ncv_softc *, u_int);
#endif /* NCV_POWER_CONTROL */
static __inline void ncv_setup_and_start_pio __P((struct ncv_softc *, u_int));
static __inline void ncv_setup_and_start_pio(struct ncv_softc *, u_int);
struct scsi_low_funcs ncv_funcs = {
SC_LOW_INIT_T ncv_world_start,
@ -571,7 +571,7 @@ ncv_targ_init(sc, ti, action)
/**************************************************************
* General probe attach
**************************************************************/
static int ncv_setup_img __P((struct ncv_hw *, u_int, int));
static int ncv_setup_img(struct ncv_hw *, u_int, int);
static int
ncv_setup_img(hw, dvcfg, hostid)

2
sys/dev/ncv/ncr53c500_pccard.c
View File

@ -77,7 +77,7 @@
static int ncvprobe(DEVPORT_PDEVICE devi);
static int ncvattach(DEVPORT_PDEVICE devi);
static void ncv_card_unload __P((DEVPORT_PDEVICE));
static void ncv_card_unload(DEVPORT_PDEVICE);
/*
* Additional code for FreeBSD new-bus PCCard frontend

8
sys/dev/ncv/ncr53c500var.h
View File

@ -90,10 +90,10 @@ struct ncv_targ_info {
/*****************************************************************
* Proto
*****************************************************************/
int ncvprobesubr __P((bus_space_tag_t, bus_space_handle_t ioh, u_int, int));
void ncvattachsubr __P((struct ncv_softc *));
int ncvprint __P((void *, const char *));
int ncvintr __P((void *));
int ncvprobesubr(bus_space_tag_t, bus_space_handle_t ioh, u_int, int);
void ncvattachsubr(struct ncv_softc *);
int ncvprint(void *, const char *);
int ncvintr(void *);
#if defined(i386)
#define SOFT_INTR_REQUIRED(slp) (softintr((slp)->sl_irq))

86
sys/dev/nge/if_nge.c
View File

@ -146,59 +146,55 @@ static struct nge_type nge_devs[] = {
{ 0, 0, NULL }
};
static int nge_probe __P((device_t));
static int nge_attach __P((device_t));
static int nge_detach __P((device_t));
static int nge_probe (device_t);
static int nge_attach (device_t);
static int nge_detach (device_t);
static int nge_alloc_jumbo_mem __P((struct nge_softc *));
static void nge_free_jumbo_mem __P((struct nge_softc *));
static void *nge_jalloc __P((struct nge_softc *));
static void nge_jfree __P((caddr_t, void *));
static int nge_alloc_jumbo_mem (struct nge_softc *);
static void nge_free_jumbo_mem (struct nge_softc *);
static void *nge_jalloc (struct nge_softc *);
static void nge_jfree (caddr_t, void *);
static int nge_newbuf __P((struct nge_softc *,
struct nge_desc *,
struct mbuf *));
static int nge_encap __P((struct nge_softc *,
struct mbuf *, u_int32_t *));
static void nge_rxeof __P((struct nge_softc *));
static int nge_newbuf (struct nge_softc *,
struct nge_desc *, struct mbuf *);
static int nge_encap (struct nge_softc *,
struct mbuf *, u_int32_t *);
static void nge_rxeof (struct nge_softc *);
#ifdef notdef
static void nge_rxeoc __P((struct nge_softc *));
static void nge_rxeoc (struct nge_softc *);
#endif
static void nge_txeof __P((struct nge_softc *));
static void nge_intr __P((void *));
static void nge_tick __P((void *));
static void nge_start __P((struct ifnet *));
static int nge_ioctl __P((struct ifnet *, u_long, caddr_t));
static void nge_init __P((void *));
static void nge_stop __P((struct nge_softc *));
static void nge_watchdog __P((struct ifnet *));
static void nge_shutdown __P((device_t));
static int nge_ifmedia_upd __P((struct ifnet *));
static void nge_ifmedia_sts __P((struct ifnet *, struct ifmediareq *));
static void nge_txeof (struct nge_softc *);
static void nge_intr (void *);
static void nge_tick (void *);
static void nge_start (struct ifnet *);
static int nge_ioctl (struct ifnet *, u_long, caddr_t);
static void nge_init (void *);
static void nge_stop (struct nge_softc *);
static void nge_watchdog (struct ifnet *);
static void nge_shutdown (device_t);
static int nge_ifmedia_upd (struct ifnet *);
static void nge_ifmedia_sts (struct ifnet *, struct ifmediareq *);
static void nge_delay __P((struct nge_softc *));
static void nge_eeprom_idle __P((struct nge_softc *));
static void nge_eeprom_putbyte __P((struct nge_softc *, int));
static void nge_eeprom_getword __P((struct nge_softc *, int, u_int16_t *));
static void nge_read_eeprom __P((struct nge_softc *, caddr_t, int,
int, int));
static void nge_delay (struct nge_softc *);
static void nge_eeprom_idle (struct nge_softc *);
static void nge_eeprom_putbyte (struct nge_softc *, int);
static void nge_eeprom_getword (struct nge_softc *, int, u_int16_t *);
static void nge_read_eeprom (struct nge_softc *, caddr_t, int, int, int);
static void nge_mii_sync __P((struct nge_softc *));
static void nge_mii_send __P((struct nge_softc *, u_int32_t, int));
static int nge_mii_readreg __P((struct nge_softc *,
struct nge_mii_frame *));
static int nge_mii_writereg __P((struct nge_softc *,
struct nge_mii_frame *));
static void nge_mii_sync (struct nge_softc *);
static void nge_mii_send (struct nge_softc *, u_int32_t, int);
static int nge_mii_readreg (struct nge_softc *, struct nge_mii_frame *);
static int nge_mii_writereg (struct nge_softc *, struct nge_mii_frame *);
static int nge_miibus_readreg __P((device_t, int, int));
static int nge_miibus_writereg __P((device_t, int, int, int));
static void nge_miibus_statchg __P((device_t));
static int nge_miibus_readreg (device_t, int, int);
static int nge_miibus_writereg (device_t, int, int, int);
static void nge_miibus_statchg (device_t);
static void nge_setmulti __P((struct nge_softc *));
static u_int32_t nge_crc __P((struct nge_softc *, caddr_t));
static void nge_reset __P((struct nge_softc *));
static int nge_list_rx_init __P((struct nge_softc *));
static int nge_list_tx_init __P((struct nge_softc *));
static void nge_setmulti (struct nge_softc *);
static u_int32_t nge_crc (struct nge_softc *, caddr_t);
static void nge_reset (struct nge_softc *);
static int nge_list_rx_init (struct nge_softc *);
static int nge_list_tx_init (struct nge_softc *);
#ifdef NGE_USEIOSPACE
#define NGE_RES SYS_RES_IOPORT

64
sys/dev/nsp/nsp.c
View File

@ -153,35 +153,35 @@ extern struct cfdriver nsp_cd;
**************************************************************/
#define NSP_FIFO_ON 1
#define NSP_FIFO_OFF 0
static void nsp_pio_read __P((struct nsp_softc *, int));
static void nsp_pio_write __P((struct nsp_softc *, int));
static int nsp_xfer __P((struct nsp_softc *, u_int8_t *, int, int, int));
static int nsp_msg __P((struct nsp_softc *, struct targ_info *, u_int));
static int nsp_reselected __P((struct nsp_softc *));
static int nsp_disconnected __P((struct nsp_softc *, struct targ_info *));
static void nsp_pdma_end __P((struct nsp_softc *, struct targ_info *));
static void nsphw_init __P((struct nsp_softc *));
static int nsp_target_nexus_establish __P((struct nsp_softc *));
static int nsp_lun_nexus_establish __P((struct nsp_softc *));
static int nsp_ccb_nexus_establish __P((struct nsp_softc *));
static int nsp_world_start __P((struct nsp_softc *, int));
static int nsphw_start_selection __P((struct nsp_softc *sc, struct slccb *));
static void nsphw_bus_reset __P((struct nsp_softc *));
static void nsphw_attention __P((struct nsp_softc *));
static u_int nsp_fifo_count __P((struct nsp_softc *));
static u_int nsp_request_count __P((struct nsp_softc *));
static int nsp_negate_signal __P((struct nsp_softc *, u_int8_t, u_char *));
static int nsp_expect_signal __P((struct nsp_softc *, u_int8_t, u_int8_t));
static void nsp_start_timer __P((struct nsp_softc *, int));
static void nsp_setup_fifo __P((struct nsp_softc *, int, int, int));
static int nsp_targ_init __P((struct nsp_softc *, struct targ_info *, int));
static void nsphw_selection_done_and_expect_msgout __P((struct nsp_softc *));
static void nsp_data_padding __P((struct nsp_softc *, int, u_int));
static int nsp_timeout __P((struct nsp_softc *));
static int nsp_read_fifo __P((struct nsp_softc *, int));
static int nsp_write_fifo __P((struct nsp_softc *, int));
static int nsp_phase_match __P((struct nsp_softc *, u_int8_t, u_int8_t));
static int nsp_wait_interrupt __P((struct nsp_softc *));
static void nsp_pio_read(struct nsp_softc *, int);
static void nsp_pio_write(struct nsp_softc *, int);
static int nsp_xfer(struct nsp_softc *, u_int8_t *, int, int, int);
static int nsp_msg(struct nsp_softc *, struct targ_info *, u_int);
static int nsp_reselected(struct nsp_softc *);
static int nsp_disconnected(struct nsp_softc *, struct targ_info *);
static void nsp_pdma_end(struct nsp_softc *, struct targ_info *);
static void nsphw_init(struct nsp_softc *);
static int nsp_target_nexus_establish(struct nsp_softc *);
static int nsp_lun_nexus_establish(struct nsp_softc *);
static int nsp_ccb_nexus_establish(struct nsp_softc *);
static int nsp_world_start(struct nsp_softc *, int);
static int nsphw_start_selection(struct nsp_softc *sc, struct slccb *);
static void nsphw_bus_reset(struct nsp_softc *);
static void nsphw_attention(struct nsp_softc *);
static u_int nsp_fifo_count(struct nsp_softc *);
static u_int nsp_request_count(struct nsp_softc *);
static int nsp_negate_signal(struct nsp_softc *, u_int8_t, u_char *);
static int nsp_expect_signal(struct nsp_softc *, u_int8_t, u_int8_t);
static void nsp_start_timer(struct nsp_softc *, int);
static void nsp_setup_fifo(struct nsp_softc *, int, int, int);
static int nsp_targ_init(struct nsp_softc *, struct targ_info *, int);
static void nsphw_selection_done_and_expect_msgout(struct nsp_softc *);
static void nsp_data_padding(struct nsp_softc *, int, u_int);
static int nsp_timeout(struct nsp_softc *);
static int nsp_read_fifo(struct nsp_softc *, int);
static int nsp_write_fifo(struct nsp_softc *, int);
static int nsp_phase_match(struct nsp_softc *, u_int8_t, u_int8_t);
static int nsp_wait_interrupt(struct nsp_softc *);
struct scsi_low_funcs nspfuncs = {
SC_LOW_INIT_T nsp_world_start,
@ -205,8 +205,8 @@ struct scsi_low_funcs nspfuncs = {
/****************************************************
* hwfuncs
****************************************************/
static __inline u_int8_t nsp_cr_read_1 __P((bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs));
static __inline void nsp_cr_write_1 __P((bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs, u_int8_t va));
static __inline u_int8_t nsp_cr_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs);
static __inline void nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs, u_int8_t va);
static __inline u_int8_t
nsp_cr_read_1(bst, bsh, ofs)
@ -1353,7 +1353,7 @@ nsp_disconnected(sc, ti)
/**************************************************************
* SEQUENCER
**************************************************************/
static void nsp_error __P((struct nsp_softc *, u_char *, u_int8_t, u_int8_t, u_int8_t));
static void nsp_error(struct nsp_softc *, u_char *, u_int8_t, u_int8_t, u_int8_t);
static void
nsp_error(sc, s, isrc, ph, irqphs)

2
sys/dev/nsp/nsp_pccard.c
View File

@ -74,7 +74,7 @@
static int nspprobe(DEVPORT_PDEVICE devi);
static int nspattach(DEVPORT_PDEVICE devi);
static void nsp_card_unload __P((DEVPORT_PDEVICE));
static void nsp_card_unload (DEVPORT_PDEVICE);
/*
* Additional code for FreeBSD new-bus PCCard frontend

8
sys/dev/nsp/nspvar.h
View File

@ -100,10 +100,10 @@ struct nsp_targ_info {
/*****************************************************************
* Proto
*****************************************************************/
int nspprobesubr __P((bus_space_tag_t, bus_space_handle_t, u_int));
void nspattachsubr __P((struct nsp_softc *));
int nspprint __P((void *, const char *));
int nspintr __P((void *));
int nspprobesubr(bus_space_tag_t, bus_space_handle_t, u_int);
void nspattachsubr(struct nsp_softc *);
int nspprint(void *, const char *);
int nspintr(void *);
#if defined(i386)
#define SOFT_INTR_REQUIRED(slp) (softintr((slp)->sl_irq))

14
sys/dev/pdq/if_fea.c
View File

@ -47,13 +47,13 @@
#include <dev/pdq/pdqvar.h>
#include <dev/pdq/pdqreg.h>
static void pdq_eisa_subprobe __P((pdq_bus_t, u_int32_t, u_int32_t *, u_int32_t *, u_int32_t *));
static void pdq_eisa_devinit __P((pdq_softc_t *));
static const char * pdq_eisa_match __P((eisa_id_t));
static int pdq_eisa_probe __P((device_t));
static int pdq_eisa_attach __P((device_t));
void pdq_eisa_intr __P((void *));
static int pdq_eisa_shutdown __P((device_t));
static void pdq_eisa_subprobe (pdq_bus_t, u_int32_t, u_int32_t *, u_int32_t *, u_int32_t *);
static void pdq_eisa_devinit (pdq_softc_t *);
static const char * pdq_eisa_match (eisa_id_t);
static int pdq_eisa_probe (device_t);
static int pdq_eisa_attach (device_t);
void pdq_eisa_intr (void *);
static int pdq_eisa_shutdown (device_t);
#define DEFEA_IRQS 0x0000FBA9U

2
sys/dev/puc/puc.c
View File

@ -115,7 +115,7 @@ struct puc_softc {
struct {
struct device *dev;
/* filled in by bus_setup_intr() */
void (*ihand) __P((void *));
void (*ihand)(void *);
void *ihandarg;
} sc_ports[PUC_MAX_PORTS];
};

10
sys/dev/rp/rp.c
View File

@ -619,11 +619,11 @@ static struct rp_port *p_rp_table[MAX_RP_PORTS];
* The top-level routines begin here
*/
static int rpparam __P((struct tty *, struct termios *));
static void rpstart __P((struct tty *));
static void rpstop __P((struct tty *, int));
static void rphardclose __P((struct rp_port *));
static void rp_disc_optim __P((struct tty *tp, struct termios *t));
static int rpparam(struct tty *, struct termios *);
static void rpstart(struct tty *);
static void rpstop(struct tty *, int);
static void rphardclose (struct rp_port *);
static void rp_disc_optim (struct tty *tp, struct termios *t);
static _INLINE_ void rp_do_receive(struct rp_port *rp, struct tty *tp,
CHANNEL_t *cp, unsigned int ChanStatus)

Some files were not shown because too many files have changed in this diff Show More