drivers/usb/misc/lvstest.c

   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
 374         if (desc->desc.bNumEndpoints < 1)
 375                 return -ENODEV;
 376
 377         endpoint = &desc->endpoint[0].desc;
 378
 379         /* valid only for SS root hub */
 380         if (hdev->descriptor.bDeviceProtocol != USB_HUB_PR_SS || hdev->parent) {
 381                 dev_err(&intf->dev, "Bind LVS driver with SS root Hub only\n");
 382                 return -EINVAL;
 383         }
 384
 385         lvs = devm_kzalloc(&intf->dev, sizeof(*lvs), GFP_KERNEL);
 386         if (!lvs)
 387                 return -ENOMEM;
 388
 389         lvs->intf = intf;
 390         usb_set_intfdata(intf, lvs);
 391
 392         /* how many number of ports this root hub has */
 393         ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 394                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
 395                         USB_DT_SS_HUB << 8, 0, &lvs->descriptor,
 396                         USB_DT_SS_HUB_SIZE, USB_CTRL_GET_TIMEOUT);
 397         if (ret < (USB_DT_HUB_NONVAR_SIZE + 2)) {
 398                 dev_err(&hdev->dev, "wrong root hub descriptor read %d\n", ret);
 399                 return ret;
 400         }
 401
 402         /* submit urb to poll interrupt endpoint */
 403         lvs->urb = usb_alloc_urb(0, GFP_KERNEL);
 404         if (!lvs->urb) {
 405                 dev_err(&intf->dev, "couldn't allocate lvs urb\n");
 406                 return -ENOMEM;
 407         }
 408
 409         lvs->rh_queue = create_singlethread_workqueue("lvs_rh_queue");
 410         if (!lvs->rh_queue) {
 411                 dev_err(&intf->dev, "couldn't create workqueue\n");
 412                 ret = -ENOMEM;
 413                 goto free_urb;
 414         }
 415
 416         INIT_WORK(&lvs->rh_work, lvs_rh_work);
 417
 418         ret = sysfs_create_group(&intf->dev.kobj, &lvs_attr_group);
 419         if (ret < 0) {
 420                 dev_err(&intf->dev, "Failed to create sysfs node %d\n", ret);
 421                 goto destroy_queue;
 422         }
 423
 424         pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
 425         maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
 426         usb_fill_int_urb(lvs->urb, hdev, pipe, &lvs->buffer[0], maxp,
 427                         lvs_rh_irq, lvs, endpoint->bInterval);
 428
 429         ret = usb_submit_urb(lvs->urb, GFP_KERNEL);
 430         if (ret < 0) {
 431                 dev_err(&intf->dev, "couldn't submit lvs urb %d\n", ret);
 432                 goto sysfs_remove;
 433         }
 434
 435         return ret;
 436
 437 sysfs_remove:
 438         sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group);
 439 destroy_queue:
 440         destroy_workqueue(lvs->rh_queue);
 441 free_urb:
 442         usb_free_urb(lvs->urb);
 443         return ret;
 444 }
 445
 446 static void lvs_rh_disconnect(struct usb_interface *intf)
 447 {
 448         struct lvs_rh *lvs = usb_get_intfdata(intf);
 449
 450         sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group);
 451         destroy_workqueue(lvs->rh_queue);
 452         usb_free_urb(lvs->urb);
 453 }
 454
 455 static struct usb_driver lvs_driver = {
 456         .name =         "lvs",
 457         .probe =        lvs_rh_probe,
 458         .disconnect =   lvs_rh_disconnect,
 459 };
 460
 461 module_usb_driver(lvs_driver);
 462
 463 MODULE_DESCRIPTION("Link Layer Validation System Driver");
 464 MODULE_LICENSE("GPL");