usb_driver.c

M68HC08 及HCS08系列单片机bootloader引导程序源码、示例

  return(retVal);
}
//---------------------------------------------------------------------------------------
// uchar USB_RxBuffPending2(void)
// returns number of bytes pending to be received to user buffer
//---------------------------------------------------------------------------------------
uchar USB_RxBuffPending2(void)
{
  return(cntDst2);
}

//---------------------------------------------------------------------------------------
// uchar USB_GetRxReady2(void)
// return number of available data bytes in EP buffer
//---------------------------------------------------------------------------------------
uchar USB_GetRxReady2(void)
{
  return(cntSrc2);
}

//---------------------------------------------------------------------------------------
// uchar USB_GetTxEmpty2(void)
// returns number of available bytes in EP buffer (to be write)
//---------------------------------------------------------------------------------------
uchar USB_GetTxEmpty2(void)
{
  if(UEP2CSR_DVALID)   // if transmit is pending
   return(0);				 // return zero
  else
   return(cntDst2);	 // else return free space in transmit buffer
}

//---------------------------------------------------------------------------------------
// uchar USB_TxChar2(uchar ch)  - used for IN bulk/interrupt packet
// BLOCKING function - waits till user Tx buffer is pending and
// EP buffer has free place. Then write character to EP buffer. When EP buffer
// is full, flushes this packet.
// Function returns number of available bytes in EP buffer
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxChar2(uchar ch)
{
  uchar retVal;
  // wait pending buffer
  while(cntSrc2)
    USB_DO_NOTHING();

  // wait while EP3 buffer not sent
  while(UEP2CSR_DVALID)
    USB_DO_NOTHING();

  // write character to buffer
  *pDst2++ = ch;

  cntDst2--;
  retVal = cntDst2;
  // if EP buffer is full, flush it
  if(retVal == 0)
  {
    UEP2DSR = EP2_BUFFER_SIZE;
    UEP2CSR |= UEP2CSR_DVALID_MASK;
  }
  return(retVal);
}
#pragma MESSAGE DEFAULT C1853
//---------------------------------------------------------------------------------------
// uchar USB_TxBuff1(uchar* adr, uchar cnt) user for IN interrupt/bulk packet
// NON BLOCKING function - function copy data from user buffer to EP
// buffer. If user buffer is larger then EP buffer the rest of data is send in interrupt
// service routine. Function returns number of bytes pending in user buffer
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxBuff2(uchar* adr, uchar cnt)
{
	 uchar retVal;

	 // set address of buffer where the data to be send are placed
	 pSrc2 = adr;
	 // set number of bytes to send
	 cntSrc2 = cnt;

   // copy data from user buffer to EP buffer
	 while(cntSrc2 && cntDst2)
	 {
	  cntSrc2--;
	  cntDst2--;
	  *pDst2++ = *pSrc2++;
	 }
   retVal = cntSrc2;

	 // flush it
   UEP2DSR = EP2_BUFFER_SIZE - cntDst2;
   UEP2CSR |= UEP2CSR_DVALID_MASK;

	 // return number of bytes pending in user buffer
	 return(retVal);
}
#pragma MESSAGE DEFAULT C1853
//---------------------------------------------------------------------------------------
// uchar USB_TxBuffPending2(void)
// function returns number of bytes pending in user buffer
//---------------------------------------------------------------------------------------
uchar USB_TxBuffPending2(void)
{
  return(cntSrc2);
}

//---------------------------------------------------------------------------------------
// uchar USB_TxFlush2(void)
// if there is at least one byte to be send in EP buffer, flush buffer
// Function returns number of send bytes
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxFlush2(void)
{
  UEP2DSR = EP2_BUFFER_SIZE - cntDst2;
  UEP2CSR |= UEP2CSR_DVALID_MASK;
  return(UEP2DSR);
}
#pragma MESSAGE DEFAULT C1853

