drivers/hid/hid-core.c

static int __init hid_init(void)

{

int ret;

ret = bus_register(&hid_bus_type);

ret = hidraw_init();

return 0;

}

drivers\usb\core\hub.c

static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,

u16 portchange)

{

int status, i;

unsigned unit_load;

struct usb_device *hdev = hub->hdev;

struct usb_hcd *hcd = bus_to_hcd(hdev->bus);

struct usb_port *port_dev = hub->ports[port1 - 1];

struct usb_device *udev = port_dev->child;

static int unreliable_port = -1;

printk("radia hub_port_connect\n");//添加log

status = 0;

for (i = 0; i < SET_CONFIG_TRIES; i++) {

/* reallocate for each attempt, since references

* to the previous one can escape in various ways

*/

udev = usb_alloc_dev(hdev, hdev->bus, port1);创建一个usb_device设备

if (!udev) {

dev_err(&port_dev->dev,

"couldn't allocate usb_device\n");

goto done;

}

........

/* Run it through the hoops (find a driver, etc) */

if (!status) {

status = usb_new_device(udev);调用usb_new_device-->usb_enumerate_device枚举设备

if (status) {

mutex_lock(&usb_port_peer_mutex);

spin_lock_irq(&device_state_lock);

port_dev->child = NULL;

spin_unlock_irq(&device_state_lock);

mutex_unlock(&usb_port_peer_mutex);

} else {

if (hcd->usb_phy && !hdev->parent)

usb_phy_notify_connect(hcd->usb_phy,

udev->speed);

}

}

}

drivers\usb\core\generic.c

static int generic_probe(struct usb_device *udev)

{

int err, c;

printk("radia generic_probe\n");//添加log

if (udev->authorized == 0)

dev_err(&udev->dev, "Device is not authorized for usage\n");

else {

c = usb_choose_configuration(udev);//选择合适的configuration

if (c >= 0) {

err = usb_set_configuration(udev, c);/配置合适的configuration

if (err && err != -ENODEV) {

dev_err(&udev->dev, "can't set config #%d, error %d\n",

c, err);

/* This need not be fatal. The user can try to

* set other configurations. */

}

}

}

/* USB device state == configured ... usable */

usb_notify_add_device(udev);

return 0;

}

drivers\usb\core\message.c

int usb_set_configuration(struct usb_device *dev, int configuration)

{

if (dev->authorized == 0 || configuration == -1)

configuration = 0;

else {

for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {

if (dev->config[i].desc.bConfigurationValue ==

configuration) {

cp = &dev->config[i];

break;

}

}

}

if (cp) {

nintf = cp->desc.bNumInterfaces;

new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),

GFP_NOIO);

if (!new_interfaces) {

dev_err(&dev->dev, "Out of memory\n");

return -ENOMEM;

}

for (; n < nintf; ++n) {

new_interfaces[n] = kzalloc(

sizeof(struct usb_interface),

GFP_NOIO);

if (!new_interfaces[n]) {

dev_err(&dev->dev, "Out of memory\n");

ret = -ENOMEM;

free_interfaces:

while (--n >= 0)

kfree(new_interfaces[n]);

kfree(new_interfaces);

return ret;

}

}

i = dev->bus_mA - usb_get_max_power(dev, cp);

if (i < 0)

dev_warn(&dev->dev, "new config #%d exceeds power "

"limit by %dmA\n",

configuration, -i);

}

/*

* Initialize the new interface structures and the

* hc/hcd/usbcore interface/endpoint state.

*/

for (i = 0; i < nintf; ++i) {

struct usb_interface_cache *intfc;

struct usb_interface *intf;

struct usb_host_interface *alt;

cp->interface[i] = intf = new_interfaces[i];

intfc = cp->intf_cache[i];

intf->altsetting = intfc->altsetting;

intf->num_altsetting = intfc->num_altsetting;

kref_get(&intfc->ref);

alt = usb_altnum_to_altsetting(intf, 0);

/* No altsetting 0? We'll assume the first altsetting.

* We could use a GetInterface call, but if a device is

* so non-compliant that it doesn't have altsetting 0

* then I wouldn't trust its reply anyway.

*/

if (!alt)

alt = &intf->altsetting[0];

intf->intf_assoc =

find_iad(dev, cp, alt->desc.bInterfaceNumber);

intf->cur_altsetting = alt;

usb_enable_interface(dev, intf, true);

intf->dev.parent = &dev->dev;

intf->dev.driver = NULL;

intf->dev.bus = &usb_bus_type;

intf->dev.type = &usb_if_device_type;

intf->dev.groups = usb_interface_groups;

intf->dev.dma_mask = dev->dev.dma_mask;

INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);

intf->minor = -1;

device_initialize(&intf->dev);

pm_runtime_no_callbacks(&intf->dev);

dev_set_name(&intf->dev, "%d-%s:%d.%d",

dev->bus->busnum, dev->devpath,

configuration, alt->desc.bInterfaceNumber);

usb_get_dev(dev);

}

kfree(new_interfaces);

ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),

USB_REQ_SET_CONFIGURATION, 0, configuration, 0,

NULL, 0, USB_CTRL_SET_TIMEOUT);

