Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * drivers/usb/generic.c - generic driver for USB devices (not interfaces)
       4                 :            :  *
       5                 :            :  * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
       6                 :            :  *
       7                 :            :  * based on drivers/usb/usb.c which had the following copyrights:
       8                 :            :  *      (C) Copyright Linus Torvalds 1999
       9                 :            :  *      (C) Copyright Johannes Erdfelt 1999-2001
      10                 :            :  *      (C) Copyright Andreas Gal 1999
      11                 :            :  *      (C) Copyright Gregory P. Smith 1999
      12                 :            :  *      (C) Copyright Deti Fliegl 1999 (new USB architecture)
      13                 :            :  *      (C) Copyright Randy Dunlap 2000
      14                 :            :  *      (C) Copyright David Brownell 2000-2004
      15                 :            :  *      (C) Copyright Yggdrasil Computing, Inc. 2000
      16                 :            :  *              (usb_device_id matching changes by Adam J. Richter)
      17                 :            :  *      (C) Copyright Greg Kroah-Hartman 2002-2003
      18                 :            :  *
      19                 :            :  * Released under the GPLv2 only.
      20                 :            :  */
      21                 :            : 
      22                 :            : #include <linux/usb.h>
      23                 :            : #include <linux/usb/hcd.h>
      24                 :            : #include <uapi/linux/usb/audio.h>
      25                 :            : #include "usb.h"
      26                 :            : 
      27                 :            : static inline const char *plural(int n)
      28                 :            : {
      29                 :          0 :         return (n == 1 ? "" : "s");
      30                 :            : }
      31                 :            : 
      32                 :            : static int is_rndis(struct usb_interface_descriptor *desc)
      33                 :            : {
      34                 :          1 :         return desc->bInterfaceClass == USB_CLASS_COMM
      35                 :          1 :                 && desc->bInterfaceSubClass == 2
      36                 :          1 :                 && desc->bInterfaceProtocol == 0xff;
      37                 :            : }
      38                 :            : 
      39                 :            : static int is_activesync(struct usb_interface_descriptor *desc)
      40                 :            : {
      41                 :            :         return desc->bInterfaceClass == USB_CLASS_MISC
      42                 :          0 :                 && desc->bInterfaceSubClass == 1
      43                 :          0 :                 && desc->bInterfaceProtocol == 1;
      44                 :            : }
      45                 :            : 
      46                 :            : static bool is_audio(struct usb_interface_descriptor *desc)
      47                 :            : {
      48                 :          3 :         return desc->bInterfaceClass == USB_CLASS_AUDIO;
      49                 :            : }
      50                 :            : 
      51                 :            : static bool is_uac3_config(struct usb_interface_descriptor *desc)
      52                 :            : {
      53                 :          0 :         return desc->bInterfaceProtocol == UAC_VERSION_3;
      54                 :            : }
      55                 :            : 
      56                 :          3 : int usb_choose_configuration(struct usb_device *udev)
      57                 :            : {
      58                 :            :         int i;
      59                 :            :         int num_configs;
      60                 :            :         int insufficient_power = 0;
      61                 :            :         struct usb_host_config *c, *best;
      62                 :            : 
      63                 :          3 :         if (usb_device_is_owned(udev))
      64                 :            :                 return 0;
      65                 :            : 
      66                 :            :         best = NULL;
      67                 :          3 :         c = udev->config;
      68                 :          3 :         num_configs = udev->descriptor.bNumConfigurations;
      69                 :          3 :         for (i = 0; i < num_configs; (i++, c++)) {
      70                 :            :                 struct usb_interface_descriptor *desc = NULL;
      71                 :            : 
      72                 :            :                 /* It's possible that a config has no interfaces! */
      73                 :          3 :                 if (c->desc.bNumInterfaces > 0)
      74                 :          3 :                         desc = &c->intf_cache[0]->altsetting->desc;
      75                 :            : 
      76                 :            :                 /*
      77                 :            :                  * HP's USB bus-powered keyboard has only one configuration
      78                 :            :                  * and it claims to be self-powered; other devices may have
      79                 :            :                  * similar errors in their descriptors.  If the next test
      80                 :            :                  * were allowed to execute, such configurations would always
      81                 :            :                  * be rejected and the devices would not work as expected.
      82                 :            :                  * In the meantime, we run the risk of selecting a config
      83                 :            :                  * that requires external power at a time when that power
      84                 :            :                  * isn't available.  It seems to be the lesser of two evils.
      85                 :            :                  *
      86                 :            :                  * Bugzilla #6448 reports a device that appears to crash
      87                 :            :                  * when it receives a GET_DEVICE_STATUS request!  We don't
      88                 :            :                  * have any other way to tell whether a device is self-powered,
      89                 :            :                  * but since we don't use that information anywhere but here,
      90                 :            :                  * the call has been removed.
      91                 :            :                  *
      92                 :            :                  * Maybe the GET_DEVICE_STATUS call and the test below can
      93                 :            :                  * be reinstated when device firmwares become more reliable.
      94                 :            :                  * Don't hold your breath.
      95                 :            :                  */
      96                 :            : #if 0
      97                 :            :                 /* Rule out self-powered configs for a bus-powered device */
      98                 :            :                 if (bus_powered && (c->desc.bmAttributes &
      99                 :            :                                         USB_CONFIG_ATT_SELFPOWER))
     100                 :            :                         continue;
     101                 :            : #endif
     102                 :            : 
     103                 :            :                 /*
     104                 :            :                  * The next test may not be as effective as it should be.
     105                 :            :                  * Some hubs have errors in their descriptor, claiming
     106                 :            :                  * to be self-powered when they are really bus-powered.
     107                 :            :                  * We will overestimate the amount of current such hubs
     108                 :            :                  * make available for each port.
     109                 :            :                  *
     110                 :            :                  * This is a fairly benign sort of failure.  It won't
     111                 :            :                  * cause us to reject configurations that we should have
     112                 :            :                  * accepted.
     113                 :            :                  */
     114                 :            : 
     115                 :            :                 /* Rule out configs that draw too much bus current */
     116                 :          3 :                 if (usb_get_max_power(udev, c) > udev->bus_mA) {
     117                 :          0 :                         insufficient_power++;
     118                 :          0 :                         continue;
     119                 :            :                 }
     120                 :            : 
     121                 :            :                 /*
     122                 :            :                  * Select first configuration as default for audio so that
     123                 :            :                  * devices that don't comply with UAC3 protocol are supported.
     124                 :            :                  * But, still iterate through other configurations and
     125                 :            :                  * select UAC3 compliant config if present.
     126                 :            :                  */
     127                 :          3 :                 if (desc && is_audio(desc)) {
     128                 :            :                         /* Always prefer the first found UAC3 config */
     129                 :          0 :                         if (is_uac3_config(desc)) {
     130                 :          0 :                                 best = c;
     131                 :          0 :                                 break;
     132                 :            :                         }
     133                 :            : 
     134                 :            :                         /* If there is no UAC3 config, prefer the first config */
     135                 :          0 :                         else if (i == 0)
     136                 :            :                                 best = c;
     137                 :            : 
     138                 :            :                         /* Unconditional continue, because the rest of the code
     139                 :            :                          * in the loop is irrelevant for audio devices, and
     140                 :            :                          * because it can reassign best, which for audio devices
     141                 :            :                          * we don't want.
     142                 :            :                          */
     143                 :          0 :                         continue;
     144                 :            :                 }
     145                 :            : 
     146                 :            :                 /* When the first config's first interface is one of Microsoft's
     147                 :            :                  * pet nonstandard Ethernet-over-USB protocols, ignore it unless
     148                 :            :                  * this kernel has enabled the necessary host side driver.
     149                 :            :                  * But: Don't ignore it if it's the only config.
     150                 :            :                  */
     151                 :          3 :                 if (i == 0 && num_configs > 1 && desc &&
     152                 :          0 :                                 (is_rndis(desc) || is_activesync(desc))) {
     153                 :            : #if !defined(CONFIG_USB_NET_RNDIS_HOST) && !defined(CONFIG_USB_NET_RNDIS_HOST_MODULE)
     154                 :            :                         continue;
     155                 :            : #else
     156                 :            :                         best = c;
     157                 :            : #endif
     158                 :            :                 }
     159                 :            : 
     160                 :            :                 /* From the remaining configs, choose the first one whose
     161                 :            :                  * first interface is for a non-vendor-specific class.
     162                 :            :                  * Reason: Linux is more likely to have a class driver
     163                 :            :                  * than a vendor-specific driver. */
     164                 :          3 :                 else if (udev->descriptor.bDeviceClass !=
     165                 :          3 :                                                 USB_CLASS_VENDOR_SPEC &&
     166                 :          3 :                                 (desc && desc->bInterfaceClass !=
     167                 :            :                                                 USB_CLASS_VENDOR_SPEC)) {
     168                 :          3 :                         best = c;
     169                 :          3 :                         break;
     170                 :            :                 }
     171                 :            : 
     172                 :            :                 /* If all the remaining configs are vendor-specific,
     173                 :            :                  * choose the first one. */
     174                 :          2 :                 else if (!best)
     175                 :            :                         best = c;
     176                 :            :         }
     177                 :            : 
     178                 :          3 :         if (insufficient_power > 0)
     179                 :          0 :                 dev_info(&udev->dev, "rejected %d configuration%s "
     180                 :            :                         "due to insufficient available bus power\n",
     181                 :            :                         insufficient_power, plural(insufficient_power));
     182                 :            : 
     183                 :          3 :         if (best) {
     184                 :          3 :                 i = best->desc.bConfigurationValue;
     185                 :            :                 dev_dbg(&udev->dev,
     186                 :            :                         "configuration #%d chosen from %d choice%s\n",
     187                 :            :                         i, num_configs, plural(num_configs));
     188                 :            :         } else {
     189                 :            :                 i = -1;
     190                 :          0 :                 dev_warn(&udev->dev,
     191                 :            :                         "no configuration chosen from %d choice%s\n",
     192                 :            :                         num_configs, plural(num_configs));
     193                 :          0 :                 dev_warn(&udev->dev, "No support over %dmA\n", udev->bus_mA);
     194                 :            :         }
     195                 :          3 :         return i;
     196                 :            : }
     197                 :            : EXPORT_SYMBOL_GPL(usb_choose_configuration);
     198                 :            : 
     199                 :          3 : static int generic_probe(struct usb_device *udev)
     200                 :            : {
     201                 :            :         int err, c;
     202                 :            : 
     203                 :            :         /* Choose and set the configuration.  This registers the interfaces
     204                 :            :          * with the driver core and lets interface drivers bind to them.
     205                 :            :          */
     206                 :          3 :         if (udev->authorized == 0)
     207                 :          0 :                 dev_err(&udev->dev, "Device is not authorized for usage\n");
     208                 :            :         else {
     209                 :          3 :                 c = usb_choose_configuration(udev);
     210                 :          3 :                 if (c >= 0) {
     211                 :          3 :                         err = usb_set_configuration(udev, c);
     212                 :          3 :                         if (err && err != -ENODEV) {
     213                 :          0 :                                 dev_err(&udev->dev, "can't set config #%d, error %d\n",
     214                 :            :                                         c, err);
     215                 :            :                                 /* This need not be fatal.  The user can try to
     216                 :            :                                  * set other configurations. */
     217                 :            :                         }
     218                 :            :                 }
     219                 :            :         }
     220                 :            :         /* USB device state == configured ... usable */
     221                 :          3 :         usb_notify_add_device(udev);
     222                 :            : 
     223                 :          3 :         return 0;
     224                 :            : }
     225                 :            : 
     226                 :          0 : static void generic_disconnect(struct usb_device *udev)
     227                 :            : {
     228                 :          0 :         usb_notify_remove_device(udev);
     229                 :            : 
     230                 :            :         /* if this is only an unbind, not a physical disconnect, then
     231                 :            :          * unconfigure the device */
     232                 :          0 :         if (udev->actconfig)
     233                 :          0 :                 usb_set_configuration(udev, -1);
     234                 :          0 : }
     235                 :            : 
     236                 :            : #ifdef  CONFIG_PM
     237                 :            : 
     238                 :          0 : static int generic_suspend(struct usb_device *udev, pm_message_t msg)
     239                 :            : {
     240                 :            :         int rc;
     241                 :            : 
     242                 :            :         /* Normal USB devices suspend through their upstream port.
     243                 :            :          * Root hubs don't have upstream ports to suspend,
     244                 :            :          * so we have to shut down their downstream HC-to-USB
     245                 :            :          * interfaces manually by doing a bus (or "global") suspend.
     246                 :            :          */
     247                 :          0 :         if (!udev->parent)
     248                 :          0 :                 rc = hcd_bus_suspend(udev, msg);
     249                 :            : 
     250                 :            :         /*
     251                 :            :          * Non-root USB2 devices don't need to do anything for FREEZE
     252                 :            :          * or PRETHAW. USB3 devices don't support global suspend and
     253                 :            :          * needs to be selectively suspended.
     254                 :            :          */
     255                 :          0 :         else if ((msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
     256                 :          0 :                  && (udev->speed < USB_SPEED_SUPER))
     257                 :            :                 rc = 0;
     258                 :            :         else
     259                 :          0 :                 rc = usb_port_suspend(udev, msg);
     260                 :            : 
     261                 :          0 :         if (rc == 0)
     262                 :          0 :                 usbfs_notify_suspend(udev);
     263                 :          0 :         return rc;
     264                 :            : }
     265                 :            : 
     266                 :          0 : static int generic_resume(struct usb_device *udev, pm_message_t msg)
     267                 :            : {
     268                 :            :         int rc;
     269                 :            : 
     270                 :            :         /* Normal USB devices resume/reset through their upstream port.
     271                 :            :          * Root hubs don't have upstream ports to resume or reset,
     272                 :            :          * so we have to start up their downstream HC-to-USB
     273                 :            :          * interfaces manually by doing a bus (or "global") resume.
     274                 :            :          */
     275                 :          0 :         if (!udev->parent)
     276                 :          0 :                 rc = hcd_bus_resume(udev, msg);
     277                 :            :         else
     278                 :          0 :                 rc = usb_port_resume(udev, msg);
     279                 :            : 
     280                 :          0 :         if (rc == 0)
     281                 :          0 :                 usbfs_notify_resume(udev);
     282                 :          0 :         return rc;
     283                 :            : }
     284                 :            : 
     285                 :            : #endif  /* CONFIG_PM */
     286                 :            : 
     287                 :            : struct usb_device_driver usb_generic_driver = {
     288                 :            :         .name = "usb",
     289                 :            :         .probe = generic_probe,
     290                 :            :         .disconnect = generic_disconnect,
     291                 :            : #ifdef  CONFIG_PM
     292                 :            :         .suspend = generic_suspend,
     293                 :            :         .resume = generic_resume,
     294                 :            : #endif
     295                 :            :         .supports_autosuspend = 1,
     296                 :            : };