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

   1 /**
   2   **************************************************************************
   3   * @file     usbh_int.c
   4   * @brief    usb host interrupt request
   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 "usbh_int.h"
  28
  29
  30 /** @addtogroup AT32F435_437_middlewares_usbh_drivers
  31   * @{
  32   */
  33
  34 /** @defgroup USBH_drivers_interrupt
  35   * @brief usb host interrupt
  36   * @{
  37   */
  38
  39 /** @defgroup USBH_int_private_functions
  40   * @{
  41   */
  42
  43 /**
  44   * @brief  usb host interrupt handler
  45   * @param  otgdev: to the structure of otg_core_type
  46   * @retval none
  47   */
  48 void usbh_irq_handler(otg_core_type *otgdev)
  49 {
  50   otg_global_type *usbx = otgdev->usb_reg;
  51   usbh_core_type *uhost = &otgdev->host;
  52   uint32_t intsts = usb_global_get_all_interrupt(usbx);
  53
  54   if(usbx->gintsts_bit.curmode == 1)
  55   {
  56     if(intsts & USB_OTG_HCH_FLAG)
  57     {
  58       usbh_hch_handler(uhost);
  59       usb_global_clear_interrupt(usbx, USB_OTG_HCH_FLAG);
  60     }
  61     if(intsts & USB_OTG_SOF_FLAG)
  62     {
  63       usbh_sof_handler(uhost);
  64       usb_global_clear_interrupt(usbx, USB_OTG_SOF_FLAG);
  65     }
  66     if(intsts & USB_OTG_MODEMIS_FLAG)
  67     {
  68       usb_global_clear_interrupt(usbx, USB_OTG_MODEMIS_FLAG);
  69     }
  70     if(intsts & USB_OTG_WKUP_FLAG)
  71     {
  72       usbh_wakeup_handler(uhost);
  73       usb_global_clear_interrupt(usbx, USB_OTG_WKUP_FLAG);
  74     }
  75     while(usbx->gintsts & USB_OTG_RXFLVL_FLAG)
  76     {
  77       usbh_rx_qlvl_handler(uhost);
  78       usb_global_clear_interrupt(usbx, USB_OTG_RXFLVL_FLAG);
  79     }
  80     if(intsts & USB_OTG_DISCON_FLAG)
  81     {
  82       usbh_disconnect_handler(uhost);
  83       usb_global_clear_interrupt(usbx, USB_OTG_DISCON_FLAG);
  84     }
  85     if(intsts & USB_OTG_PRT_FLAG)
  86     {
  87       usbh_port_handler(uhost);
  88     }
  89     if(intsts & USB_OTG_INCOMPIP_INCOMPISOOUT_FLAG)
  90     {
  91       usb_global_clear_interrupt(usbx, USB_OTG_INCOMPIP_INCOMPISOOUT_FLAG);
  92     }
  93     if(intsts & USB_OTG_INCOMISOIN_FLAG)
  94     {
  95       usb_global_clear_interrupt(usbx, USB_OTG_INCOMISOIN_FLAG);
  96     }
  97     if(intsts & USB_OTG_PTXFEMP_FLAG)
  98     {
  99       usb_global_clear_interrupt(usbx, USB_OTG_PTXFEMP_FLAG);
 100     }
 101     if(intsts & USB_OTG_ISOOUTDROP_FLAG)
 102     {
 103       usb_global_clear_interrupt(usbx, USB_OTG_INCOMISOIN_FLAG);
 104     }
 105
 106   }
 107 }
 108
 109 /**
 110   * @brief  usb host wakeup handler
 111   * @param  uhost: to the structure of usbh_core_type
 112   * @retval none
 113   */
 114 void usbh_wakeup_handler(usbh_core_type *uhost)
 115 {
 116   uhost->global_state = USBH_WAKEUP;
 117 }
 118
 119 /**
 120   * @brief  usb host sof handler
 121   * @param  uhost: to the structure of usbh_core_type
 122   * @retval none
 123   */
 124 void usbh_sof_handler(usbh_core_type *uhost)
 125 {
 126   uhost->timer ++;
 127 }
 128
 129 /**
 130   * @brief  usb host disconnect handler
 131   * @param  uhost: to the structure of usbh_core_type
 132   * @retval none
 133   */
 134 void usbh_disconnect_handler(usbh_core_type *uhost)
 135 {
 136   otg_global_type *usbx = uhost->usb_reg;
 137
 138   uint8_t i_index;
 139
 140   usb_host_disable(usbx);
 141
 142   uhost->conn_sts = 0;
 143
 144   uhost->global_state = USBH_DISCONNECT;
 145
 146   for(i_index = 0; i_index < USB_HOST_CHANNEL_NUM; i_index ++)
 147   {
 148     usbh_free_channel(uhost, i_index);
 149   }
 150   usbh_fsls_clksel(usbx, USB_HCFG_CLK_48M);
 151 }
 152
 153 /**
 154   * @brief  usb host in transfer request handler
 155   * @param  uhost: to the structure of usbh_core_type
 156   * @param  chn: channel number
 157   * @retval none
 158   */
 159 void usbh_hch_in_handler(usbh_core_type *uhost, uint8_t chn)
 160 {
 161   otg_global_type *usbx = uhost->usb_reg;
 162   otg_hchannel_type *usb_chh = USB_CHL(usbx, chn);
 163   uint32_t hcint_value = usb_chh->hcint & usb_chh->hcintmsk;
 164
 165   if( hcint_value & USB_OTG_HC_ACK_FLAG)
 166   {
 167     usb_chh->hcint = USB_OTG_HC_ACK_FLAG;
 168   }
 169   else if(hcint_value & USB_OTG_HC_STALL_FLAG)
 170   {
 171     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 172     usb_chh->hcint = USB_OTG_HC_NAK_FLAG | USB_OTG_HC_STALL_FLAG;
 173     uhost->hch[chn].state = HCH_STALL;
 174     usb_hch_halt(usbx, chn);
 175   }
 176   else if(hcint_value & USB_OTG_HC_DTGLERR_FLAG)
 177   {
 178     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 179     usb_hch_halt(usbx, chn);
 180     usb_chh->hcint = USB_OTG_HC_DTGLERR_FLAG | USB_OTG_HC_NAK_FLAG;
 181     uhost->hch[chn].state = HCH_DATATGLERR;
 182   }
 183
 184   else if(hcint_value & USB_OTG_HC_FRMOVRRUN_FLAG)
 185   {
 186     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 187     usb_hch_halt(usbx, chn);
 188     usb_chh->hcint = USB_OTG_HC_FRMOVRRUN_FLAG;
 189   }
 190   else if(hcint_value & USB_OTG_HC_XFERC_FLAG)
 191   {
 192     uhost->hch[chn].state = HCH_XFRC;
 193     usb_chh->hcint = USB_OTG_HC_XFERC_FLAG;
 194
 195     if(usb_chh->hcchar_bit.eptype == EPT_BULK_TYPE || usb_chh->hcchar_bit.eptype == EPT_CONTROL_TYPE)
 196     {
 197       usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 198       usb_hch_halt(usbx, chn);
 199       usb_chh->hcint = USB_OTG_HC_NAK_FLAG;
 200     }
 201     else if(usb_chh->hcchar_bit.eptype == EPT_INT_TYPE)
 202     {
 203       usb_chh->hcchar_bit.oddfrm = TRUE;
 204       uhost->urb_state[chn] = URB_DONE;
 205     }
 206     else if(usb_chh->hcchar_bit.eptype == EPT_ISO_TYPE)
 207     {
 208       uhost->urb_state[chn] = URB_DONE;
 209     }
 210     uhost->hch[chn].toggle_in ^= 1;
 211   }
 212   else if(hcint_value & USB_OTG_HC_CHHLTD_FLAG)
 213   {
 214     usb_chh->hcintmsk_bit.chhltdmsk = FALSE;
 215     if(uhost->hch[chn].state == HCH_XFRC )
 216     {
 217       uhost->urb_state[chn]  = URB_DONE;
 218     }
 219     else if(uhost->hch[chn].state == HCH_STALL)
 220     {
 221       uhost->urb_state[chn]  = URB_STALL;
 222     }
 223     else if(uhost->hch[chn].state == HCH_XACTERR ||
 224             uhost->hch[chn].state == HCH_DATATGLERR)
 225     {
 226       uhost->err_cnt[chn] ++;
 227       if(uhost->err_cnt[chn] > 3)
 228       {
 229         uhost->urb_state[chn] = URB_ERROR;
 230         uhost->err_cnt[chn] = 0;
 231       }
 232       else
 233       {
 234         uhost->urb_state[chn] = URB_NOTREADY;
 235       }
 236       usb_chh->hcchar_bit.chdis = FALSE;
 237       usb_chh->hcchar_bit.chena = TRUE;
 238     }
 239     else if(uhost->hch[chn].state == HCH_NAK)
 240     {
 241       usb_chh->hcchar_bit.chdis = FALSE;
 242       usb_chh->hcchar_bit.chena = TRUE;
 243       uhost->urb_state[chn] = URB_NOTREADY;
 244     }
 245     usb_chh->hcint = USB_OTG_HC_CHHLTD_FLAG;
 246   }
 247   else if(hcint_value & USB_OTG_HC_XACTERR_FLAG)
 248   {
 249     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 250     uhost->hch[chn].state = HCH_XACTERR;
 251     usb_hch_halt(usbx, chn);
 252     uhost->err_cnt[chn] ++;
 253     usb_chh->hcint = USB_OTG_HC_XACTERR_FLAG;
 254   }
 255   else if(hcint_value & USB_OTG_HC_NAK_FLAG)
 256   {
 257     if(usb_chh->hcchar_bit.eptype == EPT_INT_TYPE)
 258     {
 259       uhost->err_cnt[chn] = 0;
 260       usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 261       usb_hch_halt(usbx, chn);
 262     }
 263     else if(usb_chh->hcchar_bit.eptype == EPT_BULK_TYPE ||
 264       usb_chh->hcchar_bit.eptype == EPT_CONTROL_TYPE)
 265     {
 266       uhost->err_cnt[chn] = 0;
 267       usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 268       usb_hch_halt(usbx, chn);
 269     }
 270     uhost->hch[chn].state = HCH_NAK;
 271     usb_chh->hcint = USB_OTG_HC_NAK_FLAG;
 272   }
 273   else if(hcint_value & USB_OTG_HC_BBLERR_FLAG)
 274   {
 275     usb_chh->hcint = USB_OTG_HC_BBLERR_FLAG;
 276   }
 277 }
 278
 279 /**
 280   * @brief  usb host out transfer request handler
 281   * @param  uhost: to the structure of usbh_core_type
 282   * @param  chn: channel number
 283   * @retval none
 284   */
 285 void usbh_hch_out_handler(usbh_core_type *uhost, uint8_t chn)
 286 {
 287   otg_global_type *usbx = uhost->usb_reg;
 288   otg_hchannel_type *usb_chh = USB_CHL(usbx, chn);
 289   uint32_t hcint_value = usb_chh->hcint & usb_chh->hcintmsk;
 290
 291   if( hcint_value & USB_OTG_HC_ACK_FLAG)
 292   {
 293     usb_chh->hcint = USB_OTG_HC_ACK_FLAG;
 294   }
 295   else if( hcint_value & USB_OTG_HC_FRMOVRRUN_FLAG)
 296   {
 297     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 298     usb_hch_halt(usbx, chn);
 299     usb_chh->hcint = USB_OTG_HC_FRMOVRRUN_FLAG;
 300   }
 301   else if( hcint_value & USB_OTG_HC_XFERC_FLAG)
 302   {
 303     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 304     usb_hch_halt(usbx, chn);
 305     uhost->hch[chn].state = HCH_XFRC;
 306     usb_chh->hcint = USB_OTG_HC_XFERC_FLAG;
 307   }
 308   else if( hcint_value & USB_OTG_HC_STALL_FLAG)
 309   {
 310     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 311     usb_chh->hcint =  USB_OTG_HC_STALL_FLAG;
 312     uhost->hch[chn].state = HCH_STALL;
 313     usb_hch_halt(usbx, chn);
 314   }
 315   else if( hcint_value & USB_OTG_HC_DTGLERR_FLAG)
 316   {
 317     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 318     usb_hch_halt(usbx, chn);
 319     usb_chh->hcint = USB_OTG_HC_DTGLERR_FLAG | USB_OTG_HC_NAK_FLAG;
 320     uhost->hch[chn].state = HCH_DATATGLERR;
 321   }
 322   else if( hcint_value & USB_OTG_HC_CHHLTD_FLAG)
 323   {
 324     usb_chh->hcintmsk_bit.chhltdmsk = FALSE;
 325     if(uhost->hch[chn].state == HCH_XFRC)
 326     {
 327       uhost->urb_state[chn] = URB_DONE;
 328       if(uhost->hch[chn].ept_type == EPT_BULK_TYPE ||
 329         uhost->hch[chn].ept_type == EPT_INT_TYPE)
 330       {
 331         uhost->hch[chn].toggle_out ^= 1;
 332       }
 333     }
 334     else if(uhost->hch[chn].state == HCH_NAK)
 335     {
 336       uhost->urb_state[chn] = URB_NOTREADY;
 337     }
 338     else if(uhost->hch[chn].state == HCH_STALL)
 339     {
 340       uhost->hch[chn].urb_sts = URB_STALL;
 341     }
 342     else if(uhost->hch[chn].state == HCH_XACTERR ||
 343             uhost->hch[chn].state == HCH_DATATGLERR)
 344     {
 345       uhost->err_cnt[chn] ++;
 346       if(uhost->err_cnt[chn] > 3)
 347       {
 348         uhost->urb_state[chn] = URB_ERROR;
 349         uhost->err_cnt[chn] = 0;
 350       }
 351       else
 352       {
 353         uhost->urb_state[chn] = URB_NOTREADY;
 354       }
 355
 356       usb_chh->hcchar_bit.chdis = FALSE;
 357       usb_chh->hcchar_bit.chena = TRUE;
 358     }
 359     usb_chh->hcint = USB_OTG_HC_CHHLTD_FLAG;
 360   }
 361   else if( hcint_value & USB_OTG_HC_XACTERR_FLAG)
 362   {
 363     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 364     uhost->err_cnt[chn] ++;
 365     uhost->hch[chn].state = HCH_XACTERR;
 366     usb_hch_halt(usbx, chn);
 367     usb_chh->hcint = USB_OTG_HC_XACTERR_FLAG | USB_OTG_HC_NAK_FLAG;
 368   }
 369   else if( hcint_value & USB_OTG_HC_NAK_FLAG)
 370   {
 371     usb_chh->hcintmsk_bit.chhltdmsk = TRUE;
 372     uhost->err_cnt[chn] = 0;
 373     usb_hch_halt(usbx, chn);
 374     uhost->hch[chn].state = HCH_NAK;
 375     usb_chh->hcint = USB_OTG_HC_NAK_FLAG;
 376   }
 377 }
 378
 379 /**
 380   * @brief  usb host channel request handler
 381   * @param  uhost: to the structure of usbh_core_type
 382   * @retval none
 383   */
 384 void usbh_hch_handler(usbh_core_type *uhost)
 385 {
 386   otg_global_type *usbx = uhost->usb_reg;
 387   otg_host_type *usb_host = OTG_HOST(usbx);
 388   uint32_t intsts, i_index;
 389
 390   intsts = usb_host->haint & 0xFFFF;
 391   for(i_index = 0; i_index < 16; i_index ++)
 392   {
 393     if(intsts & (1 << i_index))
 394     {
 395       if(USB_CHL(usbx, i_index)->hcchar_bit.eptdir)
 396       {
 397         //hc in
 398         usbh_hch_in_handler(uhost, i_index);
 399       }
 400       else
 401       {
 402         //hc out
 403         usbh_hch_out_handler(uhost, i_index);
 404       }
 405     }
 406   }
 407 }
 408
 409 /**
 410   * @brief  usb host rx buffer not empty request handler
 411   * @param  uhost: to the structure of usbh_core_type
 412   * @retval none
 413   */
 414 void usbh_rx_qlvl_handler(usbh_core_type *uhost)
 415 {
 416   uint8_t chn;
 417   uint32_t pktsts;
 418   uint32_t pktcnt;
 419   uint32_t tmp;
 420   otg_hchannel_type *ch;
 421   otg_global_type *usbx = uhost->usb_reg;
 422
 423   usbx->gintmsk_bit.rxflvlmsk = 0;
 424
 425   tmp = usbx->grxstsp;
 426   chn = tmp & 0xF;
 427   pktsts = (tmp >> 17) & 0xF;
 428   pktcnt = (tmp >> 4) & 0x7FF;
 429   ch = USB_CHL(usbx, chn);
 430   switch(pktsts)
 431   {
 432     case PKTSTS_IN_DATA_PACKET_RECV:
 433       if(pktcnt > 0 && (uhost->hch[chn].trans_buf) != 0)
 434       {
 435         usb_read_packet(usbx, uhost->hch[chn].trans_buf, chn, pktcnt);
 436         uhost->hch[chn].trans_buf += pktcnt;
 437         uhost->hch[chn].trans_count += pktcnt;
 438
 439         if(ch->hctsiz_bit.pktcnt > 0)
 440         {
 441           ch->hcchar_bit.chdis = FALSE;
 442           ch->hcchar_bit.chena = TRUE;
 443           uhost->hch[chn].toggle_in ^= 1;
 444         }
 445       }
 446       break;
 447     case PKTSTS_IN_TRANSFER_COMPLETE:
 448       break;
 449     case PKTSTS_DATA_BIT_ERROR:
 450       break;
 451     case PKTSTS_CHANNEL_STOP:
 452       break;
 453     default:
 454       break;
 455
 456   }
 457   usbx->gintmsk_bit.rxflvlmsk = 1;
 458 }
 459
 460 /**
 461   * @brief  usb host port request handler
 462   * @param  uhost: to the structure of usbh_core_type
 463   * @retval none
 464   */
 465 void usbh_port_handler(usbh_core_type *uhost)
 466 {
 467   otg_global_type *usbx = uhost->usb_reg;
 468   otg_host_type *usb_host = OTG_HOST(usbx);
 469
 470   uint32_t prt = 0, prt_0;
 471
 472   prt = usb_host->hprt;
 473   prt_0 = prt;
 474
 475   prt_0 &= ~(USB_OTG_HPRT_PRTENA | USB_OTG_HPRT_PRTENCHNG |
 476                USB_OTG_HPRT_PRTOVRCACT | USB_OTG_HPRT_PRTCONDET);
 477   if(prt & USB_OTG_HPRT_PRTCONDET)
 478   {
 479     if(prt & USB_OTG_HPRT_PRTCONSTS)
 480     {
 481       /* connect callback */
 482       uhost->conn_sts = 1;
 483     }
 484     prt_0 |= USB_OTG_HPRT_PRTCONDET;
 485   }
 486
 487   if(prt & USB_OTG_HPRT_PRTENCHNG)
 488   {
 489     prt_0 |= USB_OTG_HPRT_PRTENCHNG;
 490
 491     if(prt & USB_OTG_HPRT_PRTENA)
 492     {
 493       if((prt & USB_OTG_HPRT_PRTSPD) == (USB_PRTSPD_LOW_SPEED << 17))
 494       {
 495         usbh_fsls_clksel(usbx, USB_HCFG_CLK_6M);
 496       }
 497       else
 498       {
 499         usbh_fsls_clksel(usbx, USB_HCFG_CLK_48M);
 500       }
 501       /* connect callback */
 502       uhost->port_enable = 1;
 503     }
 504     else
 505     {
 506       /* clean up hprt */
 507       uhost->port_enable = 0;
 508     }
 509   }
 510
 511   if(prt & USB_OTG_HPRT_PRTOVRCACT)
 512   {
 513     prt_0 |= USB_OTG_HPRT_PRTOVRCACT;
 514   }
 515
 516   usb_host->hprt = prt_0;
 517 }
 518
 519 /**
 520   * @}
 521   */
 522
 523 /**
 524   * @}
 525   */
 526
 527 /**
 528   * @}
 529   */
 530