s/usb2_/usb_|usbd_/ on all function names for the USB stack.

1 files changed, 52 insertions, 52 deletions

diff --git a/sys/dev/usb/usb_handle_request.c b/sys/dev/usb/usb_handle_request.c
index 0f2f8c0..e6f89f6 100644
--- a/sys/dev/usb/usb_handle_request.c
+++ b/sys/dev/usb/usb_handle_request.c
@@ -28,7 +28,7 @@
 #include <dev/usb/usb_error.h>
 #include <dev/usb/usb.h>
 
-#define	USB_DEBUG_VAR usb2_debug
+#define	USB_DEBUG_VAR usb_debug
 
 #include <dev/usb/usb_core.h>
 #include <dev/usb/usb_process.h>
@@ -44,24 +44,24 @@
 
 /* function prototypes */
 
-static uint8_t usb2_handle_get_stall(struct usb_device *, uint8_t);
-static usb_error_t	 usb2_handle_remote_wakeup(struct usb_xfer *, uint8_t);
-static usb_error_t	 usb2_handle_request(struct usb_xfer *);
-static usb_error_t	 usb2_handle_set_config(struct usb_xfer *, uint8_t);
-static usb_error_t	 usb2_handle_set_stall(struct usb_xfer *, uint8_t,
+static uint8_t usb_handle_get_stall(struct usb_device *, uint8_t);
+static usb_error_t	 usb_handle_remote_wakeup(struct usb_xfer *, uint8_t);
+static usb_error_t	 usb_handle_request(struct usb_xfer *);
+static usb_error_t	 usb_handle_set_config(struct usb_xfer *, uint8_t);
+static usb_error_t	 usb_handle_set_stall(struct usb_xfer *, uint8_t,
 			    uint8_t);
-static usb_error_t	 usb2_handle_iface_request(struct usb_xfer *, void **,
+static usb_error_t	 usb_handle_iface_request(struct usb_xfer *, void **,
 			    uint16_t *, struct usb_device_request, uint16_t,
 			    uint8_t);
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_request_callback
+ *	usb_handle_request_callback
  *
  * This function is the USB callback for generic USB Device control
  * transfers.
  *------------------------------------------------------------------------*/
 void
-usb2_handle_request_callback(struct usb_xfer *xfer)
+usb_handle_request_callback(struct usb_xfer *xfer)
 {
 	usb_error_t err;
 
@@ -72,25 +72,25 @@ usb2_handle_request_callback(struct usb_xfer *xfer)
 	case USB_ST_TRANSFERRED:
 
 		/* handle the request */
-		err = usb2_handle_request(xfer);
+		err = usb_handle_request(xfer);
 
 		if (err) {
 
 			if (err == USB_ERR_BAD_CONTEXT) {
 				/* we need to re-setup the control transfer */
-				usb2_needs_explore(xfer->xroot->bus, 0);
+				usb_needs_explore(xfer->xroot->bus, 0);
 				break;
 			}
 			goto tr_restart;
 		}
-		usb2_start_hardware(xfer);
+		usbd_transfer_submit(xfer);
 		break;
 
 	default:
 		/* check if a control transfer is active */
 		if (xfer->flags_int.control_rem != 0xFFFF) {
 			/* handle the request */
-			err = usb2_handle_request(xfer);
+			err = usb_handle_request(xfer);
 		}
 		if (xfer->error != USB_ERR_CANCELLED) {
 			/* should not happen - try stalling */
@@ -110,18 +110,18 @@ tr_restart:
 	xfer->flags.manual_status = 1;
 	xfer->flags.force_short_xfer = 0;
 	xfer->flags.stall_pipe = 1;	/* cancel previous transfer, if any */
-	usb2_start_hardware(xfer);
+	usbd_transfer_submit(xfer);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_set_config
+ *	usb_handle_set_config
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
+usb_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
 {
 	struct usb_device *udev = xfer->xroot->udev;
 	usb_error_t err = 0;
@@ -144,12 +144,12 @@ usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)
 		conf_no--;
 	}
 
-	if (usb2_set_config_index(udev, conf_no)) {
+	if (usbd_set_config_index(udev, conf_no)) {
 		DPRINTF("set config %d failed\n", conf_no);
 		err = USB_ERR_STALLED;
 		goto done;
 	}
-	if (usb2_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) {
+	if (usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) {
 		DPRINTF("probe and attach failed\n");
 		err = USB_ERR_STALLED;
 		goto done;
@@ -162,14 +162,14 @@ done:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_iface_request
+ *	usb_handle_iface_request
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_iface_request(struct usb_xfer *xfer,
+usb_handle_iface_request(struct usb_xfer *xfer,
     void **ppdata, uint16_t *plen,
     struct usb_device_request req, uint16_t off, uint8_t state)
 {
@@ -196,7 +196,7 @@ usb2_handle_iface_request(struct usb_xfer *xfer,
 	error = ENXIO;
 
 tr_repeat:
-	iface = usb2_get_iface(udev, iface_index);
+	iface = usbd_get_iface(udev, iface_index);
 	if ((iface == NULL) ||
 	    (iface->idesc == NULL)) {
 		/* end of interfaces non-existing interface */
@@ -215,7 +215,7 @@ tr_repeat:
 		    &req, ppdata, plen,
 		    off, state);
 	}
-	iface_parent = usb2_get_iface(udev, iface->parent_iface_index);
+	iface_parent = usbd_get_iface(udev, iface->parent_iface_index);
 
 	if ((iface_parent == NULL) ||
 	    (iface_parent->idesc == NULL)) {
@@ -265,11 +265,11 @@ tr_repeat:
 			 */
 			if ((iface_parent != NULL) ||
 			    (iface->alt_index == req.wValue[0])) {
-				error = usb2_reset_iface_endpoints(udev,
+				error = usb_reset_iface_endpoints(udev,
 				    iface_index);
 				if (error) {
 					DPRINTF("alt setting failed %s\n",
-					    usb2_errstr(error));
+					    usbd_errstr(error));
 					goto tr_stalled;
 				}
 				break;
@@ -278,14 +278,14 @@ tr_repeat:
 			 * Doing the alternate setting will detach the
 			 * interface aswell:
 			 */
-			error = usb2_set_alt_interface_index(udev,
+			error = usbd_set_alt_interface_index(udev,
 			    iface_index, req.wValue[0]);
 			if (error) {
 				DPRINTF("alt setting failed %s\n",
-				    usb2_errstr(error));
+				    usbd_errstr(error));
 				goto tr_stalled;
 			}
-			error = usb2_probe_and_attach(udev,
+			error = usb_probe_and_attach(udev,
 			    iface_index);
 			if (error) {
 				DPRINTF("alt setting probe failed\n");
@@ -325,39 +325,39 @@ tr_stalled:
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_stall
+ *	usb_handle_stall
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall)
+usb_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall)
 {
 	struct usb_device *udev = xfer->xroot->udev;
 	usb_error_t err;
 
 	USB_XFER_UNLOCK(xfer);
-	err = usb2_set_endpoint_stall(udev,
-	    usb2_get_ep_by_addr(udev, ep), do_stall);
+	err = usbd_set_endpoint_stall(udev,
+	    usbd_get_ep_by_addr(udev, ep), do_stall);
 	USB_XFER_LOCK(xfer);
 	return (err);
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_get_stall
+ *	usb_handle_get_stall
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static uint8_t
-usb2_handle_get_stall(struct usb_device *udev, uint8_t ea_val)
+usb_handle_get_stall(struct usb_device *udev, uint8_t ea_val)
 {
 	struct usb_endpoint *ep;
 	uint8_t halted;
 
-	ep = usb2_get_ep_by_addr(udev, ea_val);
+	ep = usbd_get_ep_by_addr(udev, ea_val);
 	if (ep == NULL) {
 		/* nothing to do */
 		return (0);
@@ -370,14 +370,14 @@ usb2_handle_get_stall(struct usb_device *udev, uint8_t ea_val)
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_remote_wakeup
+ *	usb_handle_remote_wakeup
  *
  * Returns:
  *    0: Success
  * Else: Failure
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
+usb_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
 {
 	struct usb_device *udev;
 	struct usb_bus *bus;
@@ -396,12 +396,12 @@ usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
 	USB_BUS_UNLOCK(bus);
 
 	/* In case we are out of sync, update the power state. */
-	usb2_bus_power_update(udev->bus);
+	usb_bus_power_update(udev->bus);
 	return (0);			/* success */
 }
 
 /*------------------------------------------------------------------------*
- *	usb2_handle_request
+ *	usb_handle_request
  *
  * Internal state sequence:
  *
@@ -412,7 +412,7 @@ usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)
  * Else: Stall current transfer, if any
  *------------------------------------------------------------------------*/
 static usb_error_t
-usb2_handle_request(struct usb_xfer *xfer)
+usb_handle_request(struct usb_xfer *xfer)
 {
 	struct usb_device_request req;
 	struct usb_device *udev;
@@ -460,12 +460,12 @@ usb2_handle_request(struct usb_xfer *xfer)
 
 	xfer->frlengths[0] = 0;
 
-	usb2_set_frame_offset(xfer, 0, 0);
-	usb2_set_frame_offset(xfer, sizeof(req), 1);
+	usbd_set_frame_offset(xfer, 0, 0);
+	usbd_set_frame_offset(xfer, sizeof(req), 1);
 
 	/* get the current request, if any */
 
-	usb2_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
+	usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
 
 	if (xfer->flags_int.control_rem == 0xFFFF) {
 		/* first time - not initialised */
@@ -572,7 +572,7 @@ usb2_handle_request(struct usb_xfer *xfer)
 		break;
 	default:
 		/* we use "USB_ADD_BYTES" to de-const the src_zcopy */
-		err = usb2_handle_iface_request(xfer,
+		err = usb_handle_iface_request(xfer,
 		    USB_ADD_BYTES(&src_zcopy, 0),
 		    &max_len, req, off, state);
 		if (err == 0) {
@@ -595,7 +595,7 @@ usb2_handle_request(struct usb_xfer *xfer)
 	goto tr_valid;
 
 tr_handle_get_descriptor:
-	err = (usb2_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len);
+	err = (usb_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len);
 	if (err)
 		goto tr_stalled;
 	if (src_zcopy == NULL)
@@ -643,7 +643,7 @@ tr_handle_set_address:
 
 tr_handle_set_config:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_set_config(xfer, req.wValue[0])) {
+		if (usb_handle_set_config(xfer, req.wValue[0])) {
 			goto tr_stalled;
 		}
 	}
@@ -651,7 +651,7 @@ tr_handle_set_config:
 
 tr_handle_clear_halt:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_set_stall(xfer, req.wIndex[0], 0)) {
+		if (usb_handle_set_stall(xfer, req.wIndex[0], 0)) {
 			goto tr_stalled;
 		}
 	}
@@ -659,7 +659,7 @@ tr_handle_clear_halt:
 
 tr_handle_clear_wakeup:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_remote_wakeup(xfer, 0)) {
+		if (usb_handle_remote_wakeup(xfer, 0)) {
 			goto tr_stalled;
 		}
 	}
@@ -667,7 +667,7 @@ tr_handle_clear_wakeup:
 
 tr_handle_set_halt:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_set_stall(xfer, req.wIndex[0], 1)) {
+		if (usb_handle_set_stall(xfer, req.wIndex[0], 1)) {
 			goto tr_stalled;
 		}
 	}
@@ -675,7 +675,7 @@ tr_handle_set_halt:
 
 tr_handle_set_wakeup:
 	if (state == USB_HR_NOT_COMPLETE) {
-		if (usb2_handle_remote_wakeup(xfer, 1)) {
+		if (usb_handle_remote_wakeup(xfer, 1)) {
 			goto tr_stalled;
 		}
 	}
@@ -684,7 +684,7 @@ tr_handle_set_wakeup:
 tr_handle_get_ep_status:
 	if (state == USB_HR_NOT_COMPLETE) {
 		temp.wStatus[0] =
-		    usb2_handle_get_stall(udev, req.wIndex[0]);
+		    usb_handle_get_stall(udev, req.wIndex[0]);
 		temp.wStatus[1] = 0;
 		src_mcopy = temp.wStatus;
 		max_len = sizeof(temp.wStatus);
@@ -732,10 +732,10 @@ tr_valid:
 	if (max_len > 0) {
 		if (src_mcopy) {
 			src_mcopy = USB_ADD_BYTES(src_mcopy, off);
-			usb2_copy_in(xfer->frbuffers + 1, 0,
+			usbd_copy_in(xfer->frbuffers + 1, 0,
 			    src_mcopy, max_len);
 		} else {
-			usb2_set_frame_data(xfer,
+			usbd_set_frame_data(xfer,
 			    USB_ADD_BYTES(src_zcopy, off), 1);
 		}
 		xfer->frlengths[1] = max_len;