Release 4.7 drivers/usb/core/sysfs.c

Directory: drivers/usb/core
/*
 * drivers/usb/core/sysfs.c
 *
 * (C) Copyright 2002 David Brownell
 * (C) Copyright 2002,2004 Greg Kroah-Hartman
 * (C) Copyright 2002,2004 IBM Corp.
 *
 * All of the sysfs file attributes for usb devices and interfaces.
 *
 */


#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/usb.h>
#include <linux/usb/quirks.h>
#include "usb.h"

/* Active configuration fields */

#define usb_actconfig_show(field, format_string)			\
static ssize_t field##_show(struct device *dev,                         \
                            struct device_attribute *attr, char *buf)   \
{                                                                       \
        struct usb_device *udev;                                        \
        struct usb_host_config *actconfig;                              \
        ssize_t rc;                                                     \
                                                                        \
        udev = to_usb_device(dev);                                      \
        rc = usb_lock_device_interruptible(udev);                       \
        if (rc < 0)                                                     \
                return -EINTR;                                          \
        actconfig = udev->actconfig;                                    \
        if (actconfig)                                                  \
                rc = sprintf(buf, format_string,                        \
                                actconfig->desc.field);                 \
        usb_unlock_device(udev);                                        \
        return rc;                                                      \
}                                                                       \

#define usb_actconfig_attr(field, format_string)                \
        usb_actconfig_show(field, format_string)                \
        static DEVICE_ATTR_RO(field)

usb_actconfig_attr(bNumInterfaces, "%2d\n");
usb_actconfig_attr(bmAttributes, "%2x\n");



static ssize_t bMaxPower_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct usb_device *udev;
	struct usb_host_config *actconfig;
	ssize_t rc;

	udev = to_usb_device(dev);
	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;
	actconfig = udev->actconfig;
	if (actconfig)
		rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
	usb_unlock_device(udev);
	return rc;
}
Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 56 61.54% 1 16.67%
alan stern alan stern 17 18.68% 1 16.67%
oliver neukum oliver neukum 13 14.29% 1 16.67%
greg kroah-hartman greg kroah-hartman 5 5.49% 3 50.00%
Total 91 100.00% 6 100.00%

static DEVICE_ATTR_RO(bMaxPower);



static ssize_t configuration_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct usb_device *udev;
	struct usb_host_config *actconfig;
	ssize_t rc;

	udev = to_usb_device(dev);
	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;
	actconfig = udev->actconfig;
	if (actconfig && actconfig->string)
		rc = sprintf(buf, "%s\n", actconfig->string);
	usb_unlock_device(udev);
	return rc;
}
Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 48 52.17% 2 28.57%
alan stern alan stern 20 21.74% 2 28.57%
oliver neukum oliver neukum 13 14.13% 1 14.29%
alex kanavin alex kanavin 6 6.52% 1 14.29%
yani ioannou yani ioannou 5 5.43% 1 14.29%
Total 92 100.00% 7 100.00%

static DEVICE_ATTR_RO(configuration);

/* configuration value is always present, and r/w */
usb_actconfig_show(bConfigurationValue, "%u\n");



static ssize_t bConfigurationValue_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t count)
{
	struct usb_device	*udev = to_usb_device(dev);
	int			config, value, rc;

	if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
		return -EINVAL;
	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;
	value = usb_set_configuration(udev, config);
	usb_unlock_device(udev);
	return (value < 0) ? value : count;
}
Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 82 74.55% 2 28.57%
oliver neukum oliver neukum 15 13.64% 1 14.29%
alan stern alan stern 7 6.36% 2 28.57%
yani ioannou yani ioannou 5 4.55% 1 14.29%
greg kroah-hartman greg kroah-hartman 1 0.91% 1 14.29%
Total 110 100.00% 7 100.00%

static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
		bConfigurationValue_show, bConfigurationValue_store);

/* String fields */

#define usb_string_attr(name)						\
static ssize_t  name##_show(struct device *dev,                         \
                struct device_attribute *attr, char *buf)               \
{                                                                       \
        struct usb_device *udev;                                        \
        int retval;                                                     \
                                                                        \
        udev = to_usb_device(dev);                                      \
        retval = usb_lock_device_interruptible(udev);                   \
        if (retval < 0)                                                 \
                return -EINTR;                                          \
        retval = sprintf(buf, "%s\n", udev->name);                      \
        usb_unlock_device(udev);                                        \
        return retval;                                                  \
}                                                                       \
static DEVICE_ATTR_RO(name)


usb_string_attr(product);

usb_string_attr(manufacturer);

usb_string_attr(serial);



static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct usb_device *udev;
	char *speed;

	udev = to_usb_device(dev);

	switch (udev->speed) {
	case USB_SPEED_LOW:
		speed = "1.5";
		break;
	case USB_SPEED_UNKNOWN:
	case USB_SPEED_FULL:
		speed = "12";
		break;
	case USB_SPEED_HIGH:
		speed = "480";
		break;
	case USB_SPEED_WIRELESS:
		speed = "480";
		break;
	case USB_SPEED_SUPER:
		speed = "5000";
		break;
	case USB_SPEED_SUPER_PLUS:
		speed = "10000";
		break;
	default:
		speed = "unknown";
	}
	return sprintf(buf, "%s\n", speed);
}
Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 97 88.18% 4 66.67%
mathias nyman mathias nyman 8 7.27% 1 16.67%
yani ioannou yani ioannou 5 4.55% 1 16.67%
Total 110 100.00% 6 100.00%

