1 /* 2 * drivers/usb/misc/lvstest.c 3 * 4 * Test pattern generation for Link Layer Validation System Tests 5 * 6 * Copyright (C) 2014 ST Microelectronics 7 * Pratyush Anand <pratyush.anand@gmail.com> 8 * 9 * This file is licensed under the terms of the GNU General Public 10 * License version 2. This program is licensed "as is" without any 11 * warranty of any kind, whether express or implied. 12 */ 13 14 #include <linux/init.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/platform_device.h> 18 #include <linux/slab.h> 19 #include <linux/usb.h> 20 #include <linux/usb/ch11.h> 21 #include <linux/usb/hcd.h> 22 #include <linux/usb/phy.h> 23 24 struct lvs_rh { 25 /* root hub interface */ 26 struct usb_interface *intf; 27 /* if lvs device connected */ 28 bool present; 29 /* port no at which lvs device is present */ 30 int portnum; 31 /* urb buffer */ 32 u8 buffer[8]; 33 /* class descriptor */ 34 struct usb_hub_descriptor descriptor; 35 /* urb for polling interrupt pipe */ 36 struct urb *urb; 37 /* LVH RH work */ 38 struct work_struct rh_work; 39 /* RH port status */ 40 struct usb_port_status port_status; 41 }; 42 43 static struct usb_device *create_lvs_device(struct usb_interface *intf) 44 { 45 struct usb_device *udev, *hdev; 46 struct usb_hcd *hcd; 47 struct lvs_rh *lvs = usb_get_intfdata(intf); 48 49 if (!lvs->present) { 50 dev_err(&intf->dev, "No LVS device is present\n"); 51 return NULL; 52 } 53 54 hdev = interface_to_usbdev(intf); 55 hcd = bus_to_hcd(hdev->bus); 56 57 udev = usb_alloc_dev(hdev, hdev->bus, lvs->portnum); 58 if (!udev) { 59 dev_err(&intf->dev, "Could not allocate lvs udev\n"); 60 return NULL; 61 } 62 udev->speed = USB_SPEED_SUPER; 63 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512); 64 usb_set_device_state(udev, USB_STATE_DEFAULT); 65 66 if (hcd->driver->enable_device) { 67 if (hcd->driver->enable_device(hcd, udev) < 0) { 68 dev_err(&intf->dev, "Failed to enable\n"); 69 usb_put_dev(udev); 70 return NULL; 71 } 72 } 73 74 return udev; 75 } 76 77 static void destroy_lvs_device(struct usb_device *udev) 78 { 79 struct usb_device *hdev = udev->parent; 80 struct usb_hcd *hcd = bus_to_hcd(hdev->bus); 81 82 if (hcd->driver->free_dev) 83 hcd->driver->free_dev(hcd, udev); 84 85 usb_put_dev(udev); 86 } 87 88 static int lvs_rh_clear_port_feature(struct usb_device *hdev, 89 int port1, int feature) 90 { 91 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 92 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1, 93 NULL, 0, 1000); 94 } 95 96 static int lvs_rh_set_port_feature(struct usb_device *hdev, 97 int port1, int feature) 98 { 99 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0), 100 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1, 101 NULL, 0, 1000); 102 } 103 104 static ssize_t u3_entry_store(struct device *dev, 105 struct device_attribute *attr, const char *buf, size_t count) 106 { 107 struct usb_interface *intf = to_usb_interface(dev); 108 struct usb_device *hdev = interface_to_usbdev(intf); 109 struct lvs_rh *lvs = usb_get_intfdata(intf); 110 struct usb_device *udev; 111 int ret; 112 113 udev = create_lvs_device(intf); 114 if (!udev) { 115 dev_err(dev, "failed to create lvs device\n"); 116 return -ENOMEM; 117 } 118 119 ret = lvs_rh_set_port_feature(hdev, lvs->portnum, 120 USB_PORT_FEAT_SUSPEND); 121 if (ret < 0) 122 dev_err(dev, "can't issue U3 entry %d\n", ret); 123 124 destroy_lvs_device(udev); 125 126 if (ret < 0) 127 return ret; 128 129 return count; 130 } 131 static DEVICE_ATTR_WO(u3_entry); 132 133 static ssize_t u3_exit_store(struct device *dev, 134 struct device_attribute *attr, const char *buf, size_t count) 135 { 136 struct usb_interface *intf = to_usb_interface(dev); 137 struct usb_device *hdev = interface_to_usbdev(intf); 138 struct lvs_rh *lvs = usb_get_intfdata(intf); 139 struct usb_device *udev; 140 int ret; 141 142 udev = create_lvs_device(intf); 143 if (!udev) { 144 dev_err(dev, "failed to create lvs device\n"); 145 return -ENOMEM; 146 } 147 148 ret = lvs_rh_clear_port_feature(hdev, lvs->portnum, 149 USB_PORT_FEAT_SUSPEND); 150 if (ret < 0) 151 dev_err(dev, "can't issue U3 exit %d\n", ret); 152 153 destroy_lvs_device(udev); 154 155 if (ret < 0) 156 return ret; 157 158 return count; 159 } 160 static DEVICE_ATTR_WO(u3_exit); 161 162 static ssize_t hot_reset_store(struct device *dev, 163 struct device_attribute *attr, const char *buf, size_t count) 164 { 165 struct usb_interface *intf = to_usb_interface(dev); 166 struct usb_device *hdev = interface_to_usbdev(intf); 167 struct lvs_rh *lvs = usb_get_intfdata(intf); 168 int ret; 169 170 ret = lvs_rh_set_port_feature(hdev, lvs->portnum, 171 USB_PORT_FEAT_RESET); 172 if (ret < 0) { 173 dev_err(dev, "can't issue hot reset %d\n", ret); 174 return ret; 175 } 176 177 return count; 178 } 179 static DEVICE_ATTR_WO(hot_reset); 180 181 static ssize_t warm_reset_store(struct device *dev, 182 struct device_attribute *attr, const char *buf, size_t count) 183 { 184 struct usb_interface *intf = to_usb_interface(dev); 185 struct usb_device *hdev = interface_to_usbdev(intf); 186 struct lvs_rh *lvs = usb_get_intfdata(intf); 187 int ret; 188 189 ret = lvs_rh_set_port_feature(hdev, lvs->portnum, 190 USB_PORT_FEAT_BH_PORT_RESET); 191 if (ret < 0) { 192 dev_err(dev, "can't issue warm reset %d\n", ret); 193 return ret; 194 } 195 196 return count; 197 } 198 static DEVICE_ATTR_WO(warm_reset); 199 200 static ssize_t u2_timeout_store(struct device *dev, 201 struct device_attribute *attr, const char *buf, size_t count) 202 { 203 struct usb_interface *intf = to_usb_interface(dev); 204 struct usb_device *hdev = interface_to_usbdev(intf); 205 struct lvs_rh *lvs = usb_get_intfdata(intf); 206 unsigned long val; 207 int ret; 208 209 ret = kstrtoul(buf, 10, &val); 210 if (ret < 0) { 211 dev_err(dev, "couldn't parse string %d\n", ret); 212 return ret; 213 } 214 215 if (val > 127) 216 return -EINVAL; 217 218 ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8), 219 USB_PORT_FEAT_U2_TIMEOUT); 220 if (ret < 0) { 221 dev_err(dev, "Error %d while setting U2 timeout %ld\n", ret, val); 222 return ret; 223 } 224 225 return count; 226 } 227 static DEVICE_ATTR_WO(u2_timeout); 228 229 static ssize_t u1_timeout_store(struct device *dev, 230 struct device_attribute *attr, const char *buf, size_t count) 231 { 232 struct usb_interface *intf = to_usb_interface(dev); 233 struct usb_device *hdev = interface_to_usbdev(intf); 234 struct lvs_rh *lvs = usb_get_intfdata(intf); 235 unsigned long val; 236 int ret; 237 238 ret = kstrtoul(buf, 10, &val); 239 if (ret < 0) { 240 dev_err(dev, "couldn't parse string %d\n", ret); 241 return ret; 242 } 243 244 if (val > 127) 245 return -EINVAL; 246 247 ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8), 248 USB_PORT_FEAT_U1_TIMEOUT); 249 if (ret < 0) { 250 dev_err(dev, "Error %d while setting U1 timeout %ld\n", ret, val); 251 return ret; 252 } 253 254 return count; 255 } 256 static DEVICE_ATTR_WO(u1_timeout); 257 258 static ssize_t get_dev_desc_store(struct device *dev, 259 struct device_attribute *attr, const char *buf, size_t count) 260 { 261 struct usb_interface *intf = to_usb_interface(dev); 262 struct usb_device *udev; 263 struct usb_device_descriptor *descriptor; 264 int ret; 265 266 descriptor = kmalloc(sizeof(*descriptor), GFP_KERNEL); 267 if (!descriptor) 268 return -ENOMEM; 269 270 udev = create_lvs_device(intf); 271 if (!udev) { 272 dev_err(dev, "failed to create lvs device\n"); 273 ret = -ENOMEM; 274 goto free_desc; 275 } 276 277 ret = usb_control_msg(udev, (PIPE_CONTROL << 30) | USB_DIR_IN, 278 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, USB_DT_DEVICE << 8, 279 0, descriptor, sizeof(*descriptor), 280 USB_CTRL_GET_TIMEOUT); 281 if (ret < 0) 282 dev_err(dev, "can't read device descriptor %d\n", ret); 283 284 destroy_lvs_device(udev); 285 286 free_desc: 287 kfree(descriptor); 288 289 if (ret < 0) 290 return ret; 291 292 return count; 293 } 294 static DEVICE_ATTR_WO(get_dev_desc); 295 296 static ssize_t enable_compliance_store(struct device *dev, 297 struct device_attribute *attr, const char *buf, size_t count) 298 { 299 struct usb_interface *intf = to_usb_interface(dev); 300 struct usb_device *hdev = interface_to_usbdev(intf); 301 struct lvs_rh *lvs = usb_get_intfdata(intf); 302 int ret; 303 304 ret = lvs_rh_set_port_feature(hdev, 305 lvs->portnum | USB_SS_PORT_LS_COMP_MOD << 3, 306 USB_PORT_FEAT_LINK_STATE); 307 if (ret < 0) { 308 dev_err(dev, "can't enable compliance mode %d\n", ret); 309 return ret; 310 } 311 312 return count; 313 } 314 static DEVICE_ATTR_WO(enable_compliance); 315 316 static struct attribute *lvs_attributes[] = { 317 &dev_attr_get_dev_desc.attr, 318 &dev_attr_u1_timeout.attr, 319 &dev_attr_u2_timeout.attr, 320 &dev_attr_hot_reset.attr, 321 &dev_attr_warm_reset.attr, 322 &dev_attr_u3_entry.attr, 323 &dev_attr_u3_exit.attr, 324 &dev_attr_enable_compliance.attr, 325 NULL 326 }; 327 328 static const struct attribute_group lvs_attr_group = { 329 .attrs = lvs_attributes, 330 }; 331 332 static void lvs_rh_work(struct work_struct *work) 333 { 334 struct lvs_rh *lvs = container_of(work, struct lvs_rh, rh_work); 335 struct usb_interface *intf = lvs->intf; 336 struct usb_device *hdev = interface_to_usbdev(intf); 337 struct usb_hcd *hcd = bus_to_hcd(hdev->bus); 338 struct usb_hub_descriptor *descriptor = &lvs->descriptor; 339 struct usb_port_status *port_status = &lvs->port_status; 340 int i, ret = 0; 341 u16 portchange; 342 343 /* Examine each root port */ 344 for (i = 1; i <= descriptor->bNbrPorts; i++) { 345 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 346 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, i, 347 port_status, sizeof(*port_status), 1000); 348 if (ret < 4) 349 continue; 350 351 portchange = le16_to_cpu(port_status->wPortChange); 352 353 if (portchange & USB_PORT_STAT_C_LINK_STATE) 354 lvs_rh_clear_port_feature(hdev, i, 355 USB_PORT_FEAT_C_PORT_LINK_STATE); 356 if (portchange & USB_PORT_STAT_C_ENABLE) 357 lvs_rh_clear_port_feature(hdev, i, 358 USB_PORT_FEAT_C_ENABLE); 359 if (portchange & USB_PORT_STAT_C_RESET) 360 lvs_rh_clear_port_feature(hdev, i, 361 USB_PORT_FEAT_C_RESET); 362 if (portchange & USB_PORT_STAT_C_BH_RESET) 363 lvs_rh_clear_port_feature(hdev, i, 364 USB_PORT_FEAT_C_BH_PORT_RESET); 365 if (portchange & USB_PORT_STAT_C_CONNECTION) { 366 lvs_rh_clear_port_feature(hdev, i, 367 USB_PORT_FEAT_C_CONNECTION); 368 369 if (le16_to_cpu(port_status->wPortStatus) & 370 USB_PORT_STAT_CONNECTION) { 371 lvs->present = true; 372 lvs->portnum = i; 373 if (hcd->usb_phy) 374 usb_phy_notify_connect(hcd->usb_phy, 375 USB_SPEED_SUPER); 376 } else { 377 lvs->present = false; 378 if (hcd->usb_phy) 379 usb_phy_notify_disconnect(hcd->usb_phy, 380 USB_SPEED_SUPER); 381 } 382 break; 383 } 384 } 385 386 ret = usb_submit_urb(lvs->urb, GFP_KERNEL); 387 if (ret != 0 && ret != -ENODEV && ret != -EPERM) 388 dev_err(&intf->dev, "urb resubmit error %d\n", ret); 389 } 390 391 static void lvs_rh_irq(struct urb *urb) 392 { 393 struct lvs_rh *lvs = urb->context; 394 395 schedule_work(&lvs->rh_work); 396 } 397 398 static int lvs_rh_probe(struct usb_interface *intf, 399 const struct usb_device_id *id) 400 { 401 struct usb_device *hdev; 402 struct usb_host_interface *desc; 403 struct usb_endpoint_descriptor *endpoint; 404 struct lvs_rh *lvs; 405 unsigned int pipe; 406 int ret, maxp; 407 408 hdev = interface_to_usbdev(intf); 409 desc = intf->cur_altsetting; 410 411 ret = usb_find_int_in_endpoint(desc, &endpoint); 412 if (ret) 413 return ret; 414 415 /* valid only for SS root hub */ 416 if (hdev->descriptor.bDeviceProtocol != USB_HUB_PR_SS || hdev->parent) { 417 dev_err(&intf->dev, "Bind LVS driver with SS root Hub only\n"); 418 return -EINVAL; 419 } 420 421 lvs = devm_kzalloc(&intf->dev, sizeof(*lvs), GFP_KERNEL); 422 if (!lvs) 423 return -ENOMEM; 424 425 lvs->intf = intf; 426 usb_set_intfdata(intf, lvs); 427 428 /* how many number of ports this root hub has */ 429 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 430 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 431 USB_DT_SS_HUB << 8, 0, &lvs->descriptor, 432 USB_DT_SS_HUB_SIZE, USB_CTRL_GET_TIMEOUT); 433 if (ret < (USB_DT_HUB_NONVAR_SIZE + 2)) { 434 dev_err(&hdev->dev, "wrong root hub descriptor read %d\n", ret); 435 return ret; 436 } 437 438 /* submit urb to poll interrupt endpoint */ 439 lvs->urb = usb_alloc_urb(0, GFP_KERNEL); 440 if (!lvs->urb) 441 return -ENOMEM; 442 443 INIT_WORK(&lvs->rh_work, lvs_rh_work); 444 445 ret = sysfs_create_group(&intf->dev.kobj, &lvs_attr_group); 446 if (ret < 0) { 447 dev_err(&intf->dev, "Failed to create sysfs node %d\n", ret); 448 goto free_urb; 449 } 450 451 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress); 452 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe)); 453 usb_fill_int_urb(lvs->urb, hdev, pipe, &lvs->buffer[0], maxp, 454 lvs_rh_irq, lvs, endpoint->bInterval); 455 456 ret = usb_submit_urb(lvs->urb, GFP_KERNEL); 457 if (ret < 0) { 458 dev_err(&intf->dev, "couldn't submit lvs urb %d\n", ret); 459 goto sysfs_remove; 460 } 461 462 return ret; 463 464 sysfs_remove: 465 sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group); 466 free_urb: 467 usb_free_urb(lvs->urb); 468 return ret; 469 } 470 471 static void lvs_rh_disconnect(struct usb_interface *intf) 472 { 473 struct lvs_rh *lvs = usb_get_intfdata(intf); 474 475 sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group); 476 usb_poison_urb(lvs->urb); /* used in scheduled work */ 477 flush_work(&lvs->rh_work); 478 usb_free_urb(lvs->urb); 479 } 480 481 static struct usb_driver lvs_driver = { 482 .name = "lvs", 483 .probe = lvs_rh_probe, 484 .disconnect = lvs_rh_disconnect, 485 }; 486 487 module_usb_driver(lvs_driver); 488 489 MODULE_DESCRIPTION("Link Layer Validation System Driver"); 490 MODULE_LICENSE("GPL"); 491