//---------------------------------------------------------------------------------------
// uchar USB_RxBuff3(uchar* adr, uchar cnt) - used for OUT bulk/interrupt packet
// NON BLOCKING function. Set user buffer address and number of bytes to be
// received. If there are any available data these will be copied intermidiately.
// The rest of the user buffer is filled during interrupt service routine.
// Function returns number of pending bytes in user buffer.
//---------------------------------------------------------------------------------------
uchar USB_RxBuff3(uchar* adr, uchar cnt)
{
  // set address where to copy received data
  pDst3 = adr;
  // how many bytes to be copied
  cntDst3 = cnt;

  // if there are any data available, copy them intermediately
  while(cntSrc3 && cntDst3)
  {
    cntSrc3--;
    cntDst3--;
    *pDst3++ = *pSrc3++;
  }

  // if all received bytes are copied to user buffe, enable to receive next OUT packet
  if(cntSrc3 == 0)
     UEP3CSR &= ~UEP3CSR_DVALID_MASK;

  // return number of pending data in user buffer
  return(cntDst3);
}

//---------------------------------------------------------------------------------------
// uchar USB_RxChar3(void)
// BLOCKING function - wait till RxBuffPending and there are any received data in EP buffer
// then read one byte from EP buffer and return it.
//---------------------------------------------------------------------------------------
uchar USB_RxChar3(void)
{
  uchar retVal;
  // wait until buffer pending
  while(cntDst3)
    USB_DO_NOTHING();

  // wait while data in EP buffer aviable
  while(!(cntSrc3))
    USB_DO_NOTHING();

  retVal = *pSrc3++;
  // if no more data in EP buffer, enalble another packet receive
  if(!(--cntSrc3))
     UEP3CSR &= ~UEP3CSR_DVALID_MASK;

  // return data
  return(retVal);
}

//---------------------------------------------------------------------------------------
// uchar USB_RxBuffPending3(void)
// returns number of bytes pending to be received to user buffer
//---------------------------------------------------------------------------------------
uchar USB_RxBuffPending3(void)
{
  return(cntDst3);
}

//---------------------------------------------------------------------------------------
// uchar USB_GetRxReady3(void)
// return number of available data bytes in EP buffer
//---------------------------------------------------------------------------------------
uchar USB_GetRxReady3(void)
{
  return(cntSrc3);
}

//---------------------------------------------------------------------------------------
// uchar USB_GetTxEmpty3(void)
// returns number of available bytes in EP buffer (to be write)
//---------------------------------------------------------------------------------------
uchar USB_GetTxEmpty3(void)
{
  if(UEP3CSR_DVALID)   // if transmit is pending
    return(0);				 // return zero
  else
    return(cntDst3);	 // else return free space in transmit buffer
}


#ifndef WIN_USBSER_SYS_HACK

#if ((EP3_DIR == EP_DIR_IN) && (EP3_MODE == EP_MODE_BULK))
#warning "Aren't you trying to compile code for Windows usbser.sys driver?"
#warning "XP2 version of this driver doesn't work correctly with an IN packet"
#warning "that is as long as IN packet size (ie. full packet)."
#warning "Disabling to default value = full packet may be sent"
#warning "To use usbser.sys (XP2 version) correctly,"
#warning "add #define WIN_USBSER_SYS_HACK 1 into usb_periph.cfg.h!"
#endif

#define WIN_USBSER_SYS_HACK 0

#endif

//---------------------------------------------------------------------------------------
// uchar USB_TxChar3(uchar ch)  - used for IN bulk/interrupt packet
// BLOCKING function - waits till user Tx buffer is pending and
// EP buffer has free place. Then write character to EP buffer. When EP buffer
// is full, flushes this packet.
// Function returns number of available bytes in EP buffer
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxChar3(uchar ch)
{
  uchar retVal;
  // wait pending buffer
  while(cntSrc3)
    USB_DO_NOTHING();

  // wait while EP3 buffer not sent
  while(UEP3CSR_DVALID)
    USB_DO_NOTHING();

  // write character to buffer
  *pDst3++ = ch;

  cntDst3--;
  retVal = cntDst3;

  // if EP buffer is full, flush it
  if(retVal <= WIN_USBSER_SYS_HACK)				  // WARNING! only usbser.sys (XP version)
  {												  // doesn't handle full-length buffer sent
    UEP3DSR = EP3_BUFFER_SIZE - retVal;           // without zero flush afterwards
    UEP3CSR |= UEP3CSR_DVALID_MASK;
  }
  return(retVal);
}
#pragma MESSAGE DEFAULT C1853