static DEVICE_ATTR_RO(speed);



static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", udev->bus->busnum);
}
Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 43 93.48% 1 33.33%
robert love robert love 2 4.35% 1 33.33%
greg kroah-hartman greg kroah-hartman 1 2.17% 1 33.33%
Total 46 100.00% 3 100.00%

static DEVICE_ATTR_RO(busnum);



static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", udev->devnum);
}
Contributors
Person Tokens Prop Commits CommitProp
robert love robert love 36 81.82% 1 25.00%
yani ioannou yani ioannou 5 11.36% 1 25.00%
alan stern alan stern 2 4.55% 1 25.00%
greg kroah-hartman greg kroah-hartman 1 2.27% 1 25.00%
Total 44 100.00% 4 100.00%

static DEVICE_ATTR_RO(devnum);



static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "%s\n", udev->devpath);
}
Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 42 95.45% 2 66.67%
robert love robert love 2 4.55% 1 33.33%
Total 44 100.00% 3 100.00%

static DEVICE_ATTR_RO(devpath);



static ssize_t version_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct usb_device *udev;
	u16 bcdUSB;

	udev = to_usb_device(dev);
	bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
	return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
}
Contributors
Person Tokens Prop Commits CommitProp
robert love robert love 40 64.52% 1 20.00%
greg kroah-hartman greg kroah-hartman 17 27.42% 3 60.00%
yani ioannou yani ioannou 5 8.06% 1 20.00%
Total 62 100.00% 5 100.00%

static DEVICE_ATTR_RO(version);



static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", udev->maxchild);
}
Contributors
Person Tokens Prop Commits CommitProp
robert love robert love 38 86.36% 1 33.33%
yani ioannou yani ioannou 5 11.36% 1 33.33%
greg kroah-hartman greg kroah-hartman 1 2.27% 1 33.33%
Total 44 100.00% 3 100.00%

static DEVICE_ATTR_RO(maxchild);



static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "0x%x\n", udev->quirks);
}
Contributors
Person Tokens Prop Commits CommitProp
oliver neukum oliver neukum 43 97.73% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 2.27% 1 50.00%
Total 44 100.00% 2 100.00%

static DEVICE_ATTR_RO(quirks);



static ssize_t avoid_reset_quirk_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
}

Contributors
Person Tokens Prop Commits CommitProp
oliver neukum oliver neukum 46 92.00% 1 25.00%
sarah sharp sarah sharp 2 4.00% 1 25.00%
greg kroah-hartman greg kroah-hartman 1 2.00% 1 25.00%
lan tianyu lan tianyu 1 2.00% 1 25.00%
Total 50 100.00% 4 100.00%



static ssize_t avoid_reset_quirk_store(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	struct usb_device	*udev = to_usb_device(dev);
	int			val, rc;

	if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
		return -EINVAL;
	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;
	if (val)
		udev->quirks |= USB_QUIRK_RESET;
	else
		udev->quirks &= ~USB_QUIRK_RESET;
	usb_unlock_device(udev);
	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
oliver neukum oliver neukum 100 92.59% 2 40.00%
lan tianyu lan tianyu 7 6.48% 2 40.00%
greg kroah-hartman greg kroah-hartman 1 0.93% 1 20.00%
Total 108 100.00% 5 100.00%

static DEVICE_ATTR_RW(avoid_reset_quirk);



static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct usb_device *udev;

	udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
}
Contributors
Person Tokens Prop Commits CommitProp
sarah sharp sarah sharp 45 93.75% 1 33.33%
oliver neukum oliver neukum 2 4.17% 1 33.33%
greg kroah-hartman greg kroah-hartman 1 2.08% 1 33.33%
Total 48 100.00% 3 100.00%

static DEVICE_ATTR_RO(urbnum);



static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
{
	struct usb_device *udev;
	char *state;

	udev = to_usb_device(dev);

	switch (udev->removable) {
	case USB_DEVICE_REMOVABLE:
		state = "removable";
		break;
	case USB_DEVICE_FIXED:
		state = "fixed";
		break;
	default:
		state = "unknown";
	}

	return sprintf(buf, "%s\n", state);
}
Contributors
Person Tokens Prop Commits CommitProp
matthew garrett matthew garrett 74 98.67% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 1.33% 1 50.00%
Total 75 100.00% 2 100.00%

static DEVICE_ATTR_RO(removable);



static ssize_t ltm_capable_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	if (usb_device_supports_ltm(to_usb_device(dev)))
		return sprintf(buf, "%s\n", "yes");
	return sprintf(buf, "%s\n", "no");
}
Contributors
Person Tokens Prop Commits CommitProp
sarah sharp sarah sharp 49 98.00% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 2.00% 1 50.00%
Total 50 100.00% 2 100.00%

static DEVICE_ATTR_RO(ltm_capable);

