[usb] Allow for wildcard USB class IDs

Make the class ID a property of the USB driver (rather than a property
of the USB device ID), and allow USB drivers to specify a wildcard ID
for any of the three component IDs (class, subclass, or protocol).

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

src/drivers/bus/usb.c

 	unsigned int i;
 
 	/* Fill in vendor and product ID */
+	memset ( desc, 0, sizeof ( *desc ) );
 	desc->vendor = le16_to_cpu ( usb->device.vendor );
 	desc->product = le16_to_cpu ( usb->device.product );
 
 	interfaces[0] = first;
 
 	/* Look for a CDC union descriptor, if applicable */
-	if ( ( desc->class.class == USB_CLASS_CDC ) &&
+	if ( ( desc->class.class.class == USB_CLASS_CDC ) &&
 	     ( cdc_union = cdc_union_descriptor ( config, interface ) ) ) {
 
 		/* Determine interface count */
 	for_each_table_entry ( driver, USB_DRIVERS ) {
 		for ( i = 0 ; i < driver->id_count ; i++ ) {
 
-			/* Check for a matching ID */
+			/* Ignore non-matching driver class */
+			if ( ( driver->class.class.scalar ^ desc->class.scalar )
+			     & driver->class.mask.scalar )
+				continue;
+
+			/* Look for a matching ID */
 			*id = &driver->ids[i];
 			if ( ( ( (*id)->vendor == desc->vendor ) ||
 			       ( (*id)->vendor == USB_ANY_ID ) ) &&
 			     ( ( (*id)->product == desc->product ) ||
-			       ( (*id)->product == USB_ANY_ID ) ) &&
-			     ( (*id)->class.class == desc->class.class ) &&
-			     ( (*id)->class.subclass == desc->class.subclass )&&
-			     ( (*id)->class.protocol == desc->class.protocol ) )
+			       ( (*id)->product == USB_ANY_ID ) ) )
 				return driver;
 		}
 	}
 	if ( ! driver ) {
 		DBGC ( usb, "USB %s %04x:%04x class %d:%d:%d has no driver\n",
 		       func->name, func->desc.vendor, func->desc.product,
-		       func->desc.class.class, func->desc.class.subclass,
-		       func->desc.class.protocol );
+		       func->desc.class.class.class,
+		       func->desc.class.class.subclass,
+		       func->desc.class.class.protocol );
 		return -ENOENT;
 	}
 
 			goto err_probe;
 		DBGC ( usb, "USB %s %04x:%04x class %d:%d:%d interfaces ",
 		       func->name, func->desc.vendor, func->desc.product,
-		       func->desc.class.class, func->desc.class.subclass,
-		       func->desc.class.protocol );
+		       func->desc.class.class.class,
+		       func->desc.class.class.subclass,
+		       func->desc.class.class.protocol );
 		for ( i = 0 ; i < func->desc.count ; i++ )
 			DBGC ( usb, "%s%d", ( i ? "," : "" ),
 			       func->interface[i] );

src/drivers/net/dm96xx.c

 struct usb_driver dm96xx_driver __usb_driver = {
 	.ids = dm96xx_ids,
 	.id_count = ( sizeof ( dm96xx_ids ) / sizeof ( dm96xx_ids[0] ) ),
+	.class = USB_CLASS_ID ( USB_ANY_ID, USB_ANY_ID, USB_ANY_ID ),
 	.score = USB_SCORE_NORMAL,
 	.probe = dm96xx_probe,
 	.remove = dm96xx_remove,

src/drivers/net/ecm.c

 		.name = "cdc-ecm",
 		.vendor = USB_ANY_ID,
 		.product = USB_ANY_ID,
-		.class = {
-			.class = USB_CLASS_CDC,
-			.subclass = USB_SUBCLASS_CDC_ECM,
-			.protocol = 0,
-		},
 	},
 };
 
 struct usb_driver ecm_driver __usb_driver = {
 	.ids = ecm_ids,
 	.id_count = ( sizeof ( ecm_ids ) / sizeof ( ecm_ids[0] ) ),
+	.class = USB_CLASS_ID ( USB_CLASS_CDC, USB_SUBCLASS_CDC_ECM, 0 ),
 	.score = USB_SCORE_NORMAL,
 	.probe = ecm_probe,
 	.remove = ecm_remove,

src/drivers/net/ncm.c

 		.name = "cdc-ncm",
 		.vendor = USB_ANY_ID,
 		.product = USB_ANY_ID,
-		.class = {
-			.class = USB_CLASS_CDC,
-			.subclass = USB_SUBCLASS_CDC_NCM,
-			.protocol = 0,
-		},
 	},
 };
 
 struct usb_driver ncm_driver __usb_driver = {
 	.ids = ncm_ids,
 	.id_count = ( sizeof ( ncm_ids ) / sizeof ( ncm_ids[0] ) ),
+	.class = USB_CLASS_ID ( USB_CLASS_CDC, USB_SUBCLASS_CDC_NCM, 0 ),
 	.score = USB_SCORE_NORMAL,
 	.probe = ncm_probe,
 	.remove = ncm_remove,

src/drivers/net/smsc75xx.c

 		.name = "smsc7500",
 		.vendor = 0x0424,
 		.product = 0x7500,
-		.class = { 0xff, 0x00, 0xff },
 	},
 	{
 		.name = "smsc7505",
 		.vendor = 0x0424,
 		.product = 0x7505,
-		.class = { 0xff, 0x00, 0xff },
 	},
 };
 
 struct usb_driver smsc75xx_driver __usb_driver = {
 	.ids = smsc75xx_ids,
 	.id_count = ( sizeof ( smsc75xx_ids ) / sizeof ( smsc75xx_ids[0] ) ),
+	.class = USB_CLASS_ID ( 0xff, 0x00, 0xff ),
 	.score = USB_SCORE_NORMAL,
 	.probe = smsc75xx_probe,
 	.remove = smsc75xx_remove,

src/drivers/usb/usbhub.c

 /** USB hub device IDs */
 static struct usb_device_id hub_ids[] = {
 	{
-		.name = "hub-1",
+		.name = "hub",
 		.vendor = USB_ANY_ID,
 		.product = USB_ANY_ID,
-		.class = {
-			.class = USB_CLASS_HUB,
-			.subclass = 0,
-			.protocol = 0,
-		},
-	},
-	{
-		.name = "hub-2",
-		.vendor = USB_ANY_ID,
-		.product = USB_ANY_ID,
-		.class = {
-			.class = USB_CLASS_HUB,
-			.subclass = 0,
-			.protocol = 1,
-		},
 	},
 };
 
 struct usb_driver usb_hub_driver __usb_driver = {
 	.ids = hub_ids,
 	.id_count = ( sizeof ( hub_ids ) / sizeof ( hub_ids[0] ) ),
+	.class = USB_CLASS_ID ( USB_CLASS_HUB, 0, USB_ANY_ID ),
 	.score = USB_SCORE_NORMAL,
 	.probe = hub_probe,
 	.remove = hub_remove,

src/drivers/usb/usbio.c

 		       "%s\n", efi_handle_name ( handle ), strerror ( rc ) );
 		goto err_get_device_descriptor;
 	}
