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