#ifdef	CONFIG_PM



static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct usb_device *udev = to_usb_device(dev);

	return sprintf(buf, "%d\n", udev->persist_enabled);
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 41 97.62% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 2.38% 1 50.00%
Total 42 100.00% 2 100.00%



static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct usb_device *udev = to_usb_device(dev);
	int value, rc;

	/* Hubs are always enabled for USB_PERSIST */
	if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
		return -EPERM;

	if (sscanf(buf, "%d", &value) != 1)
		return -EINVAL;

	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;
	udev->persist_enabled = !!value;
	usb_unlock_device(udev);
	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 89 84.76% 2 50.00%
oliver neukum oliver neukum 15 14.29% 1 25.00%
greg kroah-hartman greg kroah-hartman 1 0.95% 1 25.00%
Total 105 100.00% 4 100.00%

static DEVICE_ATTR_RW(persist);



static int add_persist_attributes(struct device *dev)
{
	int rc = 0;

	if (is_usb_device(dev)) {
		struct usb_device *udev = to_usb_device(dev);

		/* Hubs are automatically enabled for USB_PERSIST,
                 * no point in creating the attribute file.
                 */
		if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
			rc = sysfs_add_file_to_group(&dev->kobj,
					&dev_attr_persist.attr,
					power_group_name);
	}
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 66 100.00% 3 100.00%
Total 66 100.00% 3 100.00%



static void remove_persist_attributes(struct device *dev)
{
	sysfs_remove_file_from_group(&dev->kobj,
			&dev_attr_persist.attr,
			power_group_name);
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 26 100.00% 2 100.00%
Total 26 100.00% 2 100.00%



static ssize_t connected_duration_show(struct device *dev,
				       struct device_attribute *attr, char *buf)
{
	struct usb_device *udev = to_usb_device(dev);

	return sprintf(buf, "%u\n",
			jiffies_to_msecs(jiffies - udev->connect_time));
}
Contributors
Person Tokens Prop Commits CommitProp
sarah sharp sarah sharp 44 93.62% 1 33.33%
alan stern alan stern 2 4.26% 1 33.33%
greg kroah-hartman greg kroah-hartman 1 2.13% 1 33.33%
Total 47 100.00% 3 100.00%

static DEVICE_ATTR_RO(connected_duration);

/*
 * If the device is resumed, the last time the device was suspended has
 * been pre-subtracted from active_duration.  We add the current time to
 * get the duration that the device was actually active.
 *
 * If the device is suspended, the active_duration is up-to-date.
 */


static ssize_t active_duration_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	int duration;

	if (udev->state != USB_STATE_SUSPENDED)
		duration = jiffies_to_msecs(jiffies + udev->active_duration);
	else
		duration = jiffies_to_msecs(udev->active_duration);
	return sprintf(buf, "%u\n", duration);
}
Contributors
Person Tokens Prop Commits CommitProp
sarah sharp sarah sharp 71 98.61% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 1.39% 1 50.00%
Total 72 100.00% 2 100.00%

static DEVICE_ATTR_RO(active_duration);



static ssize_t autosuspend_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 33 91.67% 3 60.00%
sarah sharp sarah sharp 2 5.56% 1 20.00%
greg kroah-hartman greg kroah-hartman 1 2.78% 1 20.00%
Total 36 100.00% 5 100.00%



static ssize_t autosuspend_store(struct device *dev,
				 struct device_attribute *attr, const char *buf,
				 size_t count)
{
	int value;

	if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
			value <= -INT_MAX/1000)
		return -EINVAL;

	pm_runtime_set_autosuspend_delay(dev, value * 1000);
	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 69 98.57% 6 85.71%
greg kroah-hartman greg kroah-hartman 1 1.43% 1 14.29%
Total 70 100.00% 7 100.00%

static DEVICE_ATTR_RW(autosuspend);


static const char on_string[] = "on";

static const char auto_string[] = "auto";



static void warn_level(void)
{
	static int level_warned;

	if (!level_warned) {
		level_warned = 1;
		printk(KERN_WARNING "WARNING! power/level is deprecated; "
				"use power/control instead\n");
	}
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



static ssize_t level_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	const char *p = auto_string;

	warn_level();
	if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
		p = on_string;
	return sprintf(buf, "%s\n", p);
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 70 98.59% 4 80.00%
greg kroah-hartman greg kroah-hartman 1 1.41% 1 20.00%
Total 71 100.00% 5 100.00%



static ssize_t level_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	struct usb_device *udev = to_usb_device(dev);
	int len = count;
	char *cp;
	int rc = count;
	int rv;

	warn_level();
	cp = memchr(buf, '\n', count);
	if (cp)
		len = cp - buf;

	rv = usb_lock_device_interruptible(udev);
	if (rv < 0)
		return -EINTR;

	if (len == sizeof on_string - 1 &&
			strncmp(buf, on_string, len) == 0)
		usb_disable_autosuspend(udev);

	else if (len == sizeof auto_string - 1 &&
			strncmp(buf, auto_string, len) == 0)
		usb_enable_autosuspend(udev);

	else
		rc = -EINVAL;

	usb_unlock_device(udev);
	return rc;
}
Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 140 89.17% 7 77.78%
oliver neukum oliver neukum 16 10.19% 1 11.11%
greg kroah-hartman greg kroah-hartman 1 0.64% 1 11.11%
Total 157 100.00% 9 100.00%

static DEVICE_ATTR_RW(level);



static ssize_t usb2_hardware_lpm_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	const char *p;

	if (udev->usb2_hw_lpm_allowed == 1)
		p = "enabled";
	else
		p = "disabled";

	return sprintf(buf, "%s\n", p);
}