+	memset ( &desc, 0, sizeof ( desc ) );
 	desc.vendor = device.IdVendor;
 	desc.product = device.IdProduct;
 
 		       "%s\n", efi_handle_name ( handle ), strerror ( rc ) );
 		goto err_get_interface_descriptor;
 	}
-	desc.class.class = interface.InterfaceClass;
-	desc.class.subclass = interface.InterfaceSubClass;
-	desc.class.protocol = interface.InterfaceProtocol;
+	desc.class.class.class = interface.InterfaceClass;
+	desc.class.class.subclass = interface.InterfaceSubClass;
+	desc.class.class.protocol = interface.InterfaceProtocol;
 
 	/* Look for a driver for this interface */
 	driver = usb_find_driver ( &desc, &id );

src/drivers/usb/usbkbd.c

 		.name = "kbd",
 		.vendor = USB_ANY_ID,
 		.product = USB_ANY_ID,
-		.class = {
-			.class = USB_CLASS_HID,
-			.subclass = USB_SUBCLASS_HID_BOOT,
-			.protocol = USBKBD_PROTOCOL,
-		},
 	},
 };
 
 struct usb_driver usbkbd_driver __usb_driver = {
 	.ids = usbkbd_ids,
 	.id_count = ( sizeof ( usbkbd_ids ) / sizeof ( usbkbd_ids[0] ) ),
+	.class = USB_CLASS_ID ( USB_CLASS_HID, USB_SUBCLASS_HID_BOOT,
+				USBKBD_PROTOCOL ),
 	.score = USB_SCORE_NORMAL,
 	.probe = usbkbd_probe,
 	.remove = usbkbd_remove,

src/include/ipxe/usb.h

 extern int usb_refill ( struct usb_endpoint *ep );
 extern void usb_flush ( struct usb_endpoint *ep );
 
+/** A USB class descriptor */
+union usb_class_descriptor {
+	/** Class */
+	struct usb_class class;
+	/** Scalar value */
+	uint32_t scalar;
+};
+
 /**
  * A USB function descriptor
  *
 	/** Product ID */
 	uint16_t product;
 	/** Class */
-	struct usb_class class;
+	union usb_class_descriptor class;
 	/** Number of interfaces */
 	unsigned int count;
 };
 	uint16_t vendor;
 	/** Product ID */
 	uint16_t product;
-	/** Class */
-	struct usb_class class;
 };
 
 /** Match-anything ID */
 #define USB_ANY_ID 0xffff
 
+/** A USB class ID */
+struct usb_class_id {
+	/** Class */
+	union usb_class_descriptor class;
+	/** Class mask */
+	union usb_class_descriptor mask;
+};
+
+/** Construct USB class ID
+ *
+ * @v base		Base class code (or USB_ANY_ID)
+ * @v subclass		Subclass code (or USB_ANY_ID)
+ * @v protocol		Protocol code (or USB_ANY_ID)
+ */
+#define USB_CLASS_ID( base, subclass, protocol ) {			\
+	.class = {							\
+		.class = {						\
+			( (base) & 0xff ),				\
+			( (subclass) & 0xff ),				\
+			( (protocol) & 0xff ),				\
+		},							\
+	},								\
+	.mask = {							\
+		.class = {						\
+			( ( (base) == USB_ANY_ID ) ? 0x00 : 0xff ),	\
+			( ( (subclass) == USB_ANY_ID ) ? 0x00 : 0xff ),	\
+			( ( (protocol) == USB_ANY_ID ) ? 0x00 : 0xff ),	\
+		},							\
+		},							\
+	}
+
 /** A USB driver */
 struct usb_driver {
 	/** USB ID table */
 	struct usb_device_id *ids;
 	/** Number of entries in ID table */
 	unsigned int id_count;
+	/** Class ID */
+	struct usb_class_id class;
 	/** Driver score
 	 *
 	 * This is used to determine the preferred configuration for a