//---------------------------------------------------------------------------------------
// uchar USB_TxBuff1(uchar* adr, uchar cnt) user for IN interrupt/bulk packet
// NON BLOCKING function - function copy data from user buffer to EP
// buffer. If user buffer is larger then EP buffer the rest of data is send in interrupt
// service routine. Function returns number of bytes pending in user buffer
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxBuff3(uchar* adr, uchar cnt)
{
   uchar retVal;

	 // set address of buffer where the data to be send are placed
	 pSrc3 = adr;
	 // set number of bytes to send
	 cntSrc3 = cnt;

   // copy data from user buffer to EP buffer
	 while(cntSrc3 && (cntDst3 > WIN_USBSER_SYS_HACK))   /* WinXP usbser.sys hack, need to send 1B less, see TxChar */
	 {
	  cntSrc3--;
	  cntDst3--;
	  *pDst3++ = *pSrc3++;
	 }

	 retVal = cntSrc3;
	 // flush it
     UEP3DSR = EP3_BUFFER_SIZE - cntDst3;
     UEP3CSR |= UEP3CSR_DVALID_MASK;
	 // return number of bytes pending in user buffer
	 return(retVal);
}
#pragma MESSAGE DEFAULT C1853

//---------------------------------------------------------------------------------------
// uchar USB_TxBuffPending3(void)
// function returns number of bytes pending in user buffer
//---------------------------------------------------------------------------------------
uchar USB_TxBuffPending3(void)
{
  return(cntSrc3);
}

//---------------------------------------------------------------------------------------
// uchar USB_TxFlush3(void)
// if there is at least one byte to be send in EP buffer, flush buffer
// Function returns number of send bytes
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxFlush3(void)
{
  UEP3DSR = EP3_BUFFER_SIZE - cntDst3;
  UEP3CSR |= UEP3CSR_DVALID_MASK;
  return(UEP3DSR);
}
#pragma MESSAGE DEFAULT C1853

//---------------------------------------------------------------------------------------
// uchar USB_RxBuff4(uchar* adr, uchar cnt) - used for OUT bulk/interrupt packet
// NON BLOCKING function. Set user buffer address and number of bytes to be
// received. If there are any available data these will be copied intermidiately.
// The rest of the user buffer is filled during interrupt service routine.
// Function returns number of pending bytes in user buffer.
//---------------------------------------------------------------------------------------
uchar USB_RxBuff4(uchar* adr, uchar cnt)
{
  // set address where to copy received data
  pDst4 = adr;
  // how many bytes to be copied
  cntDst4 = cnt;

  // if there are any data available, copy them intermidiately
  while(cntSrc4 && cntDst4)
  {
    cntSrc4--;
    cntDst4--;
    *pDst4++ = *pSrc4++;
  }

  // if all received bytes are copied to user buffe, enable to receive next OUT packet
  if(cntSrc4 == 0)
     UEP4CSR &= ~UEP4CSR_DVALID_MASK;

  // return number of pending data in user buffer
  return(cntDst4);
}

//---------------------------------------------------------------------------------------
// uchar USB_RxChar4(void)
// BLOCKING function - wait till RxBuffPending and there are any received data in EP buffer
// then read one byte from EP buffer and return it.
//---------------------------------------------------------------------------------------
uchar USB_RxChar4(void)
{
  uchar retVal;
  // wait until buffer pending
  while(cntDst4)
    USB_DO_NOTHING();

  // wait while data in EP buffer aviable
  while(!(cntSrc4))
    USB_DO_NOTHING();

  retVal = *pSrc4++;
  // if no more data in EP buffer, enalble another packet receive
  if(!(--cntSrc4))
     UEP4CSR &= ~UEP4CSR_DVALID_MASK;

  // return data
  return(retVal);
}

