Linux USB gadget設備驅動解析（4）--編寫一個gadget驅動
一、編寫計劃
通過前面幾節(jié)的基礎，本節(jié)計劃編寫一個簡單的gadget驅動。重在讓大家快速了解gadget驅動結構。
上節(jié)中簡單介紹了zero.c程序。這個程序考慮到了多配置、高速傳輸、USB OTG等因素。應該說寫的比較清楚，是我們了解gadget驅動架構的一個非常好的途徑。但把這些東西都放在一起，對很多初學人員來說還是不能快速理解。那就再把它簡化一些，針對S3C2410平臺，只實現(xiàn)一個配置、一個接口、一個端點，不考慮高速及OTG的情況。只完成單向從hoST端接收數(shù)據(jù)的功能，但要把字符設備驅動結合在里面。這需要有一個host端的驅動，來完成向device端發(fā)送數(shù)據(jù)。關于在主機端編寫一個簡單的USB設備驅動程序，有很多的資料。相信大家很快就會完成的。
二、功能展示
1、PC端編寫了一個us^raNSfer.ko，能夠向device端發(fā)送數(shù)據(jù)
2、對目標平臺編寫一個gadget驅動，名稱是g_zero.ko
3、測試步驟
在目標平臺(基于S3C2410)上加載gadget驅動
# insmod g_zero.ko
name=ep1-bulk
smdk2410_udc: Pull-up enable
# mknod /dev/usb_rcv c 251 0
#
在PC主機上加載驅動us^ransfer.ko
#insmod us^ransfer.ko
#mknod /dev/us^ransfer c 266 0
連接設備，目標平臺的終端顯示：
cONnected
目標平臺讀取數(shù)據(jù)
# cat /dev/usb_rcv
PC端發(fā)送數(shù)據(jù)
#echo “12345” > /dev/us^ransfer
#echo “abcd” > /dev/us^ransfer
設備端會顯示收到的數(shù)據(jù)
# cat /dev/usb_rcv
12345
abcd
三、代碼分析
下面的代碼是在原有的zero.c基礎上做了精簡、修改的。一些結構的名稱還是保留以前的，但含義有所變化。如：loopback_config，不再表示loopback，而只是單向的接收數(shù)據(jù)。
/*
* zero.c -- Gadget Zero, for simple USB development
* lht@farsight.com.cn
* All rights reserved.*/
/* #define VERBOSE_DEBUG */
#include
#include
#include
#include
#include
#include "gadget_chips.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/*-------------------------------------------------------------------------*/
stATIc const char shortname[] = "zero";
staTIc const char loopback[] = "loop input to output";
static const char longname[] = "Gadget Zero";
static const char source_sink[] = "source and sink data";
#define STRING_MANUFACTURER 25
#define STRING_PRODUCT 42
#define STRING_SERIAL 101
#define STRING_SOURCE_SINK 250
#define STRING_LOOPBACK 251
//#define DRIVER_VENDOR_NUM 0x0525 /* NetChip */
//#define DRIVER_PRODUCT_NUM 0xa4a0 /* Linux-USB "Gadget Zero" */
#define DRIVER_VENDOR_NUM 0x5345 /* NetChip */
#define DRIVER_PRODUCT_NUM 0x1234 /* Linux-USB "Gadget Zero" */
static int usb_zero_major = 251;
/*-------------------------------------------------------------------------*/
static const char *EP_OUT_NAME; /* sink */
/*-------------------------------------------------------------------------*/
/* big enough to hold our biggest descriptor */
#define USB_BUFSIZ 256
struct zero_dev { //zero設備結構
spinlock_t lock;
struct usb_gadget *gadget;
struct usb_request *req; /* for control responses */
struct usb_ep *out_ep;
struct cdev cdev;
unsigned char data[128];
unsigned int data_size;
wait_queue_head_t bulkrq;
};
#define CONFIG_LOOPBACK 2
static struct usb_device_descriptor device_desc = { //設備描述符
.bLength = sizeof device_desc,
.bDescriptorType = USB_DT_DEVICE,
.bcdUSB = __constant_cpu_to_le16(0x0110),
.bDeviceClass = USB_CLASS_VENDOR_SPEC,
.idVendor = __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
.idProduct = __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
.iManufacturer = STRING_MANUFACTURER,
.iProduct = STRING_PRODUCT,
.iSerialnumber = STRING_SERIAL,
.bNumConfigurations = 1,
};
static struct usb_endpoint_descriptor fs_sink_desc = { //端點描述符
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT, //對主機端來說，輸出[!--empirenews.page--]
.bmAttributes = USB_ENDPOINT_XFER_BULK,
};
static struct usb_config_descriptor loopback_config = { //配置描述符
.bLength = sizeof loopback_config,
.bDescriptorType = USB_DT_CONFIG,
/* compute wTotalLength on the fly */
.bNumInterfaces = 1,
.bConfigurationValue = CONFIG_LOOPBACK,
.iConfiguration = STRING_LOOPBACK,
.bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFpower,
.bMaxPower = 1, /* self-powered */
};
static const struct usb_interface_descriptor loopback_intf = { //接口描述符
.bLength = sizeof loopback_intf,
.bDescriptorType = USB_DT_INTERFACE,
.bNumEndpoints = 1,
.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
.iInterface = STRING_LOOPBACK,
};
/* static strings, in UTF-8 */
#define STRING_MANUFACTURER 25
#define STRING_PRODUCT 42
#define STRING_SERIAL 101
#define STRING_SOURCE_SINK 250
#define STRING_LOOPBACK 251
static char manufacturer[50];
/* default serial number takes at least two packets */
static char serial[] = "0123456789.0123456789.0123456789";
static struct usb_string strings[] = { //字符串描述符
{ STRING_MANUFACTURER, manufacturer, },
{ STRING_PRODUCT, longname, },
{ STRING_SERIAL, serial, },
{ STRING_LOOPBACK, loopback, },
{ STRING_SOURCE_SINK, source_sink, },
{ } /* end of list */
};
static struct usb_gadget_strings stringtab = {
.language = 0x0409, /* en-us */
.strings = strings,
};
static const struct usb_descriptor_header *fs_loopback_function[] = {
(struct usb_descriptor_header *) &loopback_intf,
(struct usb_descriptor_header *) &fs_sink_desc,
NULL,
};
static int
usb_zero_open (struct inode *inode, struct file *file) //打開設備
{
struct zero_dev *dev =
container_of (inode->i_cdev, struct zero_dev, cdev);
file->private_data = dev;
init_waitqueue_head (&dev->bulkrq);
return 0;
}
static int
usb_zero_release (struct inode *inode, struct file *file) //關閉設備
{
return 0;
}
static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
{
kfree(req->buf);
usb_ep_free_request(ep, req);
}
static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)//分配請求
{
struct usb_request *req;
req = usb_ep_alloc_request(ep, GFP_ATOMIC);
if (req) {
req->length = length;
req->buf = kmalloc(length, GFP_ATOMIC);
if (!req->buf) {
usb_ep_free_request(ep, req);
req = NULL;
}
}
return req;
}
static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)//請求完成函數(shù)
{
struct zero_dev *dev = ep->driver_data;
int status = req->status;
switch (status) {
case 0: /* normal completion */
if (ep == dev->out_ep) {
memcpy(dev->data, req->buf, req-> actual);//返回數(shù)據(jù)拷貝到req->buf中， //dev->data_size=req->length;
dev->data_size=req->actual; //實際長度為req-> actual;需要確認
req –>short_not_ok為0。參考gadget.h中關于usb_request結構的注釋
}
break;
/* this endpoint is normally active while we're configured */
case -ECONNABORTED: /* hardware forced ep reset */
case -ECONNRESET: /* request dequeued */
case -ESHUTDOWN: /* disconnect from host */
printk("%s gone (%d), %d/%dn", ep->name, status,
req->actual, req->length);
case -EOVERFLOW: /* buffer overrun on read means that
* we didn't provide a big enough
* buffer.
*/
default:
#if 1
printk("%s complete --> %d, %d/%dn", ep->name,
status, req->actual, req->length);
#endif
case -EREMOTEIO: /* short read */
break;
}
free_ep_req(ep, req);
wake_up_interruptible (&dev->bulkrq); //喚醒讀函數(shù)
}
static struct usb_request *source_sink_start_ep(struct usb_ep *ep)//構造并發(fā)送讀請求
{
struct usb_request *req;
int status;
//printk("in %sn",__FUNCTION__);
req = alloc_ep_req(ep, 128);
if (!req)
return NULL;
memset(req->buf, 0, req->length);
req->complete = source_sink_complete; //請求完成函數(shù)
status = usb_ep_queue(ep, req, GFP_ATOMIC); //遞交請求
if (status) {
struct zero_dev *dev = ep->driver_data;
printk("start %s --> %dn", ep->name, status);
free_ep_req(ep, req);
req = NULL;
}[!--empirenews.page--]
return req;
}
ssize_t
usb_zero_read (struct file * file, const char __user * buf, size_t count,loff_t * f_pos) //讀設備
{
struct zero_dev *dev =file->private_data;
struct usb_request *req;
int status;
struct usb_ep *ep;
struct usb_gadget *gadget = dev->gadget;
ssize_t ret = 0;
int result;
ep=dev->out_ep;
source_sink_start_ep(ep);//構造、遞交讀請求
if (count < 0)
return -EINVAL;
interruptible_sleep_on (&dev->bulkrq);//睡眠，等到請求完成
if (copy_to_user (buf,dev->data,dev->data_size)) //拷貝讀取的數(shù)據(jù)到用戶空間
{
ret = -EFAULT;
}
else
{
ret = dev->data_size;
}
return ret;
}
struct file_operations usb_zero_fops = {
.owner = THIS_MODULE,
.read = usb_zero_read,
.open = usb_zero_open,
.release = usb_zero_release,
};
static void
usb_zero_setup_cdev (struct zero_dev *dev, int minor)//注冊字符設備驅動
{
int err, devno = MKDEV (usb_zero_major, minor);
cdev_init(&dev->cdev, &usb_zero_fops);
dev->cdev.owner = THIS_MODULE;
err = cdev_add (&dev->cdev, devno, 1);
if (err)
printk ("Error adding usb_rcvn");
}
static void zero_setup_complete(struct usb_ep *ep, struct usb_request *req)//配置端點0的請求
完成處理
{
if (req->status || req->actual != req->length)
printk("setup complete --> %d, %d/%dn",
req->status, req->actual, req->length);
}
static void zero_reset_config(struct zero_dev *dev) //復位配置
{
usb_ep_disable(dev->out_ep);
dev->out_ep = NULL;
}
static void zero_disconnect(struct usb_gadget *gadget)//卸載驅動時被調(diào)用，做一些注銷工作
{
struct zero_dev *dev = get_gadget_data(gadget);
unsigned long flags;
unregister_chrdev_region (MKDEV (usb_zero_major, 0), 1);
cdev_del (&(dev->cdev));
zero_reset_config(dev);
printk("in %sn",__FUNCTION__);
}
static int config_buf(struct usb_gadget *gadget,
u8 *buf, u8 type, unsigned index)
{
//int is_source_sink;
int len;
const struct usb_descriptor_header **function;
int hs = 0;
function =fs_loopback_function;//根據(jù)fs_loopback_function，得到長度，
//此處len=配置(9)+1個接口(9)+1個端點(7)=25
len = usb_gadget_config_buf(&loopback_config,
buf, USB_BUFSIZ, function);
if (len < 0)
return len;
((struct usb_config_descriptor *) buf)->bDescriptorType = type;
return len;
}
static int set_loopback_config(struct zero_dev *dev)
{
int result = 0;
struct usb_ep *ep;
struct usb_gadget *gadget = dev->gadget;
ep=dev->out_ep;
const struct usb_endpoint_descriptor *d;
d = &fs_sink_desc;
result = usb_ep_enable(ep, d); //激活端點
//printk("");
if (result == 0) {
printk("connectedn"); //如果成功，打印“connected”
}
else
printk("can't enable %s, result %dn", ep->name, result);
return result;
}
static int zero_set_config(struct zero_dev *dev, unsigned number)
{
int result = 0;
struct usb_gadget *gadget = dev->gadget;
result = set_loopback_config(dev);//激活設備
if (result)
zero_reset_config(dev); //復位設備
else {
char *speed;
switch (gadget->speed) {
case USB_SPEED_LOW: speed = "low"; break;
case USB_SPEED_FULL: speed = "full"; break;
case USB_SPEED_HIGH: speed = "high"; break;
default: speed = " "; break;
}
}
return result;
}
/***
zero_setup完成USB設置階段和具體功能相關的交互部分
***/
static int
zero_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
{
struct zero_dev *dev = get_gadget_data(gadget);
struct usb_request *req = dev->req;
int value = -EOPNOTSUPP;
u16 w_index = le16_to_cpu(ctrl->wIndex);
u16 w_value = le16_to_cpu(ctrl->wValue);
u16 w_length = le16_to_cpu(ctrl->wLength);
/* usually this stores reply data in the pre-allocated ep0 buffer,
* but config change events will reconfigure hardware.
*/
req->zero = 0;
switch (ctrl->bRequest) {
case USB_REQ_GET_DESCRIPTOR: //獲取描述符
if (ctrl->bRequestType != USB_DIR_IN)
goto unknown;
switch (w_value >> 8) {
case USB_DT_DEVICE: //獲取設備描述符[!--empirenews.page--]
value = min(w_length, (u16) sizeof device_desc);
memcpy(req->buf, &device_desc, value);
break;
case USB_DT_CONFIG: //獲取配置，注意：會根據(jù)fs_loopback_function讀取到接口、端點描述符，注意通過config_buf完成讀取數(shù)據(jù)及數(shù)量的統(tǒng)計。
value = config_buf(gadget, req->buf,
w_value >> 8,
w_value & 0xff);
if (value >= 0)
value = min(w_length, (u16) value);
break;
case USB_DT_STRING:
value = usb_gadget_get_string(&stringtab,
w_value & 0xff, req->buf);
if (value >= 0)
value = min(w_length, (u16) value);
break;
}
break;
case USB_REQ_SET_CONFIGURATION:
if (ctrl->bRequestType != 0)
goto unknown;
spin_lock(&dev->lock);
value = zero_set_config(dev, w_value);//激活相應的端點
spin_unlock(&dev->lock);
break;
default:
unknown:
printk(
"unknown control req%02x.%02x v%04x i%04x l%dn",
ctrl->bRequestType, ctrl->bRequest,
w_value, w_index, w_length);
}
/* respond with data transfer before status phase */
if (value >= 0) {
req->length = value;
req->zero = value < w_length;
value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);//通過端點0完成setup
if (value < 0) {
printk("ep_queue --> %dn", value);
req->status = 0;
zero_setup_complete(gadget->ep0, req);
}
}
/* device either stalls (value < 0) or reports success */
return value;
}
static void zero_unbind(struct usb_gadget *gadget) //解除綁定
{
struct zero_dev *dev = get_gadget_data(gadget);
printk("unbindn");
unregister_chrdev_region (MKDEV (usb_zero_major, 0), 1);
cdev_del (&(dev->cdev));
/* we've already been disconnected ... no i/o is active */
if (dev->req) {
dev->req->length = USB_BUFSIZ;
free_ep_req(gadget->ep0, dev->req);
}
kfree(dev);
set_gadget_data(gadget, NULL);
}
static int __init zero_bind(struct usb_gadget *gadget) //綁定過程
{
struct zero_dev *dev;
struct usb_ep *ep;
int gcnum;
usb_ep_autoconfig_reset(gadget);
ep = usb_ep_autoconfig(gadget, &fs_sink_desc);//根據(jù)端點描述符及控制器端點情況，分配一個合適的端點。
if (!ep)
goto enomem;
EP_OUT_NAME = ep->name; //記錄名稱
gcnum = usb_gadget_controller_number(gadget);//獲得控制器代號
if (gcnum >= 0)
device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);//賦值設備描述符
else {
pr_warning("%s: controller '%s' not recognizedn",
shortname, gadget->name);
device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
}
dev = kzalloc(sizeof(*dev), GFP_KERNEL); //分配設備結構體
if (!dev)
return -ENOMEM;
spin_lock_init(&dev->lock);
dev->gadget = gadget;
set_gadget_data(gadget, dev);
dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);//分配一個請求
if (!dev->req)
goto enomem;
dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
if (!dev->req->buf)
goto enomem;
dev->req->complete = zero_setup_complete;
dev->out_ep=ep; //記錄端點(就是接收host端數(shù)據(jù)的端點)
printk("name=%sn",dev->out_ep->name); //打印出這個端點的名稱
ep->driver_data=dev;
device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
usb_gadget_set_selfpowered(gadget);
gadget->ep0->driver_data = dev;
snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
init_utsname()->sysname, init_utsname()->release,
gadget->name);
/**************************字符設備注冊*******************/
dev_t usb_zero_dev = MKDEV (usb_zero_major, 0);
int result = register_chrdev_region (usb_zero_dev, 1, "usb_zero");
if (result < 0)
{
printk (KERN_NOTICE "Unable to get usb_transfer region, error %dn",result);
return 0;
}
usb_zero_setup_cdev (dev, 0);
return 0;
enomem:
zero_unbind(gadget);
return -ENOMEM;
}
/*-------------------------------------------------------------------------*/
static struct usb_gadget_driver zero_driver = { //gadget驅動的核心數(shù)據(jù)結構
#ifdef CONFIG_USB_GADGET_DUALSPEED
.speed = USB_SPEED_HIGH,
#else
.speed = USB_SPEED_FULL,
#endif
.function = (char *) longname,
.bind = zero_bind,
.unbind = __exit_p(zero_unbind),
.setup = zero_setup,
[!--empirenews.page--].disconnect = zero_disconnect,
//.suspend = zero_suspend, //不考慮電源管理的功能
//.resume = zero_resume,
.driver = {
.name = (char *) shortname,
.owner = THIS_MODULE,
},
};
MODULE_AUTHOR("David Brownell");
MODULE_LICENSE("GPL");
static int __init init(void)
{
return usb_gadget_register_driver(&zero_driver); //注冊驅動，調(diào)用bind綁定到控制器
}
module_init(init);
static void __exit cleanup(void)
{
usb_gadget_unregister_driver(&zero_driver); //注銷驅動，通常會調(diào)用到unbind解除綁定， //在s3c2410_udc.c中調(diào)用的是disconnect方法
}
module_exit(cleanup);
三、總結
時間關系，上面的代碼沒有做太多的優(yōu)化，但功能都是測試通過。希望能給大家的學習提供一點幫助。最后想談談學習USB驅動的一些方法。
USB驅動比較難掌握，主要原因是：
復雜的USB協(xié)議，包括USB基本協(xié)議、類規(guī)范等
控制器包括主機端、設備端?？刂破鞅旧硐鄬碗s，其對應的主、從控制器驅動比較復雜
Hub功能及驅動、管理程序比較復雜
需要專業(yè)的硬件測試工具，硬件信號調(diào)試較困難
主、從端上層驅動程序本身不難，但由于對硬件不理解，及不好編寫測試程序。所以往往望而卻步。 我覺得學習USB驅動前應該有一個比較好的思路，個人建議可以按下面的過程學習
熟悉USB協(xié)議。不用看完所有的協(xié)議，重點關注一些概念、配置過程及數(shù)據(jù)包格式
下載文檔
