check both FIFO size ans request queue size when transmit host channel data

xtoolbox · xtoolbox · commit ee2ebc8348ed · 2019-01-31T15:20:09.000+08:00
diff --git a/usb_stack/src/teeny_usb_stm32_otg_host.c b/usb_stack/src/teeny_usb_stm32_otg_host.c
@@ -297,29 +297,29 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
   tusb_hc_data_t* hc = &host->hc[ch_num];
   uint32_t tmpreg;
   
-  if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
+  if ((HC->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
   {
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
   }
-  else if( (USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR )
+  else if( (HC->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR )
   {
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_BBERR);
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
+  else if ((HC->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
   {
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
+  else if ((HC->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     hc->state = TUSB_CS_STALL;
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
     tusb_otg_halt_channel(USBx, ch_num);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
+  else if ((HC->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
@@ -332,18 +332,18 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
     /* ... */
   }
 
-  if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
+  if ((HC->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
+  else if ((HC->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
   {
     uint32_t HcEpType = (HC->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;
     if (USBx->GAHBCFG & USB_OTG_GAHBCFG_DMAEN)
     {
-      hc->count = hc->size - (USBx_HC(ch_num)->HCTSIZ & USB_OTG_HCTSIZ_XFRSIZ);
+      hc->count = hc->size - (HC->HCTSIZ & USB_OTG_HCTSIZ_XFRSIZ);
     }
 
     hc->state = TUSB_CS_TRANSFER_COMPLETE;
@@ -359,7 +359,7 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
     }
     else if(HcEpType == HCCHAR_INTR)
     {
-      USBx_HC(ch_num)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
+      HC->HCCHAR |= USB_OTG_HCCHAR_ODDFRM;
       hc->xfer_done = 1;
       tusb_on_channel_event(host, ch_num);
     }
@@ -370,7 +370,7 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
     hc->toggle_in ^= 1U;
 
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
+  else if ((HC->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
   {
     __HAL_HCD_MASK_HALT_HC_INT(ch_num);
 
@@ -398,19 +398,19 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
       }
 
       /* re-activate the channel  */
-      tmpreg = USBx_HC(ch_num)->HCCHAR;
+      tmpreg = HC->HCCHAR;
       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
       tmpreg |= USB_OTG_HCCHAR_CHENA;
-      USBx_HC(ch_num)->HCCHAR = tmpreg;
+      HC->HCCHAR = tmpreg;
     }
     else if (hc->state == TUSB_CS_NAK)
     {
       //hhcd->hc[ch_num].urb_state  = URB_NOTREADY;
       /* re-activate the channel  */
-      tmpreg = USBx_HC(ch_num)->HCCHAR;
+      tmpreg = HC->HCCHAR;
       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
       tmpreg |= USB_OTG_HCCHAR_CHENA;
-      USBx_HC(ch_num)->HCCHAR = tmpreg;
+      HC->HCCHAR = tmpreg;
     }
     else
     {
@@ -420,15 +420,15 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
     tusb_on_channel_event(host, ch_num);
     //HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
+  else if ((HC->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     hc->error_count++;
     hc->state = TUSB_CS_TRANSACTION_ERROR;
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
+  else if ((HC->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
   {
     uint32_t HcEpType = (HC->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;
     if(HcEpType == HCCHAR_INTR)
@@ -464,15 +464,16 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)
 static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)
 {
   USB_OTG_GlobalTypeDef *USBx = GetUSB(host);
+  USB_OTG_HostChannelTypeDef* HC = USBx_HC(ch_num);
   tusb_hc_data_t* hc = &host->hc[ch_num];
   uint32_t tmpreg;
 
-  if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
+  if ((HC->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
   {
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
+  else if ((HC->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
   {
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
 
@@ -484,7 +485,7 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)
       tusb_otg_halt_channel(USBx, ch_num);
     }
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)
+  else if ((HC->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)
   {
     hc->state = TUSB_CS_NYET;
     hc->do_ping = 1U;
@@ -493,28 +494,28 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NYET);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
+  else if ((HC->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
+  else if ((HC->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
   {
     hc->error_count = 0U;
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
     hc->state = TUSB_CS_TRANSFER_COMPLETE;
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
+  else if ((HC->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
   {
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
     hc->state = TUSB_CS_STALL;
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
+  else if ((HC->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
   {
     hc->error_count = 0U;
     hc->state = TUSB_CS_NAK;
@@ -527,27 +528,27 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
+  else if ((HC->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
     hc->state = TUSB_CS_TRANSACTION_ERROR;
      __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
+  else if ((HC->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
   {
     __HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
     tusb_otg_halt_channel(USBx, ch_num);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
     __HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
     hc->state = TUSB_CS_DT_ERROR;
   }
-  else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
+  else if ((HC->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
   {
     __HAL_HCD_MASK_HALT_HC_INT(ch_num);
 
     if (hc->state == TUSB_CS_TRANSFER_COMPLETE){
-      uint32_t HcEpType = (USBx_HC(ch_num)->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;
+      uint32_t HcEpType = (HC->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;
       if(HcEpType == HCCHAR_BULK){
         hc->toggle_out ^= 1U;
       }
@@ -556,10 +557,10 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)
     else if (hc->state == TUSB_CS_NAK)
     {
       /* re-activate the channel  */
-      //tmpreg = USBx_HC(ch_num)->HCCHAR;
+      //tmpreg = HC->HCCHAR;
       //tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
       //tmpreg |= USB_OTG_HCCHAR_CHENA;
-      //USBx_HC(ch_num)->HCCHAR = tmpreg;
+      //HC->HCCHAR = tmpreg;
       //hhcd->hc[ch_num].urb_state = URB_NOTREADY;
     }
     else if (hc->state == TUSB_CS_NYET)
@@ -585,10 +586,10 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)
       }
 
       /* re-activate the channel  */
-      tmpreg = USBx_HC(ch_num)->HCCHAR;
+      tmpreg = HC->HCCHAR;
       tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
       tmpreg |= USB_OTG_HCCHAR_CHENA;
-      USBx_HC(ch_num)->HCCHAR = tmpreg;
+      HC->HCCHAR = tmpreg;
     }
     else
     {
@@ -858,6 +859,7 @@ void tusb_otg_host_handler(tusb_host_t* host)
         tusb_otg_send_data(host, ch_num);
         break;
       }
+      ch_num++;
       mask>>=1;
     }
     if(!host->ptx_pending){
@@ -874,6 +876,7 @@ void tusb_otg_host_handler(tusb_host_t* host)
         tusb_otg_send_data(host, ch_num);
         break;
       }
+      ch_num++;
       mask>>=1;
     }
     if(!host->nptx_pending){
@@ -1044,15 +1047,21 @@ static void tusb_otg_send_data(tusb_host_t* host, uint8_t hc_num)
   tusb_hc_data_t* hc = &host->hc[hc_num];
   uint32_t i;
   uint32_t act_len;
+  uint32_t req_size;
   uint32_t *pSrc = (uint32_t *)hc->ch_buf;
   uint32_t len = hc->size;
   // len = (len+3)/4;
   if(xfer_type == EP_TYPE_CTRL || xfer_type == EP_TYPE_BULK){
-    act_len = USBx->HNPTXSTS & 0xFFFFU;
+    act_len = USBx->HNPTXSTS;
   }else{
-    act_len = USBx_HOST->HPTXSTS & 0xFFFFU;
-  }
-  act_len = ( act_len*4 / mps )  * mps;
+    act_len = USBx_HOST->HPTXSTS;
+  }
+  // calculate useful FIFO size, depend on two factor
+  // 1. remain [request queue space] * [max packet size]
+  req_size = ((act_len & 0xff0000) >> 16) * mps;
+  // 2. remain FIFO buffer size, round to max packet size boundary
+  act_len = ( (act_len & 0xffff) *4 / mps )  * mps;
+  if(act_len > req_size) act_len = req_size;
   if(len > act_len){
     len = len - act_len;
   }else{
@@ -1064,6 +1073,7 @@ static void tusb_otg_send_data(tusb_host_t* host, uint8_t hc_num)
     USBx_DFIFO((uint32_t)hc_num) = *((__packed uint32_t *)pSrc);
     pSrc++;
   }
+  
   hc->ch_buf = (uint8_t*)pSrc;
   hc->size = len;
   if(len){
@@ -1074,6 +1084,9 @@ static void tusb_otg_send_data(tusb_host_t* host, uint8_t hc_num)
       USBx->GINTMSK |= USB_OTG_GINTMSK_PTXFEM;
       host->ptx_pending |= (1<<hc_num);
     }
+  }else{
+    host->nptx_pending &= ~(1<<hc_num);
+    host->ptx_pending &= ~(1<<hc_num);
   }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -297,29 +297,29 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`297`	`297`	`tusb_hc_data_t* hc = &host->hc[ch_num];`
`298`	`298`	`uint32_t tmpreg;`
`299`	`299`
`300`		`- if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)`
	`300`	`+ if ((HC->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)`
`301`	`301`	`{`
`302`	`302`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);`
`303`	`303`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`304`	`304`	`}`
`305`		`- else if( (USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR )`
	`305`	`+ else if( (HC->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR )`
`306`	`306`	`{`
`307`	`307`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_BBERR);`
`308`	`308`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`309`	`309`	`}`
`310`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)`
	`310`	`+ else if ((HC->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)`
`311`	`311`	`{`
`312`	`312`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);`
`313`	`313`	`}`
`314`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)`
	`314`	`+ else if ((HC->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)`
`315`	`315`	`{`
`316`	`316`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`317`	`317`	`hc->state = TUSB_CS_STALL;`
`318`	`318`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);`
`319`	`319`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);`
`320`	`320`	`tusb_otg_halt_channel(USBx, ch_num);`
`321`	`321`	`}`
`322`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)`
	`322`	`+ else if ((HC->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)`
`323`	`323`	`{`
`324`	`324`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`325`	`325`	`tusb_otg_halt_channel(USBx, ch_num);`
`@@ -332,18 +332,18 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`332`	`332`	`/* ... */`
`333`	`333`	`}`
`334`	`334`
`335`		`- if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)`
	`335`	`+ if ((HC->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)`
`336`	`336`	`{`
`337`	`337`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`338`	`338`	`tusb_otg_halt_channel(USBx, ch_num);`
`339`	`339`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);`
`340`	`340`	`}`
`341`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)`
	`341`	`+ else if ((HC->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)`
`342`	`342`	`{`
`343`	`343`	`uint32_t HcEpType = (HC->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;`
`344`	`344`	`if (USBx->GAHBCFG & USB_OTG_GAHBCFG_DMAEN)`
`345`	`345`	`{`
`346`		`- hc->count = hc->size - (USBx_HC(ch_num)->HCTSIZ & USB_OTG_HCTSIZ_XFRSIZ);`
	`346`	`+ hc->count = hc->size - (HC->HCTSIZ & USB_OTG_HCTSIZ_XFRSIZ);`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`hc->state = TUSB_CS_TRANSFER_COMPLETE;`
`@@ -359,7 +359,7 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`359`	`359`	`}`
`360`	`360`	`else if(HcEpType == HCCHAR_INTR)`
`361`	`361`	`{`
`362`		`- USBx_HC(ch_num)->HCCHAR \|= USB_OTG_HCCHAR_ODDFRM;`
	`362`	`+ HC->HCCHAR \|= USB_OTG_HCCHAR_ODDFRM;`
`363`	`363`	`hc->xfer_done = 1;`
`364`	`364`	`tusb_on_channel_event(host, ch_num);`
`365`	`365`	`}`
`@@ -370,7 +370,7 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`370`	`370`	`hc->toggle_in ^= 1U;`
`371`	`371`
`372`	`372`	`}`
`373`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)`
	`373`	`+ else if ((HC->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)`
`374`	`374`	`{`
`375`	`375`	`__HAL_HCD_MASK_HALT_HC_INT(ch_num);`
`376`	`376`
`@@ -398,19 +398,19 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`398`	`398`	`}`
`399`	`399`
`400`	`400`	`/* re-activate the channel */`
`401`		`- tmpreg = USBx_HC(ch_num)->HCCHAR;`
	`401`	`+ tmpreg = HC->HCCHAR;`
`402`	`402`	`tmpreg &= ~USB_OTG_HCCHAR_CHDIS;`
`403`	`403`	`tmpreg \|= USB_OTG_HCCHAR_CHENA;`
`404`		`- USBx_HC(ch_num)->HCCHAR = tmpreg;`
	`404`	`+ HC->HCCHAR = tmpreg;`
`405`	`405`	`}`
`406`	`406`	`else if (hc->state == TUSB_CS_NAK)`
`407`	`407`	`{`
`408`	`408`	`//hhcd->hc[ch_num].urb_state = URB_NOTREADY;`
`409`	`409`	`/* re-activate the channel */`
`410`		`- tmpreg = USBx_HC(ch_num)->HCCHAR;`
	`410`	`+ tmpreg = HC->HCCHAR;`
`411`	`411`	`tmpreg &= ~USB_OTG_HCCHAR_CHDIS;`
`412`	`412`	`tmpreg \|= USB_OTG_HCCHAR_CHENA;`
`413`		`- USBx_HC(ch_num)->HCCHAR = tmpreg;`
	`413`	`+ HC->HCCHAR = tmpreg;`
`414`	`414`	`}`
`415`	`415`	`else`
`416`	`416`	`{`
`@@ -420,15 +420,15 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`420`	`420`	`tusb_on_channel_event(host, ch_num);`
`421`	`421`	`//HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);`
`422`	`422`	`}`
`423`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)`
	`423`	`+ else if ((HC->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)`
`424`	`424`	`{`
`425`	`425`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`426`	`426`	`hc->error_count++;`
`427`	`427`	`hc->state = TUSB_CS_TRANSACTION_ERROR;`
`428`	`428`	`tusb_otg_halt_channel(USBx, ch_num);`
`429`	`429`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);`
`430`	`430`	`}`
`431`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)`
	`431`	`+ else if ((HC->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)`
`432`	`432`	`{`
`433`	`433`	`uint32_t HcEpType = (HC->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;`
`434`	`434`	`if(HcEpType == HCCHAR_INTR)`
`@@ -464,15 +464,16 @@ static void tusb_otg_in_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`464`	`464`	`static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`465`	`465`	`{`
`466`	`466`	`USB_OTG_GlobalTypeDef *USBx = GetUSB(host);`
	`467`	`+ USB_OTG_HostChannelTypeDef* HC = USBx_HC(ch_num);`
`467`	`468`	`tusb_hc_data_t* hc = &host->hc[ch_num];`
`468`	`469`	`uint32_t tmpreg;`
`469`	`470`
`470`		`- if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)`
	`471`	`+ if ((HC->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)`
`471`	`472`	`{`
`472`	`473`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);`
`473`	`474`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`474`	`475`	`}`
`475`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)`
	`476`	`+ else if ((HC->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)`
`476`	`477`	`{`
`477`	`478`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);`
`478`	`479`
`@@ -484,7 +485,7 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`484`	`485`	`tusb_otg_halt_channel(USBx, ch_num);`
`485`	`486`	`}`
`486`	`487`	`}`
`487`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)`
	`488`	`+ else if ((HC->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)`
`488`	`489`	`{`
`489`	`490`	`hc->state = TUSB_CS_NYET;`
`490`	`491`	`hc->do_ping = 1U;`
`@@ -493,28 +494,28 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`493`	`494`	`tusb_otg_halt_channel(USBx, ch_num);`
`494`	`495`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NYET);`
`495`	`496`	`}`
`496`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)`
	`497`	`+ else if ((HC->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)`
`497`	`498`	`{`
`498`	`499`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`499`	`500`	`tusb_otg_halt_channel(USBx, ch_num);`
`500`	`501`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);`
`501`	`502`	`}`
`502`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)`
	`503`	`+ else if ((HC->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)`
`503`	`504`	`{`
`504`	`505`	`hc->error_count = 0U;`
`505`	`506`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`506`	`507`	`tusb_otg_halt_channel(USBx, ch_num);`
`507`	`508`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);`
`508`	`509`	`hc->state = TUSB_CS_TRANSFER_COMPLETE;`
`509`	`510`	`}`
`510`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)`
	`511`	`+ else if ((HC->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)`
`511`	`512`	`{`
`512`	`513`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);`
`513`	`514`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`514`	`515`	`tusb_otg_halt_channel(USBx, ch_num);`
`515`	`516`	`hc->state = TUSB_CS_STALL;`
`516`	`517`	`}`
`517`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)`
	`518`	`+ else if ((HC->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)`
`518`	`519`	`{`
`519`	`520`	`hc->error_count = 0U;`
`520`	`521`	`hc->state = TUSB_CS_NAK;`
`@@ -527,27 +528,27 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`527`	`528`	`tusb_otg_halt_channel(USBx, ch_num);`
`528`	`529`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);`
`529`	`530`	`}`
`530`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)`
	`531`	`+ else if ((HC->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)`
`531`	`532`	`{`
`532`	`533`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`533`	`534`	`tusb_otg_halt_channel(USBx, ch_num);`
`534`	`535`	`hc->state = TUSB_CS_TRANSACTION_ERROR;`
`535`	`536`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);`
`536`	`537`	`}`
`537`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)`
	`538`	`+ else if ((HC->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)`
`538`	`539`	`{`
`539`	`540`	`__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);`
`540`	`541`	`tusb_otg_halt_channel(USBx, ch_num);`
`541`	`542`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);`
`542`	`543`	`__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);`
`543`	`544`	`hc->state = TUSB_CS_DT_ERROR;`
`544`	`545`	`}`
`545`		`- else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)`
	`546`	`+ else if ((HC->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)`
`546`	`547`	`{`
`547`	`548`	`__HAL_HCD_MASK_HALT_HC_INT(ch_num);`
`548`	`549`
`549`	`550`	`if (hc->state == TUSB_CS_TRANSFER_COMPLETE){`
`550`		`- uint32_t HcEpType = (USBx_HC(ch_num)->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;`
	`551`	`+ uint32_t HcEpType = (HC->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;`
`551`	`552`	`if(HcEpType == HCCHAR_BULK){`
`552`	`553`	`hc->toggle_out ^= 1U;`
`553`	`554`	`}`
`@@ -556,10 +557,10 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`556`	`557`	`else if (hc->state == TUSB_CS_NAK)`
`557`	`558`	`{`
`558`	`559`	`/* re-activate the channel */`
`559`		`- //tmpreg = USBx_HC(ch_num)->HCCHAR;`
	`560`	`+ //tmpreg = HC->HCCHAR;`
`560`	`561`	`//tmpreg &= ~USB_OTG_HCCHAR_CHDIS;`
`561`	`562`	`//tmpreg \|= USB_OTG_HCCHAR_CHENA;`
`562`		`- //USBx_HC(ch_num)->HCCHAR = tmpreg;`
	`563`	`+ //HC->HCCHAR = tmpreg;`
`563`	`564`	`//hhcd->hc[ch_num].urb_state = URB_NOTREADY;`
`564`	`565`	`}`
`565`	`566`	`else if (hc->state == TUSB_CS_NYET)`
`@@ -585,10 +586,10 @@ static void tusb_otg_out_channel_handler(tusb_host_t* host, uint8_t ch_num)`
`585`	`586`	`}`
`586`	`587`
`587`	`588`	`/* re-activate the channel */`
`588`		`- tmpreg = USBx_HC(ch_num)->HCCHAR;`
	`589`	`+ tmpreg = HC->HCCHAR;`
`589`	`590`	`tmpreg &= ~USB_OTG_HCCHAR_CHDIS;`
`590`	`591`	`tmpreg \|= USB_OTG_HCCHAR_CHENA;`
`591`		`- USBx_HC(ch_num)->HCCHAR = tmpreg;`
	`592`	`+ HC->HCCHAR = tmpreg;`
`592`	`593`	`}`
`593`	`594`	`else`
`594`	`595`	`{`
`@@ -858,6 +859,7 @@ void tusb_otg_host_handler(tusb_host_t* host)`
`858`	`859`	`tusb_otg_send_data(host, ch_num);`
`859`	`860`	`break;`
`860`	`861`	`}`
	`862`	`+ ch_num++;`
`861`	`863`	`mask>>=1;`
`862`	`864`	`}`
`863`	`865`	`if(!host->ptx_pending){`
`@@ -874,6 +876,7 @@ void tusb_otg_host_handler(tusb_host_t* host)`
`874`	`876`	`tusb_otg_send_data(host, ch_num);`
`875`	`877`	`break;`
`876`	`878`	`}`
	`879`	`+ ch_num++;`
`877`	`880`	`mask>>=1;`
`878`	`881`	`}`
`879`	`882`	`if(!host->nptx_pending){`
`@@ -1044,15 +1047,21 @@ static void tusb_otg_send_data(tusb_host_t* host, uint8_t hc_num)`
`1044`	`1047`	`tusb_hc_data_t* hc = &host->hc[hc_num];`
`1045`	`1048`	`uint32_t i;`
`1046`	`1049`	`uint32_t act_len;`
	`1050`	`+ uint32_t req_size;`
`1047`	`1051`	`uint32_t pSrc = (uint32_t )hc->ch_buf;`
`1048`	`1052`	`uint32_t len = hc->size;`
`1049`	`1053`	`// len = (len+3)/4;`
`1050`	`1054`	`if(xfer_type == EP_TYPE_CTRL \|\| xfer_type == EP_TYPE_BULK){`
`1051`		`- act_len = USBx->HNPTXSTS & 0xFFFFU;`
	`1055`	`+ act_len = USBx->HNPTXSTS;`
`1052`	`1056`	`}else{`
`1053`		`- act_len = USBx_HOST->HPTXSTS & 0xFFFFU;`
`1054`		`- }`
`1055`		`- act_len = ( act_len4 / mps ) mps;`
	`1057`	`+ act_len = USBx_HOST->HPTXSTS;`
	`1058`	`+ }`
	`1059`	`+ // calculate useful FIFO size, depend on two factor`
	`1060`	`+ // 1. remain [request queue space] * [max packet size]`
	`1061`	`+ req_size = ((act_len & 0xff0000) >> 16) * mps;`
	`1062`	`+ // 2. remain FIFO buffer size, round to max packet size boundary`
	`1063`	`+ act_len = ( (act_len & 0xffff) 4 / mps ) mps;`
	`1064`	`+ if(act_len > req_size) act_len = req_size;`
`1056`	`1065`	`if(len > act_len){`
`1057`	`1066`	`len = len - act_len;`
`1058`	`1067`	`}else{`
`@@ -1064,6 +1073,7 @@ static void tusb_otg_send_data(tusb_host_t* host, uint8_t hc_num)`
`1064`	`1073`	`USBx_DFIFO((uint32_t)hc_num) = ((__packed uint32_t )pSrc);`
`1065`	`1074`	`pSrc++;`
`1066`	`1075`	`}`
	`1076`	`+`
`1067`	`1077`	`hc->ch_buf = (uint8_t*)pSrc;`
`1068`	`1078`	`hc->size = len;`
`1069`	`1079`	`if(len){`
`@@ -1074,6 +1084,9 @@ static void tusb_otg_send_data(tusb_host_t* host, uint8_t hc_num)`
`1074`	`1084`	`USBx->GINTMSK \|= USB_OTG_GINTMSK_PTXFEM;`
`1075`	`1085`	`host->ptx_pending \|= (1<<hc_num);`
`1076`	`1086`	`}`
	`1087`	`+ }else{`
	`1088`	`+ host->nptx_pending &= ~(1<<hc_num);`
	`1089`	`+ host->ptx_pending &= ~(1<<hc_num);`
`1077`	`1090`	`}`
`1078`	`1091`	`}`
`1079`	`1092`