Contributors
Person Tokens Prop Commits CommitProp
andiry xu andiry xu 60 96.77% 1 33.33%
sarah sharp sarah sharp 1 1.61% 1 33.33%
greg kroah-hartman greg kroah-hartman 1 1.61% 1 33.33%
Total 62 100.00% 3 100.00%



static ssize_t usb2_hardware_lpm_store(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
{
	struct usb_device *udev = to_usb_device(dev);
	bool value;
	int ret;

	ret = usb_lock_device_interruptible(udev);
	if (ret < 0)
		return -EINTR;

	ret = strtobool(buf, &value);

	if (!ret) {
		udev->usb2_hw_lpm_allowed = value;
		ret = usb_set_usb2_hardware_lpm(udev, value);
	}

	usb_unlock_device(udev);

	if (!ret)
		return count;

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
andiry xu andiry xu 83 79.05% 1 25.00%
oliver neukum oliver neukum 13 12.38% 1 25.00%
sarah sharp sarah sharp 8 7.62% 1 25.00%
greg kroah-hartman greg kroah-hartman 1 0.95% 1 25.00%
Total 105 100.00% 4 100.00%

static DEVICE_ATTR_RW(usb2_hardware_lpm);



static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", udev->l1_params.timeout);
}

Contributors
Person Tokens Prop Commits CommitProp
mathias nyman mathias nyman 43 97.73% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 2.27% 1 50.00%
Total 44 100.00% 2 100.00%



static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t count)
{
	struct usb_device *udev = to_usb_device(dev);
	u16 timeout;

	if (kstrtou16(buf, 0, &timeout))
		return -EINVAL;

	udev->l1_params.timeout = timeout;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
mathias nyman mathias nyman 63 98.44% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 1.56% 1 50.00%
Total 64 100.00% 2 100.00%

static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);



static ssize_t usb2_lpm_besl_show(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	return sprintf(buf, "%d\n", udev->l1_params.besl);
}

Contributors
Person Tokens Prop Commits CommitProp
mathias nyman mathias nyman 43 97.73% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 2.27% 1 50.00%
Total 44 100.00% 2 100.00%



static ssize_t usb2_lpm_besl_store(struct device *dev,
				   struct device_attribute *attr,
				   const char *buf, size_t count)
{
	struct usb_device *udev = to_usb_device(dev);
	u8 besl;

	if (kstrtou8(buf, 0, &besl) || besl > 15)
		return -EINVAL;

	udev->l1_params.besl = besl;

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
mathias nyman mathias nyman 67 98.53% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 1.47% 1 50.00%
Total 68 100.00% 2 100.00%

static DEVICE_ATTR_RW(usb2_lpm_besl);



static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	const char *p;
	int rc;

	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;

	if (udev->usb3_lpm_u1_enabled)
		p = "enabled";
	else
		p = "disabled";

	usb_unlock_device(udev);

	return sprintf(buf, "%s\n", p);
}
Contributors
Person Tokens Prop Commits CommitProp
kevin strasser kevin strasser 67 78.82% 1 33.33%
oliver neukum oliver neukum 16 18.82% 1 33.33%
lu baolu lu baolu 2 2.35% 1 33.33%
Total 85 100.00% 3 100.00%

static DEVICE_ATTR_RO(usb3_hardware_lpm_u1);



static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	struct usb_device *udev = to_usb_device(dev);
	const char *p;
	int rc;

	rc = usb_lock_device_interruptible(udev);
	if (rc < 0)
		return -EINTR;

	if (udev->usb3_lpm_u2_enabled)
		p = "enabled";
	else
		p = "disabled";

	usb_unlock_device(udev);

	return sprintf(buf, "%s\n", p);
}
Contributors
Person Tokens Prop Commits CommitProp
lu baolu lu baolu 69 81.18% 1 50.00%
oliver neukum oliver neukum 16 18.82% 1 50.00%
Total 85 100.00% 2 100.00%

static DEVICE_ATTR_RO(usb3_hardware_lpm_u2);


static struct attribute *usb2_hardware_lpm_attr[] = {
	&dev_attr_usb2_hardware_lpm.attr,
	&dev_attr_usb2_lpm_l1_timeout.attr,
	&dev_attr_usb2_lpm_besl.attr,
	NULL,
};

static struct attribute_group usb2_hardware_lpm_attr_group = {
	.name	= power_group_name,
	.attrs	= usb2_hardware_lpm_attr,
};


static struct attribute *usb3_hardware_lpm_attr[] = {
	&dev_attr_usb3_hardware_lpm_u1.attr,
	&dev_attr_usb3_hardware_lpm_u2.attr,
	NULL,
};