/* Now that all the interfaces are set up, register them

* to trigger binding of drivers to interfaces. probe()

* routines may install different altsettings and may

* claim() any interfaces not yet bound. Many class drivers

* need that: CDC, audio, video, etc.

*/

for (i = 0; i < nintf; ++i) {

struct usb_interface *intf = cp->interface[i];

dev_dbg(&dev->dev,

"adding %s (config #%d, interface %d)\n",

dev_name(&intf->dev), configuration,

intf->cur_altsetting->desc.bInterfaceNumber);

device_enable_async_suspend(&intf->dev);

ret = device_add(&intf->dev);

if (ret != 0) {

dev_err(&dev->dev, "device_add(%s) --> %d\n",

dev_name(&intf->dev), ret);

continue;

}

create_intf_ep_devs(intf);

}

usb_autosuspend_device(dev);

return 0;

}

drivers/usb/core/driver.c

static int usb_probe_interface(struct device *dev)

{

struct usb_driver *driver = to_usb_driver(dev->driver);

struct usb_interface *intf = to_usb_interface(dev);

struct usb_device *udev = interface_to_usbdev(intf);

const struct usb_device_id *id;

int error = -ENODEV;

int lpm_disable_error;

printk("radia usb_probe_interface\n");//添加log

/* Carry out a deferred switch to altsetting 0 */

if (intf->needs_altsetting0) {

error = usb_set_interface(udev, intf->altsetting[0].

desc.bInterfaceNumber, 0);

if (error < 0)

goto err;

intf->needs_altsetting0 = 0;

}

error = driver->probe(intf, id);//调用具体设备的probe

usb_autosuspend_device(udev);

return error;

}

kernel\drivers\hid\hid-generic.c

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/kernel.h>

#include <asm/unaligned.h>

#include <asm/byteorder.h>

#include <linux/hid.h>

static const struct hid_device_id hid_table[] = {

{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_GENERIC, HID_ANY_ID, HID_ANY_ID) },

{ }

};

MODULE_DEVICE_TABLE(hid, hid_table);

static struct hid_driver hid_generic = {

.name = "hid-generic",

.id_table = hid_table,

};

module_hid_driver(hid_generic);

MODULE_AUTHOR("Henrik Rydberg");

MODULE_DESCRIPTION("HID generic driver");

MODULE_LICENSE("GPL");

其中module_hid_driver定义在

kernel\include\linux\hid.h

#define module_hid_driver(__hid_driver) \

module_driver(__hid_driver, hid_register_driver, \

hid_unregister_driver)

drivers\hid\hid-input.c

static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,

struct hid_usage *usage)

{

struct input_dev *input = hidinput->input;

struct hid_device *device = input_get_drvdata(input);

int max = 0, code;

unsigned long *bit = NULL;

field->hidinput = hidinput;

switch (usage->hid & HID_USAGE_PAGE) {

case HID_UP_UNDEFINED:

goto ignore;

case HID_UP_KEYBOARD:

set_bit(EV_REP, input->evbit);

if ((usage->hid & HID_USAGE) < 256) {

if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;

map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);

} else

map_key(KEY_UNKNOWN);

break;

case HID_UP_BUTTON:

code = ((usage->hid - 1) & HID_USAGE);

switch (field->application) {

case HID_GD_MOUSE:

case HID_GD_POINTER: code += BTN_MOUSE; break;设置鼠标左键的键值

case HID_GD_JOYSTICK:

if (code <= 0xf)

code += BTN_JOYSTICK;

else

code += BTN_TRIGGER_HAPPY - 0x10;

break;

case HID_GD_GAMEPAD:

if (code <= 0xf)

code += BTN_GAMEPAD;

else

code += BTN_TRIGGER_HAPPY - 0x10;

break;

default:

switch (field->physical) {

case HID_GD_MOUSE:

case HID_GD_POINTER: code += BTN_MOUSE; break;

case HID_GD_JOYSTICK: code += BTN_JOYSTICK; break;

case HID_GD_GAMEPAD: code += BTN_GAMEPAD; break;

default: code += BTN_MISC;

}

}

map_key(code);

break;

............

case HID_UP_PID:

switch (usage->hid & HID_USAGE) {

case 0xa4: map_key_clear(BTN_DEAD); break;

default: goto ignore;

}

break;

default:

unknown:

if (field->report_size == 1) {

if (field->report->type == HID_OUTPUT_REPORT) {

map_led(LED_MISC);

break;

}

map_key(BTN_MISC);

break;

}

if (field->flags & HID_MAIN_ITEM_RELATIVE) {

map_rel(REL_MISC);

break;

}

map_abs(ABS_MISC);

break;

}

if (usage->type == EV_ABS) {

int a = field->logical_minimum;

int b = field->logical_maximum;

if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {

a = field->logical_minimum = 0;

b = field->logical_maximum = 255;

}

if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)

input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);/上报键值

else input_set_abs_params(input, usage->code, a, b, 0, 0);

input_abs_set_res(input, usage->code,

hidinput_calc_abs_res(field, usage->code));

/* use a larger default input buffer for MT devices */

if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)

input_set_events_per_packet(input, 60);

}

return;

}