Remove __P prototypes to reduce diffs between the NetBSD and FreeBSD

versions.

22 files changed, 475 insertions, 475 deletions

diff --git a/sys/dev/usb/hid.c b/sys/dev/usb/hid.c
index b061f2b..9cbc7cf 100644
--- a/sys/dev/usb/hid.c
+++ b/sys/dev/usb/hid.c
@@ -59,7 +59,7 @@ extern int usbdebug;
 #define DPRINTFN(n,x)
 #endif
 
-Static void hid_clear_local __P((struct hid_item *));
+Static void hid_clear_local(struct hid_item *);
 
 #define MAXUSAGE 100
 struct hid_data {
diff --git a/sys/dev/usb/hid.h b/sys/dev/usb/hid.h
index 5953ce5..dcf27e1 100644
--- a/sys/dev/usb/hid.h
+++ b/sys/dev/usb/hid.h
@@ -80,12 +80,12 @@ struct hid_item {
 	struct hid_item *next;
 };
 
-struct hid_data *hid_start_parse __P((void *d, int len, int kindset));
-void hid_end_parse __P((struct hid_data *s));
-int hid_get_item __P((struct hid_data *s, struct hid_item *h));
-int hid_report_size __P((void *buf, int len, enum hid_kind k, u_int8_t *id));
-int hid_locate __P((void *desc, int size, u_int32_t usage, 
+struct hid_data *hid_start_parse(void *d, int len, int kindset);
+void hid_end_parse(struct hid_data *s);
+int hid_get_item(struct hid_data *s, struct hid_item *h);
+int hid_report_size(void *buf, int len, enum hid_kind k, u_int8_t *id);
+int hid_locate(void *desc, int size, u_int32_t usage, 
 		    enum hid_kind kind, struct hid_location *loc, 
-		    u_int32_t *flags));
-u_long hid_get_data __P((u_char *buf, struct hid_location *loc));
-int hid_is_collection __P((void *desc, int size, u_int32_t usage));
+		    u_int32_t *flags);
+u_long hid_get_data(u_char *buf, struct hid_location *loc);
+int hid_is_collection(void *desc, int size, u_int32_t usage);
diff --git a/sys/dev/usb/ohci.c b/sys/dev/usb/ohci.c
index 3ba281a..9d584d9 100644
--- a/sys/dev/usb/ohci.c
+++ b/sys/dev/usb/ohci.c
@@ -109,112 +109,112 @@ int ohcidebug = 1;
 
 struct ohci_pipe;
 
-Static ohci_soft_ed_t  *ohci_alloc_sed __P((ohci_softc_t *));
-Static void		ohci_free_sed __P((ohci_softc_t *, ohci_soft_ed_t *));
+Static ohci_soft_ed_t  *ohci_alloc_sed(ohci_softc_t *);
+Static void		ohci_free_sed(ohci_softc_t *, ohci_soft_ed_t *);
 
-Static ohci_soft_td_t  *ohci_alloc_std __P((ohci_softc_t *));
-Static void		ohci_free_std __P((ohci_softc_t *, ohci_soft_td_t *));
+Static ohci_soft_td_t  *ohci_alloc_std(ohci_softc_t *);
+Static void		ohci_free_std(ohci_softc_t *, ohci_soft_td_t *);
 
-Static ohci_soft_itd_t *ohci_alloc_sitd __P((ohci_softc_t *));
-Static void		ohci_free_sitd __P((ohci_softc_t *,ohci_soft_itd_t *));
+Static ohci_soft_itd_t *ohci_alloc_sitd(ohci_softc_t *);
+Static void		ohci_free_sitd(ohci_softc_t *,ohci_soft_itd_t *);
 
 #if 0
-Static void		ohci_free_std_chain __P((ohci_softc_t *, 
-			    ohci_soft_td_t *, ohci_soft_td_t *));
+Static void		ohci_free_std_chain(ohci_softc_t *, 
+			    ohci_soft_td_t *, ohci_soft_td_t *);
 #endif
-Static usbd_status	ohci_alloc_std_chain __P((struct ohci_pipe *,
+Static usbd_status	ohci_alloc_std_chain(struct ohci_pipe *,
 			    ohci_softc_t *, int, int, u_int16_t, usb_dma_t *, 
-			    ohci_soft_td_t *, ohci_soft_td_t **));
+			    ohci_soft_td_t *, ohci_soft_td_t **);
 
 #if defined(__NetBSD__) || defined(__OpenBSD__)
-Static void		ohci_shutdown __P((void *v));
-Static void		ohci_power __P((int, void *));
+Static void		ohci_shutdown(void *v);
+Static void		ohci_power(int, void *);
 #endif
-Static usbd_status	ohci_open __P((usbd_pipe_handle));
-Static void		ohci_poll __P((struct usbd_bus *));
-Static void		ohci_waitintr __P((ohci_softc_t *,
-			    usbd_xfer_handle));
-Static void		ohci_rhsc __P((ohci_softc_t *, usbd_xfer_handle));
-Static void		ohci_process_done __P((ohci_softc_t *,
-			    ohci_physaddr_t));
-
-Static usbd_status	ohci_device_request __P((usbd_xfer_handle xfer));
-Static void		ohci_add_ed __P((ohci_soft_ed_t *, ohci_soft_ed_t *));
-Static void		ohci_rem_ed __P((ohci_soft_ed_t *, ohci_soft_ed_t *));
-Static void		ohci_hash_add_td __P((ohci_softc_t *, 
-			    ohci_soft_td_t *));
-Static void		ohci_hash_rem_td __P((ohci_softc_t *,
-			    ohci_soft_td_t *));
-Static ohci_soft_td_t  *ohci_hash_find_td __P((ohci_softc_t *,
-			    ohci_physaddr_t));
-
-Static usbd_status	ohci_setup_isoc __P((usbd_pipe_handle pipe));
-Static void		ohci_device_isoc_enter __P((usbd_xfer_handle));
-
-Static usbd_status	ohci_allocm __P((struct usbd_bus *, usb_dma_t *,
-			    u_int32_t));
-Static void		ohci_freem __P((struct usbd_bus *, usb_dma_t *));
-
-Static usbd_xfer_handle	ohci_allocx __P((struct usbd_bus *));
-Static void		ohci_freex __P((struct usbd_bus *, usbd_xfer_handle));
-
-Static usbd_status	ohci_root_ctrl_transfer __P((usbd_xfer_handle));
-Static usbd_status	ohci_root_ctrl_start __P((usbd_xfer_handle));
-Static void		ohci_root_ctrl_abort __P((usbd_xfer_handle));
-Static void		ohci_root_ctrl_close __P((usbd_pipe_handle));
-
-Static usbd_status	ohci_root_intr_transfer __P((usbd_xfer_handle));
-Static usbd_status	ohci_root_intr_start __P((usbd_xfer_handle));
-Static void		ohci_root_intr_abort __P((usbd_xfer_handle));
-Static void		ohci_root_intr_close __P((usbd_pipe_handle));
-Static void		ohci_root_intr_done  __P((usbd_xfer_handle));
-
-Static usbd_status	ohci_device_ctrl_transfer __P((usbd_xfer_handle));
-Static usbd_status	ohci_device_ctrl_start __P((usbd_xfer_handle));
-Static void		ohci_device_ctrl_abort __P((usbd_xfer_handle));
-Static void		ohci_device_ctrl_close __P((usbd_pipe_handle));
-Static void		ohci_device_ctrl_done  __P((usbd_xfer_handle));
-
-Static usbd_status	ohci_device_bulk_transfer __P((usbd_xfer_handle));
-Static usbd_status	ohci_device_bulk_start __P((usbd_xfer_handle));
-Static void		ohci_device_bulk_abort __P((usbd_xfer_handle));
-Static void		ohci_device_bulk_close __P((usbd_pipe_handle));
-Static void		ohci_device_bulk_done  __P((usbd_xfer_handle));
-
-Static usbd_status	ohci_device_intr_transfer __P((usbd_xfer_handle));
-Static usbd_status	ohci_device_intr_start __P((usbd_xfer_handle));
-Static void		ohci_device_intr_abort __P((usbd_xfer_handle));
-Static void		ohci_device_intr_close __P((usbd_pipe_handle));
-Static void		ohci_device_intr_done  __P((usbd_xfer_handle));
-
-Static usbd_status	ohci_device_isoc_transfer __P((usbd_xfer_handle));
-Static usbd_status	ohci_device_isoc_start __P((usbd_xfer_handle));
-Static void		ohci_device_isoc_abort __P((usbd_xfer_handle));
-Static void		ohci_device_isoc_close __P((usbd_pipe_handle));
-Static void		ohci_device_isoc_done  __P((usbd_xfer_handle));
-
-Static usbd_status	ohci_device_setintr __P((ohci_softc_t *sc, 
-			    struct ohci_pipe *pipe, int ival));
-
-Static int		ohci_str __P((usb_string_descriptor_t *, int, char *));
-
-Static void		ohci_timeout __P((void *));
-Static void		ohci_rhsc_able __P((ohci_softc_t *, int));
-
-Static void		ohci_close_pipe __P((usbd_pipe_handle pipe, 
-			    ohci_soft_ed_t *head));
-Static void		ohci_abort_xfer __P((usbd_xfer_handle xfer,
-			    usbd_status status));
-Static void		ohci_abort_xfer_end __P((void *));
-
-Static void		ohci_device_clear_toggle __P((usbd_pipe_handle pipe));
-Static void		ohci_noop __P((usbd_pipe_handle pipe));
+Static usbd_status	ohci_open(usbd_pipe_handle);
+Static void		ohci_poll(struct usbd_bus *);
+Static void		ohci_waitintr(ohci_softc_t *,
+			    usbd_xfer_handle);
+Static void		ohci_rhsc(ohci_softc_t *, usbd_xfer_handle);
+Static void		ohci_process_done(ohci_softc_t *,
+			    ohci_physaddr_t);
+
+Static usbd_status	ohci_device_request(usbd_xfer_handle xfer);
+Static void		ohci_add_ed(ohci_soft_ed_t *, ohci_soft_ed_t *);
+Static void		ohci_rem_ed(ohci_soft_ed_t *, ohci_soft_ed_t *);
+Static void		ohci_hash_add_td(ohci_softc_t *, 
+			    ohci_soft_td_t *);
+Static void		ohci_hash_rem_td(ohci_softc_t *,
+			    ohci_soft_td_t *);
+Static ohci_soft_td_t  *ohci_hash_find_td(ohci_softc_t *,
+			    ohci_physaddr_t);
+
+Static usbd_status	ohci_setup_isoc(usbd_pipe_handle pipe);
+Static void		ohci_device_isoc_enter(usbd_xfer_handle);
+
+Static usbd_status	ohci_allocm(struct usbd_bus *, usb_dma_t *,
+			    u_int32_t);
+Static void		ohci_freem(struct usbd_bus *, usb_dma_t *);
+
+Static usbd_xfer_handle	ohci_allocx(struct usbd_bus *);
+Static void		ohci_freex(struct usbd_bus *, usbd_xfer_handle);
+
+Static usbd_status	ohci_root_ctrl_transfer(usbd_xfer_handle);
+Static usbd_status	ohci_root_ctrl_start(usbd_xfer_handle);
+Static void		ohci_root_ctrl_abort(usbd_xfer_handle);
+Static void		ohci_root_ctrl_close(usbd_pipe_handle);
+
+Static usbd_status	ohci_root_intr_transfer(usbd_xfer_handle);
+Static usbd_status	ohci_root_intr_start(usbd_xfer_handle);
+Static void		ohci_root_intr_abort(usbd_xfer_handle);
+Static void		ohci_root_intr_close(usbd_pipe_handle);
+Static void		ohci_root_intr_done (usbd_xfer_handle);
+
+Static usbd_status	ohci_device_ctrl_transfer(usbd_xfer_handle);
+Static usbd_status	ohci_device_ctrl_start(usbd_xfer_handle);
+Static void		ohci_device_ctrl_abort(usbd_xfer_handle);
+Static void		ohci_device_ctrl_close(usbd_pipe_handle);
+Static void		ohci_device_ctrl_done (usbd_xfer_handle);
+
+Static usbd_status	ohci_device_bulk_transfer(usbd_xfer_handle);
+Static usbd_status	ohci_device_bulk_start(usbd_xfer_handle);
+Static void		ohci_device_bulk_abort(usbd_xfer_handle);
+Static void		ohci_device_bulk_close(usbd_pipe_handle);
+Static void		ohci_device_bulk_done (usbd_xfer_handle);
+
+Static usbd_status	ohci_device_intr_transfer(usbd_xfer_handle);
+Static usbd_status	ohci_device_intr_start(usbd_xfer_handle);
+Static void		ohci_device_intr_abort(usbd_xfer_handle);
+Static void		ohci_device_intr_close(usbd_pipe_handle);
+Static void		ohci_device_intr_done (usbd_xfer_handle);
+
+Static usbd_status	ohci_device_isoc_transfer(usbd_xfer_handle);
+Static usbd_status	ohci_device_isoc_start(usbd_xfer_handle);
+Static void		ohci_device_isoc_abort(usbd_xfer_handle);
+Static void		ohci_device_isoc_close(usbd_pipe_handle);
+Static void		ohci_device_isoc_done (usbd_xfer_handle);
+
+Static usbd_status	ohci_device_setintr(ohci_softc_t *sc, 
+			    struct ohci_pipe *pipe, int ival);
+
+Static int		ohci_str(usb_string_descriptor_t *, int, char *);
+
+Static void		ohci_timeout(void *);
+Static void		ohci_rhsc_able(ohci_softc_t *, int);
+
+Static void		ohci_close_pipe(usbd_pipe_handle pipe, 
+			    ohci_soft_ed_t *head);
+Static void		ohci_abort_xfer(usbd_xfer_handle xfer,
+			    usbd_status status);
+Static void		ohci_abort_xfer_end(void *);
+
+Static void		ohci_device_clear_toggle(usbd_pipe_handle pipe);
+Static void		ohci_noop(usbd_pipe_handle pipe);
 
 #ifdef OHCI_DEBUG
-Static void		ohci_dumpregs __P((ohci_softc_t *));
-Static void		ohci_dump_tds __P((ohci_soft_td_t *));
-Static void		ohci_dump_td __P((ohci_soft_td_t *));
-Static void		ohci_dump_ed __P((ohci_soft_ed_t *));
+Static void		ohci_dumpregs(ohci_softc_t *);
+Static void		ohci_dump_tds(ohci_soft_td_t *);
+Static void		ohci_dump_td(ohci_soft_td_t *);
+Static void		ohci_dump_ed(ohci_soft_ed_t *);
 #endif
 
 #define OWRITE4(sc, r, x) bus_space_write_4((sc)->iot, (sc)->ioh, (r), (x))
@@ -975,7 +975,7 @@ ohci_dumpregs(sc)
 }
 #endif
 
