STM32 USB学习笔记6

主机环境：Windows 7 SP1

开发环境：MDK5.14

目标板：STM32F103C8T6

开发库：STM32F1Cube库和STM32_USB_Device_Library

现在来分析哈USB器件库代码，先来看usbd_core文件，其头文件只有一些函数声明，没啥可说的，只有一点，之前分析usbd_conf.c文件时里面USB中断回调函数中调用的底层接口都是在usbd_core.h文件中声明的，同样由用户实现的底层接口也是在该文件中声明的，在usbd_core.c文件中实现，该文件是很重要的一个文件，因为所有上层操作最终都会调用该文件中的API来实现。在器件库文档中提到了核心库的作用，如下：

第一个分析的函数是USB栈的初始化以及重新初始化，如下：

/**

* @brief  USBD_Init

*         Initializes the device stack and load the class driver

* @param  pdev: device instance

* @param  pdesc: Descriptor structure address

* @param  id: Low level core index

* @retval None

*/

USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev, USBD_DescriptorsTypeDef *pdesc, uint8_t id)

{

  /* Check whether the USB Host handle is valid */

  if(pdev == NULL)

  {

    USBD_ErrLog("Invalid Device handle");

    return USBD_FAIL; 

  }

  /* Unlink previous class*/

  if(pdev->pClass != NULL)

  {

    pdev->pClass = NULL;

  }

  /* Assign USBD Descriptors */

  if(pdesc != NULL)

  {

    pdev->pDesc = pdesc;

  }

  /* Set Device initial State */

  pdev->dev_state  = USBD_STATE_DEFAULT;

  pdev->id = id;

  /* Initialize low level driver */

  USBD_LL_Init(pdev);

  return USBD_OK; 

}

/**

* @brief  USBD_DeInit 

*         Re-Initialize th device library

* @param  pdev: device instance

* @retval status: status

*/

USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev)

{

  /* Set Default State */

  pdev->dev_state  = USBD_STATE_DEFAULT;

  /* Free Class Resources */

  pdev->pClass->DeInit(pdev, pdev->dev_config);  

    /* Stop the low level driver  */

  USBD_LL_Stop(pdev); 

  /* Initialize low level driver */

  USBD_LL_DeInit(pdev);

  return USBD_OK;

}

USB初始化函数很简单，将USB句柄的设备类指针置NULL，同时将USB的描述符加载上去，将USB设备状态置为默认状态，该函数里面的id目前不清楚是作何用，最后调用USB_LL_Init()函数来初始化底层驱动。USB器件库中USB设备有四种状态，定义在usbd_def.h文件中，如下：

/*  Device Status */

#define USBD_STATE_DEFAULT                                1

#define USBD_STATE_ADDRESSED                              2

#define USBD_STATE_CONFIGURED                             3

#define USBD_STATE_SUSPENDED                              4

默认状态、地址状态、配置状态、挂起状态。在USB2.0协议文档的第9章节中规定了USB设备的6种状态：连接状态、上电状态、默认状态、地址状态、配置状态、挂起状态，六者之间的关系图如下所示：

在USB库中是省略了连接和上电两个状态，剩下四种状态的说明可以在USB2.0协议的第九章节找到，由此可以看出USB2.0协议中第九章节有多重要了。在USB分配地址之前其使用默认地址，处在默认状态下的USB设备不能响应正常的请求，当USB设备分配了唯一的地址后即进入地址状态，响应正常请求，USB设备配置完成后进入配置状态，USB设备在指定时间长度内没有检测到总线通信时会进入挂起状态，但会保持任何内部状态，包括地址和配置。在USB重新初始化函数中，需要释放类资源，且停止USB底层驱动，重新初始化底层驱动。接着是注册类函数：

/**

  * @brief  USBD_RegisterClass 

  *         Link class driver to Device Core.

  * @param  pDevice : Device Handle

  * @param  pclass: Class handle

  * @retval USBD Status

  */

USBD_StatusTypeDef  USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass)

{

  USBD_StatusTypeDef   status = USBD_OK;

  if(pclass != 0)

  {

    /* link the class to the USB Device handle */

    pdev->pClass = pclass;

    status = USBD_OK;

  }

  else

  {

    USBD_ErrLog("Invalid Class handle");

    status = USBD_FAIL; 

  }

  return status;

}