static struct attribute_group usb3_hardware_lpm_attr_group = {
	.name	= power_group_name,
	.attrs	= usb3_hardware_lpm_attr,
};


static struct attribute *power_attrs[] = {
	&dev_attr_autosuspend.attr,
	&dev_attr_level.attr,
	&dev_attr_connected_duration.attr,
	&dev_attr_active_duration.attr,
	NULL,
};

static struct attribute_group power_attr_group = {
	.name	= power_group_name,
	.attrs	= power_attrs,
};



static int add_power_attributes(struct device *dev)
{
	int rc = 0;

	if (is_usb_device(dev)) {
		struct usb_device *udev = to_usb_device(dev);
		rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
		if (udev->usb2_hw_lpm_capable == 1)
			rc = sysfs_merge_group(&dev->kobj,
					&usb2_hardware_lpm_attr_group);
		if (udev->speed == USB_SPEED_SUPER &&
				udev->lpm_capable == 1)
			rc = sysfs_merge_group(&dev->kobj,
					&usb3_hardware_lpm_attr_group);
	}

	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
andiry xu andiry xu 33 33.33% 1 16.67%
alan stern alan stern 28 28.28% 2 33.33%
kevin strasser kevin strasser 21 21.21% 1 16.67%
sarah sharp sarah sharp 11 11.11% 1 16.67%
lu baolu lu baolu 6 6.06% 1 16.67%
Total 99 100.00% 6 100.00%



static void remove_power_attributes(struct device *dev)
{
	sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
	sysfs_unmerge_group(&dev->kobj, &power_attr_group);
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 22 66.67% 2 66.67%
andiry xu andiry xu 11 33.33% 1 33.33%
Total 33 100.00% 3 100.00%

#else


#define add_persist_attributes(dev)	0

#define remove_persist_attributes(dev)	do {} while (0)


#define add_power_attributes(dev)	0

#define remove_power_attributes(dev)	do {} while (0)

#endif	/* CONFIG_PM */


/* Descriptor fields */

#define usb_descriptor_attr_le16(field, format_string)			\
static ssize_t                                                          \
field##_show(struct device *dev, struct device_attribute *attr, \
                char *buf)                                              \
{                                                                       \
        struct usb_device *udev;                                        \
                                                                        \
        udev = to_usb_device(dev);                                      \
        return sprintf(buf, format_string,                              \
                        le16_to_cpu(udev->descriptor.field));           \
}                                                                       \
static DEVICE_ATTR_RO(field)

usb_descriptor_attr_le16(idVendor, "%04x\n");
usb_descriptor_attr_le16(idProduct, "%04x\n");
usb_descriptor_attr_le16(bcdDevice, "%04x\n");


#define usb_descriptor_attr(field, format_string)			\
static ssize_t                                                          \
field##_show(struct device *dev, struct device_attribute *attr, \
                char *buf)                                              \
{                                                                       \
        struct usb_device *udev;                                        \
                                                                        \
        udev = to_usb_device(dev);                                      \
        return sprintf(buf, format_string, udev->descriptor.field);     \
}                                                                       \
static DEVICE_ATTR_RO(field)

usb_descriptor_attr(bDeviceClass, "%02x\n");
usb_descriptor_attr(bDeviceSubClass, "%02x\n");
usb_descriptor_attr(bDeviceProtocol, "%02x\n");
usb_descriptor_attr(bNumConfigurations, "%d\n");
usb_descriptor_attr(bMaxPacketSize0, "%d\n");


/* show if the device is authorized (1) or not (0) */


static ssize_t authorized_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct usb_device *usb_dev = to_usb_device(dev);
	return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
}

Contributors
Person Tokens Prop Commits CommitProp
inaky perez-gonzalez inaky perez-gonzalez 43 97.73% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 2.27% 1 50.00%
Total 44 100.00% 2 100.00%

/*
 * Authorize a device to be used in the system
 *
 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
 */


static ssize_t authorized_store(struct device *dev,
				struct device_attribute *attr, const char *buf,
				size_t size)
{
	ssize_t result;
	struct usb_device *usb_dev = to_usb_device(dev);
	unsigned val;
	result = sscanf(buf, "%u\n", &val);
	if (result != 1)
		result = -EINVAL;
	else if (val == 0)
		result = usb_deauthorize_device(usb_dev);
	else
		result = usb_authorize_device(usb_dev);
	return result < 0 ? result : size;
}
Contributors
Person Tokens Prop Commits CommitProp
inaky perez-gonzalez inaky perez-gonzalez 93 98.94% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 1.06% 1 50.00%
Total 94 100.00% 2 100.00%

static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
				  authorized_show, authorized_store);

/* "Safely remove a device" */


static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct usb_device *udev = to_usb_device(dev);
	int rc = 0;

	usb_lock_device(udev);
	if (udev->state != USB_STATE_NOTATTACHED) {

		/* To avoid races, first unconfigure and then remove */
		usb_set_configuration(udev, -1);
		rc = usb_remove_device(udev);
	}
	if (rc == 0)
		rc = count;
	usb_unlock_device(udev);
	return rc;
}
Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 87 98.86% 1 50.00%
greg kroah-hartman greg kroah-hartman 1 1.14% 1 50.00%
Total 88 100.00% 2 100.00%