-Static int ohci_intr1 __P((ohci_softc_t *));
+Static int ohci_intr1(ohci_softc_t *);
 
 int
 ohci_intr(p)
diff --git a/sys/dev/usb/ohcivar.h b/sys/dev/usb/ohcivar.h
index 8d37778..adf68a7 100644
--- a/sys/dev/usb/ohcivar.h
+++ b/sys/dev/usb/ohcivar.h
@@ -122,11 +122,11 @@ typedef struct ohci_softc {
 	device_ptr_t sc_child;
 } ohci_softc_t;
 
-usbd_status	ohci_init __P((ohci_softc_t *));
-int		ohci_intr __P((void *));
+usbd_status	ohci_init(ohci_softc_t *);
+int		ohci_intr(void *);
 #if defined(__NetBSD__) || defined(__OpenBSD__)
-int		ohci_detach __P((ohci_softc_t *, int));
-int		ohci_activate __P((device_ptr_t, enum devact));
+int		ohci_detach(ohci_softc_t *, int);
+int		ohci_activate(device_ptr_t, enum devact);
 #endif
 
 #define MS_TO_TICKS(ms) ((ms) * hz / 1000)
diff --git a/sys/dev/usb/udbp.c b/sys/dev/usb/udbp.c
index c769057..a38d4e2 100644
--- a/sys/dev/usb/udbp.c
+++ b/sys/dev/usb/udbp.c
@@ -201,15 +201,15 @@ Static struct ng_type ng_udbp_typestruct = {
 	ng_udbp_cmdlist
 };
 
-Static int udbp_setup_in_transfer	__P((udbp_p sc));
-Static void udbp_in_transfer_cb		__P((usbd_xfer_handle xfer,
+Static int udbp_setup_in_transfer	(udbp_p sc);
+Static void udbp_in_transfer_cb		(usbd_xfer_handle xfer,
 					usbd_private_handle priv,
-					usbd_status err));
+					usbd_status err);
 
-Static int udbp_setup_out_transfer	__P((udbp_p sc));
-Static void udbp_out_transfer_cb	__P((usbd_xfer_handle xfer,
+Static int udbp_setup_out_transfer	(udbp_p sc);
+Static void udbp_out_transfer_cb	(usbd_xfer_handle xfer,
 					usbd_private_handle priv,
-					usbd_status err));
+					usbd_status err);
 
 USB_DECLARE_DRIVER(udbp);
 
diff --git a/sys/dev/usb/ugen.c b/sys/dev/usb/ugen.c
index e504995..ccac667 100644
--- a/sys/dev/usb/ugen.c
+++ b/sys/dev/usb/ugen.c
@@ -135,18 +135,18 @@ Static struct cdevsw ugen_cdevsw = {
 };
 #endif
 
-Static void ugenintr __P((usbd_xfer_handle xfer, usbd_private_handle addr, 
-			  usbd_status status));
-
-Static int ugen_do_read __P((struct ugen_softc *, int, struct uio *, int));
-Static int ugen_do_write __P((struct ugen_softc *, int, struct uio *, int));
-Static int ugen_do_ioctl __P((struct ugen_softc *, int, u_long, 
-			      caddr_t, int, struct proc *));
-Static int ugen_set_config __P((struct ugen_softc *sc, int configno));
-Static usb_config_descriptor_t *ugen_get_cdesc __P((struct ugen_softc *sc,
-						    int index, int *lenp));
-Static usbd_status ugen_set_interface __P((struct ugen_softc *, int, int));
-Static int ugen_get_alt_index __P((struct ugen_softc *sc, int ifaceidx));
+Static void ugenintr(usbd_xfer_handle xfer, usbd_private_handle addr, 
+			  usbd_status status);
+
+Static int ugen_do_read(struct ugen_softc *, int, struct uio *, int);
+Static int ugen_do_write(struct ugen_softc *, int, struct uio *, int);
+Static int ugen_do_ioctl(struct ugen_softc *, int, u_long, 
+			      caddr_t, int, struct proc *);
+Static int ugen_set_config(struct ugen_softc *sc, int configno);
+Static usb_config_descriptor_t *ugen_get_cdesc(struct ugen_softc *sc,
+						    int index, int *lenp);
+Static usbd_status ugen_set_interface(struct ugen_softc *, int, int);
+Static int ugen_get_alt_index(struct ugen_softc *sc, int ifaceidx);
 
 #define UGENUNIT(n) ((minor(n) >> 4) & 0xf)
 #define UGENENDPOINT(n) (minor(n) & 0xf)