注册设备类函数也很简单，把设备类指针传递给USB设备句柄即可，通过指针USB句柄包含了我们所用的所有资源，接着来看USB的一些基本操作，如下：

/**

  * @brief  USBD_Start 

  *         Start the USB Device Core.

  * @param  pdev: Device Handle

  * @retval USBD Status

  */

USBD_StatusTypeDef  USBD_Start  (USBD_HandleTypeDef *pdev)

{

  /* Start the low level driver  */

  USBD_LL_Start(pdev); 

  return USBD_OK;  

}

/**

  * @brief  USBD_Stop 

  *         Stop the USB Device Core.

  * @param  pdev: Device Handle

  * @retval USBD Status

  */

USBD_StatusTypeDef  USBD_Stop   (USBD_HandleTypeDef *pdev)

{

  /* Free Class Resources */

  pdev->pClass->DeInit(pdev, pdev->dev_config);  

  /* Stop the low level driver  */

  USBD_LL_Stop(pdev); 

  return USBD_OK;  

}

/**

* @brief  USBD_RunTestMode 

*         Launch test mode process

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef  USBD_RunTestMode (USBD_HandleTypeDef  *pdev) 

{

  return USBD_OK;

}

/**

* @brief  USBD_SetClassConfig 

*        Configure device and start the interface

* @param  pdev: device instance

* @param  cfgidx: configuration index

* @retval status

*/

USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef  *pdev, uint8_t cfgidx)

{

  USBD_StatusTypeDef   ret = USBD_FAIL;

  if(pdev->pClass != NULL)

  {

    /* Set configuration  and Start the Class*/

    if(pdev->pClass->Init(pdev, cfgidx) == 0)

    {

      ret = USBD_OK;

    }

  }

  return ret; 

}

/**

* @brief  USBD_ClrClassConfig 

*         Clear current configuration

* @param  pdev: device instance

* @param  cfgidx: configuration index

* @retval status: USBD_StatusTypeDef

*/

USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef  *pdev, uint8_t cfgidx)

{

  /* Clear configuration  and De-initialize the Class process*/

  pdev->pClass->DeInit(pdev, cfgidx);  

  return USBD_OK;

}

/**

* @brief  USBD_LL_Reset 

*         Handle Reset event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_SetSpeed(USBD_HandleTypeDef  *pdev, USBD_SpeedTypeDef speed)

{

  pdev->dev_speed = speed;

  return USBD_OK;

}

其中USBD_Start和USBD_Stop跟USBD的初始化类似都是调用usbd_conf中的底层基本操作，USBD_RunTestMode()函数为空，表明不支持测试模式，测试模式在USB2.0协议文档有提及，既然这里不支持就么有去细研究该功能。另外两个函数USBD_SetClassConfig()、USBD_ClrClassConfig()函数则是跟USB设备类相关，这里我们还没有分析到USB设备类中，所以也略过，知道其功能即可。最后有一个USBD_LL_SetSpeed()函数，USB通信有三种通信速度：低速、全速、高速，STM32F103C8T6支持全速模式，USB速度的定义如下：

/* Following USB Device Speed */

typedef enum 

{

  USBD_SPEED_HIGH  = 0,

  USBD_SPEED_FULL  = 1,

  USBD_SPEED_LOW   = 2,  

}USBD_SpeedTypeDef;

usbd_core.c中剩下的一些函数体则是在usbd_conf.cUSB中断回调函数中调用的USB通信处理的真正实现者，如下：

/**

* @brief  USBD_SetupStage 

*         Handle the setup stage

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_SetupStage(USBD_HandleTypeDef *pdev, uint8_t *psetup)

{

  USBD_ParseSetupRequest(&pdev->request, psetup);

  pdev->ep0_state = USBD_EP0_SETUP;

  pdev->ep0_data_len = pdev->request.wLength;

  switch (pdev->request.bmRequest & 0x1F) 

  {

  case USB_REQ_RECIPIENT_DEVICE:   

    USBD_StdDevReq (pdev, &pdev->request);

    break;

  case USB_REQ_RECIPIENT_INTERFACE:     

    USBD_StdItfReq(pdev, &pdev->request);

    break;

  case USB_REQ_RECIPIENT_ENDPOINT:        

    USBD_StdEPReq(pdev, &pdev->request);   

    break;

  default:           

    USBD_LL_StallEP(pdev , pdev->request.bmRequest & 0x80);

    break;

  }  

  return USBD_OK;  

}

/**

* @brief  USBD_DataOutStage 

*         Handle data OUT stage

* @param  pdev: device instance

* @param  epnum: endpoint index

* @retval status

*/

USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev , uint8_t epnum, uint8_t *pdata)

{

  USBD_EndpointTypeDef    *pep;

  if(epnum == 0) 

  {

    pep = &pdev->ep_out[0];

    if ( pdev->ep0_state == USBD_EP0_DATA_OUT)

    {

      if(pep->rem_length > pep->maxpacket)

      {

        pep->rem_length -=  pep->maxpacket;

        USBD_CtlContinueRx (pdev, 

                            pdata,

                            MIN(pep->rem_length ,pep->maxpacket));

      }

      else

      {

        if((pdev->pClass->EP0_RxReady != NULL)&&

           (pdev->dev_state == USBD_STATE_CONFIGURED))

        {

          pdev->pClass->EP0_RxReady(pdev); 

        }

        USBD_CtlSendStatus(pdev);

      }

    }

  }

  else if((pdev->pClass->DataOut != NULL)&&

          (pdev->dev_state == USBD_STATE_CONFIGURED))

  {

    pdev->pClass->DataOut(pdev, epnum); 

  }  

  return USBD_OK;

}

/**

* @brief  USBD_DataInStage 

*         Handle data in stage

* @param  pdev: device instance

* @param  epnum: endpoint index

* @retval status

*/

USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev ,uint8_t epnum, uint8_t *pdata)

{

  USBD_EndpointTypeDef    *pep;

  if(epnum == 0) 

  {

    pep = &pdev->ep_in[0];

    if ( pdev->ep0_state == USBD_EP0_DATA_IN)

    {

      if(pep->rem_length > pep->maxpacket)

      {

        pep->rem_length -=  pep->maxpacket;

        USBD_CtlContinueSendData (pdev, 

                                  pdata, 

                                  pep->rem_length);

        /* Prepare endpoint for premature end of transfer */

        USBD_LL_PrepareReceive (pdev,

                                0,

                                NULL,

                                0);  

      }

      else

      { /* last packet is MPS multiple, so send ZLP packet */

        if((pep->total_length % pep->maxpacket == 0) &&

           (pep->total_length >= pep->maxpacket) &&

             (pep->total_length < pdev->ep0_data_len ))

        {

          USBD_CtlContinueSendData(pdev , NULL, 0);

          pdev->ep0_data_len = 0;

        /* Prepare endpoint for premature end of transfer */

        USBD_LL_PrepareReceive (pdev,

                                0,

                                NULL,

                                0);

        }

        else

        {

          if((pdev->pClass->EP0_TxSent != NULL)&&

             (pdev->dev_state == USBD_STATE_CONFIGURED))

          {

            pdev->pClass->EP0_TxSent(pdev); 

          }          

          USBD_CtlReceiveStatus(pdev);

        }

      }

    }

    if (pdev->dev_test_mode == 1)

    {

      USBD_RunTestMode(pdev); 

      pdev->dev_test_mode = 0;

    }

  }

  else if((pdev->pClass->DataIn != NULL)&& 

          (pdev->dev_state == USBD_STATE_CONFIGURED))

  {

    pdev->pClass->DataIn(pdev, epnum); 

  }  

  return USBD_OK;

}

/**

* @brief  USBD_LL_Reset 

*         Handle Reset event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef  *pdev)

{

  /* Open EP0 OUT */

  USBD_LL_OpenEP(pdev,

              0x00,

              USBD_EP_TYPE_CTRL,

              USB_MAX_EP0_SIZE);

  pdev->ep_out[0].maxpacket = USB_MAX_EP0_SIZE;

  /* Open EP0 IN */

  USBD_LL_OpenEP(pdev,

              0x80,

              USBD_EP_TYPE_CTRL,

              USB_MAX_EP0_SIZE);

  pdev->ep_in[0].maxpacket = USB_MAX_EP0_SIZE;

  /* Upon Reset call user call back */

  pdev->dev_state = USBD_STATE_DEFAULT;

  if (pdev->pClassData) 

    pdev->pClass->DeInit(pdev, pdev->dev_config);  

  return USBD_OK;

}

