Androidadb驱动实现原理
Androidadb的驱动由androidadb.c和f_adb.c实现，androidadb.c的开头会#include “f_adb.c”，最终编译出来的是g_androidadb.ko文件。
这里涉及到Linux USB Composite Framework的知识，下次再整理一下这方面的知识。
创建struct usb_composite_driver
Androidadb属于USB复合设备，注册这样的设备需要使用到USB Composite Framework，因此首先必须要创建一个struct usb_composite_driver并调用usb_composite_probe()向USB Composte Framework注册驱动。
static struct usb_composite_driver android_usb_driver = {
.name = "android_usb",
.dev = &device_desc,
.strings = dev_strings,
.bind = android_bind,
.unbind = android_usb_unbind,
.max_speed = USB_SPEED_HIGH,
};
static int __init init(void)
{
struct android_dev *dev;
int err;
android_class = class_create(THIS_MODULE, "android_usb");
if (IS_ERR(android_class))
return PTR_ERR(android_class);
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
return -ENOMEM;
dev->disable_depth = 1;
dev->functions = supported_functions;
INIT_LIST_HEAD(&dev->enabled_functions);
INIT_WORK(&dev->work, android_work);
mutex_init(&dev->mutex);
err = android_create_device(dev);
if (err) {
class_destroy(android_class);
kfree(dev);
return err;
}
_android_dev = dev;
/* Override composite driver functions */
composite_driver_template.setup = android_setup;
composite_driver_template.disconnect = android_disconnect;
return usb_composite_probe(&android_usb_driver);
}
module_init(init);在module_init(init)中首先去创建一个名为”android_usb”的sys class。并且调用android_create_device()函数创建”android0”的设备，它的属性文件包括：
static struct device_attribute *android_usb_attributes[] = {
&dev_attr_idVendor,
&dev_attr_idProduct,
&dev_attr_bcdDevice,
&dev_attr_bDeviceClass,
&dev_attr_bDeviceSubClass,
&dev_attr_bDeviceProtocol,
&dev_attr_iManufacturer,
&dev_attr_iProduct,
&dev_attr_iSerial,
&dev_attr_functions,
&dev_attr_enable,
&dev_attr_state,
NULL
};其中dev_attr_functions/dev_attr_enable/dev_attr_state三个属性都有对应的show和store函数，这些函数配置Androidadb或者在adbd应用程序中会去使用，通过这三个来添加functions和使能androidadb功能。
- functions_show()/functions_store()
- enable_show()/enable_store()
- state_show()
当#insmod g_androidadb.ko之后，在 /sys/class/android_usb/android0/或者 /sys/devices/virtual/android_usb/android0/目录下就可以看到这些属性文件。
-rw-r--r-- 0 0 4096 2017-05-01 18:31 bDeviceClass
-rw-r--r-- 0 0 4096 2017-05-01 18:31 bDeviceProtocol
-rw-r--r-- 0 0 4096 2017-05-01 18:31 bDeviceSubClass
-rw-r--r-- 0 0 4096 2017-05-01 18:31 bcdDevice
-rw-r--r-- 0 0 4096 2017-05-01 18:31 enable
drwxr-xr-x 0 0 2017-05-01 18:31 f_adb
-rw-r--r-- 0 0 4096 2017-05-01 18:31 functions
-rw-r--r-- 0 0 4096 2017-05-01 18:31 iManufacturer
-rw-r--r-- 0 0 4096 2017-05-01 18:31 iProduct
-rw-r--r-- 0 0 4096 2017-05-01 18:31 iSerial
-rw-r--r-- 0 0 4096 2017-05-01 18:31 idProduct
-rw-r--r-- 0 0 4096 2017-05-01 18:31 idVendor
drwxr-xr-x 0 0 2017-05-01 18:31 power
-r--r--r-- 0 0 4096 2017-05-01 18:31 state
lrwxrwxrwx 0 0 2017-05-01 18:31 subsystem -> ../../../../class/android_usb
-rw-r--r-- 0 0 4096 2017-05-01 18:31 uevent在android_bind()中初始化android_usb_function
当调用usb_composite_probe()，最终会触发android_bind()函数的执行。
在android_bind()中首先调用android_init_functions()，传递进来的参数为struct android_usb_function *supported_functions[]，这里面定义了android usb所有的function，根据需要打开某些功能，这里只使用了 adb_function的功能。
static struct android_usb_function adb_function = {
.name = "adb",
.enable = adb_android_function_enable,
.disable = adb_android_function_disable,
.init = adb_function_init,
.cleanup = adb_function_cleanup,
.bind_config = adb_function_bind_config,
};
static struct android_usb_function *supported_functions[] = {
//&ffs_function,
&adb_function,
//&acm_function,
//&mtp_function,
//&ptp_function,
//&rndis_function,
//&mass_storage_function,
//&accessory_function,
//&audio_source_function,
NULL
};
static int android_init_functions(struct android_usb_function **functions,
struct usb_composite_dev *cdev)
{
......
for (; (f = *functions++); index++) {
f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
f->dev = device_create(android_class, dev->dev,
MKDEV(0, index), f, f->dev_name);
if (IS_ERR(f->dev)) {
pr_err("%s: Failed to create dev %s", __func__,
f->dev_name);
err = PTR_ERR(f->dev);
goto err_create;
}
......
}
return 0;
err_out:
device_destroy(android_class, f->dev->devt);
err_create:
kfree(f->dev_name);
return err;
}android_init_functions()函数中会为function创建一个名为 f_xxx的sys class，比如说这里用到的是adb的function，那么名字就为 f_adb。因此可以在/sys/class/android_usb/android0/看到f_adb的目录。
接下来就会调用struct android_usb_function的.init()函数，这里肯定是adb_function_init()函数，在这里面又会调用adb_setup()函数。这样代码就从androidadb.c调到f_adb.c了。
static int
adb_function_init(struct android_usb_function *f,
struct usb_composite_dev *cdev)
{
f->config = kzalloc(sizeof(struct adb_data), GFP_KERNEL);
if (!f->config)
return -ENOMEM;
return adb_setup();
}
if (f->init) {
err = f->init(f, cdev);
if (err) {
pr_err("%s: Failed to init %s", __func__,
f->name);
goto err_out;
}
}adb_setup()
在这个函数里面，初始化了读写队列，并且调用misc_register()在 /dev 目录下创建了一个名为” android_adb”的设备节点，这个节点用于与应用空间的数据通信使用。当然，这里面肯定包含对于 /dev/android_adb节点的write()和read()函数。
/* file operations for ADB device /dev/android_adb */
static const struct file_operations adb_fops = {
.owner = THIS_MODULE,
.read = adb_read,
.write = adb_write,
.open = adb_open,
.release = adb_release,
};
static struct miscdevice adb_device = {
.minor = MISC_DYNAMIC_MINOR,
.name = adb_shortname,
.fops = &adb_fops,
};在android_bind()初始化USB设备描述符并分配string ID
/* Allocate string descriptor numbers ... note that string
* contents can be overridden by the composite_dev glue.
*/
id = usb_string_id(cdev);
if (id < 0)
return id;
strings_dev[STRING_MANUFACTURER_IDX].id = id;
device_desc.iManufacturer = id;
id = usb_string_id(cdev);
if (id < 0)
return id;
strings_dev[STRING_PRODUCT_IDX].id = id;
device_desc.iProduct = id;
/* Default strings - should be updated by userspace */
strncpy(manufacturer_string, "Android", sizeof(manufacturer_string)-1);
strncpy(product_string, "Android", sizeof(product_string) - 1);
strncpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
id = usb_string_id(cdev);
if (id < 0)
return id;
strings_dev[STRING_SERIAL_IDX].id = id;
device_desc.iSerialNumber = id;这一步跟多数的struct usb_composite_driver中.bind()所要做的工作一样，要去初始化USB设备描述符，不过此时的USB设备描述符还不是完整的。但是这里有一个很关键的地方就是没有初始化USB的configuration和为其添加usb function。正是因为这里没有做这项工作，所以当我们#insmod g_androidadb.ko的时候，此时androidadb还不是一个完整的USB设备，因为它还没有配置描述符和对应的usb function。所以还要通过 sys class中的属性文件做一些配置。
不清楚为啥androidadb不直接将configuration和usb function都初始化完毕和添加完毕，还要手动去做配置。
现在想想，因为Android usb支持很多function，都在supported_functions[]中明确的定义了。
static struct android_usb_function *supported_functions[] = {
//&ffs_function,
&adb_function,
//&acm_function,
//&mtp_function,
//&ptp_function,
//&rndis_function,
//&mass_storage_function,
//&accessory_function,
//&audio_source_function,
NULL
};这里有可能选择多种function，使得驱动支持多种fucntion。但是至于要使用何种function，那么需要用户来选择，所以会提供 /sys/class/android_usb/android0/functions接口让用户选择使用何种function，最后再使用/sys/class/android_usb/android0/enable使之与usb configuration绑定。此时这个USB设备的功能就已经明确下来了，可以正常的被枚举。
添加functions到list中
这一步需要用户手动配置，因为我们是使用adb的功能，因此需要输入以下命令：#echo adb > /sys/class/android_usb/android0/functions
对应的驱动接口是 functions_store()函数，这个函数的内容是先解析传进来的字符串，然后调用android_enable_function()，根据解析出来的字符串是否与之前
android_init_functions()中设定的名字(也就是该驱动现在支持哪些function)是否有相匹配的，如果有，那么就将名字添加到enabled_list中。
static int android_enable_function(struct android_dev *dev, char *name)
{
struct android_usb_function **functions = dev->functions;
struct android_usb_function *f;
while ((f = *functions++)) {
if (!strcmp(name, f->name)) {
list_add_tail(&f->enabled_list,
&dev->enabled_functions);
return 0;
}
}
return -EINVAL;
}使能androidadb
#echo 1 > /sys/class/android_usb/android0/enable对应的驱动接口是enable_store()，在这个函数里面会去完善USB设备描述符，然后从enabled_list中找出与之对应的struct android_usb_function，并执行它的.enable()成员函数，这里当然是会去执行adb_android_function_enable()函数。注意，在adb_android_function_enable()函数中会去先执行一次android_disable()。执行完这一步还没绑定USB configuration和USB function。函数调用如下：
[ 348.556864] [xxx-adb] in enable_store, line 561
[ 348.561705] [xxx-adb] in adb_android_function_enable, line 278
[ 348.567577] [xxx-adb] in android_disable, line 227
[ 348.572379] [xxx-adb] in android_enable, line 215, disable_depth 2if (enabled && !dev->enabled) {
/*
* Update values in composite driver's copy of
* device descriptor.
*/
cdev->desc.idVendor = device_desc.idVendor;
cdev->desc.idProduct = device_desc.idProduct;
cdev->desc.bcdDevice = device_desc.bcdDevice;
cdev->desc.bDeviceClass = device_desc.bDeviceClass;
cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
if (f->enable)
f->enable(f);
}
android_enable(dev);
dev->enabled = true;
}
static void adb_android_function_enable(struct android_usb_function *f)
{
struct android_dev *dev = _android_dev;
struct adb_data *data = f->config;
data->enabled = true;
/* Disable the gadget until adbd is ready */
if (!data->opened)
android_disable(dev);
}启动adbd进程
启动adbd进程，那么首先会去调用adb_open()，最终会调用usb_add_config()和adb_bind_config()函数将USB configuration和USB function绑定起来。此时，这个USB设备已经配置完整了，可以接受USB Host的枚举。
[ 497.782451] adb_open
[ 497.784725] [xxx-adb] in adb_open, line 366
[ 497.788928] [xxx-adb] in adb_ready_callback, line 308
[ 497.794358] [xxx-adb] in android_enable, line 215, disable_depth 1
[ 497.800601] [xxx-adb] in android_enable, line 217, invoke usb_add_config()
[ 497.807475] adb_bind_config