diff --git a/sys/dev/usb/uhci.c b/sys/dev/usb/uhci.c
index 25b3d2b..5f7be33 100644
--- a/sys/dev/usb/uhci.c
+++ b/sys/dev/usb/uhci.c
@@ -149,109 +149,109 @@ struct uhci_pipe {
  */
 LIST_HEAD(, uhci_intr_info) uhci_ii_free;
 
-Static void		uhci_busreset __P((uhci_softc_t *));
-Static usbd_status	uhci_run __P((uhci_softc_t *, int run));
-Static uhci_soft_td_t *uhci_alloc_std __P((uhci_softc_t *));
-Static void		uhci_free_std __P((uhci_softc_t *, uhci_soft_td_t *));
-Static uhci_soft_qh_t *uhci_alloc_sqh __P((uhci_softc_t *));
-Static void		uhci_free_sqh __P((uhci_softc_t *, uhci_soft_qh_t *));
-Static uhci_intr_info_t *uhci_alloc_intr_info __P((uhci_softc_t *));
-Static void		uhci_free_intr_info __P((uhci_intr_info_t *ii));
+Static void		uhci_busreset(uhci_softc_t *);
+Static usbd_status	uhci_run(uhci_softc_t *, int run);
+Static uhci_soft_td_t *uhci_alloc_std(uhci_softc_t *);
+Static void		uhci_free_std(uhci_softc_t *, uhci_soft_td_t *);
+Static uhci_soft_qh_t *uhci_alloc_sqh(uhci_softc_t *);
+Static void		uhci_free_sqh(uhci_softc_t *, uhci_soft_qh_t *);
+Static uhci_intr_info_t *uhci_alloc_intr_info(uhci_softc_t *);
+Static void		uhci_free_intr_info(uhci_intr_info_t *ii);
 #if 0
-Static void		uhci_enter_ctl_q __P((uhci_softc_t *, uhci_soft_qh_t *,
-				      uhci_intr_info_t *));
-Static void		uhci_exit_ctl_q __P((uhci_softc_t *, uhci_soft_qh_t *));
+Static void		uhci_enter_ctl_q(uhci_softc_t *, uhci_soft_qh_t *,
+				      uhci_intr_info_t *);
+Static void		uhci_exit_ctl_q(uhci_softc_t *, uhci_soft_qh_t *);
 #endif
 
-Static void		uhci_free_std_chain __P((uhci_softc_t *, 
-					 uhci_soft_td_t *, uhci_soft_td_t *));
-Static usbd_status	uhci_alloc_std_chain __P((struct uhci_pipe *,
+Static void		uhci_free_std_chain(uhci_softc_t *, 
+					 uhci_soft_td_t *, uhci_soft_td_t *);
+Static usbd_status	uhci_alloc_std_chain(struct uhci_pipe *,
 			    uhci_softc_t *, int, int, u_int16_t, usb_dma_t *, 
-			    uhci_soft_td_t **, uhci_soft_td_t **));
-Static void		uhci_timo __P((void *));
-Static void		uhci_waitintr __P((uhci_softc_t *,
-			    usbd_xfer_handle));
-Static void		uhci_check_intr __P((uhci_softc_t *,
-			    uhci_intr_info_t *));
-Static void		uhci_idone __P((uhci_intr_info_t *));
-Static void		uhci_abort_xfer __P((usbd_xfer_handle,
-			    usbd_status status));
-Static void		uhci_abort_xfer_end __P((void *v));
-Static void		uhci_timeout __P((void *));
-Static void		uhci_lock_frames __P((uhci_softc_t *));
-Static void		uhci_unlock_frames __P((uhci_softc_t *));
-Static void		uhci_add_ctrl __P((uhci_softc_t *, uhci_soft_qh_t *));
-Static void		uhci_add_bulk __P((uhci_softc_t *, uhci_soft_qh_t *));
-Static void		uhci_remove_ctrl __P((uhci_softc_t *,uhci_soft_qh_t *));
-Static void		uhci_remove_bulk __P((uhci_softc_t *,uhci_soft_qh_t *));
-Static int		uhci_str __P((usb_string_descriptor_t *, int, char *));
-
-Static usbd_status	uhci_setup_isoc __P((usbd_pipe_handle pipe));
-Static void		uhci_device_isoc_enter __P((usbd_xfer_handle));
-
-Static usbd_status	uhci_allocm __P((struct usbd_bus *, usb_dma_t *,
-			    u_int32_t));
-Static void		uhci_freem __P((struct usbd_bus *, usb_dma_t *));
-
-Static usbd_xfer_handle	uhci_allocx __P((struct usbd_bus *));
-Static void		uhci_freex __P((struct usbd_bus *, usbd_xfer_handle));
-
-Static usbd_status	uhci_device_ctrl_transfer __P((usbd_xfer_handle));
-Static usbd_status	uhci_device_ctrl_start __P((usbd_xfer_handle));
-Static void		uhci_device_ctrl_abort __P((usbd_xfer_handle));
-Static void		uhci_device_ctrl_close __P((usbd_pipe_handle));
-Static void		uhci_device_ctrl_done  __P((usbd_xfer_handle));
-
-Static usbd_status	uhci_device_intr_transfer __P((usbd_xfer_handle));
-Static usbd_status	uhci_device_intr_start __P((usbd_xfer_handle));
-Static void		uhci_device_intr_abort __P((usbd_xfer_handle));
-Static void		uhci_device_intr_close __P((usbd_pipe_handle));
-Static void		uhci_device_intr_done  __P((usbd_xfer_handle));
-
-Static usbd_status	uhci_device_bulk_transfer __P((usbd_xfer_handle));
-Static usbd_status	uhci_device_bulk_start __P((usbd_xfer_handle));
-Static void		uhci_device_bulk_abort __P((usbd_xfer_handle));
-Static void		uhci_device_bulk_close __P((usbd_pipe_handle));
-Static void		uhci_device_bulk_done  __P((usbd_xfer_handle));
-
-Static usbd_status	uhci_device_isoc_transfer __P((usbd_xfer_handle));
-Static usbd_status	uhci_device_isoc_start __P((usbd_xfer_handle));
-Static void		uhci_device_isoc_abort __P((usbd_xfer_handle));
-Static void		uhci_device_isoc_close __P((usbd_pipe_handle));
-Static void		uhci_device_isoc_done  __P((usbd_xfer_handle));
-
-Static usbd_status	uhci_root_ctrl_transfer __P((usbd_xfer_handle));
-Static usbd_status	uhci_root_ctrl_start __P((usbd_xfer_handle));
-Static void		uhci_root_ctrl_abort __P((usbd_xfer_handle));
-Static void		uhci_root_ctrl_close __P((usbd_pipe_handle));
-
-Static usbd_status	uhci_root_intr_transfer __P((usbd_xfer_handle));
-Static usbd_status	uhci_root_intr_start __P((usbd_xfer_handle));
-Static void		uhci_root_intr_abort __P((usbd_xfer_handle));
-Static void		uhci_root_intr_close __P((usbd_pipe_handle));
-Static void		uhci_root_intr_done  __P((usbd_xfer_handle));
-
-Static usbd_status	uhci_open __P((usbd_pipe_handle));
-Static void		uhci_poll __P((struct usbd_bus *));
-
-Static usbd_status	uhci_device_request __P((usbd_xfer_handle xfer));
-
-Static void		uhci_add_intr __P((uhci_softc_t *, int,
-			    uhci_soft_qh_t *));
-Static void		uhci_remove_intr __P((uhci_softc_t *, int,
-			    uhci_soft_qh_t *));
-Static usbd_status	uhci_device_setintr __P((uhci_softc_t *sc, 
-			    struct uhci_pipe *pipe, int ival));
-
-Static void		uhci_device_clear_toggle __P((usbd_pipe_handle pipe));
-Static void		uhci_noop __P((usbd_pipe_handle pipe));
+			    uhci_soft_td_t **, uhci_soft_td_t **);
+Static void		uhci_timo(void *);
+Static void		uhci_waitintr(uhci_softc_t *,
+			    usbd_xfer_handle);
+Static void		uhci_check_intr(uhci_softc_t *,
+			    uhci_intr_info_t *);
+Static void		uhci_idone(uhci_intr_info_t *);
+Static void		uhci_abort_xfer(usbd_xfer_handle,
+			    usbd_status status);
+Static void		uhci_abort_xfer_end(void *v);
+Static void		uhci_timeout(void *);
+Static void		uhci_lock_frames(uhci_softc_t *);
+Static void		uhci_unlock_frames(uhci_softc_t *);
+Static void		uhci_add_ctrl(uhci_softc_t *, uhci_soft_qh_t *);
+Static void		uhci_add_bulk(uhci_softc_t *, uhci_soft_qh_t *);
+Static void		uhci_remove_ctrl(uhci_softc_t *,uhci_soft_qh_t *);
+Static void		uhci_remove_bulk(uhci_softc_t *,uhci_soft_qh_t *);
+Static int		uhci_str(usb_string_descriptor_t *, int, char *);
+
+Static usbd_status	uhci_setup_isoc(usbd_pipe_handle pipe);
+Static void		uhci_device_isoc_enter(usbd_xfer_handle);
+
+Static usbd_status	uhci_allocm(struct usbd_bus *, usb_dma_t *,
+			    u_int32_t);
+Static void		uhci_freem(struct usbd_bus *, usb_dma_t *);
+
+Static usbd_xfer_handle	uhci_allocx(struct usbd_bus *);
+Static void		uhci_freex(struct usbd_bus *, usbd_xfer_handle);
+
+Static usbd_status	uhci_device_ctrl_transfer(usbd_xfer_handle);
+Static usbd_status	uhci_device_ctrl_start(usbd_xfer_handle);
+Static void		uhci_device_ctrl_abort(usbd_xfer_handle);
+Static void		uhci_device_ctrl_close(usbd_pipe_handle);
+Static void		uhci_device_ctrl_done (usbd_xfer_handle);
+
+Static usbd_status	uhci_device_intr_transfer(usbd_xfer_handle);
+Static usbd_status	uhci_device_intr_start(usbd_xfer_handle);
+Static void		uhci_device_intr_abort(usbd_xfer_handle);
+Static void		uhci_device_intr_close(usbd_pipe_handle);
+Static void		uhci_device_intr_done (usbd_xfer_handle);
+
+Static usbd_status	uhci_device_bulk_transfer(usbd_xfer_handle);
+Static usbd_status	uhci_device_bulk_start(usbd_xfer_handle);
+Static void		uhci_device_bulk_abort(usbd_xfer_handle);
+Static void		uhci_device_bulk_close(usbd_pipe_handle);
+Static void		uhci_device_bulk_done (usbd_xfer_handle);
+
+Static usbd_status	uhci_device_isoc_transfer(usbd_xfer_handle);
+Static usbd_status	uhci_device_isoc_start(usbd_xfer_handle);
+Static void		uhci_device_isoc_abort(usbd_xfer_handle);
+Static void		uhci_device_isoc_close(usbd_pipe_handle);
+Static void		uhci_device_isoc_done (usbd_xfer_handle);
+
+Static usbd_status	uhci_root_ctrl_transfer(usbd_xfer_handle);
+Static usbd_status	uhci_root_ctrl_start(usbd_xfer_handle);
+Static void		uhci_root_ctrl_abort(usbd_xfer_handle);
+Static void		uhci_root_ctrl_close(usbd_pipe_handle);
+
+Static usbd_status	uhci_root_intr_transfer(usbd_xfer_handle);
+Static usbd_status	uhci_root_intr_start(usbd_xfer_handle);
+Static void		uhci_root_intr_abort(usbd_xfer_handle);
+Static void		uhci_root_intr_close(usbd_pipe_handle);
+Static void		uhci_root_intr_done (usbd_xfer_handle);
+
+Static usbd_status	uhci_open(usbd_pipe_handle);
+Static void		uhci_poll(struct usbd_bus *);
+
+Static usbd_status	uhci_device_request(usbd_xfer_handle xfer);
+
+Static void		uhci_add_intr(uhci_softc_t *, int,
+			    uhci_soft_qh_t *);
+Static void		uhci_remove_intr(uhci_softc_t *, int,
+			    uhci_soft_qh_t *);
+Static usbd_status	uhci_device_setintr(uhci_softc_t *sc, 
+			    struct uhci_pipe *pipe, int ival);
+
+Static void		uhci_device_clear_toggle(usbd_pipe_handle pipe);
+Static void		uhci_noop(usbd_pipe_handle pipe);
 
 #ifdef UHCI_DEBUG
-Static void		uhci_dumpregs __P((uhci_softc_t *));
-Static void		uhci_dump_qhs __P((uhci_soft_qh_t *));
-Static void		uhci_dump_qh __P((uhci_soft_qh_t *));
-Static void		uhci_dump_tds __P((uhci_soft_td_t *));
-Static void		uhci_dump_td __P((uhci_soft_td_t *));
+Static void		uhci_dumpregs(uhci_softc_t *);
+Static void		uhci_dump_qhs(uhci_soft_qh_t *);
+Static void		uhci_dump_qh(uhci_soft_qh_t *);
+Static void		uhci_dump_tds(uhci_soft_td_t *);
+Static void		uhci_dump_td(uhci_soft_td_t *);
 #endif
 
 #define UWRITE2(sc, r, x) bus_space_write_2((sc)->iot, (sc)->ioh, (r), (x))
diff --git a/sys/dev/usb/uhcivar.h b/sys/dev/usb/uhcivar.h
index 303a429..5e73e71 100644
--- a/sys/dev/usb/uhcivar.h
+++ b/sys/dev/usb/uhcivar.h
@@ -178,13 +178,13 @@ typedef struct uhci_softc {
 	device_ptr_t sc_child;		/* /dev/usb device */
 } uhci_softc_t;
 
-usbd_status	uhci_init __P((uhci_softc_t *));
-int		uhci_intr __P((void *));
+usbd_status	uhci_init(uhci_softc_t *);
+int		uhci_intr(void *);
 #if defined(__NetBSD__) || defined(__OpenBSD__)
-int		uhci_detach __P((uhci_softc_t *, int));
-int		uhci_activate __P((device_ptr_t, enum devact));
+int		uhci_detach(uhci_softc_t *, int);
+int		uhci_activate(device_ptr_t, enum devact);
 #endif
 
-void		uhci_shutdown __P((void *v));
-void		uhci_power __P((int state, void *priv));
+void		uhci_shutdown(void *v);
+void		uhci_power(int state, void *priv);
 
diff --git a/sys/dev/usb/uhid.c b/sys/dev/usb/uhid.c
index 01bba20..c3194dc 100644
--- a/sys/dev/usb/uhid.c
+++ b/sys/dev/usb/uhid.c
@@ -153,13 +153,13 @@ Static struct cdevsw uhid_cdevsw = {
 };
 #endif
 
-Static void uhid_intr __P((usbd_xfer_handle, usbd_private_handle,
-			   usbd_status));
+Static void uhid_intr(usbd_xfer_handle, usbd_private_handle,
+			   usbd_status);
 
-Static int uhid_do_read __P((struct uhid_softc *, struct uio *uio, int));
-Static int uhid_do_write __P((struct uhid_softc *, struct uio *uio, int));
-Static int uhid_do_ioctl __P((struct uhid_softc *, u_long, caddr_t, int,
-			      struct proc *));
+Static int uhid_do_read(struct uhid_softc *, struct uio *uio, int);
+Static int uhid_do_write(struct uhid_softc *, struct uio *uio, int);
+Static int uhid_do_ioctl(struct uhid_softc *, u_long, caddr_t, int,
+			      struct proc *);
 
 USB_DECLARE_DRIVER(uhid);
 
diff --git a/sys/dev/usb/uhub.c b/sys/dev/usb/uhub.c
index 3cd2a44..ee25c74 100644
--- a/sys/dev/usb/uhub.c
+++ b/sys/dev/usb/uhub.c
@@ -81,8 +81,8 @@ struct uhub_softc {
 	u_char			sc_running;
 };
 
-Static usbd_status uhub_explore __P((usbd_device_handle hub));
-Static void uhub_intr __P((usbd_xfer_handle, usbd_private_handle,usbd_status));
+Static usbd_status uhub_explore(usbd_device_handle hub);
+Static void uhub_intr(usbd_xfer_handle, usbd_private_handle,usbd_status);
 
 #if defined(__FreeBSD__)
 Static bus_child_detached_t uhub_child_detached;
diff --git a/sys/dev/usb/ulpt.c b/sys/dev/usb/ulpt.c
index 6f6a185..b28c8cc 100644
--- a/sys/dev/usb/ulpt.c
+++ b/sys/dev/usb/ulpt.c
@@ -144,14 +144,14 @@ Static struct cdevsw ulpt_cdevsw = {
 };
 #endif
 
-void ulpt_disco __P((void *));
+void ulpt_disco(void *);
 
-int ulpt_do_write __P((struct ulpt_softc *, struct uio *uio, int));
-int ulpt_status __P((struct ulpt_softc *));
-void ulpt_reset __P((struct ulpt_softc *));
-int ulpt_statusmsg __P((u_char, struct ulpt_softc *));
+int ulpt_do_write(struct ulpt_softc *, struct uio *uio, int);
+int ulpt_status(struct ulpt_softc *);
+void ulpt_reset(struct ulpt_softc *);
+int ulpt_statusmsg(u_char, struct ulpt_softc *);
 
-void ieee1284_print_id __P((char *));
+void ieee1284_print_id(char *);
 
 #define	ULPTUNIT(s)	(minor(s) & 0x1f)
 #define	ULPTFLAGS(s)	(minor(s) & 0xe0)
diff --git a/sys/dev/usb/umass.c b/sys/dev/usb/umass.c
index 96ae64e..50276f1 100644
--- a/sys/dev/usb/umass.c
+++ b/sys/dev/usb/umass.c
@@ -242,23 +242,23 @@ typedef union {
 
 struct umass_softc;		/* see below */
 
-typedef void (*transfer_cb_f)	__P((struct umass_softc *sc, void *priv,
-				int residue, int status));
+typedef void (*transfer_cb_f)	(struct umass_softc *sc, void *priv,
+				int residue, int status);
 #define STATUS_CMD_OK		0	/* everything ok */
 #define STATUS_CMD_UNKNOWN	1	/* will have to fetch sense */
 #define STATUS_CMD_FAILED	2	/* transfer was ok, command failed */
 #define STATUS_WIRE_FAILED	3	/* couldn't even get command across */
 
-typedef void (*wire_reset_f)	__P((struct umass_softc *sc, int status));
-typedef void (*wire_transfer_f)	__P((struct umass_softc *sc, int lun,
+typedef void (*wire_reset_f)	(struct umass_softc *sc, int status);
+typedef void (*wire_transfer_f)	(struct umass_softc *sc, int lun,
 				void *cmd, int cmdlen, void *data, int datalen, 
-				int dir, transfer_cb_f cb, void *priv));
-typedef void (*wire_state_f)	__P((usbd_xfer_handle xfer,
-				usbd_private_handle priv, usbd_status err));
+				int dir, transfer_cb_f cb, void *priv);
+typedef void (*wire_state_f)	(usbd_xfer_handle xfer,
+				usbd_private_handle priv, usbd_status err);
 
-typedef int (*command_transform_f)	__P((struct umass_softc *sc,
+typedef int (*command_transform_f)	(struct umass_softc *sc,
 				unsigned char *cmd, int cmdlen,
-				unsigned char **rcmd, int *rcmdlen));
+				unsigned char **rcmd, int *rcmdlen);
 
 
 /* the per device structure */
@@ -440,98 +440,98 @@ struct cam_sim *umass_sim;	/* SCSI Interface Module */
 
 /* USB device probe/attach/detach functions */
 USB_DECLARE_DRIVER(umass);
-Static int umass_match_proto	__P((struct umass_softc *sc,
+Static int umass_match_proto	(struct umass_softc *sc,
 				usbd_interface_handle iface,
-				usbd_device_handle udev));
+				usbd_device_handle udev);
 
 /* quirk functions */
-Static void umass_init_shuttle	__P((struct umass_softc *sc));
+Static void umass_init_shuttle	(struct umass_softc *sc);
 
 /* generic transfer functions */
-Static usbd_status umass_setup_transfer	__P((struct umass_softc *sc,
+Static usbd_status umass_setup_transfer	(struct umass_softc *sc,
 				usbd_pipe_handle pipe,
 				void *buffer, int buflen, int flags,
-				usbd_xfer_handle xfer));
-Static usbd_status umass_setup_ctrl_transfer	__P((struct umass_softc *sc,
+				usbd_xfer_handle xfer);
+Static usbd_status umass_setup_ctrl_transfer	(struct umass_softc *sc,
 				usbd_device_handle udev,
 				usb_device_request_t *req,
 				void *buffer, int buflen, int flags, 
-				usbd_xfer_handle xfer));
-Static void umass_clear_endpoint_stall	__P((struct umass_softc *sc,
+				usbd_xfer_handle xfer);
+Static void umass_clear_endpoint_stall	(struct umass_softc *sc,
 				u_int8_t endpt, usbd_pipe_handle pipe,
-				int state, usbd_xfer_handle xfer));
-Static void umass_reset		__P((struct umass_softc *sc,
-				transfer_cb_f cb, void *priv));
+				int state, usbd_xfer_handle xfer);
+Static void umass_reset		(struct umass_softc *sc,
+				transfer_cb_f cb, void *priv);
 
 /* Bulk-Only related functions */
-Static void umass_bbb_reset	__P((struct umass_softc *sc, int status));
-Static void umass_bbb_transfer	__P((struct umass_softc *sc, int lun,
+Static void umass_bbb_reset	(struct umass_softc *sc, int status);
+Static void umass_bbb_transfer	(struct umass_softc *sc, int lun,
 				void *cmd, int cmdlen,
 		    		void *data, int datalen, int dir,
-				transfer_cb_f cb, void *priv));
-Static void umass_bbb_state	__P((usbd_xfer_handle xfer,
+				transfer_cb_f cb, void *priv);
+Static void umass_bbb_state	(usbd_xfer_handle xfer,
 				usbd_private_handle priv,
-				usbd_status err));
+				usbd_status err);
 Static int umass_bbb_get_max_lun
-				__P((struct umass_softc *sc));
+				(struct umass_softc *sc);
  
 /* CBI related functions */
-Static int umass_cbi_adsc	__P((struct umass_softc *sc,
+Static int umass_cbi_adsc	(struct umass_softc *sc,
 				char *buffer, int buflen,
-				usbd_xfer_handle xfer));
-Static void umass_cbi_reset	__P((struct umass_softc *sc, int status));
-Static void umass_cbi_transfer	__P((struct umass_softc *sc, int lun,
+				usbd_xfer_handle xfer);
+Static void umass_cbi_reset	(struct umass_softc *sc, int status);
+Static void umass_cbi_transfer	(struct umass_softc *sc, int lun,
 				void *cmd, int cmdlen,
 		    		void *data, int datalen, int dir,
-				transfer_cb_f cb, void *priv));
-Static void umass_cbi_state	__P((usbd_xfer_handle xfer,
-				usbd_private_handle priv, usbd_status err));
+				transfer_cb_f cb, void *priv);
+Static void umass_cbi_state	(usbd_xfer_handle xfer,
+				usbd_private_handle priv, usbd_status err);
 
 /* CAM related functions */
-Static void umass_cam_action	__P((struct cam_sim *sim, union ccb *ccb));
-Static void umass_cam_poll	__P((struct cam_sim *sim));
+Static void umass_cam_action	(struct cam_sim *sim, union ccb *ccb);
+Static void umass_cam_poll	(struct cam_sim *sim);
 
-Static void umass_cam_cb	__P((struct umass_softc *sc, void *priv,
-				int residue, int status));
-Static void umass_cam_sense_cb	__P((struct umass_softc *sc, void *priv,
-				int residue, int status));
+Static void umass_cam_cb	(struct umass_softc *sc, void *priv,
+				int residue, int status);
+Static void umass_cam_sense_cb	(struct umass_softc *sc, void *priv,
+				int residue, int status);
 
 Static void umass_cam_rescan_callback
-				__P((struct cam_periph *periph,union ccb *ccb));
-Static void umass_cam_rescan	__P((struct umass_softc *sc));
+				(struct cam_periph *periph,union ccb *ccb);
+Static void umass_cam_rescan	(struct umass_softc *sc);
 
-Static int umass_cam_attach_sim	__P((void));
-Static int umass_cam_attach	__P((struct umass_softc *sc));
-Static int umass_cam_detach_sim	__P((void));
-Static int umass_cam_detach	__P((struct umass_softc *sc));
+Static int umass_cam_attach_sim	(void);
+Static int umass_cam_attach	(struct umass_softc *sc);
+Static int umass_cam_detach_sim	(void);
+Static int umass_cam_detach	(struct umass_softc *sc);
 
 
 /* SCSI specific functions */
-Static int umass_scsi_transform	__P((struct umass_softc *sc,
+Static int umass_scsi_transform	(struct umass_softc *sc,
 				unsigned char *cmd, int cmdlen,
-		     		unsigned char **rcmd, int *rcmdlen));
+		     		unsigned char **rcmd, int *rcmdlen);
 
 /* UFI specific functions */
 #define UFI_COMMAND_LENGTH	12	/* UFI commands are always 12b */
-Static int umass_ufi_transform	__P((struct umass_softc *sc,
+Static int umass_ufi_transform	(struct umass_softc *sc,
 				unsigned char *cmd, int cmdlen,
-		    		unsigned char **rcmd, int *rcmdlen));
+		    		unsigned char **rcmd, int *rcmdlen);
 
 /* ATAPI (8070i) specific functions */
 #define ATAPI_COMMAND_LENGTH	12	/* ATAPI commands are always 12b */
-Static int umass_atapi_transform	__P((struct umass_softc *sc,
+Static int umass_atapi_transform	(struct umass_softc *sc,
 				unsigned char *cmd, int cmdlen,
-		     		unsigned char **rcmd, int *rcmdlen));
+		     		unsigned char **rcmd, int *rcmdlen);
 
 
 #ifdef UMASS_DEBUG
 /* General debugging functions */
-Static void umass_bbb_dump_cbw	__P((struct umass_softc *sc,
-				umass_bbb_cbw_t *cbw));
-Static void umass_bbb_dump_csw	__P((struct umass_softc *sc,
-				umass_bbb_csw_t *csw));
-Static void umass_dump_buffer	__P((struct umass_softc *sc, u_int8_t *buffer,
-				int buflen, int printlen));
+Static void umass_bbb_dump_cbw	(struct umass_softc *sc,
+				umass_bbb_cbw_t *cbw);
+Static void umass_bbb_dump_csw	(struct umass_softc *sc,
+				umass_bbb_csw_t *csw);
+Static void umass_dump_buffer	(struct umass_softc *sc, u_int8_t *buffer,
+				int buflen, int printlen);
 #endif
 
 
diff --git a/sys/dev/usb/ums.c b/sys/dev/usb/ums.c
index 4e7a2d1..dfd5858 100644
--- a/sys/dev/usb/ums.c
+++ b/sys/dev/usb/ums.c
@@ -123,15 +123,15 @@ struct ums_softc {
 #define MOUSE_FLAGS_MASK (HIO_CONST|HIO_RELATIVE)
 #define MOUSE_FLAGS (HIO_RELATIVE)
 
-Static void ums_intr __P((usbd_xfer_handle xfer,
-			  usbd_private_handle priv, usbd_status status));
+Static void ums_intr(usbd_xfer_handle xfer,
+			  usbd_private_handle priv, usbd_status status);
 
-Static void ums_add_to_queue __P((struct ums_softc *sc,
-				int dx, int dy, int dz, int buttons));
-Static void ums_add_to_queue_timeout __P((void *priv));
+Static void ums_add_to_queue(struct ums_softc *sc,
+				int dx, int dy, int dz, int buttons);
+Static void ums_add_to_queue_timeout(void *priv);
 
-Static int  ums_enable __P((void *));
-Static void ums_disable __P((void *));
+Static int  ums_enable(void *);
+Static void ums_disable(void *);
 
 Static d_open_t  ums_open;
 Static d_close_t ums_close;
diff --git a/sys/dev/usb/urio.c b/sys/dev/usb/urio.c
index fc1d8da..607b9cb 100644
--- a/sys/dev/usb/urio.c
+++ b/sys/dev/usb/urio.c
@@ -97,11 +97,11 @@ int	uriodebug = 100;
 #define RIO_NODIR  2
 
 #if defined(__NetBSD__)
-int urioopen __P((dev_t, int, int, struct proc *));
-int urioclose __P((dev_t, int, int, struct proc *p));
-int urioread __P((dev_t, struct uio *uio, int));
-int uriowrite __P((dev_t, struct uio *uio, int));
-int urioioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
+int urioopen(dev_t, int, int, struct proc *);
+int urioclose(dev_t, int, int, struct proc *p);
+int urioread(dev_t, struct uio *uio, int);
+int uriowrite(dev_t, struct uio *uio, int);
+int urioioctl(dev_t, u_long, caddr_t, int, struct proc *);
 
 cdev_decl(urio);
 #define RIO_UE_GET_DIR(p) ((UE_GET_DIR(p) == UE_DIR_IN) ? RIO_IN :\
diff --git a/sys/dev/usb/usb_mem.h b/sys/dev/usb/usb_mem.h
index f74e9c4..11d3528 100644
--- a/sys/dev/usb/usb_mem.h
+++ b/sys/dev/usb/usb_mem.h
@@ -54,8 +54,8 @@ typedef struct usb_dma_block {
 #define DMAADDR(dma, offset) ((dma)->block->segs[0].ds_addr + (dma)->offs + (offset))
 #define KERNADDR(dma, offset) ((void *)((dma)->block->kaddr + (dma)->offs) + (offset))
 
-usbd_status	usb_allocmem __P((usbd_bus_handle,size_t,size_t, usb_dma_t *));
-void		usb_freemem  __P((usbd_bus_handle, usb_dma_t *));
+usbd_status	usb_allocmem(usbd_bus_handle,size_t,size_t, usb_dma_t *);
+void		usb_freemem(usbd_bus_handle, usb_dma_t *);
 
 #elif defined(__FreeBSD__)
 
diff --git a/sys/dev/usb/usb_quirks.h b/sys/dev/usb/usb_quirks.h
index db5f830..828d645 100644
--- a/sys/dev/usb/usb_quirks.h
+++ b/sys/dev/usb/usb_quirks.h
@@ -52,4 +52,4 @@ struct usbd_quirks {
 
 extern struct usbd_quirks usbd_no_quirk;
 
-struct usbd_quirks *usbd_find_quirk __P((usb_device_descriptor_t *));
+struct usbd_quirks *usbd_find_quirk(usb_device_descriptor_t *);
diff --git a/sys/dev/usb/usb_subr.c b/sys/dev/usb/usb_subr.c
index 4b3ae82..22a5741 100644
--- a/sys/dev/usb/usb_subr.c
+++ b/sys/dev/usb/usb_subr.c
@@ -75,19 +75,19 @@ extern int usbdebug;
 #define DPRINTFN(n,x)
 #endif
 
-Static usbd_status	usbd_set_config __P((usbd_device_handle, int));
-Static char *usbd_get_string __P((usbd_device_handle, int, char *));
-Static int usbd_getnewaddr __P((usbd_bus_handle bus));
+Static usbd_status	usbd_set_config(usbd_device_handle, int);
+Static char *usbd_get_string(usbd_device_handle, int, char *);
+Static int usbd_getnewaddr(usbd_bus_handle bus);
 #if defined(__NetBSD__)
-Static int usbd_print __P((void *aux, const char *pnp));
-Static int usbd_submatch __P((device_ptr_t, struct cfdata *cf, void *));
+Static int usbd_print(void *aux, const char *pnp);
+Static int usbd_submatch(device_ptr_t, struct cfdata *cf, void *);
 #elif defined(__OpenBSD__)
-Static int usbd_submatch __P((device_ptr_t, void *, void *));
+Static int usbd_submatch(device_ptr_t, void *, void *);
 #endif
-Static void usbd_free_iface_data __P((usbd_device_handle dev, int ifcno));
-Static void usbd_kill_pipe __P((usbd_pipe_handle));
+Static void usbd_free_iface_data(usbd_device_handle dev, int ifcno);
+Static void usbd_kill_pipe(usbd_pipe_handle);
 Static usbd_status usbd_probe_and_attach 
-	__P((device_ptr_t parent, usbd_device_handle dev, int port, int addr));
+	(device_ptr_t parent, usbd_device_handle dev, int port, int addr);
 
 Static u_int32_t usb_cookie_no = 0;
 
diff --git a/sys/dev/usb/usbdi.c b/sys/dev/usb/usbdi.c
index e572b3e..f4ac846 100644
--- a/sys/dev/usb/usbdi.c
+++ b/sys/dev/usb/usbdi.c
@@ -76,12 +76,12 @@ extern int usbdebug;
 #define DPRINTFN(n,x)
 #endif
 
-Static usbd_status usbd_ar_pipe  __P((usbd_pipe_handle pipe));
+Static usbd_status usbd_ar_pipe(usbd_pipe_handle pipe);
 Static void usbd_do_request_async_cb 
-    __P((usbd_xfer_handle, usbd_private_handle, usbd_status));
-Static void usbd_start_next __P((usbd_pipe_handle pipe));
+    (usbd_xfer_handle, usbd_private_handle, usbd_status);
+Static void usbd_start_next(usbd_pipe_handle pipe);
 Static usbd_status usbd_open_pipe_ival
-    __P((usbd_interface_handle, u_int8_t, u_int8_t, usbd_pipe_handle *, int));
+    (usbd_interface_handle, u_int8_t, u_int8_t, usbd_pipe_handle *, int);
 
 Static int usbd_nbuses = 0;
 
@@ -97,7 +97,7 @@ usbd_finish()
 	--usbd_nbuses;
 }
 
-Static __inline int usbd_xfer_isread __P((usbd_xfer_handle xfer));
+Static __inline int usbd_xfer_isread(usbd_xfer_handle xfer);
 Static __inline int
 usbd_xfer_isread(xfer)
 	usbd_xfer_handle xfer;
@@ -110,7 +110,7 @@ usbd_xfer_isread(xfer)
 }
 
 #ifdef USB_DEBUG
-void usbd_dump_queue __P((usbd_pipe_handle));
+void usbd_dump_queue(usbd_pipe_handle);
 
 void
 usbd_dump_queue(pipe)
@@ -406,9 +406,9 @@ usbd_setup_xfer(xfer, pipe, priv, buffer, length, flags, timeout, callback)
 	u_int32_t length;
 	u_int16_t flags;
 	u_int32_t timeout;
-	void (*callback) __P((usbd_xfer_handle,
+	void (*callback)(usbd_xfer_handle,
 			      usbd_private_handle,
-			      usbd_status));
+			      usbd_status);
 {
 	xfer->pipe = pipe;
 	xfer->priv = priv;
@@ -434,9 +434,9 @@ usbd_setup_default_xfer(xfer, dev, priv, timeout, req, buffer,
 	void *buffer;
 	u_int32_t length;
 	u_int16_t flags;
-	void (*callback) __P((usbd_xfer_handle,
+	void (*callback)(usbd_xfer_handle,
 			      usbd_private_handle,
-			      usbd_status));
+			      usbd_status);
 {
 	xfer->pipe = dev->default_pipe;
 	xfer->priv = priv;
diff --git a/sys/dev/usb/usbdi.h b/sys/dev/usb/usbdi.h
index 3fb7c4b..acf3bb3 100644
--- a/sys/dev/usb/usbdi.h
+++ b/sys/dev/usb/usbdi.h
@@ -70,8 +70,8 @@ typedef enum {		/* keep in sync with usbd_status_msgs */
 	USBD_ERROR_MAX,		/* must be last */
 } usbd_status;
 
-typedef void (*usbd_callback) __P((usbd_xfer_handle, usbd_private_handle,
-				   usbd_status));
+typedef void (*usbd_callback)(usbd_xfer_handle, usbd_private_handle,
+				   usbd_status);
 
 /* Open flags */
 #define USBD_EXCLUSIVE_USE	0x01
@@ -96,94 +96,94 @@ typedef void (*usbd_callback) __P((usbd_xfer_handle, usbd_private_handle,
 #endif
 
 usbd_status usbd_open_pipe
-	__P((usbd_interface_handle iface, u_int8_t address,
-	     u_int8_t flags, usbd_pipe_handle *pipe));
-usbd_status usbd_close_pipe	__P((usbd_pipe_handle pipe));
-usbd_status usbd_transfer	__P((usbd_xfer_handle req));
-usbd_xfer_handle usbd_alloc_xfer __P((usbd_device_handle));
-usbd_status usbd_free_xfer	__P((usbd_xfer_handle xfer));
+	(usbd_interface_handle iface, u_int8_t address,
+	 u_int8_t flags, usbd_pipe_handle *pipe);
+usbd_status usbd_close_pipe	(usbd_pipe_handle pipe);
+usbd_status usbd_transfer	(usbd_xfer_handle req);
+usbd_xfer_handle usbd_alloc_xfer (usbd_device_handle);
+usbd_status usbd_free_xfer	(usbd_xfer_handle xfer);
 void usbd_setup_xfer
-	__P((usbd_xfer_handle xfer, usbd_pipe_handle pipe,
-	     usbd_private_handle priv, void *buffer,
-	     u_int32_t length, u_int16_t flags, u_int32_t timeout,
-	     usbd_callback));
+	(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
+	 usbd_private_handle priv, void *buffer,
+	 u_int32_t length, u_int16_t flags, u_int32_t timeout,
+	 usbd_callback);
 void usbd_setup_default_xfer
-	__P((usbd_xfer_handle xfer, usbd_device_handle dev,
-	     usbd_private_handle priv, u_int32_t timeout,
-	     usb_device_request_t *req,  void *buffer,
-	     u_int32_t length, u_int16_t flags, usbd_callback));
+	(usbd_xfer_handle xfer, usbd_device_handle dev,
+	 usbd_private_handle priv, u_int32_t timeout,
+	 usb_device_request_t *req,  void *buffer,
+	 u_int32_t length, u_int16_t flags, usbd_callback);
 void usbd_setup_isoc_xfer	
-	__P((usbd_xfer_handle xfer, usbd_pipe_handle pipe,
-	     usbd_private_handle priv, u_int16_t *frlengths,
-	     u_int32_t nframes, u_int16_t flags, usbd_callback));
+	(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
+	 usbd_private_handle priv, u_int16_t *frlengths,
+	 u_int32_t nframes, u_int16_t flags, usbd_callback);
 void usbd_get_xfer_status
-	__P((usbd_xfer_handle xfer, usbd_private_handle *priv,
-	     void **buffer, u_int32_t *count, usbd_status *status));
+	(usbd_xfer_handle xfer, usbd_private_handle *priv,
+	 void **buffer, u_int32_t *count, usbd_status *status);
 usb_endpoint_descriptor_t *usbd_interface2endpoint_descriptor
-	__P((usbd_interface_handle iface, u_int8_t address));
-usbd_status usbd_abort_pipe __P((usbd_pipe_handle pipe));
-usbd_status usbd_clear_endpoint_stall __P((usbd_pipe_handle pipe));
-usbd_status usbd_clear_endpoint_stall_async __P((usbd_pipe_handle pipe));
-void usbd_clear_endpoint_toggle __P((usbd_pipe_handle pipe));
+	(usbd_interface_handle iface, u_int8_t address);
+usbd_status usbd_abort_pipe(usbd_pipe_handle pipe);
+usbd_status usbd_clear_endpoint_stall(usbd_pipe_handle pipe);
+usbd_status usbd_clear_endpoint_stall_async(usbd_pipe_handle pipe);
+void usbd_clear_endpoint_toggle(usbd_pipe_handle pipe);
 usbd_status usbd_endpoint_count
-	__P((usbd_interface_handle dev, u_int8_t *count));
+	(usbd_interface_handle dev, u_int8_t *count);
 usbd_status usbd_interface_count
-	__P((usbd_device_handle dev, u_int8_t *count));
+	(usbd_device_handle dev, u_int8_t *count);
 usbd_status usbd_interface2device_handle
-	__P((usbd_interface_handle iface, usbd_device_handle *dev));
+	(usbd_interface_handle iface, usbd_device_handle *dev);
 usbd_status usbd_device2interface_handle
-	__P((usbd_device_handle dev, u_int8_t ifaceno, usbd_interface_handle *iface));
+	(usbd_device_handle dev, u_int8_t ifaceno, usbd_interface_handle *iface);
 
-usbd_device_handle usbd_pipe2device_handle __P((usbd_pipe_handle));
-void *usbd_alloc_buffer __P((usbd_xfer_handle req, u_int32_t size));
-void usbd_free_buffer __P((usbd_xfer_handle req));
-void *usbd_get_buffer __P((usbd_xfer_handle xfer));
-usbd_status usbd_sync_transfer	__P((usbd_xfer_handle req));
+usbd_device_handle usbd_pipe2device_handle(usbd_pipe_handle);
+void *usbd_alloc_buffer(usbd_xfer_handle req, u_int32_t size);
+void usbd_free_buffer(usbd_xfer_handle req);
+void *usbd_get_buffer(usbd_xfer_handle xfer);
+usbd_status usbd_sync_transfer(usbd_xfer_handle req);
 usbd_status usbd_open_pipe_intr
-	__P((usbd_interface_handle iface, u_int8_t address,
-	     u_int8_t flags, usbd_pipe_handle *pipe,
-	     usbd_private_handle priv, void *buffer,
-	     u_int32_t length, usbd_callback, int));
+	(usbd_interface_handle iface, u_int8_t address,
+	 u_int8_t flags, usbd_pipe_handle *pipe,
+	 usbd_private_handle priv, void *buffer,
+	 u_int32_t length, usbd_callback, int);
 usbd_status usbd_do_request 
-	__P((usbd_device_handle pipe, usb_device_request_t *req, void *data));
+	(usbd_device_handle pipe, usb_device_request_t *req, void *data);
 usbd_status usbd_do_request_async
-	__P((usbd_device_handle pipe, usb_device_request_t *req, void *data));
+	(usbd_device_handle pipe, usb_device_request_t *req, void *data);
 usbd_status usbd_do_request_flags
-	__P((usbd_device_handle pipe, usb_device_request_t *req, 
-	     void *data, u_int16_t flags, int *));
+	(usbd_device_handle pipe, usb_device_request_t *req, 
+	 void *data, u_int16_t flags, int *);
 usb_interface_descriptor_t *usbd_get_interface_descriptor
-	__P((usbd_interface_handle iface));
+	(usbd_interface_handle iface);
 usb_config_descriptor_t *usbd_get_config_descriptor
-	__P((usbd_device_handle dev));
+	(usbd_device_handle dev);
 usb_device_descriptor_t *usbd_get_device_descriptor
-	__P((usbd_device_handle dev));
-usbd_status usbd_set_interface __P((usbd_interface_handle, int));
-int usbd_get_no_alts __P((usb_config_descriptor_t *, int));
+	(usbd_device_handle dev);
+usbd_status usbd_set_interface(usbd_interface_handle, int);
+int usbd_get_no_alts(usb_config_descriptor_t *, int);
 usbd_status	usbd_get_interface
-	__P((usbd_interface_handle iface, u_int8_t *aiface));
+	(usbd_interface_handle iface, u_int8_t *aiface);
 void usbd_fill_deviceinfo 
-	__P((usbd_device_handle dev, struct usb_device_info *di));
-int usbd_get_interface_altindex __P((usbd_interface_handle iface));
+	(usbd_device_handle dev, struct usb_device_info *di);
+int usbd_get_interface_altindex(usbd_interface_handle iface);
 
 usb_interface_descriptor_t *usbd_find_idesc
-	__P((usb_config_descriptor_t *cd, int iindex, int ano));
+	(usb_config_descriptor_t *cd, int iindex, int ano);
 usb_endpoint_descriptor_t *usbd_find_edesc
-	__P((usb_config_descriptor_t *cd, int ifaceidx, int altidx, 
-	     int endptidx));
+	(usb_config_descriptor_t *cd, int ifaceidx, int altidx, 
+	     int endptidx);
 
-void usbd_dopoll __P((usbd_interface_handle));
-void usbd_set_polling __P((usbd_interface_handle iface, int on));
+void usbd_dopoll(usbd_interface_handle);
+void usbd_set_polling(usbd_interface_handle iface, int on);
 
-const char *usbd_errstr __P((usbd_status err));
+const char *usbd_errstr(usbd_status err);
 
-void usbd_add_event __P((int, usbd_device_handle));
+void usbd_add_event(int, usbd_device_handle);
 
-void usbd_devinfo __P((usbd_device_handle, int, char *));
-struct usbd_quirks *usbd_get_quirks __P((usbd_device_handle));
+void usbd_devinfo(usbd_device_handle, int, char *);
+struct usbd_quirks *usbd_get_quirks(usbd_device_handle);
 usb_endpoint_descriptor_t *usbd_get_endpoint_descriptor
-	__P((usbd_interface_handle iface, u_int8_t address));
+	(usbd_interface_handle iface, u_int8_t address);
 
-usbd_status usbd_reload_device_desc __P((usbd_device_handle));
+usbd_status usbd_reload_device_desc(usbd_device_handle);
 
 /* NetBSD attachment information */
 
@@ -245,7 +245,7 @@ struct usb_attach_arg {
 #endif
 
 #if defined(__FreeBSD__)
-int usbd_driver_load    __P((module_t mod, int what, void *arg));
+int usbd_driver_load(module_t mod, int what, void *arg);
 #endif
 
 /*
diff --git a/sys/dev/usb/usbdi_util.c b/sys/dev/usb/usbdi_util.c
index 09b5203..ff48fd7 100644
--- a/sys/dev/usb/usbdi_util.c
+++ b/sys/dev/usb/usbdi_util.c
@@ -480,8 +480,8 @@ usbd_get_config(dev, conf)
 	return (usbd_do_request(dev, &req, conf));
 }
 
-Static void usbd_bulk_transfer_cb __P((usbd_xfer_handle xfer, 
-		usbd_private_handle priv, usbd_status status));
+Static void usbd_bulk_transfer_cb(usbd_xfer_handle xfer, 
+		usbd_private_handle priv, usbd_status status);
 Static void
 usbd_bulk_transfer_cb(xfer, priv, status)
 	usbd_xfer_handle xfer;
diff --git a/sys/dev/usb/usbdi_util.h b/sys/dev/usb/usbdi_util.h
index 14c52ce..48c929e 100644
--- a/sys/dev/usb/usbdi_util.h
+++ b/sys/dev/usb/usbdi_util.h
@@ -38,61 +38,61 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-usbd_status	usbd_get_desc __P((usbd_device_handle dev, int type, 
-				   int index, int len, void *desc));
-usbd_status	usbd_get_config_desc __P((usbd_device_handle, int, 
-					  usb_config_descriptor_t *));
-usbd_status	usbd_get_config_desc_full __P((usbd_device_handle, int, 
-					       void *, int));
-usbd_status	usbd_get_device_desc __P((usbd_device_handle dev,
-					  usb_device_descriptor_t *d));
-usbd_status	usbd_set_address __P((usbd_device_handle dev, int addr));
-usbd_status	usbd_get_port_status __P((usbd_device_handle, 
-				      int, usb_port_status_t *));
-usbd_status	usbd_set_hub_feature __P((usbd_device_handle dev, int));
-usbd_status	usbd_clear_hub_feature __P((usbd_device_handle, int));
-usbd_status	usbd_set_port_feature __P((usbd_device_handle dev, int, int));
-usbd_status	usbd_clear_port_feature __P((usbd_device_handle, int, int));
-usbd_status	usbd_get_device_status __P((usbd_device_handle,usb_status_t*));
-usbd_status	usbd_get_hub_status __P((usbd_device_handle dev,
-					 usb_hub_status_t *st));
-usbd_status	usbd_set_protocol __P((usbd_interface_handle dev, int report));
+usbd_status	usbd_get_desc(usbd_device_handle dev, int type, 
+				   int index, int len, void *desc);
+usbd_status	usbd_get_config_desc(usbd_device_handle, int, 
+					  usb_config_descriptor_t *);
+usbd_status	usbd_get_config_desc_full(usbd_device_handle, int, 
+					       void *, int);
+usbd_status	usbd_get_device_desc(usbd_device_handle dev,
+					  usb_device_descriptor_t *d);
+usbd_status	usbd_set_address(usbd_device_handle dev, int addr);
+usbd_status	usbd_get_port_status(usbd_device_handle, 
+				      int, usb_port_status_t *);
+usbd_status	usbd_set_hub_feature(usbd_device_handle dev, int);
+usbd_status	usbd_clear_hub_feature(usbd_device_handle, int);
+usbd_status	usbd_set_port_feature(usbd_device_handle dev, int, int);
+usbd_status	usbd_clear_port_feature(usbd_device_handle, int, int);
+usbd_status	usbd_get_device_status(usbd_device_handle,usb_status_t*);
+usbd_status	usbd_get_hub_status(usbd_device_handle dev,
+					 usb_hub_status_t *st);
+usbd_status	usbd_set_protocol(usbd_interface_handle dev, int report);
 usbd_status	usbd_get_report_descriptor
-	__P((usbd_device_handle dev, int ifcno, int repid, int size, void *d));
+	(usbd_device_handle dev, int ifcno, int repid, int size, void *d);
 struct usb_hid_descriptor *usbd_get_hid_descriptor 
-	__P((usbd_interface_handle ifc));
+	(usbd_interface_handle ifc);
 usbd_status	usbd_set_report 
-	__P((usbd_interface_handle iface,int type,int id,void *data,int len));
+	(usbd_interface_handle iface,int type,int id,void *data,int len);
 usbd_status	usbd_set_report_async
-	__P((usbd_interface_handle iface,int type,int id,void *data,int len));
+	(usbd_interface_handle iface,int type,int id,void *data,int len);
 usbd_status	usbd_get_report 
-	__P((usbd_interface_handle iface,int type,int id,void *data,int len));
+	(usbd_interface_handle iface,int type,int id,void *data,int len);
 usbd_status	usbd_set_idle 
-	__P((usbd_interface_handle iface, int duration, int id));
+	(usbd_interface_handle iface, int duration, int id);
 #if defined(__NetBSD__) || defined(__OpenBSD__)
 usbd_status	usbd_alloc_report_desc
-	__P((usbd_interface_handle ifc, void **descp, int *sizep, int mem));
+	(usbd_interface_handle ifc, void **descp, int *sizep, int mem);
 #elif defined(__FreeBSD__)
 usbd_status	usbd_alloc_report_desc
-	__P((usbd_interface_handle ifc, void **descp, int *sizep, struct malloc_type * mem));
+	(usbd_interface_handle ifc, void **descp, int *sizep, struct malloc_type * mem);
 #endif
 usbd_status	usbd_get_config
-	__P((usbd_device_handle dev, u_int8_t *conf));
+	(usbd_device_handle dev, u_int8_t *conf);
 usbd_status	usbd_get_string_desc
-	__P((usbd_device_handle dev, int sindex, int langid, 
-	     usb_string_descriptor_t *sdesc));
-void		usbd_delay_ms __P((usbd_device_handle, u_int));
+	(usbd_device_handle dev, int sindex, int langid, 
+	     usb_string_descriptor_t *sdesc);
+void usbd_delay_ms (usbd_device_handle, u_int);
 
 
 usbd_status usbd_set_config_no
-	__P((usbd_device_handle dev, int no, int msg));
+	(usbd_device_handle dev, int no, int msg);
 usbd_status usbd_set_config_index
-	__P((usbd_device_handle dev, int index, int msg));
+	(usbd_device_handle dev, int index, int msg);
 
 usbd_status usbd_bulk_transfer
-	__P((usbd_xfer_handle xfer, usbd_pipe_handle pipe, u_int16_t flags,
-	     u_int32_t timeout, void *buf, u_int32_t *size, char *lbl));
+	(usbd_xfer_handle xfer, usbd_pipe_handle pipe, u_int16_t flags,
+	     u_int32_t timeout, void *buf, u_int32_t *size, char *lbl);
 
-void usb_detach_wait __P((device_ptr_t));
-void usb_detach_wakeup __P((device_ptr_t));
+void usb_detach_wait(device_ptr_t);
+void usb_detach_wakeup(device_ptr_t);
 
diff --git a/sys/dev/usb/usbdivar.h b/sys/dev/usb/usbdivar.h
index 9d8ca8a..ef939e1 100644
--- a/sys/dev/usb/usbdivar.h
+++ b/sys/dev/usb/usbdivar.h
@@ -50,23 +50,23 @@ struct usbd_endpoint {
 };
 
 struct usbd_bus_methods {
-	usbd_status	      (*open_pipe)__P((struct usbd_pipe *pipe));
-	void		      (*do_poll)__P((struct usbd_bus *));
-	usbd_status	      (*allocm)__P((struct usbd_bus *, usb_dma_t *,
-					    u_int32_t bufsize));
-	void		      (*freem)__P((struct usbd_bus *, usb_dma_t *));
-	struct usbd_xfer *    (*allocx)__P((struct usbd_bus *));
-	void		      (*freex)__P((struct usbd_bus *,
-					   struct usbd_xfer *));
+	usbd_status	      (*open_pipe)(struct usbd_pipe *pipe);
+	void		      (*do_poll)(struct usbd_bus *);
+	usbd_status	      (*allocm)(struct usbd_bus *, usb_dma_t *,
+					    u_int32_t bufsize);
+	void		      (*freem)(struct usbd_bus *, usb_dma_t *);
+	struct usbd_xfer *    (*allocx)(struct usbd_bus *);
+	void		      (*freex)(struct usbd_bus *,
+					   struct usbd_xfer *);
 };
 
 struct usbd_pipe_methods {
-	usbd_status	      (*transfer)__P((usbd_xfer_handle xfer));
-	usbd_status	      (*start)__P((usbd_xfer_handle xfer));
-	void		      (*abort)__P((usbd_xfer_handle xfer));
-	void		      (*close)__P((usbd_pipe_handle pipe));
-	void		      (*cleartoggle)__P((usbd_pipe_handle pipe));
-	void		      (*done)__P((usbd_xfer_handle xfer));
+	usbd_status	      (*transfer)(usbd_xfer_handle xfer);
+	usbd_status	      (*start)(usbd_xfer_handle xfer);
+	void		      (*abort)(usbd_xfer_handle xfer);
+	void		      (*close)(usbd_pipe_handle pipe);
+	void		      (*cleartoggle)(usbd_pipe_handle pipe);
+	void		      (*done)(usbd_xfer_handle xfer);
 };
 
 struct usbd_port {
@@ -80,7 +80,7 @@ struct usbd_port {
 };
 
 struct usbd_hub {
-	usbd_status	      (*explore)__P((usbd_device_handle hub));
+	usbd_status	      (*explore)(usbd_device_handle hub);
 	void		       *hubsoftc;
 	usb_hub_descriptor_t	hubdesc;
 	struct usbd_port        ports[1];
@@ -204,37 +204,37 @@ struct usbd_xfer {
 #endif
 };
 
-void usbd_init __P((void));
-void usbd_finish __P((void));
+void usbd_init(void);
+void usbd_finish(void);
 
 /* Routines from usb_subr.c */
-int		usbctlprint __P((void *, const char *));
-void		usb_delay_ms __P((usbd_bus_handle, u_int));
-void		usbd_devinfo_vp __P((usbd_device_handle, char *, char *));
-usbd_status	usbd_reset_port __P((usbd_device_handle dev,
-				     int port, usb_port_status_t *ps));
-usbd_status	usbd_setup_pipe __P((usbd_device_handle dev,
+int		usbctlprint(void *, const char *);
+void		usb_delay_ms(usbd_bus_handle, u_int);
+void		usbd_devinfo_vp(usbd_device_handle, char *, char *);
+usbd_status	usbd_reset_port(usbd_device_handle dev,
+				     int port, usb_port_status_t *ps);
+usbd_status	usbd_setup_pipe(usbd_device_handle dev,
 				     usbd_interface_handle iface,
 				     struct usbd_endpoint *, int,
-				     usbd_pipe_handle *pipe));
-usbd_status	usbd_new_device __P((device_ptr_t parent, 
+				     usbd_pipe_handle *pipe);
+usbd_status	usbd_new_device(device_ptr_t parent, 
 				     usbd_bus_handle bus, int depth,
 				     int lowspeed, int port, 
-				     struct usbd_port *));
-void		usbd_remove_device __P((usbd_device_handle,
-					struct usbd_port *));
-int		usbd_printBCD __P((char *cp, int bcd));
-usbd_status	usbd_fill_iface_data __P((usbd_device_handle dev, 
-					  int i, int a));
-void		usb_free_device __P((usbd_device_handle));
-
-usbd_status	usb_insert_transfer __P((usbd_xfer_handle xfer));
-void		usb_transfer_complete __P((usbd_xfer_handle xfer));
-void		usb_disconnect_port __P((struct usbd_port *up, device_ptr_t));
+				     struct usbd_port *);
+void		usbd_remove_device(usbd_device_handle,
+					struct usbd_port *);
+int		usbd_printBCD(char *cp, int bcd);
+usbd_status	usbd_fill_iface_data(usbd_device_handle dev, 
+					  int i, int a);
+void		usb_free_device(usbd_device_handle);
+
+usbd_status	usb_insert_transfer(usbd_xfer_handle xfer);
+void		usb_transfer_complete(usbd_xfer_handle xfer);
+void		usb_disconnect_port(struct usbd_port *up, device_ptr_t);
 
 /* Routines from usb.c */
-int		usb_bus_count __P((void));
-void		usb_needs_explore __P((usbd_bus_handle));
+int		usb_bus_count(void);
+void		usb_needs_explore(usbd_bus_handle);
 
 #ifdef DIAGNOSTIC
 #define SPLUSBCHECK \