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 u2_timeout_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 unsigned long val; 188 int ret; 189 190 ret = kstrtoul(buf, 10, &val); 191 if (ret < 0) { 192 dev_err(dev, "couldn't parse string %d\n", ret); 193 return ret; 194 } 195 196 if (val < 0 || val > 127) 197 return -EINVAL; 198 199 ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8), 200 USB_PORT_FEAT_U2_TIMEOUT); 201 if (ret < 0) { 202 dev_err(dev, "Error %d while setting U2 timeout %ld\n", ret, val); 203 return ret; 204 } 205 206 return count; 207 } 208 static DEVICE_ATTR_WO(u2_timeout); 209 210 static ssize_t u1_timeout_store(struct device *dev, 211 struct device_attribute *attr, const char *buf, size_t count) 212 { 213 struct usb_interface *intf = to_usb_interface(dev); 214 struct usb_device *hdev = interface_to_usbdev(intf); 215 struct lvs_rh *lvs = usb_get_intfdata(intf); 216 unsigned long val; 217 int ret; 218 219 ret = kstrtoul(buf, 10, &val); 220 if (ret < 0) { 221 dev_err(dev, "couldn't parse string %d\n", ret); 222 return ret; 223 } 224 225 if (val < 0 || val > 127) 226 return -EINVAL; 227 228 ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8), 229 USB_PORT_FEAT_U1_TIMEOUT); 230 if (ret < 0) { 231 dev_err(dev, "Error %d while setting U1 timeout %ld\n", ret, val); 232 return ret; 233 } 234 235 return count; 236 } 237 static DEVICE_ATTR_WO(u1_timeout); 238 239 static ssize_t get_dev_desc_store(struct device *dev, 240 struct device_attribute *attr, const char *buf, size_t count) 241 { 242 struct usb_interface *intf = to_usb_interface(dev); 243 struct usb_device *udev; 244 struct usb_device_descriptor *descriptor; 245 int ret; 246 247 descriptor = kmalloc(sizeof(*descriptor), GFP_KERNEL); 248 if (!descriptor) 249 return -ENOMEM; 250 251 udev = create_lvs_device(intf); 252 if (!udev) { 253 dev_err(dev, "failed to create lvs device\n"); 254 ret = -ENOMEM; 255 goto free_desc; 256 } 257 258 ret = usb_control_msg(udev, (PIPE_CONTROL << 30) | USB_DIR_IN, 259 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, USB_DT_DEVICE << 8, 260 0, descriptor, sizeof(*descriptor), 261 USB_CTRL_GET_TIMEOUT); 262 if (ret < 0) 263 dev_err(dev, "can't read device descriptor %d\n", ret); 264 265 destroy_lvs_device(udev); 266 267 free_desc: 268 kfree(descriptor); 269 270 if (ret < 0) 271 return ret; 272 273 return count; 274 } 275 static DEVICE_ATTR_WO(get_dev_desc); 276 277 static struct attribute *lvs_attributes[] = { 278 &dev_attr_get_dev_desc.attr, 279 &dev_attr_u1_timeout.attr, 280 &dev_attr_u2_timeout.attr, 281 &dev_attr_hot_reset.attr, 282 &dev_attr_u3_entry.attr, 283 &dev_attr_u3_exit.attr, 284 NULL 285 }; 286 287 static const struct attribute_group lvs_attr_group = { 288 .attrs = lvs_attributes, 289 }; 290 291 static void lvs_rh_work(struct work_struct *work) 292 { 293 struct lvs_rh *lvs = container_of(work, struct lvs_rh, rh_work); 294 struct usb_interface *intf = lvs->intf; 295 struct usb_device *hdev = interface_to_usbdev(intf); 296 struct usb_hcd *hcd = bus_to_hcd(hdev->bus); 297 struct usb_hub_descriptor *descriptor = &lvs->descriptor; 298 struct usb_port_status *port_status = &lvs->port_status; 299 int i, ret = 0; 300 u16 portchange; 301 302 /* Examine each root port */ 303 for (i = 1; i <= descriptor->bNbrPorts; i++) { 304 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 305 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, i, 306 port_status, sizeof(*port_status), 1000); 307 if (ret < 4) 308 continue; 309 310 portchange = le16_to_cpu(port_status->wPortChange); 311 312 if (portchange & USB_PORT_STAT_C_LINK_STATE) 313 lvs_rh_clear_port_feature(hdev, i, 314 USB_PORT_FEAT_C_PORT_LINK_STATE); 315 if (portchange & USB_PORT_STAT_C_ENABLE) 316 lvs_rh_clear_port_feature(hdev, i, 317 USB_PORT_FEAT_C_ENABLE); 318 if (portchange & USB_PORT_STAT_C_RESET) 319 lvs_rh_clear_port_feature(hdev, i, 320 USB_PORT_FEAT_C_RESET); 321 if (portchange & USB_PORT_STAT_C_BH_RESET) 322 lvs_rh_clear_port_feature(hdev, i, 323 USB_PORT_FEAT_C_BH_PORT_RESET); 324 if (portchange & USB_PORT_STAT_C_CONNECTION) { 325 lvs_rh_clear_port_feature(hdev, i, 326 USB_PORT_FEAT_C_CONNECTION); 327 328 if (le16_to_cpu(port_status->wPortStatus) & 329 USB_PORT_STAT_CONNECTION) { 330 lvs->present = true; 331 lvs->portnum = i; 332 if (hcd->usb_phy) 333 usb_phy_notify_connect(hcd->usb_phy, 334 USB_SPEED_SUPER); 335 } else { 336 lvs->present = false; 337 if (hcd->usb_phy) 338 usb_phy_notify_disconnect(hcd->usb_phy, 339 USB_SPEED_SUPER); 340 } 341 break; 342 } 343 } 344 345 ret = usb_submit_urb(lvs->urb, GFP_KERNEL); 346 if (ret != 0 && ret != -ENODEV && ret != -EPERM) 347 dev_err(&intf->dev, "urb resubmit error %d\n", ret); 348 } 349 350 static void lvs_rh_irq(struct urb *urb) 351 { 352 struct lvs_rh *lvs = urb->context; 353 354 schedule_work(&lvs->rh_work); 355 } 356 357 static int lvs_rh_probe(struct usb_interface *intf, 358 const struct usb_device_id *id) 359 { 360 struct usb_device *hdev; 361 struct usb_host_interface *desc; 362 struct usb_endpoint_descriptor *endpoint; 363 struct lvs_rh *lvs; 364 unsigned int pipe; 365 int ret, maxp; 366 367 hdev = interface_to_usbdev(intf); 368 desc = intf->cur_altsetting; 369 endpoint = &desc->endpoint[0].desc; 370 371 /* valid only for SS root hub */ 372 if (hdev->descriptor.bDeviceProtocol != USB_HUB_PR_SS || hdev->parent) { 373 dev_err(&intf->dev, "Bind LVS driver with SS root Hub only\n"); 374 return -EINVAL; 375 } 376 377 lvs = devm_kzalloc(&intf->dev, sizeof(*lvs), GFP_KERNEL); 378 if (!lvs) 379 return -ENOMEM; 380 381 lvs->intf = intf; 382 usb_set_intfdata(intf, lvs); 383 384 /* how many number of ports this root hub has */ 385 ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0), 386 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 387 USB_DT_SS_HUB << 8, 0, &lvs->descriptor, 388 USB_DT_SS_HUB_SIZE, USB_CTRL_GET_TIMEOUT); 389 if (ret < (USB_DT_HUB_NONVAR_SIZE + 2)) { 390 dev_err(&hdev->dev, "wrong root hub descriptor read %d\n", ret); 391 return ret; 392 } 393 394 /* submit urb to poll interrupt endpoint */ 395 lvs->urb = usb_alloc_urb(0, GFP_KERNEL); 396 if (!lvs->urb) 397 return -ENOMEM; 398 399 INIT_WORK(&lvs->rh_work, lvs_rh_work); 400 401 ret = sysfs_create_group(&intf->dev.kobj, &lvs_attr_group); 402 if (ret < 0) { 403 dev_err(&intf->dev, "Failed to create sysfs node %d\n", ret); 404 goto free_urb; 405 } 406 407 pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress); 408 maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe)); 409 usb_fill_int_urb(lvs->urb, hdev, pipe, &lvs->buffer[0], maxp, 410 lvs_rh_irq, lvs, endpoint->bInterval); 411 412 ret = usb_submit_urb(lvs->urb, GFP_KERNEL); 413 if (ret < 0) { 414 dev_err(&intf->dev, "couldn't submit lvs urb %d\n", ret); 415 goto sysfs_remove; 416 } 417 418 return ret; 419 420 sysfs_remove: 421 sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group); 422 free_urb: 423 usb_free_urb(lvs->urb); 424 return ret; 425 } 426 427 static void lvs_rh_disconnect(struct usb_interface *intf) 428 { 429 struct lvs_rh *lvs = usb_get_intfdata(intf); 430 431 sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group); 432 flush_work(&lvs->rh_work); 433 usb_free_urb(lvs->urb); 434 } 435 436 static struct usb_driver lvs_driver = { 437 .name = "lvs", 438 .probe = lvs_rh_probe, 439 .disconnect = lvs_rh_disconnect, 440 }; 441 442 module_usb_driver(lvs_driver); 443 444 MODULE_DESCRIPTION("Link Layer Validation System Driver"); 445 MODULE_LICENSE("GPL"); 446