mini2440 usb device controller 驱动的分析--gadget设备
转自：http://blog.csdn.net/ajigegege/article/details/12710707
已经看了很长时间USB的驱动了。USB是目前看到最复杂的驱动，内容很多，但网上分析USB驱动的资料很少，因此我在学习的过程中走了很多弯路。在这里记录自己的学习过程，希望可以帮到其他研究USB驱动的同事。先推荐一本书：Bootstrap Yourself With Linux-USB Stack
首先，USB的驱动分成两部分：host和gadget。usb是一个host driven的协议，即host是完全主动，每次通信过程都是由host发起的，包括读和写。而device只负责回应，不能主动去读写。另外，虽然usb有四种传输（在很多书中都有介绍），但是usb的传输和其他的通信方式都一样，都是基于硬件中断的。无论在host方还是device方，都是产生中断之后，进行相应的处理。因此，中断函数是很多处理过程的入口点。这里的硬件中断和四种传输方式中的中断传输是完全不同的概念。
在LDD中，说不介绍gadget部分的驱动，但是它提到了configuration\interface\endpoint等概念。其实这些设置在host和gadget上面都有，在gadget的驱动里负责实现 configuration\interface，在host的驱动中，主要是得到gadget的configuration和interface，进而对gadget进行控制。
本文以s3c2440上的gadget驱动为例，分析gadget的驱动。 在以后的文章中在分析host的驱动。因为gadget的驱动相对简单。
首先，usb的驱动都是分层的。gadget部分的驱动分层如下：
其中，1.usb device controller就是具体的硬件，对应到2440的usb device controller。在数据手册上面可以看到相应的说明。2440还有一个usb host controller。这是两个不同的硬件，分别用于实现2440的usb device 和 usb host功能，在使用时，各用各的，没有相互的影响。
2. device firmware driver。这是最低层的驱动实现，其实这部分的驱动就是负责直接控制 device controller硬件的。对应的文件是usb/gadget/s3c2410_udc.c。在这部分文件中，可以配置相应的寄存器，获取硬件资源等。device controller也是实现成了一个platform device的。
3. chapter 9-- Driver/usb device framework。按照我的理解，这部分的驱动主要是一个中间层，在这部分实现了 usb 枚举的过程（在device部分是被动的，主要是如何回应host 发过来的请求。），实现从 frimware driver 和 class driver 的通信。我们可以对应到 composite.c 这个文件。
4. usb class driver。这部分驱动是要实现具体的功能的。比如最常用的u盘的功能、usb 鼠标的功能。我们以zero.c驱动为例进行分析，这个驱动可以实现的功能是可以将host发送过来的消息 回送 给主机。相当于是一个echo的作用。
从上面的分析，可以看出，firmware driver负责控制硬件，class driver 负责处理具体的业务，完成具体的功能。device frimwork负责处理其他的事情。上面就是usb device部分的分层模型。
通常，在一般介绍usb驱动的资料中，上来就介绍几个usb相关的结构体，每个结构体都很大，让人看了根本摸不到头脑。我觉得这里的分层模型是更重要的。
前面转载了两篇介绍usb 枚举过程的博客，都是写的很好的。网上的资料中，最丰富的算是 linux那些事之USB。不得不佩服写相关博客的那位博主，真是相当有才。深入分析usb的同时穿插着各种各种段子，我强忍着剧烈痛苦看了一个星期，收获不大，不得不说那个博文太过庞杂。
下面，具体分析各层。首先，是s3c2410_udc.c文件。这个文件中先是按照platform device，实现了基本的probe函数等。
/*
* probe - binds to the platform device
*/
staticint s3c2410_udc_probe(struct platform_device *pdev)
{
struct s3c2410_udc *udc = &memory;
struct device *dev = &pdev->dev;
int retval;
int irq;
dev_dbg(dev, "%s()\n", __func__);
usb_bus_clock = clk_get(NULL, "usb-bus-gadget");
if (IS_ERR(usb_bus_clock)) {
dev_err(dev, "failed to get usb bus clock source\n");
return PTR_ERR(usb_bus_clock);
}
clk_enable(usb_bus_clock);
udc_clock = clk_get(NULL, "usb-device");
if (IS_ERR(udc_clock)) {
dev_err(dev, "failed to get udc clock source\n");
return PTR_ERR(udc_clock);
}
clk_enable(udc_clock);
mdelay(10);
dev_dbg(dev, "got and enabled clocks\n");
if (strncmp(pdev->name, "s3c2440", 7) == 0) {
dev_info(dev, "S3C2440: increasing FIFO to 128 bytes\n");
memory.ep[1].fifo_size = S3C2440_EP_FIFO_SIZE;
memory.ep[2].fifo_size = S3C2440_EP_FIFO_SIZE;
memory.ep[3].fifo_size = S3C2440_EP_FIFO_SIZE;
memory.ep[4].fifo_size = S3C2440_EP_FIFO_SIZE;
}
spin_lock_init (&udc->lock);
udc_info = pdev->dev.platform_data;
rsrc_start = S3C2410_PA_USBDEV;
rsrc_len = S3C24XX_SZ_USBDEV;
if (!request_mem_region(rsrc_start, rsrc_len, gadget_name))
return -EBUSY;
base_addr = ioremap(rsrc_start, rsrc_len);
if (!base_addr) {
retval = -ENOMEM;
goto err_mem;
}
device_initialize(&udc->gadget.dev);
udc->gadget.dev.parent = &pdev->dev;
udc->gadget.dev.dma_mask = pdev->dev.dma_mask;
the_controller = udc;
platform_set_drvdata(pdev, udc);
s3c2410_udc_disable(udc);
s3c2410_udc_reinit(udc);
/* irq setup after old hardware state is cleaned up */
retval = request_irq(IRQ_USBD, s3c2410_udc_irq,
IRQF_DISABLED, gadget_name, udc);
if (retval != 0) {
dev_err(dev, "cannot get irq %i, err %d\n", IRQ_USBD, retval);
retval = -EBUSY;
goto err_map;
}
dev_dbg(dev, "got irq %i\n", IRQ_USBD);
if (udc_info && udc_info->vbus_pin > 0) {
retval = gpio_request(udc_info->vbus_pin, "udc vbus");
if (retval < 0) {
dev_err(dev, "cannot claim vbus pin\n");
goto err_int;
}
irq = gpio_to_irq(udc_info->vbus_pin);
if (irq < 0) {
dev_err(dev, "no irq for gpio vbus pin\n");
goto err_gpio_claim;
}
retval = request_irq(irq, s3c2410_udc_vbus_irq,
IRQF_DISABLED | IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING | IRQF_SHARED,
gadget_name, udc);
if (retval != 0) {
dev_err(dev, "can't get vbus irq %d, err %d\n",
irq, retval);
retval = -EBUSY;
goto err_gpio_claim;
}
dev_dbg(dev, "got irq %i\n", irq);
} else {
udc->vbus = 1;
}
dev_dbg(dev, "probe ok\n");
return 0;
}
/*
* s3c2410_udc_remove
*/
staticint s3c2410_udc_remove(struct platform_device *pdev)
{
dev_dbg(&pdev->dev, "%s: remove ok\n", __func__);
...
return 0;
}
staticstruct platform_driver udc_driver_2440 = {
.driver = {
.name = "s3c2440-usbgadget",
.owner = THIS_MODULE,
},
.probe = s3c2410_udc_probe,
.remove = s3c2410_udc_remove,
.suspend = s3c2410_udc_suspend,
.resume = s3c2410_udc_resume,
};
这里的实现和一般的platfrom device 是一样的。需要说明的
1. 就是probe函数中的vbus_pin。这个管脚是与vbus相连的，练到了一个mcu的外部中断。这样，当vbus有电平变化的时候，mcu就可以知道。因为，device设备正常来讲不知道自己被插入（或拔出）到了主设备的root hub中，vbus用于给usb设备供电，当device被插入时，vbus会使高电平，拔出时会是低电平。所以，通过vbus的中断，device设备就可以感应到自己被插拔的事件。通常，在插入时，enable_udc。被拔出后，disable_udc。当然，如果在硬件上面，没有这部分电路，那么就需要一直enable_udc。
2. memory。在probe函数中有一个memory。在这个struct s3c2410_udc memory 中记录了device controller的5个end point的相关信息。其中ep0是用作control功能的，其余的用于传输数据。在udc的driver中，并不指定ep的方向，但在class driver 中会指定。
到这里probe函数执行完后，usb device controller的初始化就完成了。
接下来，程序的入口就是usb的中断函数s3c2410_udc_irq了。
static irqreturn_t s3c2410_udc_irq(int dummy, void *_dev)
{
struct s3c2410_udc *dev = _dev;
int usb_status;
int usbd_status;
int pwr_reg;
int ep0csr;
int i;
u32 idx;
unsigned long flags;
spin_lock_irqsave(&dev->lock, flags);
/* Save index */
idx = udc_read(S3C2410_UDC_INDEX_REG); 读取index register
/* Read status registers */
usb_status = udc_read(S3C2410_UDC_USB_INT_REG);
usbd_status = udc_read(S3C2410_UDC_EP_INT_REG);
pwr_reg = udc_read(S3C2410_UDC_PWR_REG);
udc_writeb(base_addr, S3C2410_UDC_INDEX_EP0, S3C2410_UDC_INDEX_REG);
ep0csr = udc_read(S3C2410_UDC_IN_CSR1_REG);
dprintk(DEBUG_NORMAL, "usbs=%02x, usbds=%02x, pwr=%02x ep0csr=%02x\n",
usb_status, usbd_status, pwr_reg, ep0csr);
/*
* Now, handle interrupts. There's two types :
* - Reset, Resume, Suspend coming -> usb_int_reg
* - EP -> ep_int_reg
*/
/* RESET */
if (usb_status & S3C2410_UDC_USBINT_RESET) {
/* two kind of reset :
* - reset start -> pwr reg = 8
* - reset end -> pwr reg = 0
**/
dprintk(DEBUG_NORMAL, "USB reset csr %x pwr %x\n",
ep0csr, pwr_reg);
dev->gadget.speed = USB_SPEED_UNKNOWN;
udc_write(0x00, S3C2410_UDC_INDEX_REG);
udc_write((dev->ep[0].ep.maxpacket & 0x7ff) >> 3,
S3C2410_UDC_MAXP_REG);
dev->address = 0;
dev->ep0state = EP0_IDLE;
dev->gadget.speed = USB_SPEED_FULL;
/* clear interrupt */
udc_write(S3C2410_UDC_USBINT_RESET,
S3C2410_UDC_USB_INT_REG);
udc_write(idx, S3C2410_UDC_INDEX_REG);
spin_unlock_irqrestore(&dev->lock, flags);
return IRQ_HANDLED;
}
/* RESUME */
if (usb_status & S3C2410_UDC_USBINT_RESUME) {
dprintk(DEBUG_NORMAL, "USB resume\n");
/* clear interrupt */
udc_write(S3C2410_UDC_USBINT_RESUME,
S3C2410_UDC_USB_INT_REG);
if (dev->gadget.speed != USB_SPEED_UNKNOWN
&& dev->driver
&& dev->driver->resume)
dev->driver->resume(&dev->gadget);
}
/* SUSPEND */
if (usb_status & S3C2410_UDC_USBINT_SUSPEND) {
dprintk(DEBUG_NORMAL, "USB suspend\n");
/* clear interrupt */
udc_write(S3C2410_UDC_USBINT_SUSPEND,
S3C2410_UDC_USB_INT_REG);
if (dev->gadget.speed != USB_SPEED_UNKNOWN
&& dev->driver
&& dev->driver->suspend)
dev->driver->suspend(&dev->gadget);
dev->ep0state = EP0_IDLE;
}
/* EP */
/* control traffic */
/* check on ep0csr != 0 is not a good idea as clearing in_pkt_ready
* generate an interrupt
*/
if (usbd_status & S3C2410_UDC_INT_EP0) {
dprintk(DEBUG_VERBOSE, "USB ep0 irq\n");
/* Clear the interrupt bit by setting it to 1 */
udc_write(S3C2410_UDC_INT_EP0, S3C2410_UDC_EP_INT_REG);
s3c2410_udc_handle_ep0(dev);
}
/* endpoint data transfers */
for (i = 1; i < S3C2410_ENDPOINTS; i++) {
u32 tmp = 1 << i;
if (usbd_status & tmp) {
dprintk(DEBUG_VERBOSE, "USB ep%d irq\n", i);
/* Clear the interrupt bit by setting it to 1 */
udc_write(tmp, S3C2410_UDC_EP_INT_REG);
s3c2410_udc_handle_ep(&dev->ep[i]);
}
}
dprintk(DEBUG_VERBOSE, "irq: %d s3c2410_udc_done.\n", IRQ_USBD);
/* Restore old index */
udc_write(idx, S3C2410_UDC_INDEX_REG);
spin_unlock_irqrestore(&dev->lock, flags);
return IRQ_HANDLED;
}
我们先看s3c2410_udc_handle_ep0
staticvoid s3c2410_udc_handle_ep0(struct s3c2410_udc *dev)
{
u32 ep0csr;
struct s3c2410_ep *ep = &dev->ep[0];
struct s3c2410_request *req;
struct usb_ctrlrequest crq;
if (list_empty(&ep->queue))
req = NULL;
else
req = list_entry(ep->queue.next, struct s3c2410_request, queue);
/* We make the assumption that S3C2410_UDC_IN_CSR1_REG equal to
* S3C2410_UDC_EP0_CSR_REG when index is zero */
udc_write(0, S3C2410_UDC_INDEX_REG);
ep0csr = udc_read(S3C2410_UDC_IN_CSR1_REG);
/* clear stall status */
if (ep0csr & S3C2410_UDC_EP0_CSR_SENTSTL) {
s3c2410_udc_nuke(dev, ep, -EPIPE);
dprintk(DEBUG_NORMAL, "... clear SENT_STALL ...\n");
s3c2410_udc_clear_ep0_sst(base_addr);
dev->ep0state = EP0_IDLE;
return;
}
/* clear setup end */
if (ep0csr & S3C2410_UDC_EP0_CSR_SE) {
dprintk(DEBUG_NORMAL, "... serviced SETUP_END ...\n");
s3c2410_udc_nuke(dev, ep, 0);
s3c2410_udc_clear_ep0_se(base_addr);
dev->ep0state = EP0_IDLE;
}
switch (dev->ep0state) {
case EP0_IDLE:
s3c2410_udc_handle_ep0_idle(dev, ep, &crq, ep0csr);
break;
case EP0_IN_DATA_PHASE: /* GET_DESCRIPTOR etc */
dprintk(DEBUG_NORMAL, "EP0_IN_DATA_PHASE ... what now?\n");
if (!(ep0csr & S3C2410_UDC_EP0_CSR_IPKRDY) && req) {
s3c2410_udc_write_fifo(ep, req);
}
break;
case EP0_OUT_DATA_PHASE: /* SET_DESCRIPTOR etc */
dprintk(DEBUG_NORMAL, "EP0_OUT_DATA_PHASE ... what now?\n");
if ((ep0csr & S3C2410_UDC_EP0_CSR_OPKRDY) && req ) {
s3c2410_udc_read_fifo(ep,req);
}
break;
case EP0_END_XFER:
dprintk(DEBUG_NORMAL, "EP0_END_XFER ... what now?\n");
dev->ep0state = EP0_IDLE;
break;
case EP0_STALL:
dprintk(DEBUG_NORMAL, "EP0_STALL ... what now?\n");
dev->ep0state = EP0_IDLE;
break;
}
}
首先是从ep0的request queue上得到一个req。struct s3c2410_request *req。request是usb device用于描述IO请求的。结构体对应如下：
struct usb_request {
void *buf;
unsigned length;
dma_addr_t dma;
unsigned no_interrupt:1;
unsigned zero:1;
unsigned short_not_ok:1;
void (*complete)(struct usb_ep *ep,
struct usb_request *req); 这个是io request完成时的回调函数。
void *context;
struct list_head list;
int status;
unsigned actual;
};
上面比较主要的状态是idle、in_data_phase、out_data_phase。其中idle应该是ep0的初始状态，in_data_phase\out_data_phase 应该是对应接收数据和发送数据的状态。分别看三个函数。
staticvoid s3c2410_udc_handle_ep0_idle(struct s3c2410_udc *dev,
struct s3c2410_ep *ep,
struct usb_ctrlrequest *crq,
u32 ep0csr)
{
int len, ret, tmp;
s3c2410_udc_nuke(dev, ep, -EPROTO); // 这个函数的作用？
len = s3c2410_udc_read_fifo_crq(crq); //从fifo中读取control request
dprintk(DEBUG_NORMAL, "bRequest = %d bRequestType %d wLength = %d\n",
crq->bRequest, crq->bRequestType, crq->wLength);
/* cope with automagic for some standard requests. */
dev->req_std = (crq->bRequestType & USB_TYPE_MASK)
== USB_TYPE_STANDARD;
dev->req_config = 0;
dev->req_pending = 1;
// 这里是根据control request的，采取不同的措施。
switch (crq->bRequest) {
case USB_REQ_SET_CONFIGURATION:
dprintk(DEBUG_NORMAL, "USB_REQ_SET_CONFIGURATION ... \n");
if (crq->bRequestType == USB_RECIP_DEVICE) {
dev->req_config = 1;
s3c2410_udc_set_ep0_de_out(base_addr);
}
break;
case USB_REQ_SET_INTERFACE:
dprintk(DEBUG_NORMAL, "USB_REQ_SET_INTERFACE ... \n");
if (crq->bRequestType == USB_RECIP_INTERFACE) {
dev->req_config = 1;
s3c2410_udc_set_ep0_de_out(base_addr);
}
break;
case USB_REQ_SET_ADDRESS:
dprintk(DEBUG_NORMAL, "USB_REQ_SET_ADDRESS ... \n");
if (crq->bRequestType == USB_RECIP_DEVICE) {
tmp = crq->wValue & 0x7F;
dev->address = tmp;
udc_write((tmp | S3C2410_UDC_FUNCADDR_UPDATE),
S3C2410_UDC_FUNC_ADDR_REG);
s3c2410_udc_set_ep0_de_out(base_addr);
return;
}
break;
case USB_REQ_GET_STATUS:
dprintk(DEBUG_NORMAL, "USB_REQ_GET_STATUS ... \n");
s3c2410_udc_clear_ep0_opr(base_addr);
if (dev->req_std) {
if (!s3c2410_udc_get_status(dev, crq)) {
return;
}
}
break;
case USB_REQ_CLEAR_FEATURE:
s3c2410_udc_clear_ep0_opr(base_addr);
if (crq->bRequestType != USB_RECIP_ENDPOINT)
break;
if (crq->wValue != USB_ENDPOINT_HALT || crq->wLength != 0)
break;
s3c2410_udc_set_halt(&dev->ep[crq->wIndex & 0x7f].ep, 0);
s3c2410_udc_set_ep0_de_out(base_addr);
return;
case USB_REQ_SET_FEATURE:
s3c2410_udc_clear_ep0_opr(base_addr);
if (crq->bRequestType != USB_RECIP_ENDPOINT)
break;
if (crq->wValue != USB_ENDPOINT_HALT || crq->wLength != 0)
break;
s3c2410_udc_set_halt(&dev->ep[crq->wIndex & 0x7f].ep, 1);
s3c2410_udc_set_ep0_de_out(base_addr);
return;
default:
s3c2410_udc_clear_ep0_opr(base_addr);
break;
}
if (crq->bRequestType & USB_DIR_IN)
dev->ep0state = EP0_IN_DATA_PHASE;
else
dev->ep0state = EP0_OUT_DATA_PHASE;
设备枚举的具体过程。
ret = dev->driver->setup(&dev->gadget, crq);
}