//---------------------------------------------------------------------------------------
// uchar USB_RxBuffPending4(void)
// returns number of bytes pending to be received to user buffer
//---------------------------------------------------------------------------------------
uchar USB_RxBuffPending4(void)
{
  return(cntDst4);
}

//---------------------------------------------------------------------------------------
// uchar USB_GetRxReady4(void)
// return number of available data bytes in EP buffer
//---------------------------------------------------------------------------------------
uchar USB_GetRxReady4(void)
{
  return(cntSrc4);
}

//---------------------------------------------------------------------------------------
// uchar USB_GetTxEmpty4(void)
// returns number of available bytes in EP buffer (to be write)
//---------------------------------------------------------------------------------------
uchar USB_GetTxEmpty4(void)
{
  if(UEP4CSR_DVALID)   // if transmit is pending
    return(0);				 // return zero
  else
    return(cntDst4);	 // else return free space in transmit buffer
}

//---------------------------------------------------------------------------------------
// uchar USB_TxChar4(uchar ch)  - used for IN bulk/interrupt packet
// BLOCKING function - waits till user Tx buffer is pending and
// EP buffer has free place. Then write character to EP buffer. When EP buffer
// is full, flushes this packet.
// Function returns number of available bytes in EP buffer
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxChar4(uchar ch)
{
  uchar retVal;
  // wait pending buffer
  while(cntSrc4)
    USB_DO_NOTHING();

  // wait while EP buffer not sent
  while(UEP4CSR_DVALID)
    USB_DO_NOTHING();

  // write character to buffer
  *pDst4++ = ch;

  cntDst4--;
  retVal = cntDst4;
  // if EP buffer is full, flush it
  if(retVal == 0)
  {
    UEP4DSR = EP4_BUFFER_SIZE;
    UEP4CSR |= UEP4CSR_DVALID_MASK;
  }
  return(cntDst4);
}
#pragma MESSAGE DEFAULT C1853
//---------------------------------------------------------------------------------------
// uchar USB_TxBuff1(uchar* adr, uchar cnt) user for IN interrupt/bulk packet
// NON BLOCKING function - function copy data from user buffer to EP
// buffer. If user buffer is larger then EP buffer the rest of data is send in interrupt
// service routine. Function returns number of bytes pending in user buffer
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxBuff4(uchar* adr, uchar cnt)
{
   uchar retVal;
	 // set address of buffer where the data to be send are placed
	 pSrc4 = adr;
	 // set number of bytes to send
	 cntSrc4 = cnt;

   // copy data from user buffer to EP buffer
	 while(cntSrc4 && cntDst4)
	 {
	  cntSrc4--;
	  cntDst4--;
	  *pDst4++ = *pSrc4++;
	 }

	 retVal = cntSrc4;
	 // flush it
   UEP4DSR = EP4_BUFFER_SIZE - cntDst4;
   UEP4CSR |= UEP4CSR_DVALID_MASK;

	 // return number of bytes pending in user buffer
	 return(retVal);
}
#pragma MESSAGE DEFAULT C1853
//---------------------------------------------------------------------------------------
// uchar USB_TxBuffPending4(void)
// function returns number of bytes pending in user buffer
//---------------------------------------------------------------------------------------
uchar USB_TxBuffPending4(void)
{
  return(cntSrc4);
}

//---------------------------------------------------------------------------------------
// uchar USB_TxFlush4(void)
// if there is at least one byte to be send in EP buffer, flush buffer
// Function returns number of send bytes
//---------------------------------------------------------------------------------------
#pragma MESSAGE DISABLE C1853
uchar USB_TxFlush4(void)
{
  UEP4DSR = EP4_BUFFER_SIZE - cntDst4;
  UEP4CSR |= UEP4CSR_DVALID_MASK;
  return(UEP4DSR);
}
#pragma MESSAGE DEFAULT C1853

//---------------------------------------------------------------------------------------
// USB_GetStatus
//---------------------------------------------------------------------------------------
uchar USB_GetStatus(void)