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 211static void usb_decode_ctrl_generic(char *str, size_t size, __u8 bRequestType, 212 __u8 bRequest, __u16 wValue, __u16 wIndex, 213 __u16 wLength) 214{ 215 u8 recip = bRequestType & USB_RECIP_MASK; 216 u8 type = bRequestType & USB_TYPE_MASK; 217 218 snprintf(str, size, 219 "Type=%s Recipient=%s Dir=%s bRequest=%u wValue=%u wIndex=%u wLength=%u", 220 (type == USB_TYPE_STANDARD) ? "Standard" : 221 (type == USB_TYPE_VENDOR) ? "Vendor" : 222 (type == USB_TYPE_CLASS) ? "Class" : "Unknown", 223 (recip == USB_RECIP_DEVICE) ? "Device" : 224 (recip == USB_RECIP_INTERFACE) ? "Interface" : 225 (recip == USB_RECIP_ENDPOINT) ? "Endpoint" : "Unknown", 226 (bRequestType & USB_DIR_IN) ? "IN" : "OUT", 227 bRequest, wValue, wIndex, wLength); 228} 229 230static void usb_decode_ctrl_standard(char *str, size_t size, __u8 bRequestType, 231 __u8 bRequest, __u16 wValue, __u16 wIndex, 232 __u16 wLength) 233{ 234 switch (bRequest) { 235 case USB_REQ_GET_STATUS: 236 usb_decode_get_status(bRequestType, wIndex, wLength, str, size); 237 break; 238 case USB_REQ_CLEAR_FEATURE: 239 case USB_REQ_SET_FEATURE: 240 usb_decode_set_clear_feature(bRequestType, bRequest, wValue, 241 wIndex, str, size); 242 break; 243 case USB_REQ_SET_ADDRESS: 244 usb_decode_set_address(wValue, str, size); 245 break; 246 case USB_REQ_GET_DESCRIPTOR: 247 case USB_REQ_SET_DESCRIPTOR: 248 usb_decode_get_set_descriptor(bRequestType, bRequest, wValue, 249 wIndex, wLength, str, size); 250 break; 251 case USB_REQ_GET_CONFIGURATION: 252 usb_decode_get_configuration(wLength, str, size); 253 break; 254 case USB_REQ_SET_CONFIGURATION: 255 usb_decode_set_configuration(wValue, str, size); 256 break; 257 case USB_REQ_GET_INTERFACE: 258 usb_decode_get_intf(wIndex, wLength, str, size); 259 break; 260 case USB_REQ_SET_INTERFACE: 261 usb_decode_set_intf(wValue, wIndex, str, size); 262 break; 263 case USB_REQ_SYNCH_FRAME: 264 usb_decode_synch_frame(wIndex, wLength, str, size); 265 break; 266 case USB_REQ_SET_SEL: 267 usb_decode_set_sel(wLength, str, size); 268 break; 269 case USB_REQ_SET_ISOCH_DELAY: 270 usb_decode_set_isoch_delay(wValue, str, size); 271 break; 272 default: 273 usb_decode_ctrl_generic(str, size, bRequestType, bRequest, 274 wValue, wIndex, wLength); 275 break; 276 } 277} 278 279/** 280 * usb_decode_ctrl - Returns human readable representation of control request. 281 * @str: buffer to return a human-readable representation of control request. 282 * This buffer should have about 200 bytes. 283 * @size: size of str buffer. 284 * @bRequestType: matches the USB bmRequestType field 285 * @bRequest: matches the USB bRequest field 286 * @wValue: matches the USB wValue field (CPU byte order) 287 * @wIndex: matches the USB wIndex field (CPU byte order) 288 * @wLength: matches the USB wLength field (CPU byte order) 289 * 290 * Function returns decoded, formatted and human-readable description of 291 * control request packet. 292 * 293 * The usage scenario for this is for tracepoints, so function as a return 294 * use the same value as in parameters. This approach allows to use this 295 * function in TP_printk 296 * 297 * Important: wValue, wIndex, wLength parameters before invoking this function 298 * should be processed by le16_to_cpu macro. 299 */ 300const char *usb_decode_ctrl(char *str, size_t size, __u8 bRequestType, 301 __u8 bRequest, __u16 wValue, __u16 wIndex, 302 __u16 wLength) 303{ 304 switch (bRequestType & USB_TYPE_MASK) { 305 case USB_TYPE_STANDARD: 306 usb_decode_ctrl_standard(str, size, bRequestType, bRequest, 307 wValue, wIndex, wLength); 308 break; 309 case USB_TYPE_VENDOR: 310 case USB_TYPE_CLASS: 311 default: 312 usb_decode_ctrl_generic(str, size, bRequestType, bRequest, 313 wValue, wIndex, wLength); 314 break; 315 } 316 317 return str; 318} 319EXPORT_SYMBOL_GPL(usb_decode_ctrl); 320