static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);



static struct attribute *dev_attrs[] = {
	/* current configuration's attributes */
	&dev_attr_configuration.attr,
	&dev_attr_bNumInterfaces.attr,
	&dev_attr_bConfigurationValue.attr,
	&dev_attr_bmAttributes.attr,
	&dev_attr_bMaxPower.attr,
	/* device attributes */
	&dev_attr_urbnum.attr,
	&dev_attr_idVendor.attr,
	&dev_attr_idProduct.attr,
	&dev_attr_bcdDevice.attr,
	&dev_attr_bDeviceClass.attr,
	&dev_attr_bDeviceSubClass.attr,
	&dev_attr_bDeviceProtocol.attr,
	&dev_attr_bNumConfigurations.attr,
	&dev_attr_bMaxPacketSize0.attr,
	&dev_attr_speed.attr,
	&dev_attr_busnum.attr,
	&dev_attr_devnum.attr,
	&dev_attr_devpath.attr,
	&dev_attr_version.attr,
	&dev_attr_maxchild.attr,
	&dev_attr_quirks.attr,
	&dev_attr_avoid_reset_quirk.attr,
	&dev_attr_authorized.attr,
	&dev_attr_remove.attr,
	&dev_attr_removable.attr,
	&dev_attr_ltm_capable.attr,
	NULL,
};

static struct attribute_group dev_attr_grp = {
	.attrs = dev_attrs,
};

/* When modifying this list, be sure to modify dev_string_attrs_are_visible()
 * accordingly.
 */

static struct attribute *dev_string_attrs[] = {
	&dev_attr_manufacturer.attr,
	&dev_attr_product.attr,
	&dev_attr_serial.attr,
	NULL
};



static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
		struct attribute *a, int n)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct usb_device *udev = to_usb_device(dev);

	if (a == &dev_attr_manufacturer.attr) {
		if (udev->manufacturer == NULL)
			return 0;
	} else if (a == &dev_attr_product.attr) {
		if (udev->product == NULL)
			return 0;
	} else if (a == &dev_attr_serial.attr) {
		if (udev->serial == NULL)
			return 0;
	}
	return a->mode;
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 105 89.74% 1 33.33%
h hartley sweeten h hartley sweeten 11 9.40% 1 33.33%
al viro al viro 1 0.85% 1 33.33%
Total 117 100.00% 3 100.00%


static struct attribute_group dev_string_attr_grp = {
	.attrs =	dev_string_attrs,
	.is_visible =	dev_string_attrs_are_visible,
};


const struct attribute_group *usb_device_groups[] = {
	&dev_attr_grp,
	&dev_string_attr_grp,
	NULL
};

/* Binary descriptors */


static ssize_t

read_descriptors(struct file *filp, struct kobject *kobj,
		struct bin_attribute *attr,
		char *buf, loff_t off, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct usb_device *udev = to_usb_device(dev);
	size_t nleft = count;
	size_t srclen, n;
	int cfgno;
	void *src;

	/* The binary attribute begins with the device descriptor.
         * Following that are the raw descriptor entries for all the
         * configurations (config plus subsidiary descriptors).
         */
	for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
			nleft > 0; ++cfgno) {
		if (cfgno < 0) {
			src = &udev->descriptor;
			srclen = sizeof(struct usb_device_descriptor);
		} else {
			src = udev->rawdescriptors[cfgno];
			srclen = __le16_to_cpu(udev->config[cfgno].desc.
					wTotalLength);
		}
		if (off < srclen) {
			n = min(nleft, srclen - (size_t) off);
			memcpy(buf, src + off, n);
			nleft -= n;
			buf += n;
			off = 0;
		} else {
			off -= srclen;
		}
	}
	return count - nleft;
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 190 92.23% 2 50.00%
h hartley sweeten h hartley sweeten 11 5.34% 1 25.00%
chris wright chris wright 5 2.43% 1 25.00%
Total 206 100.00% 4 100.00%


static struct bin_attribute dev_bin_attr_descriptors = {
	.attr = {.name = "descriptors", .mode = 0444},
	.read = read_descriptors,
	.size = 18 + 65535,	/* dev descr + max-size raw descriptor */
};