/**

* @brief  USBD_Suspend 

*         Handle Suspend event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef  *pdev)

{

  pdev->dev_old_state =  pdev->dev_state;

  pdev->dev_state  = USBD_STATE_SUSPENDED;

  return USBD_OK;

}

/**

* @brief  USBD_Resume 

*         Handle Resume event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef  *pdev)

{

  pdev->dev_state = pdev->dev_old_state;  

  return USBD_OK;

}

/**

* @brief  USBD_SOF 

*         Handle SOF event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef  *pdev)

{

  if(pdev->dev_state == USBD_STATE_CONFIGURED)

  {

    if(pdev->pClass->SOF != NULL)

    {

      pdev->pClass->SOF(pdev);

    }

  }

  return USBD_OK;

}

/**

* @brief  USBD_IsoINIncomplete 

*         Handle iso in incomplete event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef  *pdev, uint8_t epnum)

{

  return USBD_OK;

}

/**

* @brief  USBD_IsoOUTIncomplete 

*         Handle iso out incomplete event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_IsoOUTIncomplete(USBD_HandleTypeDef  *pdev, uint8_t epnum)

{

  return USBD_OK;

}

/**

* @brief  USBD_DevConnected 

*         Handle device connection event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_DevConnected(USBD_HandleTypeDef  *pdev)

{

  return USBD_OK;

}

/**

* @brief  USBD_DevDisconnected 

*         Handle device disconnection event

* @param  pdev: device instance

* @retval status

*/

USBD_StatusTypeDef USBD_LL_DevDisconnected(USBD_HandleTypeDef  *pdev)

{

  /* Free Class Resources */

  pdev->dev_state = USBD_STATE_DEFAULT;

  pdev->pClass->DeInit(pdev, pdev->dev_config);  

  return USBD_OK;

}

虽然函数有些多，但看具体函数的代码量就可以知道哪些函数是重要的，第一个函数是USBD_LL_SetupStage()，USB请求分为三个阶段：Setup阶段、可选的数据阶段、状态阶段。该函数用于处理Setup阶段，解析USB主机发来的请求，调用USBD_ParseSetupRequest()函数来获取setup请求，并赋给pdev->request变量，该函数实现如下：

/**

* @brief  USBD_ParseSetupRequest 

*         Copy buffer into setup structure

* @param  pdev: device instance

* @param  req: usb request

* @retval None

*/

void USBD_ParseSetupRequest(USBD_SetupReqTypedef *req, uint8_t *pdata)

{

  req->bmRequest     = *(uint8_t *)  (pdata);

  req->bRequest      = *(uint8_t *)  (pdata +  1);

  req->wValue        = SWAPBYTE      (pdata +  2);

  req->wIndex        = SWAPBYTE      (pdata +  4);

  req->wLength       = SWAPBYTE      (pdata +  6);

}

#define  SWAPBYTE(addr)        (((uint16_t)(*((uint8_t *)(addr)))) + \

                               (((uint16_t)(*(((uint8_t *)(addr)) + 1))) << 8))

函数实现很简单即获取Setup的8个成员变量值，至于Setup包中8个数据来源在usbd_conf.c文件中传递的是hpcd->Setup，其数据来源是在Cube库中USB的实现的，因此在这里并没有关心。在获取完Setup包数据后将端点0状态置为USBD_EP0_SETUP，端点0比较重要是因为其是USB默认的控制端点用于接收USBSetup请求数据，在USB器件库中规定了端点0的几种状态，如下：

/*  EP0 State */    

#define USBD_EP0_IDLE                                     0

#define USBD_EP0_SETUP                                    1

#define USBD_EP0_DATA_IN                                  2

#define USBD_EP0_DATA_OUT                                 3

#define USBD_EP0_STATUS_IN                                4

#define USBD_EP0_STATUS_OUT                               5

#define USBD_EP0_STALL                                    6 

