cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

debug.c (7749B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Common USB debugging functions
      4 *
      5 * Copyright (C) 2010-2011 Texas Instruments Incorporated - https://www.ti.com
      6 *
      7 * Authors: Felipe Balbi <balbi@ti.com>,
      8 *	    Sebastian Andrzej Siewior <bigeasy@linutronix.de>
      9 */
     10
     11#include <linux/kernel.h>
     12#include <linux/usb/ch9.h>
     13
     14static void usb_decode_get_status(__u8 bRequestType, __u16 wIndex,
     15				  __u16 wLength, char *str, size_t size)
     16{
     17	switch (bRequestType & USB_RECIP_MASK) {
     18	case USB_RECIP_DEVICE:
     19		snprintf(str, size, "Get Device Status(Length = %d)", wLength);
     20		break;
     21	case USB_RECIP_INTERFACE:
     22		snprintf(str, size,
     23			 "Get Interface Status(Intf = %d, Length = %d)",
     24			 wIndex, wLength);
     25		break;
     26	case USB_RECIP_ENDPOINT:
     27		snprintf(str, size, "Get Endpoint Status(ep%d%s)",
     28			 wIndex & ~USB_DIR_IN,
     29			 wIndex & USB_DIR_IN ? "in" : "out");
     30		break;
     31	}
     32}
     33
     34static const char *usb_decode_device_feature(u16 wValue)
     35{
     36	switch (wValue) {
     37	case USB_DEVICE_SELF_POWERED:
     38		return "Self Powered";
     39	case USB_DEVICE_REMOTE_WAKEUP:
     40		return "Remote Wakeup";
     41	case USB_DEVICE_TEST_MODE:
     42		return "Test Mode";
     43	case USB_DEVICE_U1_ENABLE:
     44		return "U1 Enable";
     45	case USB_DEVICE_U2_ENABLE:
     46		return "U2 Enable";
     47	case USB_DEVICE_LTM_ENABLE:
     48		return "LTM Enable";
     49	default:
     50		return "UNKNOWN";
     51	}
     52}
     53
     54static const char *usb_decode_test_mode(u16 wIndex)
     55{
     56	switch (wIndex) {
     57	case USB_TEST_J:
     58		return ": TEST_J";
     59	case USB_TEST_K:
     60		return ": TEST_K";
     61	case USB_TEST_SE0_NAK:
     62		return ": TEST_SE0_NAK";
     63	case USB_TEST_PACKET:
     64		return ": TEST_PACKET";
     65	case USB_TEST_FORCE_ENABLE:
     66		return ": TEST_FORCE_EN";
     67	default:
     68		return ": UNKNOWN";
     69	}
     70}
     71
     72static void usb_decode_set_clear_feature(__u8 bRequestType,
     73					 __u8 bRequest, __u16 wValue,
     74					 __u16 wIndex, char *str, size_t size)
     75{
     76	switch (bRequestType & USB_RECIP_MASK) {
     77	case USB_RECIP_DEVICE:
     78		snprintf(str, size, "%s Device Feature(%s%s)",
     79			 bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
     80			 usb_decode_device_feature(wValue),
     81			 wValue == USB_DEVICE_TEST_MODE ?
     82			 usb_decode_test_mode(wIndex) : "");
     83		break;
     84	case USB_RECIP_INTERFACE:
     85		snprintf(str, size, "%s Interface Feature(%s)",
     86			 bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
     87			 wValue == USB_INTRF_FUNC_SUSPEND ?
     88			 "Function Suspend" : "UNKNOWN");
     89		break;
     90	case USB_RECIP_ENDPOINT:
     91		snprintf(str, size, "%s Endpoint Feature(%s ep%d%s)",
     92			 bRequest == USB_REQ_CLEAR_FEATURE ? "Clear" : "Set",
     93			 wValue == USB_ENDPOINT_HALT ? "Halt" : "UNKNOWN",
     94			 wIndex & ~USB_DIR_IN,
     95			 wIndex & USB_DIR_IN ? "in" : "out");
     96		break;
     97	}
     98}
     99
    100static void usb_decode_set_address(__u16 wValue, char *str, size_t size)
    101{
    102	snprintf(str, size, "Set Address(Addr = %02x)", wValue);
    103}
    104
    105static void usb_decode_get_set_descriptor(__u8 bRequestType, __u8 bRequest,
    106					  __u16 wValue, __u16 wIndex,
    107					  __u16 wLength, char *str, size_t size)
    108{
    109	char *s;
    110
    111	switch (wValue >> 8) {
    112	case USB_DT_DEVICE:
    113		s = "Device";
    114		break;
    115	case USB_DT_CONFIG:
    116		s = "Configuration";
    117		break;
    118	case USB_DT_STRING:
    119		s = "String";
    120		break;
    121	case USB_DT_INTERFACE:
    122		s = "Interface";
    123		break;
    124	case USB_DT_ENDPOINT:
    125		s = "Endpoint";
    126		break;
    127	case USB_DT_DEVICE_QUALIFIER:
    128		s = "Device Qualifier";
    129		break;
    130	case USB_DT_OTHER_SPEED_CONFIG:
    131		s = "Other Speed Config";
    132		break;
    133	case USB_DT_INTERFACE_POWER:
    134		s = "Interface Power";
    135		break;
    136	case USB_DT_OTG:
    137		s = "OTG";
    138		break;
    139	case USB_DT_DEBUG:
    140		s = "Debug";
    141		break;
    142	case USB_DT_INTERFACE_ASSOCIATION:
    143		s = "Interface Association";
    144		break;
    145	case USB_DT_BOS:
    146		s = "BOS";
    147		break;
    148	case USB_DT_DEVICE_CAPABILITY:
    149		s = "Device Capability";
    150		break;
    151	case USB_DT_PIPE_USAGE:
    152		s = "Pipe Usage";
    153		break;
    154	case USB_DT_SS_ENDPOINT_COMP:
    155		s = "SS Endpoint Companion";
    156		break;
    157	case USB_DT_SSP_ISOC_ENDPOINT_COMP:
    158		s = "SSP Isochronous Endpoint Companion";
    159		break;
    160	default:
    161		s = "UNKNOWN";
    162		break;
    163	}
    164
    165	snprintf(str, size, "%s %s Descriptor(Index = %d, Length = %d)",
    166		bRequest == USB_REQ_GET_DESCRIPTOR ? "Get" : "Set",
    167		s, wValue & 0xff, wLength);
    168}
    169
    170static void usb_decode_get_configuration(__u16 wLength, char *str, size_t size)
    171{
    172	snprintf(str, size, "Get Configuration(Length = %d)", wLength);
    173}
    174
    175static void usb_decode_set_configuration(__u8 wValue, char *str, size_t size)
    176{
    177	snprintf(str, size, "Set Configuration(Config = %d)", wValue);
    178}
    179
    180static void usb_decode_get_intf(__u16 wIndex, __u16 wLength, char *str,
    181				size_t size)
    182{
    183	snprintf(str, size, "Get Interface(Intf = %d, Length = %d)",
    184		 wIndex, wLength);
    185}
    186
    187static void usb_decode_set_intf(__u8 wValue, __u16 wIndex, char *str,
    188				size_t size)
    189{
    190	snprintf(str, size, "Set Interface(Intf = %d, Alt.Setting = %d)",
    191		 wIndex, wValue);
    192}
    193
    194static void usb_decode_synch_frame(__u16 wIndex, __u16 wLength,
    195				   char *str, size_t size)
    196{
    197	snprintf(str, size, "Synch Frame(Endpoint = %d, Length = %d)",
    198		 wIndex, wLength);
    199}
    200
    201static void usb_decode_set_sel(__u16 wLength, char *str, size_t size)
    202{
    203	snprintf(str, size, "Set SEL(Length = %d)", wLength);
    204}
    205
    206static void usb_decode_set_isoch_delay(__u8 wValue, char *str, size_t size)
    207{
    208	snprintf(str, size, "Set Isochronous Delay(Delay = %d ns)", wValue);
    209}
    210
    211/**
    212 * usb_decode_ctrl - Returns human readable representation of control request.
    213 * @str: buffer to return a human-readable representation of control request.
    214 *       This buffer should have about 200 bytes.
    215 * @size: size of str buffer.
    216 * @bRequestType: matches the USB bmRequestType field
    217 * @bRequest: matches the USB bRequest field
    218 * @wValue: matches the USB wValue field (CPU byte order)
    219 * @wIndex: matches the USB wIndex field (CPU byte order)
    220 * @wLength: matches the USB wLength field (CPU byte order)
    221 *
    222 * Function returns decoded, formatted and human-readable description of
    223 * control request packet.
    224 *
    225 * The usage scenario for this is for tracepoints, so function as a return
    226 * use the same value as in parameters. This approach allows to use this
    227 * function in TP_printk
    228 *
    229 * Important: wValue, wIndex, wLength parameters before invoking this function
    230 * should be processed by le16_to_cpu macro.
    231 */
    232const char *usb_decode_ctrl(char *str, size_t size, __u8 bRequestType,
    233			    __u8 bRequest, __u16 wValue, __u16 wIndex,
    234			    __u16 wLength)
    235{
    236	switch (bRequest) {
    237	case USB_REQ_GET_STATUS:
    238		usb_decode_get_status(bRequestType, wIndex, wLength, str, size);
    239		break;
    240	case USB_REQ_CLEAR_FEATURE:
    241	case USB_REQ_SET_FEATURE:
    242		usb_decode_set_clear_feature(bRequestType, bRequest, wValue,
    243					     wIndex, str, size);
    244		break;
    245	case USB_REQ_SET_ADDRESS:
    246		usb_decode_set_address(wValue, str, size);
    247		break;
    248	case USB_REQ_GET_DESCRIPTOR:
    249	case USB_REQ_SET_DESCRIPTOR:
    250		usb_decode_get_set_descriptor(bRequestType, bRequest, wValue,
    251					      wIndex, wLength, str, size);
    252		break;
    253	case USB_REQ_GET_CONFIGURATION:
    254		usb_decode_get_configuration(wLength, str, size);
    255		break;
    256	case USB_REQ_SET_CONFIGURATION:
    257		usb_decode_set_configuration(wValue, str, size);
    258		break;
    259	case USB_REQ_GET_INTERFACE:
    260		usb_decode_get_intf(wIndex, wLength, str, size);
    261		break;
    262	case USB_REQ_SET_INTERFACE:
    263		usb_decode_set_intf(wValue, wIndex, str, size);
    264		break;
    265	case USB_REQ_SYNCH_FRAME:
    266		usb_decode_synch_frame(wIndex, wLength, str, size);
    267		break;
    268	case USB_REQ_SET_SEL:
    269		usb_decode_set_sel(wLength, str, size);
    270		break;
    271	case USB_REQ_SET_ISOCH_DELAY:
    272		usb_decode_set_isoch_delay(wValue, str, size);
    273		break;
    274	default:
    275		snprintf(str, size, "%02x %02x %02x %02x %02x %02x %02x %02x",
    276			 bRequestType, bRequest,
    277			 (u8)(cpu_to_le16(wValue) & 0xff),
    278			 (u8)(cpu_to_le16(wValue) >> 8),
    279			 (u8)(cpu_to_le16(wIndex) & 0xff),
    280			 (u8)(cpu_to_le16(wIndex) >> 8),
    281			 (u8)(cpu_to_le16(wLength) & 0xff),
    282			 (u8)(cpu_to_le16(wLength) >> 8));
    283	}
    284
    285	return str;
    286}
    287EXPORT_SYMBOL_GPL(usb_decode_ctrl);