int usb_create_sysfs_dev_files(struct usb_device *udev)
{
	struct device *dev = &udev->dev;
	int retval;

	retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
	if (retval)
		goto error;

	retval = add_persist_attributes(dev);
	if (retval)
		goto error;

	retval = add_power_attributes(dev);
	if (retval)
		goto error;
	return retval;
error:
	usb_remove_sysfs_dev_files(udev);
	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 48 59.26% 6 66.67%
greg kroah-hartman greg kroah-hartman 33 40.74% 3 33.33%
Total 81 100.00% 9 100.00%



void usb_remove_sysfs_dev_files(struct usb_device *udev)
{
	struct device *dev = &udev->dev;

	remove_power_attributes(dev);
	remove_persist_attributes(dev);
	device_remove_bin_file(dev, &dev_bin_attr_descriptors);
}

Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 20 52.63% 2 40.00%
alan stern alan stern 18 47.37% 3 60.00%
Total 38 100.00% 5 100.00%

/* Interface Association Descriptor fields */

#define usb_intf_assoc_attr(field, format_string)			\
static ssize_t                                                          \
iad_##field##_show(struct device *dev, struct device_attribute *attr,   \
                char *buf)                                              \
{                                                                       \
        struct usb_interface *intf = to_usb_interface(dev);             \
                                                                        \
        return sprintf(buf, format_string,                              \
                        intf->intf_assoc->field);                       \
}                                                                       \
static DEVICE_ATTR_RO(iad_##field)

usb_intf_assoc_attr(bFirstInterface, "%02x\n");
usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
usb_intf_assoc_attr(bFunctionClass, "%02x\n");
usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");

/* Interface fields */

#define usb_intf_attr(field, format_string)				\
static ssize_t                                                          \
field##_show(struct device *dev, struct device_attribute *attr,         \
                char *buf)                                              \
{                                                                       \
        struct usb_interface *intf = to_usb_interface(dev);             \
                                                                        \
        return sprintf(buf, format_string,                              \
                        intf->cur_altsetting->desc.field);              \
}                                                                       \
static DEVICE_ATTR_RO(field)

usb_intf_attr(bInterfaceNumber, "%02x\n");
usb_intf_attr(bAlternateSetting, "%2d\n");
usb_intf_attr(bNumEndpoints, "%02x\n");
usb_intf_attr(bInterfaceClass, "%02x\n");
usb_intf_attr(bInterfaceSubClass, "%02x\n");
usb_intf_attr(bInterfaceProtocol, "%02x\n");



static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
{
	struct usb_interface *intf;
	char *string;

	intf = to_usb_interface(dev);
	string = ACCESS_ONCE(intf->cur_altsetting->string);
	if (!string)
		return 0;
	return sprintf(buf, "%s\n", string);
}
Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 41 63.08% 2 33.33%
alan stern alan stern 16 24.62% 2 33.33%
yani ioannou yani ioannou 5 7.69% 1 16.67%
alex kanavin alex kanavin 3 4.62% 1 16.67%
Total 65 100.00% 6 100.00%

static DEVICE_ATTR_RO(interface);



static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
{
	struct usb_interface *intf;
	struct usb_device *udev;
	struct usb_host_interface *alt;

	intf = to_usb_interface(dev);
	udev = interface_to_usbdev(intf);
	alt = ACCESS_ONCE(intf->cur_altsetting);

	return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
			"ic%02Xisc%02Xip%02Xin%02X\n",
			le16_to_cpu(udev->descriptor.idVendor),
			le16_to_cpu(udev->descriptor.idProduct),
			le16_to_cpu(udev->descriptor.bcdDevice),
			udev->descriptor.bDeviceClass,
			udev->descriptor.bDeviceSubClass,
			udev->descriptor.bDeviceProtocol,
			alt->desc.bInterfaceClass,
			alt->desc.bInterfaceSubClass,
			alt->desc.bInterfaceProtocol,
			alt->desc.bInterfaceNumber);
}
Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 124 91.18% 4 57.14%
bjorn mork bjorn mork 7 5.15% 1 14.29%
alan stern alan stern 3 2.21% 1 14.29%
paulo marques paulo marques 2 1.47% 1 14.29%
Total 136 100.00% 7 100.00%

static DEVICE_ATTR_RO(modalias);



static ssize_t supports_autosuspend_show(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	int s;

	s = device_lock_interruptible(dev);
	if (s < 0)
		return -EINTR;
	/* Devices will be autosuspended even when an interface isn't claimed */
	s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
	device_unlock(dev);

	return sprintf(buf, "%u\n", s);
}
Contributors
Person Tokens Prop Commits CommitProp
sarah sharp sarah sharp 48 64.86% 1 25.00%
oliver neukum oliver neukum 13 17.57% 1 25.00%
alan stern alan stern 12 16.22% 1 25.00%
greg kroah-hartman greg kroah-hartman 1 1.35% 1 25.00%
Total 74 100.00% 4 100.00%

static DEVICE_ATTR_RO(supports_autosuspend);

/*
 * interface_authorized_show - show authorization status of an USB interface
 * 1 is authorized, 0 is deauthorized
 */


static ssize_t interface_authorized_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct usb_interface *intf = to_usb_interface(dev);

	return sprintf(buf, "%u\n", intf->authorized);
}

Contributors
Person Tokens Prop Commits CommitProp
stefan koch stefan koch 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%

/*
 * interface_authorized_store - authorize or deauthorize an USB interface
 */


static ssize_t interface_authorized_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	bool val;

	if (strtobool(buf, &val) != 0)
		return -EINVAL;

	if (val)
		usb_authorize_interface(intf);
	else
		usb_deauthorize_interface(intf);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
stefan koch stefan koch 71 100.00% 1 100.00%
Total 71 100.00% 1 100.00%


static struct device_attribute dev_attr_interface_authorized =
		__ATTR(authorized, S_IRUGO | S_IWUSR,
		interface_authorized_show, interface_authorized_store);