可以看出端点0的状态跟USB请求息息相关。接着使用ep0_data_len来存储该Setup请求的数据长度，并根据bmRequest数据值来检测该请求的接收者，在USB2.0协议中规定了请求的接收者有三个：设备、接口、端点。根据接收者的不同调用不同的函数实现体，这些实现体在另一个文件usbd_ctlreq.c中实现，所以这里不细说，等分析usbd_ctlreq.c文件时再细说，如果接收者不是以上三种则调用USBD_LL_StallEP()来将端点设置一个停止条件。USBD_LL_DataOutStage()和USBD_LL_DataInStage()是最重要的两个函数且代码行数较多，放到最后分析，先分析另外几个比较简单的函数，USBD_LL_Reset()函数是重新初始化，这里是重新设置了端点0的属性，并把设备状态置为默认状态，并调用相应类的DeInit()函数来重新初始化设备类。USB的挂起和唤醒函数更简单，只是设置设备状态即可。USBD_LL_SOF()函数是发出起始帧信号，SOF是一个数据包，而EOF是一种电平状态。后面有一个设备断开连接的实现，跟复位有些类似，将设备状态置为默认状态，并重新初始化设备类。现在来分析两个重要的函数，首先是USBD_LL_DataOutStage()，需要注意的是Setup阶段是只跟端点0相关，而数据阶段是可以跟每一个端点相关的，因为任何端点都可以传输数据，所以该函数的参数中有epnum来传递传输数据的端点号，在函数实现中可以看到如果传递的epnum不是0，则表明是设备类中的端点传递数据，如果设备处于配置状态且设备类的DataOut指针非空则执行设备类中的DataOut函数，如果epnum为0则是端点0上的数据，DataOutStage上的数据是USB模块接收USB主机发来的，要明白其数据传输的方向。每个端点都有设置其最大包大小即maxpacket，端点接收的数据大小一定是小于等于maxpacket的，当需要接收远多于maxpacket的数据时是需要分包发送/接收的，一个很形象的例子如下：

该图是STM32论坛中培训资料中得到的，根据该图可以方便于我们分析DataOutStage以及DataInStage，在DataOutStage的处理中是获取该0号端点，且该端点处于DATA_OUT状态，端点的rem_length变量存储的是当次接收的数据总长度即在Setup函数中request.wLength，而maxpacket的值是在打开该端点时传递进来的，当我们接收到的数据长度大于自身的最大包大小时，表明我们还有数据需要继续接收，这里要注意的是该函数实际是USB中断函数中的DataStage的回调函数，即该函数执行时已经接收到了一包数据，因此这里才调用USBD_CtlContinueRx()即继续接收，这个跟串口的接收中断较类似，也由此，调用USBD_CtlContinueRx()中的参数是rem_length和maxpacket中的小值，当最后数据接收完毕时rem_length的值是小于等于maxpacket，就看传输的数据量是否是maxpacket的整数倍了。数据接收完成时这里调用了设备类的EP0_RxReady回调函数即交由对应的设备类对所收到的数据进行处理，对于本例的VCP类说即交由CDC类的接口文件中的CDC_Itf_Control()函数来处理(设置设备串口属性)，最后调用USBD_CtlSendStatus()函数来执行请求的第三阶段：状态阶段。该函数我们在后面另分析。

有了分析DataOutStage的基础，DataInStage就容易分析多了，两者是相反的过程，该函数是发送数据到USB主机，首先当传输数据的端点是非0端点时调用相应设备类的DataIn函数进行处理，当传输数据的端点是0端点时且端点0处于DATA_IN状态，同理此处的rem_length同样和Setup阶段的request.wLength相等，且该函数执行时已经有一包数据发送出去，因此这里更新完rem_length后继续发送数据且使用USBD_LL_PrepareReceive()接收USB主机发来的应答信息。当rem_length小于等于maxpacket时表明数据已经发送完毕，如果所需要发送的数据量是maxpacket的整数倍这里需要发送一个0字节数据包来通知USB主机数据发送完毕。这里一直不理解的是下面这条语句

(pep->total_length < pdev->ep0_data_len )

因为按个人理解这两个值应该是相等的，通过检索可知ep0_data_len只有一处赋值即Setup阶段的request.wLength，而total_length的值在最开始的发送时与rem_length值相等也即为本次发送的数据长度值，无论怎么想二者都应该是相等才对。ep0_data_len的值只有在这里清零，下次进入该函数时total_length值即大于ep0_data_len(因此个人觉得这里应该是ep0_data_len和0的判断而不是和total_length判断)，数据发送完毕后，如果EP0_TxSent回调函数不为空则执行该回调，最后接收USB主机发来的状态信息。当端点0的状态不为DATA_IN时这里有个测试模式的调用，由于没有使能测试模式，所以这里不关心，如果有兴趣的话可以研究哈。至此，usbd_core文件分析完毕，USB器件库的核心文件还剩下两个usbd_ioreq和usbd_ctlreq。