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