[usb] Allow USB endpoints to specify a reserved header length for refills

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/drivers/bus/usb.c

  */
 int usb_prefill ( struct usb_endpoint *ep ) {
 	struct io_buffer *iobuf;
+	size_t reserve = ep->reserve;
 	size_t len = ( ep->len ? ep->len : ep->mtu );
 	unsigned int fill;
 	int rc;
 	for ( fill = 0 ; fill < ep->max ; fill++ ) {
 
 		/* Allocate I/O buffer */
-		iobuf = alloc_iob ( len );
+		iobuf = alloc_iob ( reserve + len );
 		if ( ! iobuf ) {
 			rc = -ENOMEM;
 			goto err_alloc;
 		}
+		iob_reserve ( iobuf, reserve );
 
 		/* Add to recycled buffer list */
 		list_add_tail ( &iobuf->list, &ep->recycled );
  */
 int usb_refill ( struct usb_endpoint *ep ) {
 	struct io_buffer *iobuf;
+	size_t reserve = ep->reserve;
 	size_t len = ( ep->len ? ep->len : ep->mtu );
 	int rc;
 
 		/* Get or allocate buffer */
 		if ( list_empty ( &ep->recycled ) ) {
 			/* Recycled buffer list is empty; allocate new buffer */
-			iobuf = alloc_iob ( len );
+			iobuf = alloc_iob ( reserve + len );
 			if ( ! iobuf )
 				return -ENOMEM;
+			iob_reserve ( iobuf, reserve );
 		} else {
 			/* Get buffer from recycled buffer list */
 			iobuf = list_first_entry ( &ep->recycled,

src/drivers/net/acm.c

 	acm->rndis = rndis;
 	usbnet_init ( &acm->usbnet, func, &acm_intr_operations,
 		      &acm_in_operations, &acm_out_operations );
-	usb_refill_init ( &acm->usbnet.intr, 0, ACM_INTR_MAX_FILL );
-	usb_refill_init ( &acm->usbnet.in, ACM_IN_MTU, ACM_IN_MAX_FILL );
+	usb_refill_init ( &acm->usbnet.intr, 0, 0, ACM_INTR_MAX_FILL );
+	usb_refill_init ( &acm->usbnet.in, 0, ACM_IN_MTU, ACM_IN_MAX_FILL );
 
 	/* Describe USB network device */
 	if ( ( rc = usbnet_describe ( &acm->usbnet, config ) ) != 0 ) {

src/drivers/net/dm96xx.c

 	dm96xx->netdev = netdev;
 	usbnet_init ( &dm96xx->usbnet, func, &dm96xx_intr_operations,
 		      &dm96xx_in_operations, &dm96xx_out_operations );
-	usb_refill_init ( &dm96xx->usbnet.intr, 0, DM96XX_INTR_MAX_FILL );
-	usb_refill_init ( &dm96xx->usbnet.in, DM96XX_IN_MTU,
+	usb_refill_init ( &dm96xx->usbnet.intr, 0, 0, DM96XX_INTR_MAX_FILL );
+	usb_refill_init ( &dm96xx->usbnet.in, 0, DM96XX_IN_MTU,
 			  DM96XX_IN_MAX_FILL );
 	DBGC ( dm96xx, "DM96XX %p on %s\n", dm96xx, func->name );
 

src/drivers/net/ecm.c

 	ecm->netdev = netdev;
 	usbnet_init ( &ecm->usbnet, func, &ecm_intr_operations,
 		      &ecm_in_operations, &ecm_out_operations );
-	usb_refill_init ( &ecm->usbnet.intr, 0, ECM_INTR_MAX_FILL );
-	usb_refill_init ( &ecm->usbnet.in, ECM_IN_MTU, ECM_IN_MAX_FILL );
+	usb_refill_init ( &ecm->usbnet.intr, 0, 0, ECM_INTR_MAX_FILL );
+	usb_refill_init ( &ecm->usbnet.in, 0, ECM_IN_MTU, ECM_IN_MAX_FILL );
 	DBGC ( ecm, "ECM %p on %s\n", ecm, func->name );
 
 	/* Describe USB network device */

src/drivers/net/ncm.c

 			count = NCM_IN_MIN_COUNT;
 		if ( ( count * mtu ) > NCM_IN_MAX_SIZE )
 			continue;
-		usb_refill_init ( &ncm->usbnet.in, mtu, count );
+		usb_refill_init ( &ncm->usbnet.in, 0, mtu, count );
 		if ( ( rc = usb_prefill ( &ncm->usbnet.in ) ) != 0 ) {
 			DBGC ( ncm, "NCM %p could not prefill %dx %zd-byte "
 			       "buffers for bulk IN\n", ncm, count, mtu );
 	ncm->netdev = netdev;
 	usbnet_init ( &ncm->usbnet, func, &ncm_intr_operations,
 		      &ncm_in_operations, &ncm_out_operations );
-	usb_refill_init ( &ncm->usbnet.intr, 0, NCM_INTR_COUNT );
+	usb_refill_init ( &ncm->usbnet.intr, 0, 0, NCM_INTR_COUNT );
 	DBGC ( ncm, "NCM %p on %s\n", ncm, func->name );
 
 	/* Describe USB network device */

src/drivers/net/smsc75xx.c

 	smsc75xx->netdev = netdev;
 	usbnet_init ( &smsc75xx->usbnet, func, &smsc75xx_intr_operations,
 		      &smsc75xx_in_operations, &smsc75xx_out_operations );
-	usb_refill_init ( &smsc75xx->usbnet.intr, 0, SMSC75XX_INTR_MAX_FILL );
-	usb_refill_init ( &smsc75xx->usbnet.in, SMSC75XX_IN_MTU,
+	usb_refill_init ( &smsc75xx->usbnet.intr, 0, 0,
+			  SMSC75XX_INTR_MAX_FILL );
+	usb_refill_init ( &smsc75xx->usbnet.in, 0, SMSC75XX_IN_MTU,
 			  SMSC75XX_IN_MAX_FILL );
 	mii_init ( &smsc75xx->mii, &smsc75xx_mii_operations );
 	DBGC ( smsc75xx, "SMSC75XX %p on %s\n", smsc75xx, func->name );

src/drivers/net/smsc95xx.c

 	smsc95xx->netdev = netdev;
 	usbnet_init ( &smsc95xx->usbnet, func, &smsc95xx_intr_operations,
 		      &smsc95xx_in_operations, &smsc95xx_out_operations );
-	usb_refill_init ( &smsc95xx->usbnet.intr, 0, SMSC95XX_INTR_MAX_FILL );
-	usb_refill_init ( &smsc95xx->usbnet.in, SMSC95XX_IN_MTU,
+	usb_refill_init ( &smsc95xx->usbnet.intr, 0, 0,
+			  SMSC95XX_INTR_MAX_FILL );
+	usb_refill_init ( &smsc95xx->usbnet.in, 0, SMSC95XX_IN_MTU,
 			  SMSC95XX_IN_MAX_FILL );
 	mii_init ( &smsc95xx->mii, &smsc95xx_mii_operations );
 	DBGC ( smsc95xx, "SMSC95XX %p on %s\n", smsc95xx, func->name );

src/drivers/usb/usbhub.c

 		( enhanced ? USB_HUB_FEATURES_ENHANCED : USB_HUB_FEATURES );
 	hubdev->flags = func->id->driver_data;
 	usb_endpoint_init ( &hubdev->intr, usb, &usb_hub_intr_operations );
-	usb_refill_init ( &hubdev->intr, 0, USB_HUB_INTR_FILL );
+	usb_refill_init ( &hubdev->intr, 0, 0, USB_HUB_INTR_FILL );
 	process_init_stopped ( &hubdev->refill, &hub_refill_desc, NULL );
 
 	/* Locate hub interface descriptor */

src/drivers/usb/usbkbd.c

 	kbd->name = func->name;
 	kbd->bus = usb->port->hub->bus;
 	usbhid_init ( &kbd->hid, func, &usbkbd_operations, NULL );
-	usb_refill_init ( &kbd->hid.in, sizeof ( kbd->report ),
+	usb_refill_init ( &kbd->hid.in, 0, sizeof ( kbd->report ),
 			  USBKBD_INTR_MAX_FILL );
 
 	/* Describe USB human interface device */

src/include/ipxe/usb.h

 
 	/** Recycled I/O buffer list */
 	struct list_head recycled;
-	/** Refill buffer length */
+	/** Refill buffer reserved header length */
+	size_t reserve;
+	/** Refill buffer payload length */
 	size_t len;
 	/** Maximum fill level */
 	unsigned int max;
  * Initialise USB endpoint refill
  *
  * @v ep		USB endpoint
- * @v len		Refill buffer length (or zero to use endpoint's MTU)
+ * @v reserve		Refill buffer reserved header length
+ * @v len		Refill buffer payload length (zero for endpoint's MTU)
  * @v max		Maximum fill level
  */
 static inline __attribute__ (( always_inline )) void
-usb_refill_init ( struct usb_endpoint *ep, size_t len, unsigned int max ) {
+usb_refill_init ( struct usb_endpoint *ep, size_t reserve, size_t len,
+		  unsigned int max ) {
 
 	INIT_LIST_HEAD ( &ep->recycled );
+	ep->reserve = reserve;
 	ep->len = len;
 	ep->max = max;
 }

src/interface/efi/efi_usb.c

 	usbep->context = context;
 
 	/* Prefill endpoint */
-	usb_refill_init ( &usbep->ep, len, EFI_USB_ASYNC_FILL );
+	usb_refill_init ( &usbep->ep, 0, len, EFI_USB_ASYNC_FILL );
 	if ( ( rc = usb_prefill ( &usbep->ep ) ) != 0 ) {
 		DBGC ( usbdev, "USBDEV %s %s could not prefill: %s\n",
 		       usbintf->name, usb_endpoint_name ( &usbep->ep ),