drivers/usb/common/debug.c - third_party/kernel - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Common USB debugging functions
  *
  * Copyright (C) 2010-2011 Texas Instruments Incorporated - https://www.ti.com
  *
  * Authors: Felipe Balbi <balbi@ti.com>,
  *	    Sebastian Andrzej Siewior <bigeasy@linutronix.de>
  */

 #include <linux/kernel.h>
 #include <linux/usb/ch9.h>

 static void usb_decode_get_status(__u8 bRequestType, __u16 wIndex,
 				  __u16 wLength, char *str, size_t size)
 {
 	switch (bRequestType & USB_RECIP_MASK) {
 	case USB_RECIP_DEVICE:
 		snprintf(str, size, "Get Device Status(Length = %d)", wLength);
 		break;
 	case USB_RECIP_INTERFACE:
 		snprintf(str, size,
 			 "Get Interface Status(Intf = %d, Length = %d)",
 			 wIndex, wLength);
 		break;
 	case USB_RECIP_ENDPOINT:
 		snprintf(str, size, "Get Endpoint Status(ep%d%s)",
 			 wIndex & ~USB_DIR_IN,
 			 wIndex & USB_DIR_IN ? "in" : "out");
 		break;
 	}
 }

 static const char *usb_decode_device_feature(u16 wValue)
 {
 	switch (wValue) {
 	case USB_DEVICE_SELF_POWERED:
 		return "Self Powered";
 	case USB_DEVICE_REMOTE_WAKEUP:
 		return "Remote Wakeup";
 	case USB_DEVICE_TEST_MODE:
 		return "Test Mode";
 	case USB_DEVICE_U1_ENABLE:
 		return "U1 Enable";
 	case USB_DEVICE_U2_ENABLE:
 		return "U2 Enable";
 	case USB_DEVICE_LTM_ENABLE:
 		return "LTM Enable";
 	default:
 		return "UNKNOWN";
 	}
 }

 static const char *usb_decode_test_mode(u16 wIndex)
 {
 	switch (wIndex) {
 	case USB_TEST_J:
 		return ": TEST_J";
 	case USB_TEST_K:
 		return ": TEST_K";
 	case USB_TEST_SE0_NAK:
 		return ": TEST_SE0_NAK";
 	case USB_TEST_PACKET:
 		return ": TEST_PACKET";
 	case USB_TEST_FORCE_ENABLE:
 		return ": TEST_FORCE_EN";
 	default:
 		return ": UNKNOWN";
 	}
 }

 static void usb_decode_set_clear_feature(__u8 bRequestType,
 					 __u8 bRequest, __u16 wValue,
 					 __u16 wIndex, char *str, size_t size)
 {
 	switch (bRequestType & USB_RECIP_MASK) {
 	case USB_RECIP_DEVICE:
 		snprintf(str, size, "%s Device Feature(%s%s)",
 			 bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
 			 usb_decode_device_feature(wValue),
 			 wValue == USB_DEVICE_TEST_MODE ?
 			 usb_decode_test_mode(wIndex) : "");
 		break;
 	case USB_RECIP_INTERFACE:
 		snprintf(str, size, "%s Interface Feature(%s)",
 			 bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
 			 wValue == USB_INTRF_FUNC_SUSPEND ?
 			 "Function Suspend" : "UNKNOWN");
 		break;
 	case USB_RECIP_ENDPOINT:
 		snprintf(str, size, "%s Endpoint Feature(%s ep%d%s)",
 			 bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
 			 wValue == USB_ENDPOINT_HALT ? "Halt" : "UNKNOWN",
 			 wIndex & ~USB_DIR_IN,
 			 wIndex & USB_DIR_IN ? "in" : "out");
 		break;
 	}
 }

 static void usb_decode_set_address(__u16 wValue, char *str, size_t size)
 {
 	snprintf(str, size, "Set Address(Addr = %02x)", wValue);
 }

 static void usb_decode_get_set_descriptor(__u8 bRequestType, __u8 bRequest,
 					  __u16 wValue, __u16 wIndex,
 					  __u16 wLength, char *str, size_t size)
 {
 	char *s;

 	switch (wValue >> 8) {
 	case USB_DT_DEVICE:
 		s = "Device";
 		break;
 	case USB_DT_CONFIG:
 		s = "Configuration";
 		break;
 	case USB_DT_STRING:
 		s = "String";
 		break;
 	case USB_DT_INTERFACE:
 		s = "Interface";
 		break;
 	case USB_DT_ENDPOINT:
 		s = "Endpoint";
 		break;
 	case USB_DT_DEVICE_QUALIFIER:
 		s = "Device Qualifier";
 		break;
 	case USB_DT_OTHER_SPEED_CONFIG:
 		s = "Other Speed Config";
 		break;
 	case USB_DT_INTERFACE_POWER:
 		s = "Interface Power";
 		break;
 	case USB_DT_OTG:
 		s = "OTG";
 		break;
 	case USB_DT_DEBUG:
 		s = "Debug";
 		break;
 	case USB_DT_INTERFACE_ASSOCIATION:
 		s = "Interface Association";
 		break;
 	case USB_DT_BOS:
 		s = "BOS";
 		break;
 	case USB_DT_DEVICE_CAPABILITY:
 		s = "Device Capability";
 		break;
 	case USB_DT_PIPE_USAGE:
 		s = "Pipe Usage";
 		break;
 	case USB_DT_SS_ENDPOINT_COMP:
 		s = "SS Endpoint Companion";
 		break;
 	case USB_DT_SSP_ISOC_ENDPOINT_COMP:
 		s = "SSP Isochronous Endpoint Companion";
 		break;
 	default:
 		s = "UNKNOWN";
 		break;
 	}

 	snprintf(str, size, "%s %s Descriptor(Index = %d, Length = %d)",
 		bRequest == USB_REQ_GET_DESCRIPTOR ? "Get" : "Set",
 		s, wValue & 0xff, wLength);
 }

 static void usb_decode_get_configuration(__u16 wLength, char *str, size_t size)
 {
 	snprintf(str, size, "Get Configuration(Length = %d)", wLength);
 }

 static void usb_decode_set_configuration(__u8 wValue, char *str, size_t size)
 {
 	snprintf(str, size, "Set Configuration(Config = %d)", wValue);
 }

 static void usb_decode_get_intf(__u16 wIndex, __u16 wLength, char *str,
 				size_t size)
 {
 	snprintf(str, size, "Get Interface(Intf = %d, Length = %d)",
 		 wIndex, wLength);
 }

 static void usb_decode_set_intf(__u8 wValue, __u16 wIndex, char *str,
 				size_t size)
 {
 	snprintf(str, size, "Set Interface(Intf = %d, Alt.Setting = %d)",
 		 wIndex, wValue);
 }

 static void usb_decode_synch_frame(__u16 wIndex, __u16 wLength,
 				   char *str, size_t size)
 {
 	snprintf(str, size, "Synch Frame(Endpoint = %d, Length = %d)",
 		 wIndex, wLength);
 }

 static void usb_decode_set_sel(__u16 wLength, char *str, size_t size)
 {
 	snprintf(str, size, "Set SEL(Length = %d)", wLength);
 }

 static void usb_decode_set_isoch_delay(__u8 wValue, char *str, size_t size)
 {
 	snprintf(str, size, "Set Isochronous Delay(Delay = %d ns)", wValue);
 }

 static void usb_decode_ctrl_generic(char *str, size_t size, __u8 bRequestType,
 				    __u8 bRequest, __u16 wValue, __u16 wIndex,
 				    __u16 wLength)
 {
 	u8 recip = bRequestType & USB_RECIP_MASK;
 	u8 type = bRequestType & USB_TYPE_MASK;

 	snprintf(str, size,
 		 "Type=%s Recipient=%s Dir=%s bRequest=%u wValue=%u wIndex=%u wLength=%u",
 		 (type == USB_TYPE_STANDARD)    ? "Standard" :
 		 (type == USB_TYPE_VENDOR)      ? "Vendor" :
 		 (type == USB_TYPE_CLASS)       ? "Class" : "Unknown",
 		 (recip == USB_RECIP_DEVICE)    ? "Device" :
 		 (recip == USB_RECIP_INTERFACE) ? "Interface" :
 		 (recip == USB_RECIP_ENDPOINT)  ? "Endpoint" : "Unknown",
 		 (bRequestType & USB_DIR_IN)    ? "IN" : "OUT",
 		 bRequest, wValue, wIndex, wLength);
 }

 static void usb_decode_ctrl_standard(char *str, size_t size, __u8 bRequestType,
 				     __u8 bRequest, __u16 wValue, __u16 wIndex,
 				     __u16 wLength)
 {
 	switch (bRequest) {
 	case USB_REQ_GET_STATUS:
 		usb_decode_get_status(bRequestType, wIndex, wLength, str, size);
 		break;
 	case USB_REQ_CLEAR_FEATURE:
 	case USB_REQ_SET_FEATURE:
 		usb_decode_set_clear_feature(bRequestType, bRequest, wValue,
 					     wIndex, str, size);
 		break;
 	case USB_REQ_SET_ADDRESS:
 		usb_decode_set_address(wValue, str, size);
 		break;
 	case USB_REQ_GET_DESCRIPTOR:
 	case USB_REQ_SET_DESCRIPTOR:
 		usb_decode_get_set_descriptor(bRequestType, bRequest, wValue,
 					      wIndex, wLength, str, size);
 		break;
 	case USB_REQ_GET_CONFIGURATION:
 		usb_decode_get_configuration(wLength, str, size);
 		break;
 	case USB_REQ_SET_CONFIGURATION:
 		usb_decode_set_configuration(wValue, str, size);
 		break;
 	case USB_REQ_GET_INTERFACE:
 		usb_decode_get_intf(wIndex, wLength, str, size);
 		break;
 	case USB_REQ_SET_INTERFACE:
 		usb_decode_set_intf(wValue, wIndex, str, size);
 		break;
 	case USB_REQ_SYNCH_FRAME:
 		usb_decode_synch_frame(wIndex, wLength, str, size);
 		break;
 	case USB_REQ_SET_SEL:
 		usb_decode_set_sel(wLength, str, size);
 		break;
 	case USB_REQ_SET_ISOCH_DELAY:
 		usb_decode_set_isoch_delay(wValue, str, size);
 		break;
 	default:
 		usb_decode_ctrl_generic(str, size, bRequestType, bRequest,
 					wValue, wIndex, wLength);
 		break;
 	}
 }

 /**
  * usb_decode_ctrl - Returns human readable representation of control request.
  * @str: buffer to return a human-readable representation of control request.
  *       This buffer should have about 200 bytes.
  * @size: size of str buffer.
  * @bRequestType: matches the USB bmRequestType field
  * @bRequest: matches the USB bRequest field
  * @wValue: matches the USB wValue field (CPU byte order)
  * @wIndex: matches the USB wIndex field (CPU byte order)
  * @wLength: matches the USB wLength field (CPU byte order)
  *
  * Function returns decoded, formatted and human-readable description of
  * control request packet.
  *
  * The usage scenario for this is for tracepoints, so function as a return
  * use the same value as in parameters. This approach allows to use this
  * function in TP_printk
  *
  * Important: wValue, wIndex, wLength parameters before invoking this function
  * should be processed by le16_to_cpu macro.
  */
 const char *usb_decode_ctrl(char *str, size_t size, __u8 bRequestType,
 			    __u8 bRequest, __u16 wValue, __u16 wIndex,
 			    __u16 wLength)
 {
 	switch (bRequestType & USB_TYPE_MASK) {
 	case USB_TYPE_STANDARD:
 		usb_decode_ctrl_standard(str, size, bRequestType, bRequest,
 					 wValue, wIndex, wLength);
 		break;
 	case USB_TYPE_VENDOR:
 	case USB_TYPE_CLASS:
 	default:
 		usb_decode_ctrl_generic(str, size, bRequestType, bRequest,
 					wValue, wIndex, wLength);
 		break;
 	}

 	return str;
 }
 EXPORT_SYMBOL_GPL(usb_decode_ctrl);
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Common USB debugging functions
	*
	* Copyright (C) 2010-2011 Texas Instruments Incorporated - https://www.ti.com
	*
	* Authors: Felipe Balbi <balbi@ti.com>,
	* Sebastian Andrzej Siewior <bigeasy@linutronix.de>
	*/

	#include <linux/kernel.h>
	#include <linux/usb/ch9.h>

	static void usb_decode_get_status(__u8 bRequestType, __u16 wIndex,
	__u16 wLength, char *str, size_t size)
	{
	switch (bRequestType & USB_RECIP_MASK) {
	case USB_RECIP_DEVICE:
	snprintf(str, size, "Get Device Status(Length = %d)", wLength);
	break;
	case USB_RECIP_INTERFACE:
	snprintf(str, size,
	"Get Interface Status(Intf = %d, Length = %d)",
	wIndex, wLength);
	break;
	case USB_RECIP_ENDPOINT:
	snprintf(str, size, "Get Endpoint Status(ep%d%s)",
	wIndex & ~USB_DIR_IN,
	wIndex & USB_DIR_IN ? "in" : "out");
	break;
	}
	}

	static const char *usb_decode_device_feature(u16 wValue)
	{
	switch (wValue) {
	case USB_DEVICE_SELF_POWERED:
	return "Self Powered";
	case USB_DEVICE_REMOTE_WAKEUP:
	return "Remote Wakeup";
	case USB_DEVICE_TEST_MODE:
	return "Test Mode";
	case USB_DEVICE_U1_ENABLE:
	return "U1 Enable";
	case USB_DEVICE_U2_ENABLE:
	return "U2 Enable";
	case USB_DEVICE_LTM_ENABLE:
	return "LTM Enable";
	default:
	return "UNKNOWN";
	}
	}

	static const char *usb_decode_test_mode(u16 wIndex)
	{
	switch (wIndex) {
	case USB_TEST_J:
	return ": TEST_J";
	case USB_TEST_K:
	return ": TEST_K";
	case USB_TEST_SE0_NAK:
	return ": TEST_SE0_NAK";
	case USB_TEST_PACKET:
	return ": TEST_PACKET";
	case USB_TEST_FORCE_ENABLE:
	return ": TEST_FORCE_EN";
	default:
	return ": UNKNOWN";
	}
	}

	static void usb_decode_set_clear_feature(__u8 bRequestType,
	__u8 bRequest, __u16 wValue,
	__u16 wIndex, char *str, size_t size)
	{
	switch (bRequestType & USB_RECIP_MASK) {
	case USB_RECIP_DEVICE:
	snprintf(str, size, "%s Device Feature(%s%s)",
	bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
	usb_decode_device_feature(wValue),
	wValue == USB_DEVICE_TEST_MODE ?
	usb_decode_test_mode(wIndex) : "");
	break;
	case USB_RECIP_INTERFACE:
	snprintf(str, size, "%s Interface Feature(%s)",
	bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
	wValue == USB_INTRF_FUNC_SUSPEND ?
	"Function Suspend" : "UNKNOWN");
	break;
	case USB_RECIP_ENDPOINT:
	snprintf(str, size, "%s Endpoint Feature(%s ep%d%s)",
	bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
	wValue == USB_ENDPOINT_HALT ? "Halt" : "UNKNOWN",
	wIndex & ~USB_DIR_IN,
	wIndex & USB_DIR_IN ? "in" : "out");
	break;
	}
	}

	static void usb_decode_set_address(__u16 wValue, char *str, size_t size)
	{
	snprintf(str, size, "Set Address(Addr = %02x)", wValue);
	}

	static void usb_decode_get_set_descriptor(__u8 bRequestType, __u8 bRequest,
	__u16 wValue, __u16 wIndex,
	__u16 wLength, char *str, size_t size)
	{
	char *s;

	switch (wValue >> 8) {
	case USB_DT_DEVICE:
	s = "Device";
	break;
	case USB_DT_CONFIG:
	s = "Configuration";
	break;
	case USB_DT_STRING:
	s = "String";
	break;
	case USB_DT_INTERFACE:
	s = "Interface";
	break;
	case USB_DT_ENDPOINT:
	s = "Endpoint";
	break;
	case USB_DT_DEVICE_QUALIFIER:
	s = "Device Qualifier";
	break;
	case USB_DT_OTHER_SPEED_CONFIG:
	s = "Other Speed Config";
	break;
	case USB_DT_INTERFACE_POWER:
	s = "Interface Power";
	break;
	case USB_DT_OTG:
	s = "OTG";
	break;
	case USB_DT_DEBUG:
	s = "Debug";
	break;
	case USB_DT_INTERFACE_ASSOCIATION:
	s = "Interface Association";
	break;
	case USB_DT_BOS:
	s = "BOS";
	break;
	case USB_DT_DEVICE_CAPABILITY:
	s = "Device Capability";
	break;
	case USB_DT_PIPE_USAGE:
	s = "Pipe Usage";
	break;
	case USB_DT_SS_ENDPOINT_COMP:
	s = "SS Endpoint Companion";
	break;
	case USB_DT_SSP_ISOC_ENDPOINT_COMP:
	s = "SSP Isochronous Endpoint Companion";
	break;
	default:
	s = "UNKNOWN";
	break;
	}

	snprintf(str, size, "%s %s Descriptor(Index = %d, Length = %d)",
	bRequest == USB_REQ_GET_DESCRIPTOR ? "Get" : "Set",
	s, wValue & 0xff, wLength);
	}

	static void usb_decode_get_configuration(__u16 wLength, char *str, size_t size)
	{
	snprintf(str, size, "Get Configuration(Length = %d)", wLength);
	}

	static void usb_decode_set_configuration(__u8 wValue, char *str, size_t size)
	{
	snprintf(str, size, "Set Configuration(Config = %d)", wValue);
	}

	static void usb_decode_get_intf(__u16 wIndex, __u16 wLength, char *str,
	size_t size)
	{
	snprintf(str, size, "Get Interface(Intf = %d, Length = %d)",
	wIndex, wLength);
	}

	static void usb_decode_set_intf(__u8 wValue, __u16 wIndex, char *str,
	size_t size)
	{
	snprintf(str, size, "Set Interface(Intf = %d, Alt.Setting = %d)",
	wIndex, wValue);
	}

	static void usb_decode_synch_frame(__u16 wIndex, __u16 wLength,
	char *str, size_t size)
	{
	snprintf(str, size, "Synch Frame(Endpoint = %d, Length = %d)",
	wIndex, wLength);
	}

	static void usb_decode_set_sel(__u16 wLength, char *str, size_t size)
	{
	snprintf(str, size, "Set SEL(Length = %d)", wLength);
	}

	static void usb_decode_set_isoch_delay(__u8 wValue, char *str, size_t size)
	{
	snprintf(str, size, "Set Isochronous Delay(Delay = %d ns)", wValue);
	}

	static void usb_decode_ctrl_generic(char *str, size_t size, __u8 bRequestType,
	__u8 bRequest, __u16 wValue, __u16 wIndex,
	__u16 wLength)
	{
	u8 recip = bRequestType & USB_RECIP_MASK;
	u8 type = bRequestType & USB_TYPE_MASK;

	snprintf(str, size,
	"Type=%s Recipient=%s Dir=%s bRequest=%u wValue=%u wIndex=%u wLength=%u",
	(type == USB_TYPE_STANDARD) ? "Standard" :
	(type == USB_TYPE_VENDOR) ? "Vendor" :
	(type == USB_TYPE_CLASS) ? "Class" : "Unknown",
	(recip == USB_RECIP_DEVICE) ? "Device" :
	(recip == USB_RECIP_INTERFACE) ? "Interface" :
	(recip == USB_RECIP_ENDPOINT) ? "Endpoint" : "Unknown",
	(bRequestType & USB_DIR_IN) ? "IN" : "OUT",
	bRequest, wValue, wIndex, wLength);
	}

	static void usb_decode_ctrl_standard(char *str, size_t size, __u8 bRequestType,
	__u8 bRequest, __u16 wValue, __u16 wIndex,
	__u16 wLength)
	{
	switch (bRequest) {
	case USB_REQ_GET_STATUS:
	usb_decode_get_status(bRequestType, wIndex, wLength, str, size);
	break;
	case USB_REQ_CLEAR_FEATURE:
	case USB_REQ_SET_FEATURE:
	usb_decode_set_clear_feature(bRequestType, bRequest, wValue,
	wIndex, str, size);
	break;
	case USB_REQ_SET_ADDRESS:
	usb_decode_set_address(wValue, str, size);
	break;
	case USB_REQ_GET_DESCRIPTOR:
	case USB_REQ_SET_DESCRIPTOR:
	usb_decode_get_set_descriptor(bRequestType, bRequest, wValue,
	wIndex, wLength, str, size);
	break;
	case USB_REQ_GET_CONFIGURATION:
	usb_decode_get_configuration(wLength, str, size);
	break;
	case USB_REQ_SET_CONFIGURATION:
	usb_decode_set_configuration(wValue, str, size);
	break;
	case USB_REQ_GET_INTERFACE:
	usb_decode_get_intf(wIndex, wLength, str, size);
	break;
	case USB_REQ_SET_INTERFACE:
	usb_decode_set_intf(wValue, wIndex, str, size);
	break;
	case USB_REQ_SYNCH_FRAME:
	usb_decode_synch_frame(wIndex, wLength, str, size);
	break;
	case USB_REQ_SET_SEL:
	usb_decode_set_sel(wLength, str, size);
	break;
	case USB_REQ_SET_ISOCH_DELAY:
	usb_decode_set_isoch_delay(wValue, str, size);
	break;
	default:
	usb_decode_ctrl_generic(str, size, bRequestType, bRequest,
	wValue, wIndex, wLength);
	break;
	}
	}

	/**
	* usb_decode_ctrl - Returns human readable representation of control request.
	* @str: buffer to return a human-readable representation of control request.
	* This buffer should have about 200 bytes.
	* @size: size of str buffer.
	* @bRequestType: matches the USB bmRequestType field
	* @bRequest: matches the USB bRequest field
	* @wValue: matches the USB wValue field (CPU byte order)
	* @wIndex: matches the USB wIndex field (CPU byte order)
	* @wLength: matches the USB wLength field (CPU byte order)
	*
	* Function returns decoded, formatted and human-readable description of
	* control request packet.
	*
	* The usage scenario for this is for tracepoints, so function as a return
	* use the same value as in parameters. This approach allows to use this
	* function in TP_printk
	*
	* Important: wValue, wIndex, wLength parameters before invoking this function
	* should be processed by le16_to_cpu macro.
	*/
	const char usb_decode_ctrl(char str, size_t size, __u8 bRequestType,
	__u8 bRequest, __u16 wValue, __u16 wIndex,
	__u16 wLength)
	{
	switch (bRequestType & USB_TYPE_MASK) {
	case USB_TYPE_STANDARD:
	usb_decode_ctrl_standard(str, size, bRequestType, bRequest,
	wValue, wIndex, wLength);
	break;
	case USB_TYPE_VENDOR:
	case USB_TYPE_CLASS:
	default:
	usb_decode_ctrl_generic(str, size, bRequestType, bRequest,
	wValue, wIndex, wLength);
	break;
	}

	return str;
	}
	EXPORT_SYMBOL_GPL(usb_decode_ctrl);