[l1k:smsc95xx_5.17 56/887] drivers/usb/core/message.c:2155:36: sparse: sparse: restricted __le16 degrades to integer

[kernel test robot]

tree:   https://github.com/l1k/linux smsc95xx_5.17
head:   240f56c27361c195cd502d95aba51c6b8e5b808c
commit: a8197852bb8f1f6804cff9442d426888e97aaed3 [56/887] Add dwc_otg driver
config: nios2-randconfig-s032-20220408 (https://download.01.org/0day-ci/archive/20220409/202204090227.0vFmXBXd-lkp@xxxxxxxxx/config)
compiler: nios2-linux-gcc (GCC) 11.2.0
reproduce:
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # apt-get install sparse
        # sparse version: v0.6.4-dirty
        # https://github.com/l1k/linux/commit/a8197852bb8f1f6804cff9442d426888e97aaed3
        git remote add l1k https://github.com/l1k/linux
        git fetch --no-tags l1k smsc95xx_5.17
        git checkout a8197852bb8f1f6804cff9442d426888e97aaed3
        # save the config file to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' O=build_dir ARCH=nios2 SHELL=/bin/bash

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@xxxxxxxxx>


sparse warnings: (new ones prefixed by >>)
>> drivers/usb/core/message.c:2155:36: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer
   drivers/usb/core/message.c:2163:56: sparse: sparse: restricted __le16 degrades to integer

vim +2155 drivers/usb/core/message.c

  1909	
  1910	
  1911	/*
  1912	 * usb_set_configuration - Makes a particular device setting be current
  1913	 * @dev: the device whose configuration is being updated
  1914	 * @configuration: the configuration being chosen.
  1915	 *
  1916	 * Context: task context, might sleep. Caller holds device lock.
  1917	 *
  1918	 * This is used to enable non-default device modes.  Not all devices
  1919	 * use this kind of configurability; many devices only have one
  1920	 * configuration.
  1921	 *
  1922	 * @configuration is the value of the configuration to be installed.
  1923	 * According to the USB spec (e.g. section 9.1.1.5), configuration values
  1924	 * must be non-zero; a value of zero indicates that the device in
  1925	 * unconfigured.  However some devices erroneously use 0 as one of their
  1926	 * configuration values.  To help manage such devices, this routine will
  1927	 * accept @configuration = -1 as indicating the device should be put in
  1928	 * an unconfigured state.
  1929	 *
  1930	 * USB device configurations may affect Linux interoperability,
  1931	 * power consumption and the functionality available.  For example,
  1932	 * the default configuration is limited to using 100mA of bus power,
  1933	 * so that when certain device functionality requires more power,
  1934	 * and the device is bus powered, that functionality should be in some
  1935	 * non-default device configuration.  Other device modes may also be
  1936	 * reflected as configuration options, such as whether two ISDN
  1937	 * channels are available independently; and choosing between open
  1938	 * standard device protocols (like CDC) or proprietary ones.
  1939	 *
  1940	 * Note that a non-authorized device (dev->authorized == 0) will only
  1941	 * be put in unconfigured mode.
  1942	 *
  1943	 * Note that USB has an additional level of device configurability,
  1944	 * associated with interfaces.  That configurability is accessed using
  1945	 * usb_set_interface().
  1946	 *
  1947	 * This call is synchronous. The calling context must be able to sleep,
  1948	 * must own the device lock, and must not hold the driver model's USB
  1949	 * bus mutex; usb interface driver probe() methods cannot use this routine.
  1950	 *
  1951	 * Returns zero on success, or else the status code returned by the
  1952	 * underlying call that failed.  On successful completion, each interface
  1953	 * in the original device configuration has been destroyed, and each one
  1954	 * in the new configuration has been probed by all relevant usb device
  1955	 * drivers currently known to the kernel.
  1956	 */
  1957	int usb_set_configuration(struct usb_device *dev, int configuration)
  1958	{
  1959		int i, ret;
  1960		struct usb_host_config *cp = NULL;
  1961		struct usb_interface **new_interfaces = NULL;
  1962		struct usb_hcd *hcd = bus_to_hcd(dev->bus);
  1963		int n, nintf;
  1964	
  1965		if (dev->authorized == 0 || configuration == -1)
  1966			configuration = 0;
  1967		else {
  1968			for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
  1969				if (dev->config[i].desc.bConfigurationValue ==
  1970						configuration) {
  1971					cp = &dev->config[i];
  1972					break;
  1973				}
  1974			}
  1975		}
  1976		if ((!cp && configuration != 0))
  1977			return -EINVAL;
  1978	
  1979		/* The USB spec says configuration 0 means unconfigured.
  1980		 * But if a device includes a configuration numbered 0,
  1981		 * we will accept it as a correctly configured state.
  1982		 * Use -1 if you really want to unconfigure the device.
  1983		 */
  1984		if (cp && configuration == 0)
  1985			dev_warn(&dev->dev, "config 0 descriptor??\n");
  1986	
  1987		/* Allocate memory for new interfaces before doing anything else,
  1988		 * so that if we run out then nothing will have changed. */
  1989		n = nintf = 0;
  1990		if (cp) {
  1991			nintf = cp->desc.bNumInterfaces;
  1992			new_interfaces = kmalloc_array(nintf, sizeof(*new_interfaces),
  1993						       GFP_NOIO);
  1994			if (!new_interfaces)
  1995				return -ENOMEM;
  1996	
  1997			for (; n < nintf; ++n) {
  1998				new_interfaces[n] = kzalloc(
  1999						sizeof(struct usb_interface),
  2000						GFP_NOIO);
  2001				if (!new_interfaces[n]) {
  2002					ret = -ENOMEM;
  2003	free_interfaces:
  2004					while (--n >= 0)
  2005						kfree(new_interfaces[n]);
  2006					kfree(new_interfaces);
  2007					return ret;
  2008				}
  2009			}
  2010	
  2011			i = dev->bus_mA - usb_get_max_power(dev, cp);
  2012			if (i < 0)
  2013				dev_warn(&dev->dev, "new config #%d exceeds power "
  2014						"limit by %dmA\n",
  2015						configuration, -i);
  2016		}
  2017	
  2018		/* Wake up the device so we can send it the Set-Config request */
  2019		ret = usb_autoresume_device(dev);
  2020		if (ret)
  2021			goto free_interfaces;
  2022	
  2023		/* if it's already configured, clear out old state first.
  2024		 * getting rid of old interfaces means unbinding their drivers.
  2025		 */
  2026		if (dev->state != USB_STATE_ADDRESS)
  2027			usb_disable_device(dev, 1);	/* Skip ep0 */
  2028	
  2029		/* Get rid of pending async Set-Config requests for this device */
  2030		cancel_async_set_config(dev);
  2031	
  2032		/* Make sure we have bandwidth (and available HCD resources) for this
  2033		 * configuration.  Remove endpoints from the schedule if we're dropping
  2034		 * this configuration to set configuration 0.  After this point, the
  2035		 * host controller will not allow submissions to dropped endpoints.  If
  2036		 * this call fails, the device state is unchanged.
  2037		 */
  2038		mutex_lock(hcd->bandwidth_mutex);
  2039		/* Disable LPM, and re-enable it once the new configuration is
  2040		 * installed, so that the xHCI driver can recalculate the U1/U2
  2041		 * timeouts.
  2042		 */
  2043		if (dev->actconfig && usb_disable_lpm(dev)) {
  2044			dev_err(&dev->dev, "%s Failed to disable LPM\n", __func__);
  2045			mutex_unlock(hcd->bandwidth_mutex);
  2046			ret = -ENOMEM;
  2047			goto free_interfaces;
  2048		}
  2049		ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL);
  2050		if (ret < 0) {
  2051			if (dev->actconfig)
  2052				usb_enable_lpm(dev);
  2053			mutex_unlock(hcd->bandwidth_mutex);
  2054			usb_autosuspend_device(dev);
  2055			goto free_interfaces;
  2056		}
  2057	
  2058		/*
  2059		 * Initialize the new interface structures and the
  2060		 * hc/hcd/usbcore interface/endpoint state.
  2061		 */
  2062		for (i = 0; i < nintf; ++i) {
  2063			struct usb_interface_cache *intfc;
  2064			struct usb_interface *intf;
  2065			struct usb_host_interface *alt;
  2066			u8 ifnum;
  2067	
  2068			cp->interface[i] = intf = new_interfaces[i];
  2069			intfc = cp->intf_cache[i];
  2070			intf->altsetting = intfc->altsetting;
  2071			intf->num_altsetting = intfc->num_altsetting;
  2072			intf->authorized = !!HCD_INTF_AUTHORIZED(hcd);
  2073			kref_get(&intfc->ref);
  2074	
  2075			alt = usb_altnum_to_altsetting(intf, 0);
  2076	
  2077			/* No altsetting 0?  We'll assume the first altsetting.
  2078			 * We could use a GetInterface call, but if a device is
  2079			 * so non-compliant that it doesn't have altsetting 0
  2080			 * then I wouldn't trust its reply anyway.
  2081			 */
  2082			if (!alt)
  2083				alt = &intf->altsetting[0];
  2084	
  2085			ifnum = alt->desc.bInterfaceNumber;
  2086			intf->intf_assoc = find_iad(dev, cp, ifnum);
  2087			intf->cur_altsetting = alt;
  2088			usb_enable_interface(dev, intf, true);
  2089			intf->dev.parent = &dev->dev;
  2090			if (usb_of_has_combined_node(dev)) {
  2091				device_set_of_node_from_dev(&intf->dev, &dev->dev);
  2092			} else {
  2093				intf->dev.of_node = usb_of_get_interface_node(dev,
  2094						configuration, ifnum);
  2095			}
  2096			ACPI_COMPANION_SET(&intf->dev, ACPI_COMPANION(&dev->dev));
  2097			intf->dev.driver = NULL;
  2098			intf->dev.bus = &usb_bus_type;
  2099			intf->dev.type = &usb_if_device_type;
  2100			intf->dev.groups = usb_interface_groups;
  2101			INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
  2102			intf->minor = -1;
  2103			device_initialize(&intf->dev);
  2104			pm_runtime_no_callbacks(&intf->dev);
  2105			dev_set_name(&intf->dev, "%d-%s:%d.%d", dev->bus->busnum,
  2106					dev->devpath, configuration, ifnum);
  2107			usb_get_dev(dev);
  2108		}
  2109		kfree(new_interfaces);
  2110	
  2111		ret = usb_control_msg_send(dev, 0, USB_REQ_SET_CONFIGURATION, 0,
  2112					   configuration, 0, NULL, 0,
  2113					   USB_CTRL_SET_TIMEOUT, GFP_NOIO);
  2114		if (ret && cp) {
  2115			/*
  2116			 * All the old state is gone, so what else can we do?
  2117			 * The device is probably useless now anyway.
  2118			 */
  2119			usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
  2120			for (i = 0; i < nintf; ++i) {
  2121				usb_disable_interface(dev, cp->interface[i], true);
  2122				put_device(&cp->interface[i]->dev);
  2123				cp->interface[i] = NULL;
  2124			}
  2125			cp = NULL;
  2126		}
  2127	
  2128		dev->actconfig = cp;
  2129		mutex_unlock(hcd->bandwidth_mutex);
  2130	
  2131		if (!cp) {
  2132			usb_set_device_state(dev, USB_STATE_ADDRESS);
  2133	
  2134			/* Leave LPM disabled while the device is unconfigured. */
  2135			usb_autosuspend_device(dev);
  2136			return ret;
  2137		}
  2138		usb_set_device_state(dev, USB_STATE_CONFIGURED);
  2139	
  2140		if (cp->string == NULL &&
  2141				!(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
  2142			cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
  2143	/* Uncomment this define to enable the HS Electrical Test support */
  2144	#define DWC_HS_ELECT_TST 1
  2145	#ifdef DWC_HS_ELECT_TST
  2146			/* Here we implement the HS Electrical Test support. The
  2147			 * tester uses a vendor ID of 0x1A0A to indicate we should
  2148			 * run a special test sequence. The product ID tells us
  2149			 * which sequence to run. We invoke the test sequence by
  2150			 * sending a non-standard SetFeature command to our root
  2151			 * hub port. Our dwc_otg_hcd_hub_control() routine will
  2152			 * recognize the command and perform the desired test
  2153			 * sequence.
  2154			 */
> 2155			if (dev->descriptor.idVendor == 0x1A0A) {
  2156				/* HSOTG Electrical Test */
  2157				dev_warn(&dev->dev, "VID from HSOTG Electrical Test Fixture\n");
  2158	
  2159				if (dev->bus && dev->bus->root_hub) {
  2160					struct usb_device *hdev = dev->bus->root_hub;
  2161					dev_warn(&dev->dev, "Got PID 0x%x\n", dev->descriptor.idProduct);
  2162	
  2163					switch (dev->descriptor.idProduct) {
  2164					case 0x0101:	/* TEST_SE0_NAK */
  2165						dev_warn(&dev->dev, "TEST_SE0_NAK\n");
  2166						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2167								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2168								USB_PORT_FEAT_TEST, 0x300, NULL, 0, HZ);
  2169						break;
  2170	
  2171					case 0x0102:	/* TEST_J */
  2172						dev_warn(&dev->dev, "TEST_J\n");
  2173						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2174								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2175								USB_PORT_FEAT_TEST, 0x100, NULL, 0, HZ);
  2176						break;
  2177	
  2178					case 0x0103:	/* TEST_K */
  2179						dev_warn(&dev->dev, "TEST_K\n");
  2180						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2181								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2182								USB_PORT_FEAT_TEST, 0x200, NULL, 0, HZ);
  2183						break;
  2184	
  2185					case 0x0104:	/* TEST_PACKET */
  2186						dev_warn(&dev->dev, "TEST_PACKET\n");
  2187						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2188								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2189								USB_PORT_FEAT_TEST, 0x400, NULL, 0, HZ);
  2190						break;
  2191	
  2192					case 0x0105:	/* TEST_FORCE_ENABLE */
  2193						dev_warn(&dev->dev, "TEST_FORCE_ENABLE\n");
  2194						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2195								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2196								USB_PORT_FEAT_TEST, 0x500, NULL, 0, HZ);
  2197						break;
  2198	
  2199					case 0x0106:	/* HS_HOST_PORT_SUSPEND_RESUME */
  2200						dev_warn(&dev->dev, "HS_HOST_PORT_SUSPEND_RESUME\n");
  2201						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2202								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2203								USB_PORT_FEAT_TEST, 0x600, NULL, 0, 40 * HZ);
  2204						break;
  2205	
  2206					case 0x0107:	/* SINGLE_STEP_GET_DEVICE_DESCRIPTOR setup */
  2207						dev_warn(&dev->dev, "SINGLE_STEP_GET_DEVICE_DESCRIPTOR setup\n");
  2208						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2209								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2210								USB_PORT_FEAT_TEST, 0x700, NULL, 0, 40 * HZ);
  2211						break;
  2212	
  2213					case 0x0108:	/* SINGLE_STEP_GET_DEVICE_DESCRIPTOR execute */
  2214						dev_warn(&dev->dev, "SINGLE_STEP_GET_DEVICE_DESCRIPTOR execute\n");
  2215						usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  2216								USB_REQ_SET_FEATURE, USB_RT_PORT,
  2217								USB_PORT_FEAT_TEST, 0x800, NULL, 0, 40 * HZ);
  2218					}
  2219				}
  2220			}
  2221	#endif /* DWC_HS_ELECT_TST */
  2222	
  2223		/* Now that the interfaces are installed, re-enable LPM. */
  2224		usb_unlocked_enable_lpm(dev);
  2225		/* Enable LTM if it was turned off by usb_disable_device. */
  2226		usb_enable_ltm(dev);
  2227	
  2228		/* Now that all the interfaces are set up, register them
  2229		 * to trigger binding of drivers to interfaces.  probe()
  2230		 * routines may install different altsettings and may
  2231		 * claim() any interfaces not yet bound.  Many class drivers
  2232		 * need that: CDC, audio, video, etc.
  2233		 */
  2234		for (i = 0; i < nintf; ++i) {
  2235			struct usb_interface *intf = cp->interface[i];
  2236	
  2237			if (intf->dev.of_node &&
  2238			    !of_device_is_available(intf->dev.of_node)) {
  2239				dev_info(&dev->dev, "skipping disabled interface %d\n",
  2240					 intf->cur_altsetting->desc.bInterfaceNumber);
  2241				continue;
  2242			}
  2243	
  2244			dev_dbg(&dev->dev,
  2245				"adding %s (config #%d, interface %d)\n",
  2246				dev_name(&intf->dev), configuration,
  2247				intf->cur_altsetting->desc.bInterfaceNumber);
  2248			device_enable_async_suspend(&intf->dev);
  2249			ret = device_add(&intf->dev);
  2250			if (ret != 0) {
  2251				dev_err(&dev->dev, "device_add(%s) --> %d\n",
  2252					dev_name(&intf->dev), ret);
  2253				continue;
  2254			}
  2255			create_intf_ep_devs(intf);
  2256		}
  2257	
  2258		usb_autosuspend_device(dev);
  2259		return 0;
  2260	}
  2261	EXPORT_SYMBOL_GPL(usb_set_configuration);
  2262	

-- 
0-DAY CI Kernel Test Service
https://01.org/lkp