static struct attribute *intf_attrs[] = {
	&dev_attr_bInterfaceNumber.attr,
	&dev_attr_bAlternateSetting.attr,
	&dev_attr_bNumEndpoints.attr,
	&dev_attr_bInterfaceClass.attr,
	&dev_attr_bInterfaceSubClass.attr,
	&dev_attr_bInterfaceProtocol.attr,
	&dev_attr_modalias.attr,
	&dev_attr_supports_autosuspend.attr,
	&dev_attr_interface_authorized.attr,
	NULL,
};

static struct attribute_group intf_attr_grp = {
	.attrs = intf_attrs,
};


static struct attribute *intf_assoc_attrs[] = {
	&dev_attr_iad_bFirstInterface.attr,
	&dev_attr_iad_bInterfaceCount.attr,
	&dev_attr_iad_bFunctionClass.attr,
	&dev_attr_iad_bFunctionSubClass.attr,
	&dev_attr_iad_bFunctionProtocol.attr,
	NULL,
};



static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
		struct attribute *a, int n)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct usb_interface *intf = to_usb_interface(dev);

	if (intf->intf_assoc == NULL)
		return 0;
	return a->mode;
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 48 80.00% 1 33.33%
h hartley sweeten h hartley sweeten 11 18.33% 1 33.33%
al viro al viro 1 1.67% 1 33.33%
Total 60 100.00% 3 100.00%


static struct attribute_group intf_assoc_attr_grp = {
	.attrs =	intf_assoc_attrs,
	.is_visible =	intf_assoc_attrs_are_visible,
};


const struct attribute_group *usb_interface_groups[] = {
	&intf_attr_grp,
	&intf_assoc_attr_grp,
	NULL
};



void usb_create_sysfs_intf_files(struct usb_interface *intf)
{
	struct usb_device *udev = interface_to_usbdev(intf);
	struct usb_host_interface *alt = intf->cur_altsetting;

	if (intf->sysfs_files_created || intf->unregistering)
		return;

	if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
		alt->string = usb_cache_string(udev, alt->desc.iInterface);
	if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
		;	/* We don't actually care if the function fails. */
	intf->sysfs_files_created = 1;
}

Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 66 68.75% 5 45.45%
greg kroah-hartman greg kroah-hartman 12 12.50% 3 27.27%
michal nazarewicz michal nazarewicz 7 7.29% 1 9.09%
craig w. nadler craig w. nadler 6 6.25% 1 9.09%
alex kanavin alex kanavin 5 5.21% 1 9.09%
Total 96 100.00% 11 100.00%



void usb_remove_sysfs_intf_files(struct usb_interface *intf)
{
	if (!intf->sysfs_files_created)
		return;

	device_remove_file(&intf->dev, &dev_attr_interface);
	intf->sysfs_files_created = 0;
}
Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 19 54.29% 3 50.00%
greg kroah-hartman greg kroah-hartman 16 45.71% 3 50.00%
Total 35 100.00% 6 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
alan stern alan stern 1600 33.92% 33 38.37%
greg kroah-hartman greg kroah-hartman 882 18.70% 18 20.93%
oliver neukum oliver neukum 343 7.27% 3 3.49%
sarah sharp sarah sharp 322 6.83% 5 5.81%
mathias nyman mathias nyman 244 5.17% 2 2.33%
andiry xu andiry xu 225 4.77% 1 1.16%
inaky perez-gonzalez inaky perez-gonzalez 151 3.20% 1 1.16%
stefan koch stefan koch 138 2.93% 1 1.16%
robert love robert love 132 2.80% 1 1.16%
kevin strasser kevin strasser 125 2.65% 1 1.16%
david brownell david brownell 109 2.31% 4 4.65%
lu baolu lu baolu 90 1.91% 1 1.16%
matthew garrett matthew garrett 84 1.78% 1 1.16%
craig w. nadler craig w. nadler 80 1.70% 1 1.16%
sebastian andrzej siewior sebastian andrzej siewior 61 1.29% 1 1.16%
yani ioannou yani ioannou 35 0.74% 1 1.16%
h hartley sweeten h hartley sweeten 33 0.70% 1 1.16%
alex kanavin alex kanavin 16 0.34% 1 1.16%
rafael j. wysocki rafael j. wysocki 15 0.32% 1 1.16%
lan tianyu lan tianyu 8 0.17% 2 2.33%
bjorn mork bjorn mork 7 0.15% 1 1.16%
michal nazarewicz michal nazarewicz 7 0.15% 1 1.16%
chris wright chris wright 5 0.11% 1 1.16%
paulo marques paulo marques 2 0.04% 1 1.16%
al viro al viro 2 0.04% 1 1.16%
rahul bedarkar rahul bedarkar 1 0.02% 1 1.16%
Total 4717 100.00% 86 100.00%
  Directory: drivers/usb/core

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
sebastian andrzej siewior	sebastian andrzej siewior	56	61.54%	1	16.67%
alan stern	alan stern	17	18.68%	1	16.67%
oliver neukum	oliver neukum	13	14.29%	1	16.67%
greg kroah-hartman	greg kroah-hartman	5	5.49%	3	50.00%
	Total	91	100.00%	6	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/usb/core/sysfs.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
