LCOV - code coverage report
Current view: top level - drivers/usb/core - sysfs.c (source / functions) Hit Total Coverage
Test: Real Lines: 81 310 26.1 %
Date: 2020-10-17 15:46:16 Functions: 3 81 3.7 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * drivers/usb/core/sysfs.c
       4                 :            :  *
       5                 :            :  * (C) Copyright 2002 David Brownell
       6                 :            :  * (C) Copyright 2002,2004 Greg Kroah-Hartman
       7                 :            :  * (C) Copyright 2002,2004 IBM Corp.
       8                 :            :  *
       9                 :            :  * All of the sysfs file attributes for usb devices and interfaces.
      10                 :            :  *
      11                 :            :  * Released under the GPLv2 only.
      12                 :            :  */
      13                 :            : 
      14                 :            : 
      15                 :            : #include <linux/kernel.h>
      16                 :            : #include <linux/string.h>
      17                 :            : #include <linux/usb.h>
      18                 :            : #include <linux/usb/hcd.h>
      19                 :            : #include <linux/usb/quirks.h>
      20                 :            : #include <linux/of.h>
      21                 :            : #include "usb.h"
      22                 :            : 
      23                 :            : /* Active configuration fields */
      24                 :            : #define usb_actconfig_show(field, format_string)                        \
      25                 :            : static ssize_t field##_show(struct device *dev,                         \
      26                 :            :                             struct device_attribute *attr, char *buf)   \
      27                 :            : {                                                                       \
      28                 :            :         struct usb_device *udev;                                        \
      29                 :            :         struct usb_host_config *actconfig;                              \
      30                 :            :         ssize_t rc;                                                     \
      31                 :            :                                                                         \
      32                 :            :         udev = to_usb_device(dev);                                      \
      33                 :            :         rc = usb_lock_device_interruptible(udev);                       \
      34                 :            :         if (rc < 0)                                                  \
      35                 :            :                 return -EINTR;                                          \
      36                 :            :         actconfig = udev->actconfig;                                 \
      37                 :            :         if (actconfig)                                                  \
      38                 :            :                 rc = sprintf(buf, format_string,                        \
      39                 :            :                                 actconfig->desc.field);                      \
      40                 :            :         usb_unlock_device(udev);                                        \
      41                 :            :         return rc;                                                      \
      42                 :            : }                                                                       \
      43                 :            : 
      44                 :            : #define usb_actconfig_attr(field, format_string)                \
      45                 :            :         usb_actconfig_show(field, format_string)                \
      46                 :            :         static DEVICE_ATTR_RO(field)
      47                 :            : 
      48                 :          0 : usb_actconfig_attr(bNumInterfaces, "%2d\n");
      49                 :          0 : usb_actconfig_attr(bmAttributes, "%2x\n");
      50                 :            : 
      51                 :          0 : static ssize_t bMaxPower_show(struct device *dev,
      52                 :            :                 struct device_attribute *attr, char *buf)
      53                 :            : {
      54                 :            :         struct usb_device *udev;
      55                 :            :         struct usb_host_config *actconfig;
      56                 :            :         ssize_t rc;
      57                 :            : 
      58                 :            :         udev = to_usb_device(dev);
      59                 :            :         rc = usb_lock_device_interruptible(udev);
      60                 :          0 :         if (rc < 0)
      61                 :            :                 return -EINTR;
      62                 :          0 :         actconfig = udev->actconfig;
      63                 :          0 :         if (actconfig)
      64                 :          0 :                 rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
      65                 :            :         usb_unlock_device(udev);
      66                 :          0 :         return rc;
      67                 :            : }
      68                 :            : static DEVICE_ATTR_RO(bMaxPower);
      69                 :            : 
      70                 :          0 : static ssize_t configuration_show(struct device *dev,
      71                 :            :                 struct device_attribute *attr, char *buf)
      72                 :            : {
      73                 :            :         struct usb_device *udev;
      74                 :            :         struct usb_host_config *actconfig;
      75                 :            :         ssize_t rc;
      76                 :            : 
      77                 :            :         udev = to_usb_device(dev);
      78                 :            :         rc = usb_lock_device_interruptible(udev);
      79                 :          0 :         if (rc < 0)
      80                 :            :                 return -EINTR;
      81                 :          0 :         actconfig = udev->actconfig;
      82                 :          0 :         if (actconfig && actconfig->string)
      83                 :          0 :                 rc = sprintf(buf, "%s\n", actconfig->string);
      84                 :            :         usb_unlock_device(udev);
      85                 :          0 :         return rc;
      86                 :            : }
      87                 :            : static DEVICE_ATTR_RO(configuration);
      88                 :            : 
      89                 :            : /* configuration value is always present, and r/w */
      90                 :          1 : usb_actconfig_show(bConfigurationValue, "%u\n");
      91                 :            : 
      92                 :          0 : static ssize_t bConfigurationValue_store(struct device *dev,
      93                 :            :                                          struct device_attribute *attr,
      94                 :            :                                          const char *buf, size_t count)
      95                 :            : {
      96                 :          0 :         struct usb_device       *udev = to_usb_device(dev);
      97                 :            :         int                     config, value, rc;
      98                 :            : 
      99                 :          0 :         if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
     100                 :            :                 return -EINVAL;
     101                 :            :         rc = usb_lock_device_interruptible(udev);
     102                 :          0 :         if (rc < 0)
     103                 :            :                 return -EINTR;
     104                 :          0 :         value = usb_set_configuration(udev, config);
     105                 :            :         usb_unlock_device(udev);
     106                 :          0 :         return (value < 0) ? value : count;
     107                 :            : }
     108                 :            : static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
     109                 :            :                 bConfigurationValue_show, bConfigurationValue_store);
     110                 :            : 
     111                 :            : #ifdef CONFIG_OF
     112                 :          0 : static ssize_t devspec_show(struct device *dev, struct device_attribute *attr,
     113                 :            :                             char *buf)
     114                 :            : {
     115                 :          0 :         struct device_node *of_node = dev->of_node;
     116                 :            : 
     117                 :          0 :         return sprintf(buf, "%pOF\n", of_node);
     118                 :            : }
     119                 :            : static DEVICE_ATTR_RO(devspec);
     120                 :            : #endif
     121                 :            : 
     122                 :            : /* String fields */
     123                 :            : #define usb_string_attr(name)                                           \
     124                 :            : static ssize_t  name##_show(struct device *dev,                         \
     125                 :            :                 struct device_attribute *attr, char *buf)               \
     126                 :            : {                                                                       \
     127                 :            :         struct usb_device *udev;                                        \
     128                 :            :         int retval;                                                     \
     129                 :            :                                                                         \
     130                 :            :         udev = to_usb_device(dev);                                      \
     131                 :            :         retval = usb_lock_device_interruptible(udev);                   \
     132                 :            :         if (retval < 0)                                                      \
     133                 :            :                 return -EINTR;                                          \
     134                 :            :         retval = sprintf(buf, "%s\n", udev->name);                 \
     135                 :            :         usb_unlock_device(udev);                                        \
     136                 :            :         return retval;                                                  \
     137                 :            : }                                                                       \
     138                 :            : static DEVICE_ATTR_RO(name)
     139                 :            : 
     140                 :          3 : usb_string_attr(product);
     141                 :          3 : usb_string_attr(manufacturer);
     142                 :          3 : usb_string_attr(serial);
     143                 :            : 
     144                 :          2 : static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
     145                 :            :                           char *buf)
     146                 :            : {
     147                 :            :         struct usb_device *udev;
     148                 :            :         char *speed;
     149                 :            : 
     150                 :            :         udev = to_usb_device(dev);
     151                 :            : 
     152                 :          2 :         switch (udev->speed) {
     153                 :            :         case USB_SPEED_LOW:
     154                 :            :                 speed = "1.5";
     155                 :            :                 break;
     156                 :            :         case USB_SPEED_UNKNOWN:
     157                 :            :         case USB_SPEED_FULL:
     158                 :            :                 speed = "12";
     159                 :            :                 break;
     160                 :            :         case USB_SPEED_HIGH:
     161                 :            :                 speed = "480";
     162                 :            :                 break;
     163                 :            :         case USB_SPEED_WIRELESS:
     164                 :            :                 speed = "480";
     165                 :            :                 break;
     166                 :            :         case USB_SPEED_SUPER:
     167                 :            :                 speed = "5000";
     168                 :            :                 break;
     169                 :            :         case USB_SPEED_SUPER_PLUS:
     170                 :            :                 speed = "10000";
     171                 :            :                 break;
     172                 :            :         default:
     173                 :            :                 speed = "unknown";
     174                 :            :         }
     175                 :          2 :         return sprintf(buf, "%s\n", speed);
     176                 :            : }
     177                 :            : static DEVICE_ATTR_RO(speed);
     178                 :            : 
     179                 :          0 : static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
     180                 :            :                           char *buf)
     181                 :            : {
     182                 :            :         struct usb_device *udev;
     183                 :            : 
     184                 :            :         udev = to_usb_device(dev);
     185                 :          0 :         return sprintf(buf, "%d\n", udev->rx_lanes);
     186                 :            : }
     187                 :            : static DEVICE_ATTR_RO(rx_lanes);
     188                 :            : 
     189                 :          0 : static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
     190                 :            :                           char *buf)
     191                 :            : {
     192                 :            :         struct usb_device *udev;
     193                 :            : 
     194                 :            :         udev = to_usb_device(dev);
     195                 :          0 :         return sprintf(buf, "%d\n", udev->tx_lanes);
     196                 :            : }
     197                 :            : static DEVICE_ATTR_RO(tx_lanes);
     198                 :            : 
     199                 :          3 : static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
     200                 :            :                            char *buf)
     201                 :            : {
     202                 :            :         struct usb_device *udev;
     203                 :            : 
     204                 :            :         udev = to_usb_device(dev);
     205                 :          3 :         return sprintf(buf, "%d\n", udev->bus->busnum);
     206                 :            : }
     207                 :            : static DEVICE_ATTR_RO(busnum);
     208                 :            : 
     209                 :          3 : static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
     210                 :            :                            char *buf)
     211                 :            : {
     212                 :            :         struct usb_device *udev;
     213                 :            : 
     214                 :            :         udev = to_usb_device(dev);
     215                 :          3 :         return sprintf(buf, "%d\n", udev->devnum);
     216                 :            : }
     217                 :            : static DEVICE_ATTR_RO(devnum);
     218                 :            : 
     219                 :          0 : static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
     220                 :            :                             char *buf)
     221                 :            : {
     222                 :            :         struct usb_device *udev;
     223                 :            : 
     224                 :            :         udev = to_usb_device(dev);
     225                 :          0 :         return sprintf(buf, "%s\n", udev->devpath);
     226                 :            : }
     227                 :            : static DEVICE_ATTR_RO(devpath);
     228                 :            : 
     229                 :          0 : static ssize_t version_show(struct device *dev, struct device_attribute *attr,
     230                 :            :                             char *buf)
     231                 :            : {
     232                 :            :         struct usb_device *udev;
     233                 :            :         u16 bcdUSB;
     234                 :            : 
     235                 :            :         udev = to_usb_device(dev);
     236                 :          0 :         bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
     237                 :          0 :         return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
     238                 :            : }
     239                 :            : static DEVICE_ATTR_RO(version);
     240                 :            : 
     241                 :          0 : static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr,
     242                 :            :                              char *buf)
     243                 :            : {
     244                 :            :         struct usb_device *udev;
     245                 :            : 
     246                 :            :         udev = to_usb_device(dev);
     247                 :          0 :         return sprintf(buf, "%d\n", udev->maxchild);
     248                 :            : }
     249                 :            : static DEVICE_ATTR_RO(maxchild);
     250                 :            : 
     251                 :          0 : static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
     252                 :            :                            char *buf)
     253                 :            : {
     254                 :            :         struct usb_device *udev;
     255                 :            : 
     256                 :            :         udev = to_usb_device(dev);
     257                 :          0 :         return sprintf(buf, "0x%x\n", udev->quirks);
     258                 :            : }
     259                 :            : static DEVICE_ATTR_RO(quirks);
     260                 :            : 
     261                 :          0 : static ssize_t avoid_reset_quirk_show(struct device *dev,
     262                 :            :                                       struct device_attribute *attr, char *buf)
     263                 :            : {
     264                 :            :         struct usb_device *udev;
     265                 :            : 
     266                 :            :         udev = to_usb_device(dev);
     267                 :          0 :         return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
     268                 :            : }
     269                 :            : 
     270                 :          0 : static ssize_t avoid_reset_quirk_store(struct device *dev,
     271                 :            :                                       struct device_attribute *attr,
     272                 :            :                                       const char *buf, size_t count)
     273                 :            : {
     274                 :            :         struct usb_device       *udev = to_usb_device(dev);
     275                 :            :         int                     val, rc;
     276                 :            : 
     277                 :          0 :         if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
     278                 :            :                 return -EINVAL;
     279                 :            :         rc = usb_lock_device_interruptible(udev);
     280                 :          0 :         if (rc < 0)
     281                 :            :                 return -EINTR;
     282                 :          0 :         if (val)
     283                 :          0 :                 udev->quirks |= USB_QUIRK_RESET;
     284                 :            :         else
     285                 :          0 :                 udev->quirks &= ~USB_QUIRK_RESET;
     286                 :            :         usb_unlock_device(udev);
     287                 :          0 :         return count;
     288                 :            : }
     289                 :            : static DEVICE_ATTR_RW(avoid_reset_quirk);
     290                 :            : 
     291                 :          0 : static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
     292                 :            :                            char *buf)
     293                 :            : {
     294                 :            :         struct usb_device *udev;
     295                 :            : 
     296                 :            :         udev = to_usb_device(dev);
     297                 :          0 :         return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
     298                 :            : }
     299                 :            : static DEVICE_ATTR_RO(urbnum);
     300                 :            : 
     301                 :          0 : static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
     302                 :            :                               char *buf)
     303                 :            : {
     304                 :            :         struct usb_device *udev;
     305                 :            :         char *state;
     306                 :            : 
     307                 :            :         udev = to_usb_device(dev);
     308                 :            : 
     309                 :          0 :         switch (udev->removable) {
     310                 :            :         case USB_DEVICE_REMOVABLE:
     311                 :            :                 state = "removable";
     312                 :            :                 break;
     313                 :            :         case USB_DEVICE_FIXED:
     314                 :            :                 state = "fixed";
     315                 :          0 :                 break;
     316                 :            :         default:
     317                 :            :                 state = "unknown";
     318                 :            :         }
     319                 :            : 
     320                 :          0 :         return sprintf(buf, "%s\n", state);
     321                 :            : }
     322                 :            : static DEVICE_ATTR_RO(removable);
     323                 :            : 
     324                 :          0 : static ssize_t ltm_capable_show(struct device *dev,
     325                 :            :                                 struct device_attribute *attr, char *buf)
     326                 :            : {
     327                 :          0 :         if (usb_device_supports_ltm(to_usb_device(dev)))
     328                 :          0 :                 return sprintf(buf, "%s\n", "yes");
     329                 :          0 :         return sprintf(buf, "%s\n", "no");
     330                 :            : }
     331                 :            : static DEVICE_ATTR_RO(ltm_capable);
     332                 :            : 
     333                 :            : #ifdef  CONFIG_PM
     334                 :            : 
     335                 :          0 : static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
     336                 :            :                             char *buf)
     337                 :            : {
     338                 :            :         struct usb_device *udev = to_usb_device(dev);
     339                 :            : 
     340                 :          0 :         return sprintf(buf, "%d\n", udev->persist_enabled);
     341                 :            : }
     342                 :            : 
     343                 :          0 : static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
     344                 :            :                              const char *buf, size_t count)
     345                 :            : {
     346                 :            :         struct usb_device *udev = to_usb_device(dev);
     347                 :            :         int value, rc;
     348                 :            : 
     349                 :            :         /* Hubs are always enabled for USB_PERSIST */
     350                 :          0 :         if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
     351                 :            :                 return -EPERM;
     352                 :            : 
     353                 :          0 :         if (sscanf(buf, "%d", &value) != 1)
     354                 :            :                 return -EINVAL;
     355                 :            : 
     356                 :            :         rc = usb_lock_device_interruptible(udev);
     357                 :          0 :         if (rc < 0)
     358                 :            :                 return -EINTR;
     359                 :          0 :         udev->persist_enabled = !!value;
     360                 :            :         usb_unlock_device(udev);
     361                 :          0 :         return count;
     362                 :            : }
     363                 :            : static DEVICE_ATTR_RW(persist);
     364                 :            : 
     365                 :          3 : static int add_persist_attributes(struct device *dev)
     366                 :            : {
     367                 :            :         int rc = 0;
     368                 :            : 
     369                 :          3 :         if (is_usb_device(dev)) {
     370                 :            :                 struct usb_device *udev = to_usb_device(dev);
     371                 :            : 
     372                 :            :                 /* Hubs are automatically enabled for USB_PERSIST,
     373                 :            :                  * no point in creating the attribute file.
     374                 :            :                  */
     375                 :          3 :                 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
     376                 :          3 :                         rc = sysfs_add_file_to_group(&dev->kobj,
     377                 :            :                                         &dev_attr_persist.attr,
     378                 :            :                                         power_group_name);
     379                 :            :         }
     380                 :          3 :         return rc;
     381                 :            : }
     382                 :            : 
     383                 :            : static void remove_persist_attributes(struct device *dev)
     384                 :            : {
     385                 :          0 :         sysfs_remove_file_from_group(&dev->kobj,
     386                 :            :                         &dev_attr_persist.attr,
     387                 :            :                         power_group_name);
     388                 :            : }
     389                 :            : 
     390                 :          0 : static ssize_t connected_duration_show(struct device *dev,
     391                 :            :                                        struct device_attribute *attr, char *buf)
     392                 :            : {
     393                 :            :         struct usb_device *udev = to_usb_device(dev);
     394                 :            : 
     395                 :          0 :         return sprintf(buf, "%u\n",
     396                 :          0 :                         jiffies_to_msecs(jiffies - udev->connect_time));
     397                 :            : }
     398                 :            : static DEVICE_ATTR_RO(connected_duration);
     399                 :            : 
     400                 :            : /*
     401                 :            :  * If the device is resumed, the last time the device was suspended has
     402                 :            :  * been pre-subtracted from active_duration.  We add the current time to
     403                 :            :  * get the duration that the device was actually active.
     404                 :            :  *
     405                 :            :  * If the device is suspended, the active_duration is up-to-date.
     406                 :            :  */
     407                 :          0 : static ssize_t active_duration_show(struct device *dev,
     408                 :            :                                     struct device_attribute *attr, char *buf)
     409                 :            : {
     410                 :            :         struct usb_device *udev = to_usb_device(dev);
     411                 :            :         int duration;
     412                 :            : 
     413                 :          0 :         if (udev->state != USB_STATE_SUSPENDED)
     414                 :          0 :                 duration = jiffies_to_msecs(jiffies + udev->active_duration);
     415                 :            :         else
     416                 :          0 :                 duration = jiffies_to_msecs(udev->active_duration);
     417                 :          0 :         return sprintf(buf, "%u\n", duration);
     418                 :            : }
     419                 :            : static DEVICE_ATTR_RO(active_duration);
     420                 :            : 
     421                 :          0 : static ssize_t autosuspend_show(struct device *dev,
     422                 :            :                                 struct device_attribute *attr, char *buf)
     423                 :            : {
     424                 :          0 :         return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
     425                 :            : }
     426                 :            : 
     427                 :          0 : static ssize_t autosuspend_store(struct device *dev,
     428                 :            :                                  struct device_attribute *attr, const char *buf,
     429                 :            :                                  size_t count)
     430                 :            : {
     431                 :            :         int value;
     432                 :            : 
     433                 :          0 :         if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
     434                 :            :                         value <= -INT_MAX/1000)
     435                 :            :                 return -EINVAL;
     436                 :            : 
     437                 :          0 :         pm_runtime_set_autosuspend_delay(dev, value * 1000);
     438                 :          0 :         return count;
     439                 :            : }
     440                 :            : static DEVICE_ATTR_RW(autosuspend);
     441                 :            : 
     442                 :            : static const char on_string[] = "on";
     443                 :            : static const char auto_string[] = "auto";
     444                 :            : 
     445                 :            : static void warn_level(void)
     446                 :            : {
     447                 :            :         static int level_warned;
     448                 :            : 
     449                 :          0 :         if (!level_warned) {
     450                 :          0 :                 level_warned = 1;
     451                 :          0 :                 printk(KERN_WARNING "WARNING! power/level is deprecated; "
     452                 :            :                                 "use power/control instead\n");
     453                 :            :         }
     454                 :            : }
     455                 :            : 
     456                 :          0 : static ssize_t level_show(struct device *dev, struct device_attribute *attr,
     457                 :            :                           char *buf)
     458                 :            : {
     459                 :            :         struct usb_device *udev = to_usb_device(dev);
     460                 :            :         const char *p = auto_string;
     461                 :            : 
     462                 :            :         warn_level();
     463                 :          0 :         if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
     464                 :            :                 p = on_string;
     465                 :          0 :         return sprintf(buf, "%s\n", p);
     466                 :            : }
     467                 :            : 
     468                 :          0 : static ssize_t level_store(struct device *dev, struct device_attribute *attr,
     469                 :            :                            const char *buf, size_t count)
     470                 :            : {
     471                 :          0 :         struct usb_device *udev = to_usb_device(dev);
     472                 :          0 :         int len = count;
     473                 :            :         char *cp;
     474                 :            :         int rc = count;
     475                 :            :         int rv;
     476                 :            : 
     477                 :            :         warn_level();
     478                 :          0 :         cp = memchr(buf, '\n', count);
     479                 :          0 :         if (cp)
     480                 :          0 :                 len = cp - buf;
     481                 :            : 
     482                 :            :         rv = usb_lock_device_interruptible(udev);
     483                 :          0 :         if (rv < 0)
     484                 :            :                 return -EINTR;
     485                 :            : 
     486                 :          0 :         if (len == sizeof on_string - 1 &&
     487                 :          0 :                         strncmp(buf, on_string, len) == 0)
     488                 :          0 :                 usb_disable_autosuspend(udev);
     489                 :            : 
     490                 :          0 :         else if (len == sizeof auto_string - 1 &&
     491                 :          0 :                         strncmp(buf, auto_string, len) == 0)
     492                 :          0 :                 usb_enable_autosuspend(udev);
     493                 :            : 
     494                 :            :         else
     495                 :            :                 rc = -EINVAL;
     496                 :            : 
     497                 :            :         usb_unlock_device(udev);
     498                 :          0 :         return rc;
     499                 :            : }
     500                 :            : static DEVICE_ATTR_RW(level);
     501                 :            : 
     502                 :          0 : static ssize_t usb2_hardware_lpm_show(struct device *dev,
     503                 :            :                                       struct device_attribute *attr, char *buf)
     504                 :            : {
     505                 :            :         struct usb_device *udev = to_usb_device(dev);
     506                 :            :         const char *p;
     507                 :            : 
     508                 :          0 :         if (udev->usb2_hw_lpm_allowed == 1)
     509                 :            :                 p = "enabled";
     510                 :            :         else
     511                 :            :                 p = "disabled";
     512                 :            : 
     513                 :          0 :         return sprintf(buf, "%s\n", p);
     514                 :            : }
     515                 :            : 
     516                 :          0 : static ssize_t usb2_hardware_lpm_store(struct device *dev,
     517                 :            :                                        struct device_attribute *attr,
     518                 :            :                                        const char *buf, size_t count)
     519                 :            : {
     520                 :          0 :         struct usb_device *udev = to_usb_device(dev);
     521                 :            :         bool value;
     522                 :            :         int ret;
     523                 :            : 
     524                 :            :         ret = usb_lock_device_interruptible(udev);
     525                 :          0 :         if (ret < 0)
     526                 :            :                 return -EINTR;
     527                 :            : 
     528                 :            :         ret = strtobool(buf, &value);
     529                 :            : 
     530                 :          0 :         if (!ret) {
     531                 :          0 :                 udev->usb2_hw_lpm_allowed = value;
     532                 :          0 :                 if (value)
     533                 :          0 :                         ret = usb_enable_usb2_hardware_lpm(udev);
     534                 :            :                 else
     535                 :          0 :                         ret = usb_disable_usb2_hardware_lpm(udev);
     536                 :            :         }
     537                 :            : 
     538                 :            :         usb_unlock_device(udev);
     539                 :            : 
     540                 :          0 :         if (!ret)
     541                 :          0 :                 return count;
     542                 :            : 
     543                 :            :         return ret;
     544                 :            : }
     545                 :            : static DEVICE_ATTR_RW(usb2_hardware_lpm);
     546                 :            : 
     547                 :          0 : static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
     548                 :            :                                         struct device_attribute *attr,
     549                 :            :                                         char *buf)
     550                 :            : {
     551                 :            :         struct usb_device *udev = to_usb_device(dev);
     552                 :          0 :         return sprintf(buf, "%d\n", udev->l1_params.timeout);
     553                 :            : }
     554                 :            : 
     555                 :          0 : static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
     556                 :            :                                          struct device_attribute *attr,
     557                 :            :                                          const char *buf, size_t count)
     558                 :            : {
     559                 :            :         struct usb_device *udev = to_usb_device(dev);
     560                 :            :         u16 timeout;
     561                 :            : 
     562                 :          0 :         if (kstrtou16(buf, 0, &timeout))
     563                 :            :                 return -EINVAL;
     564                 :            : 
     565                 :          0 :         udev->l1_params.timeout = timeout;
     566                 :            : 
     567                 :          0 :         return count;
     568                 :            : }
     569                 :            : static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
     570                 :            : 
     571                 :          0 : static ssize_t usb2_lpm_besl_show(struct device *dev,
     572                 :            :                                   struct device_attribute *attr, char *buf)
     573                 :            : {
     574                 :            :         struct usb_device *udev = to_usb_device(dev);
     575                 :          0 :         return sprintf(buf, "%d\n", udev->l1_params.besl);
     576                 :            : }
     577                 :            : 
     578                 :          0 : static ssize_t usb2_lpm_besl_store(struct device *dev,
     579                 :            :                                    struct device_attribute *attr,
     580                 :            :                                    const char *buf, size_t count)
     581                 :            : {
     582                 :            :         struct usb_device *udev = to_usb_device(dev);
     583                 :            :         u8 besl;
     584                 :            : 
     585                 :          0 :         if (kstrtou8(buf, 0, &besl) || besl > 15)
     586                 :            :                 return -EINVAL;
     587                 :            : 
     588                 :          0 :         udev->l1_params.besl = besl;
     589                 :            : 
     590                 :          0 :         return count;
     591                 :            : }
     592                 :            : static DEVICE_ATTR_RW(usb2_lpm_besl);
     593                 :            : 
     594                 :          0 : static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
     595                 :            :                                       struct device_attribute *attr, char *buf)
     596                 :            : {
     597                 :            :         struct usb_device *udev = to_usb_device(dev);
     598                 :            :         const char *p;
     599                 :            :         int rc;
     600                 :            : 
     601                 :            :         rc = usb_lock_device_interruptible(udev);
     602                 :          0 :         if (rc < 0)
     603                 :            :                 return -EINTR;
     604                 :            : 
     605                 :          0 :         if (udev->usb3_lpm_u1_enabled)
     606                 :            :                 p = "enabled";
     607                 :            :         else
     608                 :            :                 p = "disabled";
     609                 :            : 
     610                 :            :         usb_unlock_device(udev);
     611                 :            : 
     612                 :          0 :         return sprintf(buf, "%s\n", p);
     613                 :            : }
     614                 :            : static DEVICE_ATTR_RO(usb3_hardware_lpm_u1);
     615                 :            : 
     616                 :          0 : static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
     617                 :            :                                       struct device_attribute *attr, char *buf)
     618                 :            : {
     619                 :            :         struct usb_device *udev = to_usb_device(dev);
     620                 :            :         const char *p;
     621                 :            :         int rc;
     622                 :            : 
     623                 :            :         rc = usb_lock_device_interruptible(udev);
     624                 :          0 :         if (rc < 0)
     625                 :            :                 return -EINTR;
     626                 :            : 
     627                 :          0 :         if (udev->usb3_lpm_u2_enabled)
     628                 :            :                 p = "enabled";
     629                 :            :         else
     630                 :            :                 p = "disabled";
     631                 :            : 
     632                 :            :         usb_unlock_device(udev);
     633                 :            : 
     634                 :          0 :         return sprintf(buf, "%s\n", p);
     635                 :            : }
     636                 :            : static DEVICE_ATTR_RO(usb3_hardware_lpm_u2);
     637                 :            : 
     638                 :            : static struct attribute *usb2_hardware_lpm_attr[] = {
     639                 :            :         &dev_attr_usb2_hardware_lpm.attr,
     640                 :            :         &dev_attr_usb2_lpm_l1_timeout.attr,
     641                 :            :         &dev_attr_usb2_lpm_besl.attr,
     642                 :            :         NULL,
     643                 :            : };
     644                 :            : static struct attribute_group usb2_hardware_lpm_attr_group = {
     645                 :            :         .name   = power_group_name,
     646                 :            :         .attrs  = usb2_hardware_lpm_attr,
     647                 :            : };
     648                 :            : 
     649                 :            : static struct attribute *usb3_hardware_lpm_attr[] = {
     650                 :            :         &dev_attr_usb3_hardware_lpm_u1.attr,
     651                 :            :         &dev_attr_usb3_hardware_lpm_u2.attr,
     652                 :            :         NULL,
     653                 :            : };
     654                 :            : static struct attribute_group usb3_hardware_lpm_attr_group = {
     655                 :            :         .name   = power_group_name,
     656                 :            :         .attrs  = usb3_hardware_lpm_attr,
     657                 :            : };
     658                 :            : 
     659                 :            : static struct attribute *power_attrs[] = {
     660                 :            :         &dev_attr_autosuspend.attr,
     661                 :            :         &dev_attr_level.attr,
     662                 :            :         &dev_attr_connected_duration.attr,
     663                 :            :         &dev_attr_active_duration.attr,
     664                 :            :         NULL,
     665                 :            : };
     666                 :            : static struct attribute_group power_attr_group = {
     667                 :            :         .name   = power_group_name,
     668                 :            :         .attrs  = power_attrs,
     669                 :            : };
     670                 :            : 
     671                 :          3 : static int add_power_attributes(struct device *dev)
     672                 :            : {
     673                 :            :         int rc = 0;
     674                 :            : 
     675                 :          3 :         if (is_usb_device(dev)) {
     676                 :            :                 struct usb_device *udev = to_usb_device(dev);
     677                 :          3 :                 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
     678                 :          3 :                 if (udev->usb2_hw_lpm_capable == 1)
     679                 :          0 :                         rc = sysfs_merge_group(&dev->kobj,
     680                 :            :                                         &usb2_hardware_lpm_attr_group);
     681                 :          3 :                 if ((udev->speed == USB_SPEED_SUPER ||
     682                 :          0 :                      udev->speed == USB_SPEED_SUPER_PLUS) &&
     683                 :          0 :                                 udev->lpm_capable == 1)
     684                 :          0 :                         rc = sysfs_merge_group(&dev->kobj,
     685                 :            :                                         &usb3_hardware_lpm_attr_group);
     686                 :            :         }
     687                 :            : 
     688                 :          3 :         return rc;
     689                 :            : }
     690                 :            : 
     691                 :          0 : static void remove_power_attributes(struct device *dev)
     692                 :            : {
     693                 :          0 :         sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
     694                 :          0 :         sysfs_unmerge_group(&dev->kobj, &power_attr_group);
     695                 :          0 : }
     696                 :            : 
     697                 :            : #else
     698                 :            : 
     699                 :            : #define add_persist_attributes(dev)     0
     700                 :            : #define remove_persist_attributes(dev)  do {} while (0)
     701                 :            : 
     702                 :            : #define add_power_attributes(dev)       0
     703                 :            : #define remove_power_attributes(dev)    do {} while (0)
     704                 :            : 
     705                 :            : #endif  /* CONFIG_PM */
     706                 :            : 
     707                 :            : 
     708                 :            : /* Descriptor fields */
     709                 :            : #define usb_descriptor_attr_le16(field, format_string)                  \
     710                 :            : static ssize_t                                                          \
     711                 :            : field##_show(struct device *dev, struct device_attribute *attr, \
     712                 :            :                 char *buf)                                              \
     713                 :            : {                                                                       \
     714                 :            :         struct usb_device *udev;                                        \
     715                 :            :                                                                         \
     716                 :            :         udev = to_usb_device(dev);                                      \
     717                 :            :         return sprintf(buf, format_string,                              \
     718                 :            :                         le16_to_cpu(udev->descriptor.field));                \
     719                 :            : }                                                                       \
     720                 :            : static DEVICE_ATTR_RO(field)
     721                 :            : 
     722                 :          3 : usb_descriptor_attr_le16(idVendor, "%04x\n");
     723                 :          3 : usb_descriptor_attr_le16(idProduct, "%04x\n");
     724                 :          3 : usb_descriptor_attr_le16(bcdDevice, "%04x\n");
     725                 :            : 
     726                 :            : #define usb_descriptor_attr(field, format_string)                       \
     727                 :            : static ssize_t                                                          \
     728                 :            : field##_show(struct device *dev, struct device_attribute *attr, \
     729                 :            :                 char *buf)                                              \
     730                 :            : {                                                                       \
     731                 :            :         struct usb_device *udev;                                        \
     732                 :            :                                                                         \
     733                 :            :         udev = to_usb_device(dev);                                      \
     734                 :            :         return sprintf(buf, format_string, udev->descriptor.field);  \
     735                 :            : }                                                                       \
     736                 :            : static DEVICE_ATTR_RO(field)
     737                 :            : 
     738                 :          3 : usb_descriptor_attr(bDeviceClass, "%02x\n");
     739                 :          0 : usb_descriptor_attr(bDeviceSubClass, "%02x\n");
     740                 :          0 : usb_descriptor_attr(bDeviceProtocol, "%02x\n");
     741                 :          0 : usb_descriptor_attr(bNumConfigurations, "%d\n");
     742                 :          0 : usb_descriptor_attr(bMaxPacketSize0, "%d\n");
     743                 :            : 
     744                 :            : 
     745                 :            : /* show if the device is authorized (1) or not (0) */
     746                 :          0 : static ssize_t authorized_show(struct device *dev,
     747                 :            :                                struct device_attribute *attr, char *buf)
     748                 :            : {
     749                 :            :         struct usb_device *usb_dev = to_usb_device(dev);
     750                 :          0 :         return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
     751                 :            : }
     752                 :            : 
     753                 :            : /*
     754                 :            :  * Authorize a device to be used in the system
     755                 :            :  *
     756                 :            :  * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
     757                 :            :  */
     758                 :          0 : static ssize_t authorized_store(struct device *dev,
     759                 :            :                                 struct device_attribute *attr, const char *buf,
     760                 :            :                                 size_t size)
     761                 :            : {
     762                 :            :         ssize_t result;
     763                 :          0 :         struct usb_device *usb_dev = to_usb_device(dev);
     764                 :            :         unsigned val;
     765                 :          0 :         result = sscanf(buf, "%u\n", &val);
     766                 :          0 :         if (result != 1)
     767                 :            :                 result = -EINVAL;
     768                 :          0 :         else if (val == 0)
     769                 :          0 :                 result = usb_deauthorize_device(usb_dev);
     770                 :            :         else
     771                 :          0 :                 result = usb_authorize_device(usb_dev);
     772                 :          0 :         return result < 0 ? result : size;
     773                 :            : }
     774                 :            : static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
     775                 :            :                                   authorized_show, authorized_store);
     776                 :            : 
     777                 :            : /* "Safely remove a device" */
     778                 :          0 : static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
     779                 :            :                             const char *buf, size_t count)
     780                 :            : {
     781                 :          0 :         struct usb_device *udev = to_usb_device(dev);
     782                 :            :         int rc = 0;
     783                 :            : 
     784                 :            :         usb_lock_device(udev);
     785                 :          0 :         if (udev->state != USB_STATE_NOTATTACHED) {
     786                 :            : 
     787                 :            :                 /* To avoid races, first unconfigure and then remove */
     788                 :          0 :                 usb_set_configuration(udev, -1);
     789                 :          0 :                 rc = usb_remove_device(udev);
     790                 :            :         }
     791                 :          0 :         if (rc == 0)
     792                 :          0 :                 rc = count;
     793                 :            :         usb_unlock_device(udev);
     794                 :          0 :         return rc;
     795                 :            : }
     796                 :            : static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
     797                 :            : 
     798                 :            : 
     799                 :            : static struct attribute *dev_attrs[] = {
     800                 :            :         /* current configuration's attributes */
     801                 :            :         &dev_attr_configuration.attr,
     802                 :            :         &dev_attr_bNumInterfaces.attr,
     803                 :            :         &dev_attr_bConfigurationValue.attr,
     804                 :            :         &dev_attr_bmAttributes.attr,
     805                 :            :         &dev_attr_bMaxPower.attr,
     806                 :            :         /* device attributes */
     807                 :            :         &dev_attr_urbnum.attr,
     808                 :            :         &dev_attr_idVendor.attr,
     809                 :            :         &dev_attr_idProduct.attr,
     810                 :            :         &dev_attr_bcdDevice.attr,
     811                 :            :         &dev_attr_bDeviceClass.attr,
     812                 :            :         &dev_attr_bDeviceSubClass.attr,
     813                 :            :         &dev_attr_bDeviceProtocol.attr,
     814                 :            :         &dev_attr_bNumConfigurations.attr,
     815                 :            :         &dev_attr_bMaxPacketSize0.attr,
     816                 :            :         &dev_attr_speed.attr,
     817                 :            :         &dev_attr_rx_lanes.attr,
     818                 :            :         &dev_attr_tx_lanes.attr,
     819                 :            :         &dev_attr_busnum.attr,
     820                 :            :         &dev_attr_devnum.attr,
     821                 :            :         &dev_attr_devpath.attr,
     822                 :            :         &dev_attr_version.attr,
     823                 :            :         &dev_attr_maxchild.attr,
     824                 :            :         &dev_attr_quirks.attr,
     825                 :            :         &dev_attr_avoid_reset_quirk.attr,
     826                 :            :         &dev_attr_authorized.attr,
     827                 :            :         &dev_attr_remove.attr,
     828                 :            :         &dev_attr_removable.attr,
     829                 :            :         &dev_attr_ltm_capable.attr,
     830                 :            : #ifdef CONFIG_OF
     831                 :            :         &dev_attr_devspec.attr,
     832                 :            : #endif
     833                 :            :         NULL,
     834                 :            : };
     835                 :            : static struct attribute_group dev_attr_grp = {
     836                 :            :         .attrs = dev_attrs,
     837                 :            : };
     838                 :            : 
     839                 :            : /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
     840                 :            :  * accordingly.
     841                 :            :  */
     842                 :            : static struct attribute *dev_string_attrs[] = {
     843                 :            :         &dev_attr_manufacturer.attr,
     844                 :            :         &dev_attr_product.attr,
     845                 :            :         &dev_attr_serial.attr,
     846                 :            :         NULL
     847                 :            : };
     848                 :            : 
     849                 :          3 : static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
     850                 :            :                 struct attribute *a, int n)
     851                 :            : {
     852                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
     853                 :            :         struct usb_device *udev = to_usb_device(dev);
     854                 :            : 
     855                 :          3 :         if (a == &dev_attr_manufacturer.attr) {
     856                 :          3 :                 if (udev->manufacturer == NULL)
     857                 :            :                         return 0;
     858                 :          3 :         } else if (a == &dev_attr_product.attr) {
     859                 :          3 :                 if (udev->product == NULL)
     860                 :            :                         return 0;
     861                 :          3 :         } else if (a == &dev_attr_serial.attr) {
     862                 :          3 :                 if (udev->serial == NULL)
     863                 :            :                         return 0;
     864                 :            :         }
     865                 :          3 :         return a->mode;
     866                 :            : }
     867                 :            : 
     868                 :            : static struct attribute_group dev_string_attr_grp = {
     869                 :            :         .attrs =        dev_string_attrs,
     870                 :            :         .is_visible =   dev_string_attrs_are_visible,
     871                 :            : };
     872                 :            : 
     873                 :            : const struct attribute_group *usb_device_groups[] = {
     874                 :            :         &dev_attr_grp,
     875                 :            :         &dev_string_attr_grp,
     876                 :            :         NULL
     877                 :            : };
     878                 :            : 
     879                 :            : /* Binary descriptors */
     880                 :            : 
     881                 :            : static ssize_t
     882                 :          3 : read_descriptors(struct file *filp, struct kobject *kobj,
     883                 :            :                 struct bin_attribute *attr,
     884                 :            :                 char *buf, loff_t off, size_t count)
     885                 :            : {
     886                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
     887                 :            :         struct usb_device *udev = to_usb_device(dev);
     888                 :            :         size_t nleft = count;
     889                 :            :         size_t srclen, n;
     890                 :            :         int cfgno;
     891                 :            :         void *src;
     892                 :            : 
     893                 :            :         /* The binary attribute begins with the device descriptor.
     894                 :            :          * Following that are the raw descriptor entries for all the
     895                 :            :          * configurations (config plus subsidiary descriptors).
     896                 :            :          */
     897                 :          3 :         for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
     898                 :          3 :                         nleft > 0; ++cfgno) {
     899                 :          3 :                 if (cfgno < 0) {
     900                 :          3 :                         src = &udev->descriptor;
     901                 :            :                         srclen = sizeof(struct usb_device_descriptor);
     902                 :            :                 } else {
     903                 :          3 :                         src = udev->rawdescriptors[cfgno];
     904                 :          3 :                         srclen = __le16_to_cpu(udev->config[cfgno].desc.
     905                 :            :                                         wTotalLength);
     906                 :            :                 }
     907                 :          3 :                 if (off < srclen) {
     908                 :          3 :                         n = min(nleft, srclen - (size_t) off);
     909                 :          3 :                         memcpy(buf, src + off, n);
     910                 :          3 :                         nleft -= n;
     911                 :          3 :                         buf += n;
     912                 :            :                         off = 0;
     913                 :            :                 } else {
     914                 :          1 :                         off -= srclen;
     915                 :            :                 }
     916                 :            :         }
     917                 :          3 :         return count - nleft;
     918                 :            : }
     919                 :            : 
     920                 :            : static struct bin_attribute dev_bin_attr_descriptors = {
     921                 :            :         .attr = {.name = "descriptors", .mode = 0444},
     922                 :            :         .read = read_descriptors,
     923                 :            :         .size = 18 + 65535,     /* dev descr + max-size raw descriptor */
     924                 :            : };
     925                 :            : 
     926                 :            : /*
     927                 :            :  * Show & store the current value of authorized_default
     928                 :            :  */
     929                 :          0 : static ssize_t authorized_default_show(struct device *dev,
     930                 :            :                                        struct device_attribute *attr, char *buf)
     931                 :            : {
     932                 :            :         struct usb_device *rh_usb_dev = to_usb_device(dev);
     933                 :          0 :         struct usb_bus *usb_bus = rh_usb_dev->bus;
     934                 :            :         struct usb_hcd *hcd;
     935                 :            : 
     936                 :            :         hcd = bus_to_hcd(usb_bus);
     937                 :          0 :         return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy);
     938                 :            : }
     939                 :            : 
     940                 :          0 : static ssize_t authorized_default_store(struct device *dev,
     941                 :            :                                         struct device_attribute *attr,
     942                 :            :                                         const char *buf, size_t size)
     943                 :            : {
     944                 :            :         ssize_t result;
     945                 :            :         unsigned int val;
     946                 :            :         struct usb_device *rh_usb_dev = to_usb_device(dev);
     947                 :          0 :         struct usb_bus *usb_bus = rh_usb_dev->bus;
     948                 :            :         struct usb_hcd *hcd;
     949                 :            : 
     950                 :            :         hcd = bus_to_hcd(usb_bus);
     951                 :          0 :         result = sscanf(buf, "%u\n", &val);
     952                 :          0 :         if (result == 1) {
     953                 :          0 :                 hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ?
     954                 :            :                         val : USB_DEVICE_AUTHORIZE_ALL;
     955                 :          0 :                 result = size;
     956                 :            :         } else {
     957                 :            :                 result = -EINVAL;
     958                 :            :         }
     959                 :          0 :         return result;
     960                 :            : }
     961                 :            : static DEVICE_ATTR_RW(authorized_default);
     962                 :            : 
     963                 :            : /*
     964                 :            :  * interface_authorized_default_show - show default authorization status
     965                 :            :  * for USB interfaces
     966                 :            :  *
     967                 :            :  * note: interface_authorized_default is the default value
     968                 :            :  *       for initializing the authorized attribute of interfaces
     969                 :            :  */
     970                 :          0 : static ssize_t interface_authorized_default_show(struct device *dev,
     971                 :            :                 struct device_attribute *attr, char *buf)
     972                 :            : {
     973                 :            :         struct usb_device *usb_dev = to_usb_device(dev);
     974                 :          0 :         struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
     975                 :            : 
     976                 :          0 :         return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd));
     977                 :            : }
     978                 :            : 
     979                 :            : /*
     980                 :            :  * interface_authorized_default_store - store default authorization status
     981                 :            :  * for USB interfaces
     982                 :            :  *
     983                 :            :  * note: interface_authorized_default is the default value
     984                 :            :  *       for initializing the authorized attribute of interfaces
     985                 :            :  */
     986                 :          0 : static ssize_t interface_authorized_default_store(struct device *dev,
     987                 :            :                 struct device_attribute *attr, const char *buf, size_t count)
     988                 :            : {
     989                 :            :         struct usb_device *usb_dev = to_usb_device(dev);
     990                 :          0 :         struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
     991                 :          0 :         int rc = count;
     992                 :            :         bool val;
     993                 :            : 
     994                 :          0 :         if (strtobool(buf, &val) != 0)
     995                 :            :                 return -EINVAL;
     996                 :            : 
     997                 :          0 :         if (val)
     998                 :          0 :                 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
     999                 :            :         else
    1000                 :          0 :                 clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
    1001                 :            : 
    1002                 :          0 :         return rc;
    1003                 :            : }
    1004                 :            : static DEVICE_ATTR_RW(interface_authorized_default);
    1005                 :            : 
    1006                 :            : /* Group all the USB bus attributes */
    1007                 :            : static struct attribute *usb_bus_attrs[] = {
    1008                 :            :                 &dev_attr_authorized_default.attr,
    1009                 :            :                 &dev_attr_interface_authorized_default.attr,
    1010                 :            :                 NULL,
    1011                 :            : };
    1012                 :            : 
    1013                 :            : static const struct attribute_group usb_bus_attr_group = {
    1014                 :            :         .name = NULL,   /* we want them in the same directory */
    1015                 :            :         .attrs = usb_bus_attrs,
    1016                 :            : };
    1017                 :            : 
    1018                 :            : 
    1019                 :            : static int add_default_authorized_attributes(struct device *dev)
    1020                 :            : {
    1021                 :            :         int rc = 0;
    1022                 :            : 
    1023                 :          3 :         if (is_usb_device(dev))
    1024                 :          3 :                 rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group);
    1025                 :            : 
    1026                 :            :         return rc;
    1027                 :            : }
    1028                 :            : 
    1029                 :            : static void remove_default_authorized_attributes(struct device *dev)
    1030                 :            : {
    1031                 :          0 :         if (is_usb_device(dev)) {
    1032                 :          0 :                 sysfs_remove_group(&dev->kobj, &usb_bus_attr_group);
    1033                 :            :         }
    1034                 :            : }
    1035                 :            : 
    1036                 :          3 : int usb_create_sysfs_dev_files(struct usb_device *udev)
    1037                 :            : {
    1038                 :          3 :         struct device *dev = &udev->dev;
    1039                 :            :         int retval;
    1040                 :            : 
    1041                 :          3 :         retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
    1042                 :          3 :         if (retval)
    1043                 :            :                 goto error;
    1044                 :            : 
    1045                 :          3 :         retval = add_persist_attributes(dev);
    1046                 :          3 :         if (retval)
    1047                 :            :                 goto error;
    1048                 :            : 
    1049                 :          3 :         retval = add_power_attributes(dev);
    1050                 :          3 :         if (retval)
    1051                 :            :                 goto error;
    1052                 :            : 
    1053                 :          3 :         if (is_root_hub(udev)) {
    1054                 :            :                 retval = add_default_authorized_attributes(dev);
    1055                 :          3 :                 if (retval)
    1056                 :            :                         goto error;
    1057                 :            :         }
    1058                 :          3 :         return retval;
    1059                 :            : 
    1060                 :            : error:
    1061                 :          0 :         usb_remove_sysfs_dev_files(udev);
    1062                 :          0 :         return retval;
    1063                 :            : }
    1064                 :            : 
    1065                 :          0 : void usb_remove_sysfs_dev_files(struct usb_device *udev)
    1066                 :            : {
    1067                 :          0 :         struct device *dev = &udev->dev;
    1068                 :            : 
    1069                 :          0 :         if (is_root_hub(udev))
    1070                 :            :                 remove_default_authorized_attributes(dev);
    1071                 :            : 
    1072                 :          0 :         remove_power_attributes(dev);
    1073                 :            :         remove_persist_attributes(dev);
    1074                 :          0 :         device_remove_bin_file(dev, &dev_bin_attr_descriptors);
    1075                 :          0 : }
    1076                 :            : 
    1077                 :            : /* Interface Association Descriptor fields */
    1078                 :            : #define usb_intf_assoc_attr(field, format_string)                       \
    1079                 :            : static ssize_t                                                          \
    1080                 :            : iad_##field##_show(struct device *dev, struct device_attribute *attr,   \
    1081                 :            :                 char *buf)                                              \
    1082                 :            : {                                                                       \
    1083                 :            :         struct usb_interface *intf = to_usb_interface(dev);             \
    1084                 :            :                                                                         \
    1085                 :            :         return sprintf(buf, format_string,                              \
    1086                 :            :                         intf->intf_assoc->field);                         \
    1087                 :            : }                                                                       \
    1088                 :            : static DEVICE_ATTR_RO(iad_##field)
    1089                 :            : 
    1090                 :          0 : usb_intf_assoc_attr(bFirstInterface, "%02x\n");
    1091                 :          0 : usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
    1092                 :          0 : usb_intf_assoc_attr(bFunctionClass, "%02x\n");
    1093                 :          0 : usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
    1094                 :          0 : usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
    1095                 :            : 
    1096                 :            : /* Interface fields */
    1097                 :            : #define usb_intf_attr(field, format_string)                             \
    1098                 :            : static ssize_t                                                          \
    1099                 :            : field##_show(struct device *dev, struct device_attribute *attr,         \
    1100                 :            :                 char *buf)                                              \
    1101                 :            : {                                                                       \
    1102                 :            :         struct usb_interface *intf = to_usb_interface(dev);             \
    1103                 :            :                                                                         \
    1104                 :            :         return sprintf(buf, format_string,                              \
    1105                 :            :                         intf->cur_altsetting->desc.field);                \
    1106                 :            : }                                                                       \
    1107                 :            : static DEVICE_ATTR_RO(field)
    1108                 :            : 
    1109                 :          3 : usb_intf_attr(bInterfaceNumber, "%02x\n");
    1110                 :          0 : usb_intf_attr(bAlternateSetting, "%2d\n");
    1111                 :          3 : usb_intf_attr(bNumEndpoints, "%02x\n");
    1112                 :          3 : usb_intf_attr(bInterfaceClass, "%02x\n");
    1113                 :          3 : usb_intf_attr(bInterfaceSubClass, "%02x\n");
    1114                 :          3 : usb_intf_attr(bInterfaceProtocol, "%02x\n");
    1115                 :            : 
    1116                 :          0 : static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
    1117                 :            :                               char *buf)
    1118                 :            : {
    1119                 :            :         struct usb_interface *intf;
    1120                 :            :         char *string;
    1121                 :            : 
    1122                 :            :         intf = to_usb_interface(dev);
    1123                 :          0 :         string = READ_ONCE(intf->cur_altsetting->string);
    1124                 :          0 :         if (!string)
    1125                 :            :                 return 0;
    1126                 :          0 :         return sprintf(buf, "%s\n", string);
    1127                 :            : }
    1128                 :            : static DEVICE_ATTR_RO(interface);
    1129                 :            : 
    1130                 :          0 : static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
    1131                 :            :                              char *buf)
    1132                 :            : {
    1133                 :            :         struct usb_interface *intf;
    1134                 :            :         struct usb_device *udev;
    1135                 :            :         struct usb_host_interface *alt;
    1136                 :            : 
    1137                 :            :         intf = to_usb_interface(dev);
    1138                 :            :         udev = interface_to_usbdev(intf);
    1139                 :          0 :         alt = READ_ONCE(intf->cur_altsetting);
    1140                 :            : 
    1141                 :          0 :         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
    1142                 :            :                         "ic%02Xisc%02Xip%02Xin%02X\n",
    1143                 :          0 :                         le16_to_cpu(udev->descriptor.idVendor),
    1144                 :          0 :                         le16_to_cpu(udev->descriptor.idProduct),
    1145                 :          0 :                         le16_to_cpu(udev->descriptor.bcdDevice),
    1146                 :          0 :                         udev->descriptor.bDeviceClass,
    1147                 :          0 :                         udev->descriptor.bDeviceSubClass,
    1148                 :          0 :                         udev->descriptor.bDeviceProtocol,
    1149                 :          0 :                         alt->desc.bInterfaceClass,
    1150                 :          0 :                         alt->desc.bInterfaceSubClass,
    1151                 :          0 :                         alt->desc.bInterfaceProtocol,
    1152                 :          0 :                         alt->desc.bInterfaceNumber);
    1153                 :            : }
    1154                 :            : static DEVICE_ATTR_RO(modalias);
    1155                 :            : 
    1156                 :          0 : static ssize_t supports_autosuspend_show(struct device *dev,
    1157                 :            :                                          struct device_attribute *attr,
    1158                 :            :                                          char *buf)
    1159                 :            : {
    1160                 :            :         int s;
    1161                 :            : 
    1162                 :            :         s = device_lock_interruptible(dev);
    1163                 :          0 :         if (s < 0)
    1164                 :            :                 return -EINTR;
    1165                 :            :         /* Devices will be autosuspended even when an interface isn't claimed */
    1166                 :          0 :         s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
    1167                 :            :         device_unlock(dev);
    1168                 :            : 
    1169                 :          0 :         return sprintf(buf, "%u\n", s);
    1170                 :            : }
    1171                 :            : static DEVICE_ATTR_RO(supports_autosuspend);
    1172                 :            : 
    1173                 :            : /*
    1174                 :            :  * interface_authorized_show - show authorization status of an USB interface
    1175                 :            :  * 1 is authorized, 0 is deauthorized
    1176                 :            :  */
    1177                 :          0 : static ssize_t interface_authorized_show(struct device *dev,
    1178                 :            :                 struct device_attribute *attr, char *buf)
    1179                 :            : {
    1180                 :            :         struct usb_interface *intf = to_usb_interface(dev);
    1181                 :            : 
    1182                 :          0 :         return sprintf(buf, "%u\n", intf->authorized);
    1183                 :            : }
    1184                 :            : 
    1185                 :            : /*
    1186                 :            :  * interface_authorized_store - authorize or deauthorize an USB interface
    1187                 :            :  */
    1188                 :          0 : static ssize_t interface_authorized_store(struct device *dev,
    1189                 :            :                 struct device_attribute *attr, const char *buf, size_t count)
    1190                 :            : {
    1191                 :          0 :         struct usb_interface *intf = to_usb_interface(dev);
    1192                 :            :         bool val;
    1193                 :            : 
    1194                 :          0 :         if (strtobool(buf, &val) != 0)
    1195                 :            :                 return -EINVAL;
    1196                 :            : 
    1197                 :          0 :         if (val)
    1198                 :          0 :                 usb_authorize_interface(intf);
    1199                 :            :         else
    1200                 :          0 :                 usb_deauthorize_interface(intf);
    1201                 :            : 
    1202                 :          0 :         return count;
    1203                 :            : }
    1204                 :            : static struct device_attribute dev_attr_interface_authorized =
    1205                 :            :                 __ATTR(authorized, S_IRUGO | S_IWUSR,
    1206                 :            :                 interface_authorized_show, interface_authorized_store);
    1207                 :            : 
    1208                 :            : static struct attribute *intf_attrs[] = {
    1209                 :            :         &dev_attr_bInterfaceNumber.attr,
    1210                 :            :         &dev_attr_bAlternateSetting.attr,
    1211                 :            :         &dev_attr_bNumEndpoints.attr,
    1212                 :            :         &dev_attr_bInterfaceClass.attr,
    1213                 :            :         &dev_attr_bInterfaceSubClass.attr,
    1214                 :            :         &dev_attr_bInterfaceProtocol.attr,
    1215                 :            :         &dev_attr_modalias.attr,
    1216                 :            :         &dev_attr_supports_autosuspend.attr,
    1217                 :            :         &dev_attr_interface_authorized.attr,
    1218                 :            :         NULL,
    1219                 :            : };
    1220                 :            : static struct attribute_group intf_attr_grp = {
    1221                 :            :         .attrs = intf_attrs,
    1222                 :            : };
    1223                 :            : 
    1224                 :            : static struct attribute *intf_assoc_attrs[] = {
    1225                 :            :         &dev_attr_iad_bFirstInterface.attr,
    1226                 :            :         &dev_attr_iad_bInterfaceCount.attr,
    1227                 :            :         &dev_attr_iad_bFunctionClass.attr,
    1228                 :            :         &dev_attr_iad_bFunctionSubClass.attr,
    1229                 :            :         &dev_attr_iad_bFunctionProtocol.attr,
    1230                 :            :         NULL,
    1231                 :            : };
    1232                 :            : 
    1233                 :          3 : static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
    1234                 :            :                 struct attribute *a, int n)
    1235                 :            : {
    1236                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
    1237                 :            :         struct usb_interface *intf = to_usb_interface(dev);
    1238                 :            : 
    1239                 :          3 :         if (intf->intf_assoc == NULL)
    1240                 :            :                 return 0;
    1241                 :          0 :         return a->mode;
    1242                 :            : }
    1243                 :            : 
    1244                 :            : static struct attribute_group intf_assoc_attr_grp = {
    1245                 :            :         .attrs =        intf_assoc_attrs,
    1246                 :            :         .is_visible =   intf_assoc_attrs_are_visible,
    1247                 :            : };
    1248                 :            : 
    1249                 :            : const struct attribute_group *usb_interface_groups[] = {
    1250                 :            :         &intf_attr_grp,
    1251                 :            :         &intf_assoc_attr_grp,
    1252                 :            :         NULL
    1253                 :            : };
    1254                 :            : 
    1255                 :          3 : void usb_create_sysfs_intf_files(struct usb_interface *intf)
    1256                 :            : {
    1257                 :            :         struct usb_device *udev = interface_to_usbdev(intf);
    1258                 :          3 :         struct usb_host_interface *alt = intf->cur_altsetting;
    1259                 :            : 
    1260                 :          3 :         if (intf->sysfs_files_created || intf->unregistering)
    1261                 :          3 :                 return;
    1262                 :            : 
    1263                 :          3 :         if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
    1264                 :          3 :                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
    1265                 :          3 :         if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
    1266                 :            :                 ;       /* We don't actually care if the function fails. */
    1267                 :          3 :         intf->sysfs_files_created = 1;
    1268                 :            : }
    1269                 :            : 
    1270                 :          3 : void usb_remove_sysfs_intf_files(struct usb_interface *intf)
    1271                 :            : {
    1272                 :          3 :         if (!intf->sysfs_files_created)
    1273                 :          3 :                 return;
    1274                 :            : 
    1275                 :          3 :         device_remove_file(&intf->dev, &dev_attr_interface);
    1276                 :          3 :         intf->sysfs_files_created = 0;
    1277                 :            : }
    

Generated by: LCOV version 1.14