usb_control_msg(drivers/usb/core/message.c)

	这个函数主要目的是创建一个控制 urb,并把它发送给 usb 设备,然后等待它完成。urb是什么?如果你要想和你的 usb 通信,就得创建一个 urb,并且为它  赋好值,交给 usb core,它会找到合适的 host controller,从而进行具体的数据传输。

/**
 * usb_control_msg - Builds a control urb, sends it off and waits for completion
 * @dev: pointer to the usb device to send the message to
 * @pipe: endpoint "pipe" to send the message to
 * @request: USB message request value
 * @requesttype: USB message request type value
 * @value: USB message value
 * @index: USB message index value
 * @data: pointer to the data to send
 * @size: length in bytes of the data to send
 * @timeout: time in msecs to wait for the message to complete before timing
 *	out (if 0 the wait is forever)
 *
 * Context: !in_interrupt ()
 *
 * This function sends a simple control message to a specified endpoint and
 * waits for the message to complete, or timeout.
 *
 * If successful, it returns the number of bytes transferred, otherwise a
 * negative error number.
 *
 * Don't use this function from within an interrupt context, like a bottom half
 * handler.  If you need an asynchronous message, or need to send a message
 * from within interrupt context, use usb_submit_urb().
 * If a thread in your driver uses this call, make sure your disconnect()
 * method can wait for it to complete.  Since you don't have a handle on the
 * URB used, you can't cancel the request.
 */
 /**
 *创建一个控制urb，把它发送给usb设备，并等待它结束.
 */
int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
		    __u8 requesttype, __u16 value, __u16 index, void *data,
		    __u16 size, int timeout)
{
	struct usb_ctrlrequest *dr;
	int ret;

	dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
	if (!dr)
		return -ENOMEM;

	dr->bRequestType = requesttype;
	dr->bRequest = request;
	dr->wValue = cpu_to_le16(value);
	dr->wIndex = cpu_to_le16(index);
	dr->wLength = cpu_to_le16(size);

	/* dbg("usb_control_msg"); */

	ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);

	kfree(dr);

	return ret;
}
EXPORT_SYMBOL_GPL(usb_control_msg);

/* returns status (negative) or length (positive) */
static int usb_internal_control_msg(struct usb_device *usb_dev,
        unsigned int pipe,
        struct usb_ctrlrequest *cmd,
        void *data, int len, int timeout)
{
 struct urb *urb;
 int retv;
 int length;
    /*创建一个struct urb只能用usb_alloc_urb*/
 urb = usb_alloc_urb(0, GFP_NOIO);
 if (!urb)
  return -ENOMEM;
    /*初始化一个控制urb，urb在使用之前必须初始化*/
 usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
        len, usb_api_blocking_completion, NULL);
    /*将urb提交给usb core以便分配给hcd进行处理然后等待结果或者超时*/
 retv = usb_start_wait_urb(urb, timeout, &length);
 if (retv < 0)
  return retv;
 else
  return length;
}