USBHAL_STM32F7.cpp

00001 /* Copyright (c) 2010-2011 mbed.org, MIT License
00002 *
00003 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
00004 * and associated documentation files (the "Software"), to deal in the Software without
00005 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
00006 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
00007 * Software is furnished to do so, subject to the following conditions:
00008 *
00009 * The above copyright notice and this permission notice shall be included in all copies or
00010 * substantial portions of the Software.
00011 *
00012 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
00013 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00014 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
00015 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00016 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00017 */
00018 
00019 #if defined (TARGET_DISCO_F746NG)
00020 #include "USBDevice.h"
00021 static PCD_HandleTypeDef hpcd_USB_FS;
00022 static PCD_HandleTypeDef hpcd_USB_HS;
00023 static volatile int epCompleteFS = 0;
00024 static volatile int epCompleteHS = 0;
00025 USBHAL * USBHAL::instance;
00026 uint32_t USBHAL::endpointReadcore(uint8_t endpoint, uint8_t *buffer)
00027 {
00028     return 0;
00029 }
00030 
00031 void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
00032 {
00033     GPIO_InitTypeDef  GPIO_InitStruct;
00034 
00035     if(hpcd->Instance == USB_OTG_FS)
00036     {
00037         /* Configure USB FS GPIOs */
00038         __HAL_RCC_GPIOA_CLK_ENABLE();
00039 
00040         /* Configure DM DP Pins */
00041         GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);
00042         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00043         GPIO_InitStruct.Pull = GPIO_NOPULL;
00044         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
00045         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;
00046         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
00047 
00048         /* Enable USB FS Clock */
00049         __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
00050 
00051 
00052     }
00053     else if(hpcd->Instance == USB_OTG_HS)
00054     {
00055         /* Configure USB FS GPIOs */
00056         __HAL_RCC_GPIOA_CLK_ENABLE();
00057         __HAL_RCC_GPIOB_CLK_ENABLE();
00058         __HAL_RCC_GPIOC_CLK_ENABLE();
00059         __HAL_RCC_GPIOH_CLK_ENABLE();
00060 
00061         /* CLK */
00062         GPIO_InitStruct.Pin = GPIO_PIN_5;
00063         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00064         GPIO_InitStruct.Pull = GPIO_NOPULL;
00065         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
00066         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
00067         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
00068 
00069         /* D0 */
00070         GPIO_InitStruct.Pin = GPIO_PIN_3;
00071         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00072         GPIO_InitStruct.Pull = GPIO_NOPULL;
00073         GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
00074         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
00075         HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
00076 
00077         /* D1 D2 D3 D4 D5 D6 D7 */
00078         GPIO_InitStruct.Pin = GPIO_PIN_0  | GPIO_PIN_1  | GPIO_PIN_5 |\
00079                               GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;
00080         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00081         GPIO_InitStruct.Pull = GPIO_NOPULL;
00082         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
00083         HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
00084 
00085         /* STP */
00086         GPIO_InitStruct.Pin = GPIO_PIN_0;
00087         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00088         GPIO_InitStruct.Pull = GPIO_NOPULL;
00089         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
00090         HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
00091 
00092         /* NXT */
00093         GPIO_InitStruct.Pin = GPIO_PIN_4;
00094         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00095         GPIO_InitStruct.Pull = GPIO_NOPULL;
00096         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
00097         HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
00098 
00099         /* DIR */
00100         GPIO_InitStruct.Pin = GPIO_PIN_2;
00101         GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
00102         GPIO_InitStruct.Pull = GPIO_NOPULL;
00103         GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
00104         HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
00105 
00106         __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();
00107 
00108         /* Enable USB HS Clocks */
00109         __HAL_RCC_USB_OTG_HS_CLK_ENABLE();
00110 
00111 
00112     }
00113 }
00114 
00115 void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
00116 {
00117     if(hpcd->Instance == USB_OTG_FS)
00118     {
00119         /* Disable USB FS Clock */
00120         __HAL_RCC_USB_OTG_FS_CLK_DISABLE();
00121         __HAL_RCC_SYSCFG_CLK_DISABLE();
00122     }
00123     else if(hpcd->Instance == USB_OTG_HS)
00124     {
00125         /* Disable USB HS Clocks */
00126         __HAL_RCC_USB_OTG_HS_CLK_DISABLE();
00127         __HAL_RCC_SYSCFG_CLK_DISABLE();
00128     }
00129 }
00130 
00131 
00132 USBHAL::USBHAL(uint16_t HW_Interface)
00133 {
00134     HW_Interfaces=HW_Interface;
00135     if(HW_Interface==Fastspeed_Interface)
00136     {
00137         hpcd_USB_FS.pData = this;
00138         hpcd_USB_FS.Instance =  USB_OTG_FS;
00139         hpcd_USB_FS.Init.dev_endpoints = 8;
00140         hpcd_USB_FS.Init.speed = PCD_SPEED_FULL;
00141         hpcd_USB_FS.Init.ep0_mps = 0x40;
00142         hpcd_USB_FS.Init.phy_itface = PCD_PHY_EMBEDDED;
00143         hpcd_USB_FS.Init.Sof_enable = DISABLE;
00144         hpcd_USB_FS.Init.dma_enable = DISABLE;
00145         hpcd_USB_FS.Init.vbus_sensing_enable = DISABLE;
00146         hpcd_USB_FS.Init.lpm_enable = DISABLE;
00147         hpcd_USB_FS.Init.low_power_enable = DISABLE;
00148         //hpcd_USB_FS.Init.battery_charging_enable = DISABLE;
00149 
00150 
00151         NVIC_SetVector(OTG_FS_IRQn, (uint32_t)&_usbisrFS);
00152         /* Set USBFS Interrupt priority */
00153         HAL_NVIC_SetPriority(OTG_FS_IRQn, 5, 0);
00154         /* Enable USBFS Interrupt */
00155         HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
00156         HAL_PCD_Init(&hpcd_USB_FS);
00157         HAL_PCDEx_SetRxFiFo(&hpcd_USB_FS, 0x80);
00158         HAL_PCD_Start(&hpcd_USB_FS);
00159     }
00160     else
00161     {
00162         hpcd_USB_HS.pData = this;
00163         hpcd_USB_HS.Instance =  USB_OTG_HS;
00164         hpcd_USB_HS.Init.dev_endpoints = 8;
00165         hpcd_USB_HS.Init.speed = PCD_SPEED_HIGH;
00166         hpcd_USB_HS.Init.ep0_mps = 0x40;
00167         hpcd_USB_HS.Init.phy_itface = PCD_PHY_ULPI;
00168         hpcd_USB_HS.Init.Sof_enable = DISABLE;
00169         hpcd_USB_HS.Init.dma_enable = DISABLE;
00170         hpcd_USB_HS.Init.vbus_sensing_enable = ENABLE;
00171         hpcd_USB_HS.Init.lpm_enable = DISABLE;
00172         hpcd_USB_HS.Init.low_power_enable = DISABLE;
00173         //hpcd_USB_HS.Init.battery_charging_enable = DISABLE;
00174 
00175         NVIC_SetVector(OTG_HS_IRQn, (uint32_t)&_usbisrHS);
00176         /* Set USBHS Interrupt to the lowest priority */
00177         HAL_NVIC_SetPriority(OTG_HS_IRQn, 5, 0);
00178         /* Enable USBHS Interrupt */
00179         HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
00180         HAL_PCD_Init(&hpcd_USB_HS);
00181         HAL_PCDEx_SetRxFiFo(&hpcd_USB_HS, 0x200);
00182         HAL_PCD_Start(&hpcd_USB_HS);
00183     }
00184 }
00185 
00186 USBHAL::~USBHAL(void)
00187 {
00188     if(HW_Interfaces==Fastspeed_Interface)
00189     {
00190         HAL_PCD_DeInit(&hpcd_USB_FS);
00191     }
00192     else
00193     {
00194         HAL_PCD_DeInit(&hpcd_USB_HS);
00195     }
00196 }
00197 
00198 
00199 void USBHAL::connect(void)
00200 {
00201     if(HW_Interfaces==Fastspeed_Interface)
00202     {
00203         HAL_PCD_DevConnect(&hpcd_USB_FS);
00204     }
00205     else
00206     {
00207         HAL_PCD_DevConnect(&hpcd_USB_HS);
00208     }
00209 }
00210 
00211 void USBHAL::disconnect(void)
00212 {
00213     if(HW_Interfaces==Fastspeed_Interface)
00214     {
00215         HAL_PCD_DevDisconnect(&hpcd_USB_FS);
00216     }
00217     else
00218     {
00219         HAL_PCD_DevDisconnect(&hpcd_USB_HS);
00220     }
00221 }
00222 
00223 void USBHAL::configureDevice(void)
00224 {
00225     // Not needed
00226 }
00227 void USBHAL::unconfigureDevice(void)
00228 {
00229     // Not needed
00230 }
00231 
00232 void USBHAL::setAddress(uint8_t address)
00233 {
00234     if(HW_Interfaces==Fastspeed_Interface)
00235     {
00236         HAL_PCD_SetAddress(&hpcd_USB_FS, address);
00237     }
00238     else
00239     {
00240         HAL_PCD_SetAddress(&hpcd_USB_HS, address);
00241     }
00242 }
00243 
00244 
00245 class PacketBufferAreaManager
00246 {
00247 public:
00248     PacketBufferAreaManager(int bufsize_):bufsize(bufsize_)
00249     {
00250         reset();
00251     }
00252     void reset()
00253     {
00254         head = 0;
00255         tail = bufsize;
00256     }
00257     int allocBuf(int maxPacketSize)
00258     {
00259         head += 4;
00260         tail -= maxPacketSize;
00261         if (tail < head)
00262         {
00263             return 0;
00264         }
00265         return tail;
00266     }
00267 private:
00268     int head,tail;
00269     int bufsize;
00270 } PktBufArea(512);
00271 
00272 
00273 bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags)
00274 {
00275 
00276     PCD_HandleTypeDef *hpcd;
00277 
00278     if(HW_Interfaces==Fastspeed_Interface)
00279     {
00280         hpcd = &hpcd_USB_FS;
00281     }
00282     else
00283     {
00284         hpcd = &hpcd_USB_HS;
00285     }
00286     uint8_t ep_type;
00287     switch(endpoint)
00288     {
00289     case EP0OUT:
00290         HAL_PCD_EP_Open(hpcd, 0x00, maxPacket, EP_TYPE_CTRL);
00291         break;
00292     case EP0IN:
00293         HAL_PCDEx_SetTxFiFo(hpcd,0,maxPacket);
00294         HAL_PCD_EP_Open(hpcd, 0x80, maxPacket, EP_TYPE_CTRL);
00295         break;
00296     case EPINT_OUT:
00297         HAL_PCD_EP_Open(hpcd, 0x01, maxPacket, EP_TYPE_INTR);
00298         break;
00299     case EPINT_IN:
00300         HAL_PCDEx_SetTxFiFo(hpcd,1,maxPacket);
00301         HAL_PCD_EP_Open(hpcd, 0x81, maxPacket, EP_TYPE_INTR);
00302         break;
00303     case EPBULK_OUT:
00304         HAL_PCD_EP_Open(hpcd, 0x02, maxPacket, EP_TYPE_BULK);
00305         break;
00306     case EPBULK_IN:
00307         HAL_PCDEx_SetTxFiFo(hpcd,2,maxPacket);
00308         HAL_PCD_EP_Open(hpcd, 0x82, maxPacket, EP_TYPE_BULK);
00309         break;
00310     case EP3OUT:
00311         ep_type = (flags & ISOCHRONOUS) ? EP_TYPE_ISOC : EP_TYPE_BULK;
00312         HAL_PCD_EP_Open(hpcd, 0x03, maxPacket, ep_type);
00313         break;
00314     case EP3IN:
00315         HAL_PCDEx_SetTxFiFo(hpcd,3,maxPacket);
00316         ep_type = (flags & ISOCHRONOUS) ? EP_TYPE_ISOC : EP_TYPE_BULK;
00317         HAL_PCD_EP_Open(hpcd, 0x83, maxPacket, ep_type);
00318         break;
00319     default:
00320         MBED_ASSERT(0);
00321         return false;
00322     }
00323     return true;
00324 }
00325 
00326 
00327 // read setup packet
00328 void USBHAL::EP0setup(uint8_t *buffer)
00329 {
00330     if(HW_Interfaces==Fastspeed_Interface)
00331     {
00332         memcpy(buffer, hpcd_USB_FS.Setup, 8);
00333     }
00334     else
00335     {
00336         memcpy(buffer, hpcd_USB_HS.Setup, 8);
00337     }
00338 }
00339 
00340 void USBHAL::EP0readStage(void)
00341 {
00342 }
00343 
00344 void USBHAL::EP0read(void)
00345 {
00346     endpointRead(EP0OUT, MAX_PACKET_SIZE_EP0);
00347 }
00348 
00349 
00350 class rxTempBufferManager
00351 {
00352     uint8_t buf0[MAX_PACKET_SIZE_EP0];
00353     uint8_t buf1[MAX_PACKET_SIZE_EP1];
00354     uint8_t buf2[MAX_PACKET_SIZE_EP2];
00355     uint8_t buf3[MAX_PACKET_SIZE_EP3_ISO];
00356 public:
00357     uint8_t* ptr(uint8_t endpoint, int maxPacketSize)
00358     {
00359         switch(endpoint)
00360         {
00361         case EP0OUT:
00362             MBED_ASSERT(maxPacketSize <= MAX_PACKET_SIZE_EP0);
00363             break;
00364         case EP1OUT:
00365             MBED_ASSERT(maxPacketSize <= MAX_PACKET_SIZE_EP1);
00366             break;
00367         case EP2OUT:
00368             MBED_ASSERT(maxPacketSize <= MAX_PACKET_SIZE_EP2);
00369             break;
00370         case EP3OUT:
00371             MBED_ASSERT(maxPacketSize <= MAX_PACKET_SIZE_EP3_ISO);
00372             break;
00373         }
00374         return ptr(endpoint);
00375     }
00376     uint8_t* ptr(uint8_t endpoint)
00377     {
00378         switch(endpoint)
00379         {
00380         case EP0OUT:
00381             return buf0;
00382         case EP1OUT:
00383             return buf1;
00384         case EP2OUT:
00385             return buf2;
00386         case EP3OUT:
00387             return buf3;
00388         }
00389         MBED_ASSERT(0);
00390         return NULL;
00391     }
00392 } rxtmp;
00393 
00394 
00395 uint32_t USBHAL::EP0getReadResult(uint8_t *buffer)
00396 {
00397     const uint8_t endpoint = EP0OUT;
00398     uint32_t length;
00399     if(HW_Interfaces==Fastspeed_Interface)
00400     {
00401         length = HAL_PCD_EP_GetRxCount(&hpcd_USB_FS, endpoint>>1);
00402     }
00403     else
00404     {
00405         length = HAL_PCD_EP_GetRxCount(&hpcd_USB_HS, endpoint>>1);
00406     }
00407     memcpy(buffer, rxtmp.ptr(endpoint), length);
00408     return length;
00409 }
00410 
00411 void USBHAL::EP0write(uint8_t *buffer, uint32_t size)
00412 {
00413     endpointWrite(EP0IN, buffer, size);
00414 }
00415 
00416 void USBHAL::EP0getWriteResult(void)
00417 {
00418 }
00419 
00420 void USBHAL::EP0stall(void)
00421 {
00422     // If we stall the out endpoint here then we have problems transferring
00423     // and setup requests after the (stalled) get device qualifier requests.
00424     // TODO: Find out if this is correct behavior, or whether we are doing
00425     // something else wrong
00426     stallEndpoint(EP0IN);
00427 //    stallEndpoint(EP0OUT);
00428 }
00429 
00430 EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize)
00431 {
00432     if(HW_Interfaces==Fastspeed_Interface)
00433     {
00434         epCompleteFS &= ~(1 << endpoint);
00435         HAL_PCD_EP_Receive(&hpcd_USB_FS, endpoint>>1, rxtmp.ptr(endpoint, maximumSize), maximumSize);
00436     }
00437     else
00438     {
00439         epCompleteHS &= ~(1 << endpoint);
00440         HAL_PCD_EP_Receive(&hpcd_USB_HS, endpoint>>1, rxtmp.ptr(endpoint, maximumSize), maximumSize);
00441     }
00442 
00443     return EP_PENDING;
00444 }
00445 
00446 EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t * buffer, uint32_t *bytesRead)
00447 {
00448     int len;
00449     if(HW_Interfaces==Fastspeed_Interface)
00450     {
00451 
00452         if (!(epCompleteFS & (1 << endpoint)))
00453         {
00454             return EP_PENDING;
00455         }
00456 
00457         len = HAL_PCD_EP_GetRxCount(&hpcd_USB_FS, endpoint>>1);
00458     }
00459     else
00460     {
00461 
00462         if (!(epCompleteHS & (1 << endpoint)))
00463         {
00464             return EP_PENDING;
00465         }
00466 
00467         len = HAL_PCD_EP_GetRxCount(&hpcd_USB_HS, endpoint>>1);
00468     }
00469     memcpy(buffer, rxtmp.ptr(endpoint), len);
00470     *bytesRead = len;
00471     return EP_COMPLETED;
00472 }
00473 
00474 EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size)
00475 {
00476     if(HW_Interfaces==Fastspeed_Interface)
00477     {
00478         epCompleteFS &= ~(1 << endpoint);
00479         HAL_PCD_EP_Transmit(&hpcd_USB_FS, endpoint>>1, data, size);
00480     }
00481     else
00482     {
00483         epCompleteHS &= ~(1 << endpoint);
00484         HAL_PCD_EP_Transmit(&hpcd_USB_HS, endpoint>>1, data, size);
00485     }
00486 
00487     return EP_PENDING;
00488 }
00489 
00490 EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint)
00491 {
00492     if(HW_Interfaces==Fastspeed_Interface)
00493     {
00494         if (epCompleteFS & (1 << endpoint))
00495         {
00496             epCompleteFS &= ~(1 << endpoint);
00497             return EP_COMPLETED;
00498         }
00499         return EP_PENDING;
00500     }
00501     else
00502     {
00503         if (epCompleteHS & (1 << endpoint))
00504         {
00505             epCompleteHS &= ~(1 << endpoint);
00506             return EP_COMPLETED;
00507         }
00508         return EP_PENDING;
00509     }
00510 }
00511 
00512 void USBHAL::stallEndpoint(uint8_t endpoint)
00513 {
00514     PCD_HandleTypeDef *hpcd;
00515     if(HW_Interfaces==Fastspeed_Interface)
00516     {
00517         hpcd = &hpcd_USB_FS;
00518     }
00519     else
00520     {
00521         hpcd = &hpcd_USB_HS;
00522     }
00523     switch(endpoint)
00524     {
00525     case EP0IN:
00526         HAL_PCD_EP_SetStall(hpcd, 0x80);
00527         break;
00528     case EP0OUT:
00529         HAL_PCD_EP_SetStall(hpcd, 0x00);
00530         break;
00531     default:
00532         break;
00533     }
00534 }
00535 
00536 void USBHAL::unstallEndpoint(uint8_t endpoint)
00537 {
00538 }
00539 
00540 bool USBHAL::getEndpointStallState(uint8_t endpoint)
00541 {
00542     return false;
00543 }
00544 
00545 void USBHAL::remoteWakeup(void) {}
00546 
00547 void USBHAL::_usbisrFS(void)
00548 {
00549     HAL_PCD_IRQHandler(&hpcd_USB_FS);
00550 }
00551 
00552 void USBHAL::_usbisrHS(void)
00553 {
00554     HAL_PCD_IRQHandler(&hpcd_USB_HS);
00555 }
00556 
00557 void USBHAL::usbisr(void) {}
00558 
00559 void USBHAL::SetupStageCallback()
00560 {
00561     EP0setupCallback();
00562 }
00563 
00564 void USBHAL::DataInStageCallback(uint8_t epnum)
00565 {
00566     if(HW_Interfaces==Fastspeed_Interface)
00567     {
00568         switch(epnum)
00569         {
00570         case 0: // EP0IN
00571             EP0in();
00572             break;
00573         case 1:
00574             epCompleteFS |= (1<<EP1IN);
00575             if (EP1_IN_callback())
00576             {
00577                 epCompleteFS &= ~(1<<EP1IN);
00578             }
00579             break;
00580         case 2:
00581             epCompleteFS |= (1<<EP2IN);
00582             if (EP2_IN_callback())
00583             {
00584                 epCompleteFS &= ~(1<<EP2IN);
00585             }
00586             break;
00587         case 3:
00588             epCompleteFS |= (1<<EP3IN);
00589             if (EP3_IN_callback())
00590             {
00591                 epCompleteFS &= ~(1<<EP3IN);
00592             }
00593             break;
00594         default:
00595             MBED_ASSERT(0);
00596             break;
00597         }
00598     }
00599     else
00600     {
00601         switch(epnum)
00602         {
00603         case 0: // EP0IN
00604             EP0in();
00605             break;
00606         case 1:
00607             epCompleteHS |= (1<<EP1IN);
00608             if (EP1_IN_callback())
00609             {
00610                 epCompleteHS &= ~(1<<EP1IN);
00611             }
00612             break;
00613         case 2:
00614             epCompleteHS |= (1<<EP2IN);
00615             if (EP2_IN_callback())
00616             {
00617                 epCompleteHS &= ~(1<<EP2IN);
00618             }
00619             break;
00620         case 3:
00621             epCompleteFS |= (1<<EP3IN);
00622             if (EP3_IN_callback())
00623             {
00624                 epCompleteFS &= ~(1<<EP3IN);
00625             }
00626             break;
00627         default:
00628             MBED_ASSERT(0);
00629             break;
00630         }
00631     }
00632 }
00633 
00634 void USBHAL::DataOutStageCallback(uint8_t epnum)
00635 {
00636     if(HW_Interfaces==Fastspeed_Interface)
00637     {
00638         switch(epnum)
00639         {
00640         case 0: // EP0OUT
00641             if ((hpcd_USB_FS.Setup[0]&0x80) == 0x00)   // host to device ?
00642             {
00643                 EP0out();
00644             }
00645 
00646             break;
00647         case 1:
00648             epCompleteFS |= (1<<EP1OUT);
00649             if (EP1_OUT_callback())
00650             {
00651                 epCompleteFS &= ~(1<<EP1OUT);
00652             }
00653             break;
00654         case 2:
00655             epCompleteFS |= (1<<EP2OUT);
00656             if (EP2_OUT_callback())
00657             {
00658                 epCompleteFS &= ~(1<<EP2OUT);
00659             }
00660             break;
00661         case 3:
00662             epCompleteFS |= (1<<EP3OUT);
00663             if (EP3_OUT_callback())
00664             {
00665                 epCompleteFS &= ~(1<<EP3OUT);
00666             }
00667             break;
00668         default:
00669             MBED_ASSERT(0);
00670             break;
00671         }
00672     }
00673     else
00674     {
00675         switch(epnum)
00676         {
00677         case 0: // EP0OUT
00678 
00679             if ((hpcd_USB_HS.Setup[0]&0x80) == 0x00)   // host to device ?
00680             {
00681                 EP0out();
00682             }
00683 
00684             break;
00685         case 1:
00686             epCompleteHS |= (1<<EP1OUT);
00687             if (EP1_OUT_callback())
00688             {
00689                 epCompleteHS &= ~(1<<EP1OUT);
00690             }
00691             break;
00692         case 2:
00693             epCompleteHS |= (1<<EP2OUT);
00694             if (EP2_OUT_callback())
00695             {
00696                 epCompleteHS &= ~(1<<EP2OUT);
00697             }
00698             break;
00699         case 3:
00700             epCompleteHS |= (1<<EP3OUT);
00701             if (EP3_OUT_callback())
00702             {
00703                 epCompleteHS &= ~(1<<EP3OUT);
00704             }
00705             break;
00706         default:
00707             MBED_ASSERT(0);
00708             break;
00709         }
00710     }
00711 }
00712 
00713 void USBHAL::ResetCallback()
00714 {
00715     PktBufArea.reset();
00716     realiseEndpoint(EP0IN, MAX_PACKET_SIZE_EP0, 0);
00717     realiseEndpoint(EP0OUT, MAX_PACKET_SIZE_EP0, 0);
00718 }
00719 
00720 void USBHAL::SOFCallback()
00721 {
00722     if(HW_Interfaces==Fastspeed_Interface)
00723     {
00724         SOF(1);
00725     }
00726     else
00727     {
00728         SOF(1);
00729     }
00730 }
00731 
00732 void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
00733 {
00734     reinterpret_cast<USBHAL*>(hpcd->pData)->SetupStageCallback();
00735 }
00736 
00737 void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
00738 {
00739     reinterpret_cast<USBHAL*>(hpcd->pData)->DataInStageCallback(epnum);
00740 }
00741 
00742 void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
00743 {
00744     reinterpret_cast<USBHAL*>(hpcd->pData)->DataOutStageCallback(epnum);
00745 }
00746 
00747 void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
00748 {
00749     reinterpret_cast<USBHAL*>(hpcd->pData)->ResetCallback();
00750 }
00751 
00752 void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
00753 {
00754     reinterpret_cast<USBHAL*>(hpcd->pData)->SOFCallback();
00755 }
00756 
00757 void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
00758 {
00759     if (hpcd->Init.low_power_enable)
00760     {
00761         SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
00762     }
00763 }
00764 
00765 
00766 
00767 #endif