src/main/drivers/at32/usb/usbd_core.c

   1 /**
   2   **************************************************************************
   3   * @file     usbd_core.c
   4   * @brief    usb device driver
   5   **************************************************************************
   6   *                       Copyright notice & Disclaimer
   7   *
   8   * The software Board Support Package (BSP) that is made available to
   9   * download from Artery official website is the copyrighted work of Artery.
  10   * Artery authorizes customers to use, copy, and distribute the BSP
  11   * software and its related documentation for the purpose of design and
  12   * development in conjunction with Artery microcontrollers. Use of the
  13   * software is governed by this copyright notice and the following disclaimer.
  14   *
  15   * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES,
  16   * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS,
  17   * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR
  18   * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS,
  19   * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
  20   * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
  21   *
  22   **************************************************************************
  23   */
  24
  25 #include "platform.h"
  26
  27 #include "usb_core.h"
  28 #include "usbd_core.h"
  29 #include "usbd_sdr.h"
  30
  31 /** @addtogroup AT32F435_437_middlewares_usbd_drivers
  32   * @{
  33   */
  34
  35 /** @defgroup USBD_drivers_core
  36   * @brief usb device drivers core
  37   * @{
  38   */
  39
  40 /** @defgroup USBD_core_private_functions
  41   * @{
  42   */
  43
  44 /**
  45   * @brief  usb core in transfer complete handler
  46   * @param  udev: to the structure of usbd_core_type
  47   * @param  ept_addr: endpoint number
  48   * @retval none
  49   */
  50 void usbd_core_in_handler(usbd_core_type *udev, uint8_t ept_addr)
  51 {
  52   /* get endpoint info*/
  53   usb_ept_info *ept_info = &udev->ept_in[ept_addr & 0x7F];
  54
  55   if(ept_addr == 0)
  56   {
  57     if(udev->ept0_sts == USB_EPT0_DATA_IN)
  58     {
  59       if(ept_info->rem0_len > ept_info->maxpacket)
  60       {
  61         ept_info->rem0_len -= ept_info->maxpacket;
  62         usbd_ept_send(udev, 0, ept_info->trans_buf,
  63                       MIN(ept_info->rem0_len, ept_info->maxpacket));
  64       }
  65       /* endpoint 0 */
  66       else if(ept_info->last_len == ept_info->maxpacket
  67         && ept_info->ept0_slen >= ept_info->maxpacket
  68         && ept_info->ept0_slen < udev->ept0_wlength)
  69       {
  70         ept_info->last_len = 0;
  71         usbd_ept_send(udev, 0, 0, 0);
  72         usbd_ept_recv(udev, ept_addr, 0, 0);
  73       }
  74       else
  75       {
  76
  77         if(udev->class_handler->ept0_tx_handler != 0 &&
  78             udev->conn_state == USB_CONN_STATE_CONFIGURED)
  79         {
  80           udev->class_handler->ept0_tx_handler(udev);
  81         }
  82         usbd_ctrl_recv_status(udev);
  83
  84       }
  85     }
  86   }
  87   else if(udev->class_handler->in_handler != 0 &&
  88           udev->conn_state == USB_CONN_STATE_CONFIGURED)
  89   {
  90     /* other user define endpoint */
  91     udev->class_handler->in_handler(udev, ept_addr);
  92   }
  93 }
  94
  95 /**
  96   * @brief  usb core out transfer complete handler
  97   * @param  udev: to the structure of usbd_core_type
  98   * @param  ept_addr: endpoint number
  99   * @retval none
 100   */
 101 void usbd_core_out_handler(usbd_core_type *udev, uint8_t ept_addr)
 102 {
 103    /* get endpoint info*/
 104   usb_ept_info *ept_info = &udev->ept_out[ept_addr & 0x7F];
 105
 106   if(ept_addr == 0)
 107   {
 108     /* endpoint 0 */
 109     if(udev->ept0_sts == USB_EPT0_DATA_OUT)
 110     {
 111       if(ept_info->rem0_len > ept_info->maxpacket)
 112       {
 113         ept_info->rem0_len -= ept_info->maxpacket;
 114         usbd_ept_recv(udev, ept_addr, ept_info->trans_buf,
 115                       MIN(ept_info->rem0_len, ept_info->maxpacket));
 116       }
 117       else
 118       {
 119           if(udev->class_handler->ept0_rx_handler != 0)
 120           {
 121             udev->class_handler->ept0_rx_handler(udev);
 122           }
 123           usbd_ctrl_send_status(udev);
 124       }
 125     }
 126   }
 127   else if(udev->class_handler->out_handler != 0 &&
 128           udev->conn_state == USB_CONN_STATE_CONFIGURED)
 129   {
 130     /* other user define endpoint */
 131     udev->class_handler->out_handler(udev, ept_addr);
 132   }
 133 }
 134
 135 /**
 136   * @brief  usb core setup transfer complete handler
 137   * @param  udev: to the structure of usbd_core_type
 138   * @param  ept_addr: endpoint number
 139   * @retval none
 140   */
 141 void usbd_core_setup_handler(usbd_core_type *udev, uint8_t ept_num)
 142 {
 143     UNUSED(ept_num);
 144
 145   /* setup parse */
 146   usbd_setup_request_parse(&udev->setup, udev->setup_buffer);
 147
 148   /* set ept0 status */
 149   udev->ept0_sts = USB_EPT0_SETUP;
 150   udev->ept0_wlength = udev->setup.wLength;
 151
 152   switch(udev->setup.bmRequestType & USB_REQ_RECIPIENT_MASK)
 153   {
 154     case USB_REQ_RECIPIENT_DEVICE:
 155       /* recipient device request */
 156       usbd_device_request(udev);
 157       break;
 158     case USB_REQ_RECIPIENT_INTERFACE:
 159       /* recipient interface request */
 160       usbd_interface_request(udev);
 161       break;
 162     case USB_REQ_RECIPIENT_ENDPOINT:
 163       /* recipient endpoint request */
 164       usbd_endpoint_request(udev);
 165       break;
 166     default:
 167       break;
 168   }
 169 }
 170
 171 /**
 172   * @brief  usb control endpoint send data
 173   * @param  udev: to the structure of usbd_core_type
 174   * @param  ept_addr: endpoint number
 175   * @param  buffer: send data buffer
 176   * @param  len: send data length
 177   * @retval none
 178   */
 179 void usbd_ctrl_send(usbd_core_type *udev, uint8_t *buffer, uint16_t len)
 180 {
 181   usb_ept_info *ept_info = &udev->ept_in[0];
 182
 183   ept_info->ept0_slen = len;
 184   ept_info->rem0_len = len;
 185   udev->ept0_sts = USB_EPT0_DATA_IN;
 186
 187   usbd_ept_send(udev, 0, buffer, len);
 188 }
 189
 190 /**
 191   * @brief  usb control endpoint recv data
 192   * @param  udev: to the structure of usbd_core_type
 193   * @param  ept_addr: endpoint number
 194   * @param  buffer: recv data buffer
 195   * @param  len: recv data length
 196   * @retval none
 197   */
 198 void usbd_ctrl_recv(usbd_core_type *udev, uint8_t *buffer, uint16_t len)
 199 {
 200   usb_ept_info *ept_info = &udev->ept_out[0];
 201
 202   ept_info->ept0_slen = len;
 203   ept_info->rem0_len = len;
 204   udev->ept0_sts = USB_EPT0_DATA_OUT;
 205
 206   usbd_ept_recv(udev, 0, buffer, len);
 207 }
 208
 209 /**
 210   * @brief  usb control endpoint send in status
 211   * @param  udev: to the structure of usbd_core_type
 212   * @retval none
 213   */
 214 void usbd_ctrl_send_status(usbd_core_type *udev)
 215 {
 216   udev->ept0_sts = USB_EPT0_STATUS_IN;
 217
 218   usbd_ept_send(udev, 0, 0, 0);
 219 }
 220
 221 /**
 222   * @brief  usb control endpoint send out status
 223   * @param  udev: to the structure of usbd_core_type
 224   * @retval none
 225   */
 226 void usbd_ctrl_recv_status(usbd_core_type *udev)
 227 {
 228   udev->ept0_sts = USB_EPT0_STATUS_OUT;
 229
 230   usbd_ept_recv(udev, 0, 0, 0);
 231 }
 232
 233 /**
 234   * @brief  clear endpoint stall
 235   * @param  udev: to the structure of usbd_core_type
 236   * @param  ept_addr: endpoint number
 237   * @retval none
 238   */
 239 void usbd_clear_stall(usbd_core_type *udev, uint8_t ept_addr)
 240 {
 241   usb_ept_info *ept_info;
 242   usb_reg_type *usbx = udev->usb_reg;
 243
 244   if(ept_addr & 0x80)
 245   {
 246     /* in endpoint */
 247     ept_info = &udev->ept_in[ept_addr & 0x7F];
 248   }
 249   else
 250   {
 251     /* out endpoint */
 252     ept_info = &udev->ept_out[ept_addr & 0x7F];
 253   }
 254   usb_ept_clear_stall(usbx, ept_info);
 255   ept_info->stall = 0;
 256 }
 257
 258 /**
 259   * @brief  usb set endpoint to stall status
 260   * @param  udev: to the structure of usbd_core_type
 261   * @param  ept_addr: endpoint number
 262   * @retval none
 263   */
 264 void usbd_set_stall(usbd_core_type *udev, uint8_t ept_addr)
 265 {
 266   usb_ept_info *ept_info;
 267   usb_reg_type *usbx = udev->usb_reg;
 268
 269   if(ept_addr & 0x80)
 270   {
 271     /* in endpoint */
 272     ept_info = &udev->ept_in[ept_addr & 0x7F];
 273   }
 274   else
 275   {
 276     /* out endpoint */
 277     ept_info = &udev->ept_out[ept_addr & 0x7F];
 278   }
 279   usb_ept_stall(usbx, ept_info);
 280
 281   ept_info->stall = 1;
 282 }
 283
 284 /**
 285   * @brief  un-support device request
 286   * @param  udev: to the structure of usbd_core_type
 287   * @retval none
 288   */
 289 void usbd_ctrl_unsupport(usbd_core_type *udev)
 290 {
 291   /* return stall status */
 292   usbd_set_stall(udev, 0x00);
 293   usbd_set_stall(udev, 0x80);
 294 }
 295
 296 /**
 297   * @brief  get endpoint receive data length
 298   * @param  udev: to the structure of usbd_core_type
 299   * @param  ept_addr: endpoint number
 300   * @retval data receive len
 301   */
 302 uint32_t usbd_get_recv_len(usbd_core_type *udev, uint8_t ept_addr)
 303 {
 304   usb_ept_info *ept = &udev->ept_out[ept_addr & 0x7F];
 305   return ept->trans_len;
 306 }
 307
 308 /**
 309   * @brief  usb open endpoint
 310   * @param  udev: to the structure of usbd_core_type
 311   * @param  ept_addr: endpoint number
 312   * @param  ept_type: endpoint type
 313   * @param  maxpacket: endpoint support max buffer size
 314   * @retval none
 315   */
 316 void usbd_ept_open(usbd_core_type *udev, uint8_t ept_addr, uint8_t ept_type, uint16_t maxpacket)
 317 {
 318   usb_reg_type *usbx = udev->usb_reg;
 319   usb_ept_info *ept_info;
 320
 321   if((ept_addr & 0x80) == 0)
 322   {
 323     /* out endpoint info */
 324     ept_info = &udev->ept_out[ept_addr & 0x7F];
 325     ept_info->inout = EPT_DIR_OUT;
 326   }
 327   else
 328   {
 329     /* in endpoint info */
 330     ept_info = &udev->ept_in[ept_addr & 0x7F];
 331     ept_info->inout = EPT_DIR_IN;
 332   }
 333
 334   /* set endpoint maxpacket and type */
 335   ept_info->maxpacket = maxpacket;
 336   ept_info->trans_type = ept_type;
 337
 338   /* open endpoint */
 339   usb_ept_open(usbx, ept_info);
 340 }
 341
 342 /**
 343   * @brief  usb close endpoint
 344   * @param  udev: to the structure of usbd_core_type
 345   * @param  ept_addr: endpoint number
 346   * @retval none
 347   */
 348 void usbd_ept_close(usbd_core_type *udev, uint8_t ept_addr)
 349 {
 350   usb_ept_info *ept_info;
 351   if(ept_addr & 0x80)
 352   {
 353     /* in endpoint */
 354     ept_info = &udev->ept_in[ept_addr & 0x7F];
 355   }
 356   else
 357   {
 358     /* out endpoint */
 359     ept_info = &udev->ept_out[ept_addr & 0x7F];
 360   }
 361
 362   /* close endpoint */
 363   usb_ept_close(udev->usb_reg, ept_info);
 364 }
 365
 366 /**
 367   * @brief  usb device connect to host
 368   * @param  udev: to the structure of usbd_core_type
 369   * @retval none
 370   */
 371 void usbd_connect(usbd_core_type *udev)
 372 {
 373   usb_connect(udev->usb_reg);
 374 }
 375
 376 /**
 377   * @brief  usb device disconnect to host
 378   * @param  udev: to the structure of usbd_core_type
 379   * @retval none
 380   */
 381 void usbd_disconnect(usbd_core_type *udev)
 382 {
 383   usb_disconnect(udev->usb_reg);
 384 }
 385
 386 /**
 387   * @brief  usb device set device address.
 388   * @param  udev: to the structure of usbd_core_type
 389   * @param  address: host assignment address
 390   * @retval none
 391   */
 392 void usbd_set_device_addr(usbd_core_type *udev, uint8_t address)
 393 {
 394   usb_set_address(udev->usb_reg, address);
 395 }
 396
 397 /**
 398   * @brief  usb endpoint structure initialization
 399   * @param  udev: to the structure of usbd_core_type
 400   * @retval none
 401   */
 402 void usb_ept_default_init(usbd_core_type *udev)
 403 {
 404   uint8_t i_index = 0;
 405   /* init in endpoint info structure */
 406   for(i_index = 0; i_index < USB_EPT_MAX_NUM; i_index ++)
 407   {
 408     udev->ept_in[i_index].eptn        = i_index;
 409     udev->ept_in[i_index].ept_address = i_index;
 410     udev->ept_in[i_index].inout         = EPT_DIR_IN;
 411     udev->ept_in[i_index].maxpacket   = 0;
 412     udev->ept_in[i_index].trans_buf   = 0;
 413     udev->ept_in[i_index].total_len   = 0;
 414   }
 415
 416   /* init out endpoint info structure */
 417   for(i_index = 0; i_index < USB_EPT_MAX_NUM; i_index ++)
 418   {
 419     udev->ept_out[i_index].eptn        = i_index;
 420     udev->ept_out[i_index].ept_address = i_index;
 421     udev->ept_out[i_index].inout       = EPT_DIR_OUT;
 422     udev->ept_out[i_index].maxpacket   = 0;
 423     udev->ept_out[i_index].trans_buf   = 0;
 424     udev->ept_out[i_index].total_len   = 0;
 425   }
 426 }
 427
 428 /**
 429   * @brief  endpoint send data
 430   * @param  udev: to the structure of usbd_core_type
 431   * @param  ept_addr: endpoint number
 432   * @param  buffer: send data buffer
 433   * @param  len: send data length
 434   * @retval none
 435   */
 436 void usbd_ept_send(usbd_core_type *udev, uint8_t ept_addr, uint8_t *buffer, uint16_t len)
 437 {
 438   /* get endpoint info struct and register */
 439   usb_reg_type *usbx = udev->usb_reg;
 440   usb_ept_info *ept_info = &udev->ept_in[ept_addr & 0x7F];
 441   otg_eptin_type *ept_in = USB_INEPT(usbx, ept_info->eptn);
 442   otg_device_type *dev = OTG_DEVICE(usbx);
 443   uint32_t pktcnt;
 444
 445   /* set send data buffer and length */
 446   ept_info->trans_buf = buffer;
 447   ept_info->total_len = len;
 448   ept_info->trans_len = 0;
 449
 450   /* transfer data len is zero */
 451   if(ept_info->total_len == 0)
 452   {
 453     ept_in->dieptsiz_bit.pktcnt = 1;
 454     ept_in->dieptsiz_bit.xfersize = 0;
 455   }
 456   else
 457   {
 458     if((ept_addr & 0x7F) == 0) // endpoint 0
 459     {
 460       /* endpoint 0 */
 461       if(ept_info->total_len > ept_info->maxpacket)
 462       {
 463         ept_info->total_len = ept_info->maxpacket;
 464       }
 465
 466       /* set transfer size  */
 467       ept_in->dieptsiz_bit.xfersize = ept_info->total_len;
 468
 469       /* set packet count */
 470       ept_in->dieptsiz_bit.pktcnt = 1;
 471
 472       ept_info->last_len = ept_info->total_len;
 473     }
 474     else
 475     {
 476       /* other endpoint */
 477
 478       /* packet count */
 479       pktcnt = (ept_info->total_len + ept_info->maxpacket - 1) / ept_info->maxpacket;
 480
 481       /* set transfer size  */
 482       ept_in->dieptsiz_bit.xfersize = ept_info->total_len;
 483
 484       /* set packet count */
 485       ept_in->dieptsiz_bit.pktcnt = pktcnt;
 486
 487       if(ept_info->trans_type == EPT_ISO_TYPE)
 488       {
 489         ept_in->dieptsiz_bit.mc = 1;
 490       }
 491     }
 492   }
 493
 494   if(ept_info->trans_type != EPT_ISO_TYPE)
 495   {
 496     if(ept_info->total_len > 0)
 497     {
 498       /* set in endpoint tx fifo empty interrupt mask */
 499       dev->diepempmsk |= 1 << ept_info->eptn;
 500     }
 501   }
 502
 503   if(ept_info->trans_type == EPT_ISO_TYPE)
 504   {
 505     if((dev->dsts_bit.soffn & 0x1) == 0)
 506     {
 507       ept_in->diepctl_bit.setd1pid = TRUE;
 508     }
 509     else
 510     {
 511       ept_in->diepctl_bit.setd0pid = TRUE;
 512     }
 513   }
 514
 515   /* clear endpoint nak */
 516   ept_in->diepctl_bit.cnak = TRUE;
 517
 518   /* endpoint enable */
 519   ept_in->diepctl_bit.eptena = TRUE;
 520
 521   if(ept_info->trans_type == EPT_ISO_TYPE)
 522   {
 523     /* write data to fifo */
 524     usb_write_packet(usbx, ept_info->trans_buf, ept_info->eptn, ept_info->total_len);
 525   }
 526 }
 527
 528 /**
 529   * @brief  endpoint receive data
 530   * @param  udev: to the structure of usbd_core_type
 531   * @param  ept_addr: endpoint number
 532   * @param  buffer: receive data buffer
 533   * @param  len: receive data length
 534   * @retval none
 535   */
 536 void usbd_ept_recv(usbd_core_type *udev, uint8_t ept_addr, uint8_t *buffer, uint16_t len)
 537 {
 538   /* get endpoint info struct and register */
 539   usb_reg_type *usbx = udev->usb_reg;
 540   usb_ept_info *ept_info = &udev->ept_out[ept_addr & 0x7F];
 541   otg_eptout_type *ept_out = USB_OUTEPT(usbx, ept_info->eptn);
 542   otg_device_type *dev = OTG_DEVICE(usbx);
 543   uint32_t pktcnt;
 544
 545    /* set receive data buffer and length */
 546   ept_info->trans_buf = buffer;
 547   ept_info->total_len = len;
 548   ept_info->trans_len = 0;
 549
 550   if((ept_addr & 0x7F) == 0)
 551   {
 552     /* endpoint 0 */
 553     ept_info->total_len = ept_info->maxpacket;
 554   }
 555
 556   if(ept_info->total_len == 0 || ((ept_addr & 0x7F) == 0))
 557   {
 558     /* set transfer size  */
 559     ept_out->doeptsiz_bit.xfersize = ept_info->maxpacket;
 560
 561     /* set packet count */
 562     ept_out->doeptsiz_bit.pktcnt = 1;
 563   }
 564   else
 565   {
 566     pktcnt = (ept_info->total_len + ept_info->maxpacket - 1) / ept_info->maxpacket;
 567
 568     /* set transfer size  */
 569     ept_out->doeptsiz_bit.xfersize = ept_info->maxpacket * pktcnt;
 570
 571     /* set packet count */
 572     ept_out->doeptsiz_bit.pktcnt = pktcnt;
 573   }
 574
 575   if(ept_info->trans_type == EPT_ISO_TYPE)
 576   {
 577    if((dev->dsts_bit.soffn & 0x01) == 0)
 578    {
 579      ept_out->doepctl_bit.setd1pid = TRUE;
 580    }
 581    else
 582    {
 583      ept_out->doepctl_bit.setd0pid = TRUE;
 584    }
 585   }
 586
 587   /* clear endpoint nak */
 588   ept_out->doepctl_bit.cnak = TRUE;
 589
 590   /* endpoint enable */
 591   ept_out->doepctl_bit.eptena = TRUE;
 592 }
 593
 594 /**
 595   * @brief  get usb connect state
 596   * @param  udev: to the structure of usbd_core_type
 597   * @retval usb connect state
 598   */
 599 usbd_conn_state usbd_connect_state_get(usbd_core_type *udev)
 600 {
 601   return udev->conn_state;
 602 }
 603
 604 /**
 605   * @brief  usb device remote wakeup
 606   * @param  udev: to the structure of usbd_core_type
 607   * @retval none
 608   */
 609 void usbd_remote_wakeup(usbd_core_type *udev)
 610 {
 611   /* check device is in suspend mode */
 612   if(usb_suspend_status_get(udev->usb_reg) == 1)
 613   {
 614     /* set connect state */
 615     udev->conn_state = udev->old_conn_state;
 616
 617     /* open phy clock */
 618     usb_open_phy_clk(udev->usb_reg);
 619
 620     /* set remote wakeup */
 621     usb_remote_wkup_set(udev->usb_reg);
 622
 623     /* delay 10 ms */
 624     usb_delay_ms(10);
 625
 626     /* clear remote wakup */
 627     usb_remote_wkup_clear(udev->usb_reg);
 628   }
 629 }
 630
 631 /**
 632   * @brief  usb device enter suspend mode
 633   * @param  udev: to the structure of usbd_core_type
 634   * @retval none
 635   */
 636 void usbd_enter_suspend(usbd_core_type *udev)
 637 {
 638   /* check device is in suspend mode */
 639   if(usb_suspend_status_get(udev->usb_reg) == 1)
 640   {
 641     /* stop phy clk */
 642     usb_stop_phy_clk(udev->usb_reg);
 643   }
 644 }
 645
 646 /**
 647   * @brief  usb device flush in endpoint fifo
 648   * @param  udev: to the structure of usbd_core_type
 649   * @param  ept_num: endpoint number
 650   * @retval none
 651   */
 652 void usbd_flush_tx_fifo(usbd_core_type *udev, uint8_t ept_num)
 653 {
 654   /* flush endpoint tx fifo */
 655   usb_flush_tx_fifo(udev->usb_reg, ept_num & 0x1F);
 656 }
 657
 658 /**
 659   * @brief  usb device endpoint fifo alloc
 660   * @param  udev: to the structure of usbd_core_type
 661   * @retval none
 662   */
 663 void usbd_fifo_alloc(usbd_core_type *udev)
 664 {
 665   usb_reg_type *usbx = udev->usb_reg;
 666
 667   if(usbx == OTG1_GLOBAL)
 668   {
 669     /* set receive fifo size */
 670     usb_set_rx_fifo(usbx, USBD_RX_SIZE);
 671
 672     /* set endpoint0 tx fifo size */
 673     usb_set_tx_fifo(usbx, USB_EPT0, USBD_EP0_TX_SIZE);
 674
 675     /* set endpoint1 tx fifo size */
 676     usb_set_tx_fifo(usbx, USB_EPT1, USBD_EP1_TX_SIZE);
 677
 678     /* set endpoint2 tx fifo size */
 679     usb_set_tx_fifo(usbx, USB_EPT2, USBD_EP2_TX_SIZE);
 680
 681     /* set endpoint3 tx fifo size */
 682     usb_set_tx_fifo(usbx, USB_EPT3, USBD_EP3_TX_SIZE);
 683
 684     if(USB_EPT_MAX_NUM == 8)
 685     {
 686       /* set endpoint4 tx fifo size */
 687       usb_set_tx_fifo(usbx, USB_EPT4, USBD_EP4_TX_SIZE);
 688
 689       /* set endpoint5 tx fifo size */
 690       usb_set_tx_fifo(usbx, USB_EPT5, USBD_EP5_TX_SIZE);
 691
 692       /* set endpoint6 tx fifo size */
 693       usb_set_tx_fifo(usbx, USB_EPT6, USBD_EP6_TX_SIZE);
 694
 695       /* set endpoint7 tx fifo size */
 696       usb_set_tx_fifo(usbx, USB_EPT7, USBD_EP7_TX_SIZE);
 697     }
 698   }
 699 #ifdef OTG2_GLOBAL
 700   if(usbx == OTG2_GLOBAL)
 701   {
 702     /* set receive fifo size */
 703     usb_set_rx_fifo(usbx, USBD2_RX_SIZE);
 704
 705     /* set endpoint0 tx fifo size */
 706     usb_set_tx_fifo(usbx, USB_EPT0, USBD2_EP0_TX_SIZE);
 707
 708     /* set endpoint1 tx fifo size */
 709     usb_set_tx_fifo(usbx, USB_EPT1, USBD2_EP1_TX_SIZE);
 710
 711     /* set endpoint2 tx fifo size */
 712     usb_set_tx_fifo(usbx, USB_EPT2, USBD2_EP2_TX_SIZE);
 713
 714     /* set endpoint3 tx fifo size */
 715     usb_set_tx_fifo(usbx, USB_EPT3, USBD2_EP3_TX_SIZE);
 716
 717     if(USB_EPT_MAX_NUM == 8)
 718     {
 719       /* set endpoint4 tx fifo size */
 720       usb_set_tx_fifo(usbx, USB_EPT4, USBD2_EP4_TX_SIZE);
 721
 722       /* set endpoint5 tx fifo size */
 723       usb_set_tx_fifo(usbx, USB_EPT5, USBD2_EP5_TX_SIZE);
 724
 725       /* set endpoint6 tx fifo size */
 726       usb_set_tx_fifo(usbx, USB_EPT6, USBD2_EP6_TX_SIZE);
 727
 728       /* set endpoint7 tx fifo size */
 729       usb_set_tx_fifo(usbx, USB_EPT7, USBD2_EP7_TX_SIZE);
 730     }
 731   }
 732 #endif
 733 }
 734
 735 /**
 736   * @brief  usb device core initialization
 737   * @param  udev: to the structure of usbd_core_type
 738   * @param  usb_reg: usb otgfs peripheral global register
 739   *         this parameter can be one of the following values:
 740   *         OTG1_GLOBAL , OTG2_GLOBAL
 741   * @param  class_handler: usb class handler
 742   * @param  desc_handler: device config handler
 743   * @param  core_id: usb core id number
 744   * @retval usb_sts_type
 745   */
 746 usb_sts_type usbd_core_init(usbd_core_type *udev,
 747                             usb_reg_type *usb_reg,
 748                             usbd_class_handler *class_handler,
 749                             usbd_desc_handler *desc_handler,
 750                             uint8_t core_id)
 751 {
 752     UNUSED(core_id);
 753     usb_reg_type *usbx;
 754     otg_device_type *dev;
 755     otg_eptin_type *ept_in;
 756     otg_eptout_type *ept_out;
 757     uint32_t i_index;
 758
 759     udev->usb_reg = usb_reg;
 760     usbx = usb_reg;
 761     dev = OTG_DEVICE(usbx);
 762
 763   /* set connect state */
 764   udev->conn_state = USB_CONN_STATE_DEFAULT;
 765
 766   /* device class config */
 767   udev->device_addr = 0;
 768   udev->class_handler = class_handler;
 769   udev->desc_handler = desc_handler;
 770   /* set device disconnect */
 771   usbd_disconnect(udev);
 772
 773   /* set endpoint to default status */
 774   usb_ept_default_init(udev);
 775
 776   /* disable usb global interrupt */
 777   usb_interrupt_disable(usbx);
 778
 779   /* init global register */
 780   usb_global_init(usbx);
 781
 782   /* set device mode */
 783   usb_global_set_mode(usbx, OTG_DEVICE_MODE);
 784
 785   /* open phy clock */
 786   usb_open_phy_clk(udev->usb_reg);
 787
 788   /* set periodic frame interval */
 789   dev->dcfg_bit.perfrint = DCFG_PERFRINT_80;
 790
 791   /* set device speed to full-speed */
 792   dev->dcfg_bit.devspd = USB_DCFG_FULL_SPEED;
 793
 794   /* flush all tx fifo */
 795   usb_flush_tx_fifo(usbx, 16);
 796
 797   /* flush share rx fifo */
 798   usb_flush_rx_fifo(usbx);
 799
 800   /* clear all endpoint interrupt flag and mask */
 801   dev->daint = 0xFFFFFFFF;
 802   dev->daintmsk = 0;
 803   dev->diepmsk = 0;
 804   dev->doepmsk = 0;
 805
 806   for(i_index = 0; i_index < USB_EPT_MAX_NUM; i_index ++)
 807   {
 808     usbx->dieptxfn[i_index] = 0;
 809   }
 810
 811   /* endpoint fifo alloc */
 812   usbd_fifo_alloc(udev);
 813
 814   /* disable all in endpoint */
 815   for(i_index = 0; i_index < USB_EPT_MAX_NUM; i_index ++)
 816   {
 817     ept_in = USB_INEPT(usbx, i_index);
 818     if(ept_in->diepctl_bit.eptena)
 819     {
 820       ept_in->diepctl = 0;
 821       ept_in->diepctl_bit.eptdis = TRUE;
 822       ept_in->diepctl_bit.snak = TRUE;
 823     }
 824     else
 825     {
 826       ept_in->diepctl = 0;
 827     }
 828     ept_in->dieptsiz = 0;
 829     ept_in->diepint = 0xFF;
 830   }
 831
 832   /* disable all out endpoint */
 833   for(i_index = 0; i_index < USB_EPT_MAX_NUM; i_index ++)
 834   {
 835     ept_out = USB_OUTEPT(usbx, i_index);
 836     if(ept_out->doepctl_bit.eptena)
 837     {
 838       ept_out->doepctl = 0;
 839       ept_out->doepctl_bit.eptdis = TRUE;
 840       ept_out->doepctl_bit.snak = TRUE;
 841     }
 842     else
 843     {
 844       ept_out->doepctl = 0;
 845     }
 846     ept_out->doeptsiz = 0;
 847     ept_out->doepint = 0xFF;
 848   }
 849   dev->diepmsk_bit.txfifoudrmsk = TRUE;
 850
 851   /* clear global interrupt and mask */
 852   usbx->gintmsk = 0;
 853   usbx->gintsts = 0xBFFFFFFF;
 854
 855   /* enable global interrupt mask */
 856   usbx->gintmsk = USB_OTG_SOF_INT | USB_OTG_RXFLVL_INT |
 857                   USB_OTG_USBSUSP_INT | USB_OTG_USBRST_INT |
 858                   USB_OTG_ENUMDONE_INT | USB_OTG_IEPT_INT |
 859                   USB_OTG_OEPT_INT | USB_OTG_INCOMISOIN_INT |
 860                   USB_OTG_INCOMPIP_INCOMPISOOUT_INT | USB_OTG_WKUP_INT |
 861                   USB_OTG_OTGINT_INT;
 862
 863   /* usb connect */
 864   usbd_connect(udev);
 865
 866   /* enable global interrupt */
 867   usb_interrupt_enable(usbx);
 868
 869   return USB_OK;
 870
 871 }
 872
 873 /**
 874   * @}
 875   */
 876
 877 /**
 878   * @}
 879   */
 880
 881 /**
 882   * @}
 883   */
 884