tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/host/usb1_host_usbsig.c

   1 /*******************************************************************************
   2 * DISCLAIMER
   3 * This software is supplied by Renesas Electronics Corporation and is only
   4 * intended for use with Renesas products. No other uses are authorized. This
   5 * software is owned by Renesas Electronics Corporation and is protected under
   6 * all applicable laws, including copyright laws.
   7 * THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
   8 * THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
   9 * LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
  10 * AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
  11 * TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
  12 * ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
  13 * FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
  14 * ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
  15 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  16 * Renesas reserves the right, without notice, to make changes to this software
  17 * and to discontinue the availability of this software. By using this software,
  18 * you agree to the additional terms and conditions found by accessing the
  19 * following link:
  20 * http://www.renesas.com/disclaimer
  21 * Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
  22 *******************************************************************************/
  23 /*******************************************************************************
  24 * File Name    : usb1_host_usbsig.c
  25 * $Rev: 1116 $
  26 * $Date:: 2014-07-09 16:29:19 +0900#$
  27 * Device(s)    : RZ/A1H
  28 * Tool-Chain   :
  29 * OS           : None
  30 * H/W Platform :
  31 * Description  : RZ/A1H R7S72100 USB Sample Program
  32 * Operation    :
  33 * Limitations  :
  34 *******************************************************************************/
  35
  36
  37 /*******************************************************************************
  38 Includes   <System Includes> , "Project Includes"
  39 *******************************************************************************/
  40 #include "usb1_host.h"
  41 #include "dev_drv.h"
  42
  43
  44 /*******************************************************************************
  45 Typedef definitions
  46 *******************************************************************************/
  47
  48
  49 /*******************************************************************************
  50 Macro definitions
  51 *******************************************************************************/
  52
  53
  54 /*******************************************************************************
  55 Imported global variables and functions (from other files)
  56 *******************************************************************************/
  57
  58
  59 /*******************************************************************************
  60 Exported global variables and functions (to be accessed by other files)
  61 *******************************************************************************/
  62 static void usb1_host_EnableINT_Module(void);
  63 static void usb1_host_Enable_AttachINT(void);
  64 static void usb1_host_Disable_AttachINT(void);
  65 static void usb1_host_Disable_BchgINT(void);
  66
  67
  68 /*******************************************************************************
  69 Private global variables and functions
  70 *******************************************************************************/
  71
  72
  73 /*******************************************************************************
  74 * Function Name: usb1_host_InitModule
  75 * Description  : Initializes the USB module in USB host module.
  76 * Arguments    : none
  77 * Return Value : none
  78 *******************************************************************************/
  79 void usb1_host_InitModule (void)
  80 {
  81     uint16_t buf1;
  82     uint16_t buf2;
  83     uint16_t buf3;
  84
  85     usb1_host_init_pipe_status();
  86
  87     RZA_IO_RegWrite_16(&USB201.SYSCFG0,
  88                         1,
  89                         USB_SYSCFG_DCFM_SHIFT,
  90                         USB_SYSCFG_DCFM);       /* HOST mode */
  91     RZA_IO_RegWrite_16(&USB201.SYSCFG0,
  92                         1,
  93                         USB_SYSCFG_DRPD_SHIFT,
  94                         USB_SYSCFG_DRPD);       /* PORT0 D+, D- setting */
  95
  96     do
  97     {
  98         buf1 = RZA_IO_RegRead_16(&USB201.SYSSTS0,
  99                                 USB_SYSSTS0_LNST_SHIFT,
 100                                 USB_SYSSTS0_LNST);
 101         Userdef_USB_usb1_host_delay_xms(50);
 102         buf2 = RZA_IO_RegRead_16(&USB201.SYSSTS0,
 103                                 USB_SYSSTS0_LNST_SHIFT,
 104                                 USB_SYSSTS0_LNST);
 105         Userdef_USB_usb1_host_delay_xms(50);
 106         buf3 = RZA_IO_RegRead_16(&USB201.SYSSTS0,
 107                                 USB_SYSSTS0_LNST_SHIFT,
 108                                 USB_SYSSTS0_LNST);
 109
 110     } while ((buf1 != buf2) || (buf1 != buf3));
 111
 112     RZA_IO_RegWrite_16(&USB201.SYSCFG0,
 113                         1,
 114                         USB_SYSCFG_USBE_SHIFT,
 115                         USB_SYSCFG_USBE);
 116
 117     USB201.CFIFOSEL  = (uint16_t)(USB_HOST_BITRCNT | USB_HOST_BITMBW_8 | USB_HOST_BITBYTE_LITTLE);
 118     USB201.D0FIFOSEL = (uint16_t)(                   USB_HOST_BITMBW_8 | USB_HOST_BITBYTE_LITTLE);
 119     USB201.D1FIFOSEL = (uint16_t)(                   USB_HOST_BITMBW_8 | USB_HOST_BITBYTE_LITTLE);
 120 }
 121
 122 /*******************************************************************************
 123 * Function Name: usb1_host_CheckAttach
 124 * Description  : Returns the USB device connection state.
 125 * Arguments    : none
 126 * Return Value : uint16_t ; USB_HOST_ATTACH : Attached
 127 *              :          ; USB_HOST_DETACH : not Attached
 128 *******************************************************************************/
 129 uint16_t usb1_host_CheckAttach (void)
 130 {
 131     uint16_t buf1;
 132     uint16_t buf2;
 133     uint16_t buf3;
 134     uint16_t rhst;
 135
 136     do
 137     {
 138         buf1 = RZA_IO_RegRead_16(&USB201.SYSSTS0,
 139                                 USB_SYSSTS0_LNST_SHIFT,
 140                                 USB_SYSSTS0_LNST);
 141         Userdef_USB_usb1_host_delay_xms(50);
 142         buf2 = RZA_IO_RegRead_16(&USB201.SYSSTS0,
 143                                 USB_SYSSTS0_LNST_SHIFT,
 144                                 USB_SYSSTS0_LNST);
 145         Userdef_USB_usb1_host_delay_xms(50);
 146         buf3 = RZA_IO_RegRead_16(&USB201.SYSSTS0,
 147                                 USB_SYSSTS0_LNST_SHIFT,
 148                                 USB_SYSSTS0_LNST);
 149
 150     } while ((buf1 != buf2) || (buf1 != buf3));
 151
 152     rhst = RZA_IO_RegRead_16(&USB201.DVSTCTR0,
 153                                 USB_DVSTCTR0_RHST_SHIFT,
 154                                 USB_DVSTCTR0_RHST);
 155     if (rhst == USB_HOST_UNDECID)
 156     {
 157         if (buf1 == USB_HOST_FS_JSTS)
 158         {
 159             if (g_usb1_host_SupportUsbDeviceSpeed == USB_HOST_HIGH_SPEED)
 160             {
 161                 RZA_IO_RegWrite_16(&USB201.SYSCFG0,
 162                                     1,
 163                                     USB_SYSCFG_HSE_SHIFT,
 164                                     USB_SYSCFG_HSE);
 165             }
 166             else
 167             {
 168                 RZA_IO_RegWrite_16(&USB201.SYSCFG0,
 169                                     0,
 170                                     USB_SYSCFG_HSE_SHIFT,
 171                                     USB_SYSCFG_HSE);
 172             }
 173             return USB_HOST_ATTACH;
 174         }
 175         else if (buf1 == USB_HOST_LS_JSTS)
 176         {
 177             /* Low Speed Device */
 178             RZA_IO_RegWrite_16(&USB201.SYSCFG0,
 179                                 0,
 180                                 USB_SYSCFG_HSE_SHIFT,
 181                                 USB_SYSCFG_HSE);
 182             return USB_HOST_ATTACH;
 183         }
 184         else
 185         {
 186             /* Do Nothing */
 187         }
 188     }
 189     else if ((rhst == USB_HOST_HSMODE) || (rhst == USB_HOST_FSMODE))
 190     {
 191         return USB_HOST_ATTACH;
 192     }
 193     else if (rhst == USB_HOST_LSMODE)
 194     {
 195         return USB_HOST_ATTACH;
 196     }
 197     else
 198     {
 199         /* Do Nothing */
 200     }
 201
 202     return USB_HOST_DETACH;
 203 }
 204
 205 /*******************************************************************************
 206 * Function Name: usb1_host_UsbAttach
 207 * Description  : Connects the USB device.
 208 * Arguments    : none
 209 * Return Value : none
 210 *******************************************************************************/
 211 void usb1_host_UsbAttach (void)
 212 {
 213     usb1_host_EnableINT_Module();
 214     usb1_host_Disable_BchgINT();
 215     usb1_host_Disable_AttachINT();
 216     usb1_host_Enable_DetachINT();
 217 }
 218
 219 /*******************************************************************************
 220 * Function Name: usb1_host_UsbDetach
 221 * Description  : Disconnects the USB device.
 222 * Arguments    : none
 223 * Return Value : none
 224 *******************************************************************************/
 225 void usb1_host_UsbDetach (void)
 226 {
 227     uint16_t pipe;
 228     uint16_t devadr;
 229
 230     g_usb1_host_driver_state = USB_HOST_DRV_DETACHED;
 231
 232     /* Terminate all the pipes in which communications on port  */
 233     /* are currently carried out                                */
 234     for (pipe = 0; pipe < (USB_HOST_MAX_PIPE_NO + 1); ++pipe)
 235     {
 236         if (g_usb1_host_pipe_status[pipe] != USB_HOST_PIPE_IDLE)
 237         {
 238             if (pipe == USB_HOST_PIPE0)
 239             {
 240                 devadr = RZA_IO_RegRead_16(&USB201.DCPMAXP,
 241                                             USB_DCPMAXP_DEVSEL_SHIFT,
 242                                             USB_DCPMAXP_DEVSEL);
 243             }
 244             else
 245             {
 246                 devadr = RZA_IO_RegRead_16(&g_usb1_host_pipemaxp[pipe], USB_PIPEMAXP_DEVSEL_SHIFT, USB_PIPEMAXP_DEVSEL);
 247             }
 248
 249             if (devadr == g_usb1_host_UsbAddress)
 250             {
 251                 usb1_host_stop_transfer(pipe);
 252             }
 253
 254             g_usb1_host_pipe_status[pipe] = USB_HOST_PIPE_IDLE;
 255         }
 256     }
 257
 258     g_usb1_host_ConfigNum  = 0;
 259     g_usb1_host_UsbAddress = 0;
 260     g_usb1_host_default_max_packet[USB_HOST_DEVICE_0] = 64;
 261
 262     usb1_host_UsbDetach2();
 263 }
 264
 265 /*******************************************************************************
 266 * Function Name: usb1_host_UsbDetach2
 267 * Description  : Disconnects the USB device.
 268 * Arguments    : none
 269 * Return Value : none
 270 *******************************************************************************/
 271 void usb1_host_UsbDetach2 (void)
 272 {
 273     usb1_host_Disable_DetachINT();
 274     usb1_host_Disable_BchgINT();
 275     usb1_host_Enable_AttachINT();
 276 }
 277
 278 /*******************************************************************************
 279 * Function Name: usb1_host_UsbBusReset
 280 * Description  : Issues the USB bus reset signal.
 281 * Arguments    : none
 282 * Return Value : uint16_t               ; RHST
 283 *******************************************************************************/
 284 uint16_t usb1_host_UsbBusReset (void)
 285 {
 286     uint16_t buffer;
 287     uint16_t loop;
 288
 289     RZA_IO_RegWrite_16(&USB201.DVSTCTR0,
 290                         1,
 291                         USB_DVSTCTR0_USBRST_SHIFT,
 292                         USB_DVSTCTR0_USBRST);
 293     RZA_IO_RegWrite_16(&USB201.DVSTCTR0,
 294                         0,
 295                         USB_DVSTCTR0_UACT_SHIFT,
 296                         USB_DVSTCTR0_UACT);
 297
 298     Userdef_USB_usb1_host_delay_xms(50);
 299
 300     buffer  = USB201.DVSTCTR0;
 301     buffer &= (uint16_t)(~(USB_HOST_BITRST));
 302     buffer |= USB_HOST_BITUACT;
 303     USB201.DVSTCTR0 = buffer;
 304
 305     Userdef_USB_usb1_host_delay_xms(20);
 306
 307     for (loop = 0, buffer = USB_HOST_HSPROC;  loop < 3; ++loop)
 308     {
 309         buffer = RZA_IO_RegRead_16(&USB201.DVSTCTR0,
 310                                     USB_DVSTCTR0_RHST_SHIFT,
 311                                     USB_DVSTCTR0_RHST);
 312         if (buffer == USB_HOST_HSPROC)
 313         {
 314             Userdef_USB_usb1_host_delay_xms(10);
 315         }
 316         else
 317         {
 318             break;
 319         }
 320     }
 321
 322     return buffer;
 323 }
 324
 325 /*******************************************************************************
 326 * Function Name: usb1_host_UsbResume
 327 * Description  : Issues the USB resume signal.
 328 * Arguments    : none
 329 * Return Value : int32_t            ; DEVDRV_SUCCESS
 330 *              :                    ; DEVDRV_ERROR
 331 *******************************************************************************/
 332 int32_t usb1_host_UsbResume (void)
 333 {
 334     uint16_t buf;
 335
 336     if ((g_usb1_host_driver_state & USB_HOST_DRV_SUSPEND) == 0)
 337     {
 338         /* not SUSPEND */
 339         return DEVDRV_ERROR;
 340     }
 341
 342     RZA_IO_RegWrite_16(&USB201.INTENB1,
 343                         0,
 344                         USB_INTENB1_BCHGE_SHIFT,
 345                         USB_INTENB1_BCHGE);
 346     RZA_IO_RegWrite_16(&USB201.DVSTCTR0,
 347                         1,
 348                         USB_DVSTCTR0_RESUME_SHIFT,
 349                         USB_DVSTCTR0_RESUME);
 350     Userdef_USB_usb1_host_delay_xms(20);
 351
 352     buf  = USB201.DVSTCTR0;
 353     buf &= (uint16_t)(~(USB_HOST_BITRESUME));
 354     buf |= USB_HOST_BITUACT;
 355     USB201.DVSTCTR0 = buf;
 356
 357     g_usb1_host_driver_state &= (uint16_t)~USB_HOST_DRV_SUSPEND;
 358
 359     return DEVDRV_SUCCESS;
 360 }
 361
 362 /*******************************************************************************
 363 * Function Name: usb1_host_UsbSuspend
 364 * Description  : Issues the USB suspend signal.
 365 * Arguments    : none
 366 * Return Value : int32_t            ; DEVDRV_SUCCESS   :not SUSPEND
 367 *              :                    ; DEVDRV_ERROR     :SUSPEND
 368 *******************************************************************************/
 369 int32_t usb1_host_UsbSuspend (void)
 370 {
 371     uint16_t buf;
 372
 373     if ((g_usb1_host_driver_state & USB_HOST_DRV_SUSPEND) != 0)
 374     {
 375         /* SUSPEND */
 376         return DEVDRV_ERROR;
 377     }
 378
 379     RZA_IO_RegWrite_16(&USB201.DVSTCTR0,
 380                         0,
 381                         USB_DVSTCTR0_UACT_SHIFT,
 382                         USB_DVSTCTR0_UACT);
 383
 384     Userdef_USB_usb1_host_delay_xms(5);
 385
 386     buf = RZA_IO_RegRead_16(&USB201.SYSSTS0,
 387                                 USB_SYSSTS0_LNST_SHIFT,
 388                                 USB_SYSSTS0_LNST);
 389     if ((buf != USB_HOST_FS_JSTS) && (buf != USB_HOST_LS_JSTS))
 390     {
 391         usb1_host_UsbDetach();
 392     }
 393     else
 394     {
 395         g_usb1_host_driver_state |= USB_HOST_DRV_SUSPEND;
 396     }
 397
 398     return DEVDRV_SUCCESS;
 399 }
 400
 401 /*******************************************************************************
 402 * Function Name: usb1_host_Enable_DetachINT
 403 * Description  : Enables the USB disconnection interrupt.
 404 * Arguments    : none
 405 * Return Value : none
 406 *******************************************************************************/
 407 void usb1_host_Enable_DetachINT (void)
 408 {
 409     USB201.INTSTS1 = (uint16_t)(~(USB_HOST_BITDTCH));
 410     RZA_IO_RegWrite_16(&USB201.INTENB1,
 411                         1,
 412                         USB_INTENB1_DTCHE_SHIFT,
 413                         USB_INTENB1_DTCHE);
 414 }
 415
 416 /*******************************************************************************
 417 * Function Name: usb1_host_Disable_DetachINT
 418 * Description  : Disables the USB disconnection interrupt.
 419 * Arguments    : none
 420 * Return Value : none
 421 *******************************************************************************/
 422 void usb1_host_Disable_DetachINT (void)
 423 {
 424     USB201.INTSTS1 = (uint16_t)(~(USB_HOST_BITDTCH));
 425     RZA_IO_RegWrite_16(&USB201.INTENB1,
 426                         0,
 427                         USB_INTENB1_DTCHE_SHIFT,
 428                         USB_INTENB1_DTCHE);
 429 }
 430
 431 /*******************************************************************************
 432 * Function Name: usb1_host_Enable_AttachINT
 433 * Description  : Enables the USB connection detection interrupt.
 434 * Arguments    : none
 435 * Return Value : none
 436 *******************************************************************************/
 437 void usb1_host_Enable_AttachINT (void)
 438 {
 439     USB201.INTSTS1 = (uint16_t)(~(USB_HOST_BITATTCH));
 440     RZA_IO_RegWrite_16(&USB201.INTENB1,
 441                         1,
 442                         USB_INTENB1_ATTCHE_SHIFT,
 443                         USB_INTENB1_ATTCHE);
 444 }
 445
 446 /*******************************************************************************
 447 * Function Name: usb1_host_Disable_AttachINT
 448 * Description  : Disables the USB connection detection interrupt.
 449 * Arguments    : none
 450 * Return Value : none
 451 *******************************************************************************/
 452 void usb1_host_Disable_AttachINT (void)
 453 {
 454     USB201.INTSTS1 = (uint16_t)(~(USB_HOST_BITATTCH));
 455     RZA_IO_RegWrite_16(&USB201.INTENB1,
 456                         0,
 457                         USB_INTENB1_ATTCHE_SHIFT,
 458                         USB_INTENB1_ATTCHE);
 459 }
 460
 461 /*******************************************************************************
 462 * Function Name: usb1_host_Disable_BchgINT
 463 * Description  : Disables the USB bus change detection interrupt.
 464 * Arguments    : none
 465 * Return Value : none
 466 *******************************************************************************/
 467 void usb1_host_Disable_BchgINT (void)
 468 {
 469     USB201.INTSTS1 = (uint16_t)(~(USB_HOST_BITBCHG));
 470     RZA_IO_RegWrite_16(&USB201.INTENB1,
 471                         0,
 472                         USB_INTENB1_BCHGE_SHIFT,
 473                         USB_INTENB1_BCHGE);
 474 }
 475
 476 /*******************************************************************************
 477 * Function Name: usb1_host_set_devadd
 478 * Description  : DEVADDn register is set by specified value
 479 * Arguments    : uint16_t addr             : Device address
 480 *              : uint16_t *devadd          : Set value
 481 * Return Value : none
 482 *******************************************************************************/
 483 void usb1_host_set_devadd (uint16_t addr, uint16_t * devadd)
 484 {
 485     uint16_t * ptr;
 486     uint16_t ret_flag = DEVDRV_FLAG_ON;                             // avoid warning.
 487
 488     switch (addr)
 489     {
 490         case USB_HOST_DEVICE_0:
 491             ptr = (uint16_t *)&USB201.DEVADD0;
 492         break;
 493
 494         case USB_HOST_DEVICE_1:
 495             ptr = (uint16_t *)&USB201.DEVADD1;
 496         break;
 497
 498         case USB_HOST_DEVICE_2:
 499             ptr = (uint16_t *)&USB201.DEVADD2;
 500         break;
 501
 502         case USB_HOST_DEVICE_3:
 503             ptr = (uint16_t *)&USB201.DEVADD3;
 504         break;
 505
 506         case USB_HOST_DEVICE_4:
 507             ptr = (uint16_t *)&USB201.DEVADD4;
 508         break;
 509
 510         case USB_HOST_DEVICE_5:
 511             ptr = (uint16_t *)&USB201.DEVADD5;
 512         break;
 513
 514         case USB_HOST_DEVICE_6:
 515             ptr = (uint16_t *)&USB201.DEVADD6;
 516         break;
 517
 518         case USB_HOST_DEVICE_7:
 519             ptr = (uint16_t *)&USB201.DEVADD7;
 520         break;
 521
 522         case USB_HOST_DEVICE_8:
 523             ptr = (uint16_t *)&USB201.DEVADD8;
 524         break;
 525
 526         case USB_HOST_DEVICE_9:
 527             ptr = (uint16_t *)&USB201.DEVADD9;
 528         break;
 529
 530         case USB_HOST_DEVICE_10:
 531             ptr = (uint16_t *)&USB201.DEVADDA;
 532         break;
 533
 534         default:
 535             ret_flag = DEVDRV_FLAG_OFF;
 536         break;
 537     }
 538
 539     if (ret_flag == DEVDRV_FLAG_ON)
 540     {
 541         *ptr = (uint16_t)(*devadd & USB_HOST_DEVADD_MASK);
 542     }
 543 }
 544
 545 /*******************************************************************************
 546 * Function Name: usb1_host_get_devadd
 547 * Description  : DEVADDn register is obtained
 548 * Arguments    : uint16_t addr      : Device address
 549 *              : uint16_t *devadd   : USB_HOST_DEVADD register value
 550 * Return Value : none
 551 *******************************************************************************/
 552 void usb1_host_get_devadd (uint16_t addr, uint16_t * devadd)
 553 {
 554     uint16_t * ptr;
 555     uint16_t ret_flag = DEVDRV_FLAG_ON;                             // avoid warning.
 556
 557     switch (addr)
 558     {
 559         case USB_HOST_DEVICE_0:
 560             ptr = (uint16_t *)&USB201.DEVADD0;
 561         break;
 562
 563         case USB_HOST_DEVICE_1:
 564             ptr = (uint16_t *)&USB201.DEVADD1;
 565         break;
 566
 567         case USB_HOST_DEVICE_2:
 568             ptr = (uint16_t *)&USB201.DEVADD2;
 569         break;
 570
 571         case USB_HOST_DEVICE_3:
 572             ptr = (uint16_t *)&USB201.DEVADD3;
 573         break;
 574
 575         case USB_HOST_DEVICE_4:
 576             ptr = (uint16_t *)&USB201.DEVADD4;
 577         break;
 578
 579         case USB_HOST_DEVICE_5:
 580             ptr = (uint16_t *)&USB201.DEVADD5;
 581         break;
 582
 583         case USB_HOST_DEVICE_6:
 584             ptr = (uint16_t *)&USB201.DEVADD6;
 585         break;
 586
 587         case USB_HOST_DEVICE_7:
 588             ptr = (uint16_t *)&USB201.DEVADD7;
 589         break;
 590
 591         case USB_HOST_DEVICE_8:
 592             ptr = (uint16_t *)&USB201.DEVADD8;
 593         break;
 594
 595         case USB_HOST_DEVICE_9:
 596             ptr = (uint16_t *)&USB201.DEVADD9;
 597         break;
 598
 599         case USB_HOST_DEVICE_10:
 600             ptr = (uint16_t *)&USB201.DEVADDA;
 601         break;
 602
 603         default:
 604             ret_flag = DEVDRV_FLAG_OFF;
 605         break;
 606     }
 607
 608     if (ret_flag == DEVDRV_FLAG_ON)
 609     {
 610         *devadd = *ptr;
 611     }
 612 }
 613
 614 /*******************************************************************************
 615 * Function Name: usb1_host_EnableINT_Module
 616 * Description  : Enables BEMP/NRDY/BRDY interrupt and SIGN/SACK interrupt.
 617 *              : Enables NRDY/BEMP interrupt in the pipe0.
 618 * Arguments    : none
 619 * Return Value : none
 620 *******************************************************************************/
 621 void usb1_host_EnableINT_Module (void)
 622 {
 623     uint16_t buf;
 624
 625     buf  = USB201.INTENB0;
 626     buf |= (USB_HOST_BITBEMPE | USB_HOST_BITNRDYE | USB_HOST_BITBRDYE);
 627     USB201.INTENB0 = buf;
 628
 629     buf  = USB201.INTENB1;
 630     buf |= (USB_HOST_BITSIGNE | USB_HOST_BITSACKE);
 631     USB201.INTENB1 = buf;
 632
 633     usb1_host_enable_nrdy_int(USB_HOST_PIPE0);
 634     usb1_host_enable_bemp_int(USB_HOST_PIPE0);
 635 }
 636
 637 /* End of File */