STM32 USB Host Library

[Christian (Gast)]

Hallo alle zusammen!

Seit einigen Tagen beschäftige ich mich mit der USB Host Library für 
mein STM32F4 Discovery. Ziel ist es später meine Kamera steuern zu 
können. Bis dahin is es aber noch ein weiter Weg. Nun habe ich 
allerdings folgendes Problem, bzw. folgende Frage:

Die Abfrage der Gerätekonfiguration liefert mir ein Interface und drei 
Endpunkte zurück. Soweit so gut! Nun wird

USBH_ParseCfgDesc()

 aufgerufen um das Interface und die Endpunktdeskriptoren in die 
endsprechenden Datenstrukturen zu schreiben. Dabei kommt mir eines 
seltsam vor. Während des Abarbeitens der Endpunktdeskriptoren merkt sich 
der Parser jeweils die entsprechende wMaxPacketSize mittels

prev_ep_size = LE16((uint8_t *)pdesc + 4);

 Zeile ~466 usbh_stdreq.c. Ist nun wMaxPacketSize des aktuellen 
EP-Deskriptors kleiner als die verangegangenen wird abgebrochen. 
wMaxPacketSize des betreffenden Endpointdeskriptors ist bei mir 8, die 
des vorangegangenen 64.
Kann mir dafür einer einen Grund nennen? Ist es Bug oder ein Feature ;-)

LG, Christian

Anbei der Code der entsprechenden Parse-Methode.

// usbh_stdreq.c

static void  USBH_ParseCfgDesc (USBH_CfgDesc_TypeDef* cfg_desc,
                                USBH_InterfaceDesc_TypeDef* itf_desc,
                                USBH_EpDesc_TypeDef   ep_desc[][USBH_MAX_NUM_ENDPOINTS], 
                                uint8_t *buf, 
                                uint16_t length)
{  
  USBH_InterfaceDesc_TypeDef    *pif ;
  USBH_InterfaceDesc_TypeDef    temp_pif ;  
  USBH_EpDesc_TypeDef           *pep;  
  USBH_DescHeader_t             *pdesc = (USBH_DescHeader_t *)buf;
  uint16_t                      ptr;
  int8_t                        if_ix = 0;
  int8_t                        ep_ix = 0;  
  static uint16_t               prev_ep_size = 0;
  static uint8_t                prev_itf = 0;  
  
  
  pdesc   = (USBH_DescHeader_t *)buf;
  
  /* Parse configuration descriptor */
  cfg_desc->bLength             = *(uint8_t  *) (buf + 0);
  cfg_desc->bDescriptorType     = *(uint8_t  *) (buf + 1);
  cfg_desc->wTotalLength        = LE16 (buf + 2);
  cfg_desc->bNumInterfaces      = *(uint8_t  *) (buf + 4);
  cfg_desc->bConfigurationValue = *(uint8_t  *) (buf + 5);
  cfg_desc->iConfiguration      = *(uint8_t  *) (buf + 6);
  cfg_desc->bmAttributes        = *(uint8_t  *) (buf + 7);
  cfg_desc->bMaxPower           = *(uint8_t  *) (buf + 8);    
  
  
  if (length > USB_CONFIGURATION_DESC_SIZE)
  {
    ptr = USB_LEN_CFG_DESC;
    
    if ( cfg_desc->bNumInterfaces <= USBH_MAX_NUM_INTERFACES) 
    {
      pif = (USBH_InterfaceDesc_TypeDef *)0;
      
      while (ptr < cfg_desc->wTotalLength ) 
      {
        pdesc = USBH_GetNextDesc((uint8_t *)pdesc, &ptr);
        if (pdesc->bDescriptorType   == USB_DESC_TYPE_INTERFACE) 
        {
          if_ix             = *(((uint8_t *)pdesc ) + 2);
          pif               = &itf_desc[if_ix];
          
          if((*((uint8_t *)pdesc + 3)) < 3)
          {
          USBH_ParseInterfaceDesc (&temp_pif, (uint8_t *)pdesc);            
          ep_ix = 0;
          
          /* Parse Ep descriptors relative to the current interface */
          if(temp_pif.bNumEndpoints <= USBH_MAX_NUM_ENDPOINTS)
          {          
            while (ep_ix < temp_pif.bNumEndpoints) 
            {
              pdesc = USBH_GetNextDesc((void* )pdesc, &ptr);
              if (pdesc->bDescriptorType   == USB_DESC_TYPE_ENDPOINT) 
              {  
                pep               = &ep_desc[if_ix][ep_ix];
                
                if(prev_itf != if_ix)
                {
                  prev_itf = if_ix;
                  USBH_ParseInterfaceDesc (pif, (uint8_t *)&temp_pif); 
                }
                else
                {
                  //---------------------------------------------
                     HIER WIRD ABGEBROCHEN
                  //---------------------------------------------
                  if(prev_ep_size > LE16((uint8_t *)pdesc + 4))
                  {
                    break;
                  }
                  else
                  {
                    USBH_ParseInterfaceDesc (pif, (uint8_t *)&temp_pif);    
                  }
                }
                USBH_ParseEPDesc (pep, (uint8_t *)pdesc);
                prev_ep_size = LE16((uint8_t *)pdesc + 4);
                ep_ix++;
              }
            }
          }
         }
        }
      }
    }
    prev_ep_size = 0;
    prev_itf = 0; 
  }  
}

[Detlef K. (adenin)]

Hmm, komischer Code.
Ich sehe, so auf den ersten Blick, keinen Sinn des ELSE-Teiles von 
"if(prev_itf != if_ix)"
Entweder er bricht die while-Schleife ab oder USBH_ParseInterfaceDesc 
(pif, (uint8_t *)&temp_pif) wird ausgeführt, was eigentlich nur den 
Interface-Descriptor aus temp_pif nach pif kopiert. Mir ist unklar, 
wieso dieser wiederholte Kopiervorgang abhängig von wMaxPacketSize 
sein soll und was der Sinn sein soll. Das muss doch nur einmal bei jedem 
neuen Interface gemacht werden (also bei "if(prev_itf != if_ix)").
Ich würde den ELSE-Teil mal auskommentiern und sehen ob's noch geht.