[android-common:android16-6.12-desktop 0/2] drivers/usb/host/xhci-sideband.c:263: warning: Function parameter or struct member 'imod_interval' not described in 'xhci_sideband_create_interrupter'

[kernel test robot <lkp@intel.com>]

tree:   https://android.googlesource.com/kernel/common android16-6.12-desktop
head:   0144e2490a70c3551bfb173921278f21d8255d44
commit: 8b9c57ce39a5a88dbc923cebe1fdd234239a7f94 [0/2] FROMGIT: xhci: sideband: add initial api to register a secondary interrupter entity
config: x86_64-buildonly-randconfig-2001-20250626 (https://download.01.org/0day-ci/archive/20250627/202506271933.JldoP9ef-lkp@intel.com/config)
compiler: gcc-12 (Debian 12.2.0-14+deb12u1) 12.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250627/202506271933.JldoP9ef-lkp@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202506271933.JldoP9ef-lkp@intel.com/

All warnings (new ones prefixed by >>):

>> drivers/usb/host/xhci-sideband.c:263: warning: Function parameter or struct member 'imod_interval' not described in 'xhci_sideband_create_interrupter'
>> drivers/usb/host/xhci-sideband.c:345: warning: Function parameter or struct member 'type' not described in 'xhci_sideband_register'


vim +263 drivers/usb/host/xhci-sideband.c

   244	
   245	/**
   246	 * xhci_sideband_create_interrupter - creates a new interrupter for this sideband
   247	 * @sb: sideband instance for this usb device
   248	 * @num_seg: number of event ring segments to allocate
   249	 * @ip_autoclear: IP autoclearing support such as MSI implemented
   250	 *
   251	 * Sets up a xhci interrupter that can be used for this sideband accessed usb
   252	 * device. Transfer events for this device can be routed to this interrupters
   253	 * event ring by setting the 'Interrupter Target' field correctly when queueing
   254	 * the transfer TRBs.
   255	 * Once this interrupter is created the interrupter target ID can be obtained
   256	 * by calling xhci_sideband_interrupter_id()
   257	 *
   258	 * Returns 0 on success, negative error otherwise
   259	 */
   260	int
   261	xhci_sideband_create_interrupter(struct xhci_sideband *sb, int num_seg,
   262					 bool ip_autoclear, u32 imod_interval)
 > 263	{
   264		int ret = 0;
   265	
   266		if (!sb || !sb->xhci)
   267			return -ENODEV;
   268	
   269		mutex_lock(&sb->mutex);
   270		if (sb->ir) {
   271			ret = -EBUSY;
   272			goto out;
   273		}
   274	
   275		sb->ir = xhci_create_secondary_interrupter(xhci_to_hcd(sb->xhci),
   276							   num_seg, imod_interval);
   277		if (!sb->ir) {
   278			ret = -ENOMEM;
   279			goto out;
   280		}
   281	
   282		sb->ir->ip_autoclear = ip_autoclear;
   283	
   284	out:
   285		mutex_unlock(&sb->mutex);
   286	
   287		return ret;
   288	}
   289	EXPORT_SYMBOL_GPL(xhci_sideband_create_interrupter);
   290	
   291	/**
   292	 * xhci_sideband_remove_interrupter - remove the interrupter from a sideband
   293	 * @sb: sideband instance for this usb device
   294	 *
   295	 * Removes a registered interrupt for a sideband.  This would allow for other
   296	 * sideband users to utilize this interrupter.
   297	 */
   298	void
   299	xhci_sideband_remove_interrupter(struct xhci_sideband *sb)
   300	{
   301		if (!sb || !sb->ir)
   302			return;
   303	
   304		mutex_lock(&sb->mutex);
   305		xhci_remove_secondary_interrupter(xhci_to_hcd(sb->xhci), sb->ir);
   306	
   307		sb->ir = NULL;
   308		mutex_unlock(&sb->mutex);
   309	}
   310	EXPORT_SYMBOL_GPL(xhci_sideband_remove_interrupter);
   311	
   312	/**
   313	 * xhci_sideband_interrupter_id - return the interrupter target id
   314	 * @sb: sideband instance for this usb device
   315	 *
   316	 * If a secondary xhci interrupter is set up for this usb device then this
   317	 * function returns the ID used by the interrupter. The sideband client
   318	 * needs to write this ID to the 'Interrupter Target' field of the transfer TRBs
   319	 * it queues on the endpoints transfer ring to ensure transfer completion event
   320	 * are written by xHC to the correct interrupter event ring.
   321	 *
   322	 * Returns interrupter id on success, negative error othgerwise
   323	 */
   324	int
   325	xhci_sideband_interrupter_id(struct xhci_sideband *sb)
   326	{
   327		if (!sb || !sb->ir)
   328			return -ENODEV;
   329	
   330		return sb->ir->intr_num;
   331	}
   332	EXPORT_SYMBOL_GPL(xhci_sideband_interrupter_id);
   333	
   334	/**
   335	 * xhci_sideband_register - register a sideband for a usb device
   336	 * @intf: usb interface associated with the sideband device
   337	 *
   338	 * Allows for clients to utilize XHCI interrupters and fetch transfer and event
   339	 * ring parameters for executing data transfers.
   340	 *
   341	 * Return: pointer to a new xhci_sideband instance if successful. NULL otherwise.
   342	 */
   343	struct xhci_sideband *
   344	xhci_sideband_register(struct usb_interface *intf, enum xhci_sideband_type type)
 > 345	{
   346		struct usb_device *udev = interface_to_usbdev(intf);
   347		struct usb_hcd *hcd = bus_to_hcd(udev->bus);
   348		struct xhci_hcd *xhci = hcd_to_xhci(hcd);
   349		struct xhci_virt_device *vdev;
   350		struct xhci_sideband *sb;
   351	
   352		/*
   353		 * Make sure the usb device is connected to a xhci controller.  Fail
   354		 * registration if the type is anything other than  XHCI_SIDEBAND_VENDOR,
   355		 * as this is the only type that is currently supported by xhci-sideband.
   356		 */
   357		if (!udev->slot_id || type != XHCI_SIDEBAND_VENDOR)
   358			return NULL;
   359	
   360		sb = kzalloc_node(sizeof(*sb), GFP_KERNEL, dev_to_node(hcd->self.sysdev));
   361		if (!sb)
   362			return NULL;
   363	
   364		mutex_init(&sb->mutex);
   365	
   366		/* check this device isn't already controlled via sideband */
   367		spin_lock_irq(&xhci->lock);
   368	
   369		vdev = xhci->devs[udev->slot_id];
   370	
   371		if (!vdev || vdev->sideband) {
   372			xhci_warn(xhci, "XHCI sideband for slot %d already in use\n",
   373				  udev->slot_id);
   374			spin_unlock_irq(&xhci->lock);
   375			kfree(sb);
   376			return NULL;
   377		}
   378	
   379		sb->xhci = xhci;
   380		sb->vdev = vdev;
   381		sb->intf = intf;
   382		sb->type = type;
   383		vdev->sideband = sb;
   384	
   385		spin_unlock_irq(&xhci->lock);
   386	
   387		return sb;
   388	}
   389	EXPORT_SYMBOL_GPL(xhci_sideband_register);
   390	

-- 
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki