tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.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    : usb0_function_dataio.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 "usb0_function.h"
  41
  42
  43 /*******************************************************************************
  44 Typedef definitions
  45 *******************************************************************************/
  46
  47
  48 /*******************************************************************************
  49 Macro definitions
  50 *******************************************************************************/
  51
  52
  53 /*******************************************************************************
  54 Imported global variables and functions (from other files)
  55 *******************************************************************************/
  56
  57
  58 /*******************************************************************************
  59 Exported global variables and functions (to be accessed by other files)
  60 *******************************************************************************/
  61
  62
  63 /*******************************************************************************
  64 Private global variables and functions
  65 *******************************************************************************/
  66 static uint16_t g_usb0_function_mbw[(USB_FUNCTION_MAX_PIPE_NO + 1)];
  67
  68 static void     usb0_function_start_receive_trns_c(uint16_t pipe, uint32_t size, uint8_t *data);
  69 static void     usb0_function_start_receive_trns_d0(uint16_t pipe, uint32_t size, uint8_t *data);
  70 static void     usb0_function_start_receive_trns_d1(uint16_t pipe, uint32_t size, uint8_t *data);
  71 static void     usb0_function_start_receive_dma_d0(uint16_t pipe, uint32_t size, uint8_t *data);
  72 static void     usb0_function_start_receive_dma_d1(uint16_t pipe, uint32_t size, uint8_t *data);
  73 static uint16_t usb0_function_read_dma_d0(uint16_t pipe);
  74 static uint16_t usb0_function_read_dma_d1(uint16_t pipe);
  75 static uint16_t usb0_function_write_dma_d0(uint16_t pipe);
  76 static uint16_t usb0_function_write_dma_d1(uint16_t pipe);
  77
  78 static void     usb0_function_read_c_fifo(uint16_t pipe, uint16_t count);
  79 static void     usb0_function_write_c_fifo(uint16_t Pipe, uint16_t count);
  80 static void     usb0_function_read_d0_fifo(uint16_t pipe, uint16_t count);
  81 static void     usb0_function_write_d0_fifo(uint16_t pipe, uint16_t count);
  82 static void     usb0_function_read_d1_fifo(uint16_t pipe, uint16_t count);
  83 static void     usb0_function_write_d1_fifo(uint16_t pipe, uint16_t count);
  84
  85 static void     usb0_function_clear_transaction_counter(uint16_t pipe);
  86 static void     usb0_function_set_transaction_counter(uint16_t pipe, uint32_t count);
  87
  88 static uint32_t usb0_function_com_get_dmasize(uint32_t trncount, uint32_t dtptr);
  89
  90 static uint16_t usb0_function_set_dfacc_d0(uint16_t mbw, uint32_t count);
  91 static uint16_t usb0_function_set_dfacc_d1(uint16_t mbw, uint32_t count);
  92
  93
  94 /*******************************************************************************
  95 * Function Name: usb0_function_start_send_transfer
  96 * Description  : Starts the USB data communication using pipe specified by the argument.
  97 * Arguments    : uint16_t  pipe    ; Pipe Number
  98 *              : uint32_t size     ; Data Size
  99 *              : uint8_t  *data    ; Data Address
 100 * Return Value : DEVDRV_USBF_WRITEEND           ; Write end
 101 *              : DEVDRV_USBF_WRITESHRT          ; short data
 102 *              : DEVDRV_USBF_WRITING            ; Continue of data write
 103 *              : DEVDRV_USBF_WRITEDMA           ; Write DMA
 104 *              : DEVDRV_USBF_FIFOERROR          ; FIFO status
 105 *******************************************************************************/
 106 uint16_t usb0_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data)
 107 {
 108     uint16_t status;
 109     uint16_t usefifo;
 110     uint16_t mbw;
 111
 112     g_usb0_function_data_count[pipe]   = size;
 113     g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
 114     g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
 115
 116     usb0_function_clear_bemp_sts(pipe);
 117     usb0_function_clear_brdy_sts(pipe);
 118     usb0_function_clear_nrdy_sts(pipe);
 119
 120     mbw = usb0_function_get_mbw(size, (uint32_t)data);
 121
 122     usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
 123
 124     switch (usefifo)
 125     {
 126         case USB_FUNCTION_D0FIFO_USE:
 127         case USB_FUNCTION_D0FIFO_DMA:
 128             usefifo = USB_FUNCTION_D0USE;
 129         break;
 130
 131         case USB_FUNCTION_D1FIFO_USE:
 132         case USB_FUNCTION_D1FIFO_DMA:
 133             usefifo = USB_FUNCTION_D1USE;
 134         break;
 135
 136         default:
 137             usefifo = USB_FUNCTION_CUSE;
 138         break;
 139     };
 140
 141     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, usefifo, DEVDRV_USBF_NO, mbw);
 142
 143     usb0_function_clear_transaction_counter(pipe);
 144
 145     usb0_function_aclrm(pipe);
 146
 147     status = usb0_function_write_buffer(pipe);
 148
 149     if (status != DEVDRV_USBF_FIFOERROR)
 150     {
 151         usb0_function_set_pid_buf(pipe);
 152     }
 153
 154     return status;
 155 }
 156
 157 /*******************************************************************************
 158 * Function Name: usb0_function_write_buffer
 159 * Description  : Writes data in the buffer allocated in the pipe specified by
 160 *              : the argument. The FIFO for using is set in the pipe definition table.
 161 * Arguments    : uint16_t pipe      ; Pipe Number
 162 * Return Value : DEVDRV_USBF_WRITEEND           ; Write end
 163 *              : DEVDRV_USBF_WRITESHRT          ; short data
 164 *              : DEVDRV_USBF_WRITING            ; Continue of data write
 165 *              : DEVDRV_USBF_WRITEDMA           ; Write DMA
 166 *              : DEVDRV_USBF_FIFOERROR          ; FIFO status
 167 *******************************************************************************/
 168 uint16_t usb0_function_write_buffer (uint16_t pipe)
 169 {
 170     uint16_t status;
 171     uint16_t usefifo;
 172
 173     g_usb0_function_PipeIgnore[pipe] = 0;
 174     usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
 175
 176     switch (usefifo)
 177     {
 178         case USB_FUNCTION_D0FIFO_USE:
 179             status = usb0_function_write_buffer_d0(pipe);
 180         break;
 181
 182         case USB_FUNCTION_D1FIFO_USE:
 183             status = usb0_function_write_buffer_d1(pipe);
 184         break;
 185
 186         case USB_FUNCTION_D0FIFO_DMA:
 187             status = usb0_function_write_dma_d0(pipe);
 188         break;
 189
 190         case USB_FUNCTION_D1FIFO_DMA:
 191             status = usb0_function_write_dma_d1(pipe);
 192         break;
 193
 194         default:
 195             status = usb0_function_write_buffer_c(pipe);
 196         break;
 197     };
 198
 199     switch (status)
 200     {
 201         case DEVDRV_USBF_WRITING:                       /* Continue of data write */
 202             usb0_function_enable_nrdy_int(pipe);        /* Error (NORES or STALL) */
 203             usb0_function_enable_brdy_int(pipe);        /* Enable Ready Interrupt */
 204         break;
 205
 206         case DEVDRV_USBF_WRITEEND:                      /* End of data write */
 207         case DEVDRV_USBF_WRITESHRT:                     /* End of data write */
 208             usb0_function_disable_brdy_int(pipe);       /* Disable Ready Interrupt */
 209             usb0_function_clear_nrdy_sts(pipe);
 210             usb0_function_enable_nrdy_int(pipe);        /* Error (NORES or STALL) */
 211             /* for last transfer */
 212             usb0_function_enable_bemp_int(pipe);        /* Enable Empty Interrupt */
 213         break;
 214
 215         case DEVDRV_USBF_WRITEDMA:                      /* DMA write */
 216             usb0_function_clear_nrdy_sts(pipe);
 217             usb0_function_enable_nrdy_int(pipe);        /* Error (NORES or STALL) */
 218         break;
 219
 220         case DEVDRV_USBF_FIFOERROR:                     /* FIFO access status */
 221         default:
 222             usb0_function_disable_brdy_int(pipe);       /* Disable Ready Interrupt */
 223             usb0_function_disable_bemp_int(pipe);       /* Disable Empty Interrupt */
 224             g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
 225         break;
 226     }
 227
 228     return status;                      /* End or Err or Continue */
 229 }
 230
 231 /*******************************************************************************
 232 * Function Name: usb0_function_write_buffer_c
 233 * Description  : Writes data in the buffer allocated in the pipe specified in
 234 *              : the argument. Writes data by CPU transfer using CFIFO.
 235 * Arguments    : uint16_t pipe      ; Pipe Number
 236 * Return Value : DEVDRV_USBF_WRITEEND           ; Write end
 237 *              : DEVDRV_USBF_WRITESHRT          ; short data
 238 *              : DEVDRV_USBF_WRITING            ; Continue of data write
 239 *              : DEVDRV_USBF_WRITEDMA           ; Write DMA
 240 *              : DEVDRV_USBF_FIFOERROR          ; FIFO status
 241 *******************************************************************************/
 242 uint16_t usb0_function_write_buffer_c (uint16_t pipe)
 243 {
 244     uint32_t count;
 245     uint16_t size;
 246     uint16_t buffer;
 247     uint16_t mxps;
 248     uint16_t status;
 249     uint16_t mbw;
 250
 251     if (g_usb0_function_CtrZeroLengthFlag == 1)
 252     {
 253         g_usb0_function_CtrZeroLengthFlag = 0;                  /* Zero Length Packet Flag CLR */
 254         return DEVDRV_USBF_WRITEEND;
 255     }
 256
 257     mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
 258     if (pipe == USB_FUNCTION_PIPE0)
 259     {
 260         buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw);
 261     }
 262     else
 263     {
 264         buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw);
 265     }
 266
 267     if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
 268     {
 269         return DEVDRV_USBF_FIFOERROR;
 270     }
 271
 272     size = usb0_function_get_buf_size(pipe);                    /* Data buffer size */
 273     mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
 274
 275     if (g_usb0_function_data_count[pipe] <= (uint32_t)size)
 276     {
 277         status = DEVDRV_USBF_WRITEEND;                          /* write continues */
 278         count  = g_usb0_function_data_count[pipe];
 279
 280         if (count == 0)
 281         {
 282             status = DEVDRV_USBF_WRITESHRT;                     /* Null Packet is end of write */
 283         }
 284
 285         if ((count % mxps) != 0)
 286         {
 287             status = DEVDRV_USBF_WRITESHRT;                     /* Short Packet is end of write */
 288         }
 289     }
 290     else
 291     {
 292         status = DEVDRV_USBF_WRITING;                           /* write continues */
 293         count  = (uint32_t)size;
 294     }
 295
 296     usb0_function_write_c_fifo(pipe, (uint16_t)count);
 297
 298     if (g_usb0_function_data_count[pipe] < (uint32_t)size)
 299     {
 300         g_usb0_function_data_count[pipe] = 0;
 301
 302         if (RZA_IO_RegRead_16(&USB200.CFIFOCTR, USB_CFIFOCTR_BVAL_SHIFT, USB_CFIFOCTR_BVAL) == 0)
 303         {
 304             USB200.CFIFOCTR = USB_FUNCTION_BITBVAL;             /* Short Packet */
 305             g_usb0_function_CtrZeroLengthFlag = 1;              /* Zero Length Packet Flag */
 306         }
 307     }
 308     else
 309     {
 310         g_usb0_function_data_count[pipe] -= count;
 311     }
 312
 313     return status;                                              /* End or Err or Continue */
 314 }
 315
 316 /*******************************************************************************
 317 * Function Name: usb0_function_write_buffer_d0
 318 * Description  : Writes data in the buffer allocated in the pipe specified in the argument.
 319 *              : Writes data by CPU transfer using D0FIFO.
 320 * Arguments    : uint16_t pipe      ; Pipe Number
 321 * Return Value : DEVDRV_USBF_WRITEEND           ; Write end
 322 *              : DEVDRV_USBF_WRITESHRT          ; short data
 323 *              : DEVDRV_USBF_WRITING            ; Continue of data write
 324 *              : DEVDRV_USBF_WRITEDMA           ; Write DMA
 325 *              : DEVDRV_USBF_FIFOERROR          ; FIFO status
 326 *******************************************************************************/
 327 uint16_t usb0_function_write_buffer_d0 (uint16_t pipe)
 328 {
 329     uint32_t count;
 330     uint16_t size;
 331     uint16_t buffer;
 332     uint16_t mxps;
 333     uint16_t status;
 334     uint16_t mbw;
 335
 336     mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
 337     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
 338     if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
 339     {
 340         return DEVDRV_USBF_FIFOERROR;
 341     }
 342
 343     size = usb0_function_get_buf_size(pipe);                    /* Data buffer size */
 344     mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
 345
 346     if (g_usb0_function_data_count[pipe] <= (uint32_t)size)
 347     {
 348         status = DEVDRV_USBF_WRITEEND;                          /* write continues */
 349         count  = g_usb0_function_data_count[pipe];
 350
 351         if (count == 0)
 352         {
 353             status = DEVDRV_USBF_WRITESHRT;                     /* Null Packet is end of write */
 354         }
 355
 356         if ((count % mxps) != 0)
 357         {
 358             status = DEVDRV_USBF_WRITESHRT;                     /* Short Packet is end of write */
 359         }
 360     }
 361     else
 362     {
 363         status = DEVDRV_USBF_WRITING;                           /* write continues */
 364         count  = (uint32_t)size;
 365     }
 366
 367     usb0_function_write_d0_fifo(pipe, (uint16_t)count);
 368
 369     if (g_usb0_function_data_count[pipe] < (uint32_t)size)
 370     {
 371         g_usb0_function_data_count[pipe] = 0;
 372         if (RZA_IO_RegRead_16(&USB200.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
 373         {
 374             USB200.D0FIFOCTR = USB_FUNCTION_BITBVAL;            /* Short Packet */
 375         }
 376     }
 377     else
 378     {
 379         g_usb0_function_data_count[pipe] -= count;
 380     }
 381
 382     return status;                                              /* End or Err or Continue */
 383 }
 384
 385 /*******************************************************************************
 386 * Function Name: usb0_function_write_buffer_d1
 387 * Description  : Writes data in the buffer allocated in the pipe specified in the argument.
 388 *              : Writes data by CPU transfer using D1FIFO.
 389 * Arguments    : uint16_t pipe      ; Pipe Number
 390 * Return Value : DEVDRV_USBF_WRITEEND           ; Write end
 391 *              : DEVDRV_USBF_WRITESHRT          ; short data
 392 *              : DEVDRV_USBF_WRITING            ; Continue of data write
 393 *              : DEVDRV_USBF_WRITEDMA           ; Write DMA
 394 *              : DEVDRV_USBF_FIFOERROR          ; FIFO status
 395 *******************************************************************************/
 396 uint16_t usb0_function_write_buffer_d1 (uint16_t pipe)
 397 {
 398     uint32_t count;
 399     uint16_t size;
 400     uint16_t buffer;
 401     uint16_t mxps;
 402     uint16_t status;
 403     uint16_t mbw;
 404
 405     mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
 406     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
 407
 408     if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
 409     {
 410         return DEVDRV_USBF_FIFOERROR;
 411     }
 412
 413     size = usb0_function_get_buf_size(pipe);                    /* Data buffer size */
 414     mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
 415
 416     if (g_usb0_function_data_count[pipe] <= (uint32_t)size)
 417     {
 418         status = DEVDRV_USBF_WRITEEND;                          /* write continues */
 419         count  = g_usb0_function_data_count[pipe];
 420
 421         if (count == 0)
 422         {
 423             status = DEVDRV_USBF_WRITESHRT;                     /* Null Packet is end of write */
 424         }
 425
 426         if ((count % mxps) != 0)
 427         {
 428             status = DEVDRV_USBF_WRITESHRT;                     /* Short Packet is end of write */
 429         }
 430     }
 431     else
 432     {
 433         status = DEVDRV_USBF_WRITING;                           /* write continues */
 434         count  = (uint32_t)size;
 435     }
 436
 437     usb0_function_write_d1_fifo(pipe, (uint16_t)count);
 438
 439     if (g_usb0_function_data_count[pipe] < (uint32_t)size)
 440     {
 441         g_usb0_function_data_count[pipe] = 0;
 442
 443         if (RZA_IO_RegRead_16(&USB200.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
 444         {
 445             USB200.D1FIFOCTR = USB_FUNCTION_BITBVAL;            /* Short Packet */
 446         }
 447     }
 448     else
 449     {
 450         g_usb0_function_data_count[pipe] -= count;
 451     }
 452
 453     return status;                                              /* End or Err or Continue */
 454 }
 455
 456 /*******************************************************************************
 457 * Function Name: usb0_function_write_dma_d0
 458 * Description  : Writes data in the buffer allocated in the pipe specified in the argument.
 459 *              : Writes data by DMA transfer using D0FIFO.
 460 *              : The DMA-ch for using is specified by Userdef_USB_usb0_function_start_dma().
 461 * Arguments    : uint16_t pipe     ; Pipe Number
 462 * Return Value : DEVDRV_USBF_WRITEEND           : Write end
 463 *              : DEVDRV_USBF_WRITESHRT          : short data
 464 *              : DEVDRV_USBF_WRITING            : Continue of data write
 465 *              : DEVDRV_USBF_WRITEDMA           : Write DMA
 466 *              : DEVDRV_USBF_FIFOERROR          : FIFO status
 467 *******************************************************************************/
 468 static uint16_t usb0_function_write_dma_d0 (uint16_t pipe)
 469 {
 470     uint32_t count;
 471     uint16_t size;
 472     uint16_t buffer;
 473     uint16_t status;
 474     uint16_t mbw;
 475     uint16_t dfacc = 0;
 476
 477     mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
 478     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw);
 479
 480     if (buffer == DEVDRV_USBF_FIFOERROR)                            /* FIFO access status */
 481     {
 482         return DEVDRV_USBF_FIFOERROR;
 483     }
 484
 485     size  = usb0_function_get_buf_size(pipe);                       /* Data buffer size */
 486     count = g_usb0_function_data_count[pipe];
 487
 488     if (count != 0)
 489     {
 490         g_usb0_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe;
 491
 492         if ((count % size) != 0)
 493         {
 494             g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 1;
 495         }
 496         else
 497         {
 498             g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 0;
 499         }
 500
 501         dfacc = usb0_function_set_dfacc_d0(mbw, count);
 502
 503         if (mbw == USB_FUNCTION_BITMBW_32)
 504         {
 505             g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2;  /* 32bit transfer */
 506         }
 507         else if (mbw == USB_FUNCTION_BITMBW_16)
 508         {
 509             g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1;  /* 16bit transfer */
 510         }
 511         else
 512         {
 513             g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0;  /* 8bit transfer */
 514         }
 515
 516         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo   = USB_FUNCTION_D0FIFO_DMA;
 517         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].dir    = USB_FUNCTION_BUF2FIFO;
 518         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
 519         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes  = count;
 520
 521         Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc);
 522
 523         usb0_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc);
 524
 525         RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
 526
 527         g_usb0_function_data_count[pipe]    = 0;
 528         g_usb0_function_data_pointer[pipe] += count;
 529         status = DEVDRV_USBF_WRITEDMA;                              /* DMA write  */
 530     }
 531     else
 532     {
 533         if (RZA_IO_RegRead_16(&USB200.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
 534         {
 535             RZA_IO_RegWrite_16(&USB200.D0FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */
 536         }
 537         status = DEVDRV_USBF_WRITESHRT;                             /* Short Packet is end of write */
 538     }
 539
 540     return status;                                                  /* End or Err or Continue */
 541 }
 542
 543 /*******************************************************************************
 544 * Function Name: usb0_function_write_dma_d1
 545 * Description  : Writes data in the buffer allocated in the pipe specified in the argument.
 546 *              : Writes data by DMA transfer using D1FIFO.
 547 *              : The DMA-ch for using is specified by Userdef_USB_usb0_function_start_dma().
 548 * Arguments    : uint16_t pipe      ; Pipe Number
 549 * Return Value : DEVDRV_USBF_WRITEEND           : Write end
 550 *              : DEVDRV_USBF_WRITESHRT          : short data
 551 *              : DEVDRV_USBF_WRITING            : Continue of data write
 552 *              : DEVDRV_USBF_WRITEDMA           : Write DMA
 553 *              : DEVDRV_USBF_FIFOERROR          : FIFO status
 554 *******************************************************************************/
 555 static uint16_t usb0_function_write_dma_d1 (uint16_t pipe)
 556 {
 557     uint32_t count;
 558     uint16_t size;
 559     uint16_t buffer;
 560     uint16_t status;
 561     uint16_t mbw;
 562     uint16_t dfacc=0;
 563
 564     mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
 565     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw);
 566
 567     if (buffer == DEVDRV_USBF_FIFOERROR)                            /* FIFO access status */
 568     {
 569         return DEVDRV_USBF_FIFOERROR;
 570     }
 571
 572     size  = usb0_function_get_buf_size(pipe);                       /* Data buffer size */
 573     count = g_usb0_function_data_count[pipe];
 574
 575     if (count != 0)
 576     {
 577         g_usb0_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe;
 578         if ((count % size) != 0)
 579         {
 580             g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 1;
 581         }
 582         else
 583         {
 584             g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 0;
 585         }
 586
 587         dfacc = usb0_function_set_dfacc_d1(mbw, count);
 588
 589         if (mbw == USB_FUNCTION_BITMBW_32)
 590         {
 591             g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2;  /* 32bit transfer */
 592         }
 593         else if (mbw == USB_FUNCTION_BITMBW_16)
 594         {
 595             g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1;  /* 16bit transfer */
 596         }
 597         else
 598         {
 599             g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0;  /* 8bit transfer */
 600         }
 601
 602         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo   = USB_FUNCTION_D1FIFO_DMA;
 603         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].dir    = USB_FUNCTION_BUF2FIFO;
 604         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
 605         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes  = count;
 606
 607         Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc);
 608
 609         usb0_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc);
 610
 611         RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
 612
 613         g_usb0_function_data_count[pipe]    = 0;
 614         g_usb0_function_data_pointer[pipe] += count;
 615
 616         status = DEVDRV_USBF_WRITEDMA;                             /* DMA write  */
 617     }
 618     else
 619     {
 620         if (RZA_IO_RegRead_16(&USB200.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
 621         {
 622             RZA_IO_RegWrite_16(&USB200.D1FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */
 623         }
 624         status = DEVDRV_USBF_WRITESHRT;                             /* Short Packet is end of write */
 625     }
 626
 627     return status;                                                  /* End or Err or Continue */
 628 }
 629
 630 /*******************************************************************************
 631 * Function Name: usb0_function_start_receive_transfer
 632 * Description  : Starts USB data reception using the pipe specified in the argument.
 633 *              : The FIFO for using is set in the pipe definition table.
 634 * Arguments    : uint16_t pipe      ; Pipe Number
 635 *              : uint32_t size      ; Data Size
 636 *              : uint8_t *data      ; Data Address
 637 * Return Value : none
 638 *******************************************************************************/
 639 void usb0_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data)
 640 {
 641     uint16_t usefifo;
 642
 643     usb0_function_clear_bemp_sts(pipe);
 644     usb0_function_clear_brdy_sts(pipe);
 645     usb0_function_clear_nrdy_sts(pipe);
 646
 647     usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
 648
 649     switch (usefifo)
 650     {
 651         case USB_FUNCTION_D0FIFO_USE:
 652             usb0_function_start_receive_trns_d0(pipe, size, data);
 653         break;
 654
 655         case USB_FUNCTION_D1FIFO_USE:
 656             usb0_function_start_receive_trns_d1(pipe, size, data);
 657         break;
 658
 659         case USB_FUNCTION_D0FIFO_DMA:
 660             usb0_function_start_receive_dma_d0(pipe, size, data);
 661         break;
 662
 663         case USB_FUNCTION_D1FIFO_DMA:
 664             usb0_function_start_receive_dma_d1(pipe, size, data);
 665         break;
 666
 667         default:
 668             usb0_function_start_receive_trns_c(pipe, size, data);
 669         break;
 670     }
 671 }
 672
 673 /*******************************************************************************
 674 * Function Name: usb0_function_start_receive_trns_c
 675 * Description  : Reads data from the buffer allocated in the pipe specified in the argument.
 676 *              : Reads data by CPU transfer using CFIFO.
 677 *              : When storing data in the buffer allocated in the pipe specified in the
 678 *              : argument, BRDY interrupt is generated to read data
 679 *              : in the interrupt.
 680 * Arguments    : uint16_t pipe      ; Pipe Number
 681 *              : uint32_t size      ; Data Size
 682 *              : uint8_t *data      ; Data Address
 683 * Return Value : none
 684 *******************************************************************************/
 685 static void usb0_function_start_receive_trns_c (uint16_t pipe, uint32_t size, uint8_t * data)
 686 {
 687     uint16_t mbw;
 688
 689     usb0_function_set_pid_nak(pipe);
 690     g_usb0_function_data_count[pipe]   = size;
 691     g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
 692     g_usb0_function_PipeIgnore[pipe]   = 0;
 693
 694     g_usb0_function_PipeDataSize[pipe] = size;
 695     g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
 696
 697     mbw = usb0_function_get_mbw(size, (uint32_t)data);
 698     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw);
 699     USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;
 700
 701     usb0_function_set_transaction_counter(pipe, size);
 702
 703     usb0_function_aclrm(pipe);
 704
 705     usb0_function_enable_nrdy_int(pipe);
 706     usb0_function_enable_brdy_int(pipe);
 707
 708     usb0_function_set_pid_buf(pipe);
 709 }
 710
 711 /*******************************************************************************
 712 * Function Name: usb0_function_start_receive_trns_d0
 713 * Description  : Reads data from the buffer allocated in the pipe specified in the argument.
 714 *              : Reads data by CPU transfer using D0FIFO.
 715 *              : This function does not read data from the buffer.
 716 *              : When storing data in the buffer allocated in the pipe specified
 717 *              : in the argument, BRDY interrupt is generated to read data in the
 718 *              : interrupt.
 719 * Arguments    : uint16_t pipe      ; Pipe Number
 720 *              : uint32_t size      ; Data Size
 721 *              : uint8_t *data      ; Data Address
 722 * Return Value : none
 723 *******************************************************************************/
 724 static void usb0_function_start_receive_trns_d0 (uint16_t pipe, uint32_t size, uint8_t * data)
 725 {
 726     uint16_t mbw;
 727
 728     usb0_function_set_pid_nak(pipe);
 729     g_usb0_function_data_count[pipe]   = size;
 730     g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
 731     g_usb0_function_PipeIgnore[pipe]   = 0;
 732
 733     g_usb0_function_PipeDataSize[pipe] = size;
 734     g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
 735
 736     mbw = usb0_function_get_mbw(size, (uint32_t)data);
 737     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
 738
 739     usb0_function_set_transaction_counter(pipe, size);
 740
 741     usb0_function_aclrm(pipe);
 742
 743     usb0_function_enable_nrdy_int(pipe);
 744     usb0_function_enable_brdy_int(pipe);
 745
 746     usb0_function_set_pid_buf(pipe);
 747 }
 748
 749 /*******************************************************************************
 750 * Function Name: usb0_function_start_receive_trns_d1
 751 * Description  : Reads data from the buffer allocated in the pipe specified in the argument.
 752 *              : Reads data by CPU transfer using D1FIFO.
 753 *              : This function does not read data from the buffer.
 754 *              : When storing data in the buffer allocated in the pipe specified
 755 *              : in the argument, BRDY interrupt is generated to read data.
 756 * Arguments    : uint16_t pipe      ; Pipe Number
 757 *              : uint32_t size      ; Data Size
 758 *              : uint8_t *data      ; Data Address
 759 * Return Value : none
 760 *******************************************************************************/
 761 static void usb0_function_start_receive_trns_d1 (uint16_t pipe, uint32_t size, uint8_t * data)
 762 {
 763     uint16_t mbw;
 764
 765     usb0_function_set_pid_nak(pipe);
 766     g_usb0_function_data_count[pipe]   = size;
 767     g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
 768     g_usb0_function_PipeIgnore[pipe]   = 0;
 769
 770     g_usb0_function_PipeDataSize[pipe] = size;
 771     g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
 772
 773     mbw = usb0_function_get_mbw(size, (uint32_t)data);
 774     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
 775
 776     usb0_function_set_transaction_counter(pipe, size);
 777
 778     usb0_function_aclrm(pipe);
 779
 780     usb0_function_enable_nrdy_int(pipe);
 781     usb0_function_enable_brdy_int(pipe);
 782
 783     usb0_function_set_pid_buf(pipe);
 784 }
 785
 786 /*******************************************************************************
 787 * Function Name: usb0_function_start_receive_dma_d0
 788 * Description  : Reads data from the buffer allocated in the pipe specified in the argument.
 789 *              : Reads data by DMA transfer using D0FIFO.
 790 *              : This function does not read data from the buffer.
 791 *              : When storing data in the buffer allocated in the pipe specified
 792 *              : in the argument, delivered read request to DMAC to read data from
 793 *              : the buffer by DMAC.
 794 * Arguments    : uint16_t pipe      ; Pipe Number
 795 *              : uint32_t size      ; Data Size
 796 *              : uint8_t *data      ; Data Address
 797 * Return Value : none
 798 *******************************************************************************/
 799 static void usb0_function_start_receive_dma_d0 (uint16_t pipe, uint32_t size, uint8_t * data)
 800 {
 801     uint16_t mbw;
 802
 803     usb0_function_set_pid_nak(pipe);
 804     g_usb0_function_data_count[pipe]   = size;
 805     g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
 806     g_usb0_function_PipeIgnore[pipe]   = 0;
 807
 808     g_usb0_function_PipeDataSize[pipe] = 0;
 809     g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
 810
 811     mbw = usb0_function_get_mbw(size, (uint32_t)data);
 812     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
 813
 814     usb0_function_set_transaction_counter(pipe, size);
 815
 816     usb0_function_aclrm(pipe);
 817
 818     if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
 819     {
 820         usb0_function_read_dma(pipe);
 821
 822         usb0_function_enable_nrdy_int(pipe);
 823         usb0_function_enable_brdy_int(pipe);
 824     }
 825     else
 826     {
 827         usb0_function_enable_nrdy_int(pipe);
 828         usb0_function_enable_brdy_int(pipe);
 829     }
 830
 831     usb0_function_set_pid_buf(pipe);
 832 }
 833
 834 /*******************************************************************************
 835 * Function Name: usb0_function_start_receive_dma_d1
 836 * Description  : Read data from the buffer allocated in the pipe specified in the argument.
 837 *              : Reads data by DMA transfer using D0FIFO.
 838 *              : This function does not read data from the buffer.
 839 *              : When storing data in the buffer allocated in the pipe specified
 840 *              : in the argument, delivered read request to DMAC to read data from
 841 *              : the buffer by DMAC.
 842 * Arguments    : uint16_t pipe      ; Pipe Number
 843 *              : uint32_t size      ; Data Size
 844 *              : uint8_t *data      ; Data Address
 845 * Return Value : none
 846 *******************************************************************************/
 847 static void usb0_function_start_receive_dma_d1 (uint16_t pipe, uint32_t size, uint8_t * data)
 848 {
 849     uint16_t mbw;
 850
 851     usb0_function_set_pid_nak(pipe);
 852     g_usb0_function_data_count[pipe]   = size;
 853     g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
 854     g_usb0_function_PipeIgnore[pipe]   = 0;
 855
 856     g_usb0_function_PipeDataSize[pipe] = 0;
 857     g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
 858
 859     mbw = usb0_function_get_mbw(size, (uint32_t)data);
 860     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
 861
 862     usb0_function_set_transaction_counter(pipe, size);
 863
 864     usb0_function_aclrm(pipe);
 865
 866     if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
 867     {
 868         usb0_function_read_dma(pipe);
 869
 870         usb0_function_enable_nrdy_int(pipe);
 871         usb0_function_enable_brdy_int(pipe);
 872     }
 873     else
 874     {
 875         usb0_function_enable_nrdy_int(pipe);
 876         usb0_function_enable_brdy_int(pipe);
 877     }
 878
 879     usb0_function_set_pid_buf(pipe);
 880 }
 881
 882 /*******************************************************************************
 883 * Function Name: usb0_function_read_buffer
 884 * Description  : Reads data from the buffer allocated in the pipe specified
 885 *              : in the argument.
 886 *              : Uses FIF0 set in the pipe definition table.
 887 * Arguments    : uint16_t pipe     ; Pipe Number
 888 * Return Value : USB_FUNCTION_READEND          ; Read end
 889 *              : USB_FUNCTION_READSHRT         ; short data
 890 *              : USB_FUNCTION_READING          ; Continue of data read
 891 *              : USB_FUNCTION_READOVER         ; buffer over
 892 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
 893 *******************************************************************************/
 894 uint16_t usb0_function_read_buffer (uint16_t pipe)
 895 {
 896     uint16_t status;
 897
 898     g_usb0_function_PipeIgnore[pipe] = 0;
 899
 900     if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE)
 901     {
 902         status = usb0_function_read_buffer_d0(pipe);
 903     }
 904     else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE)
 905     {
 906         status = usb0_function_read_buffer_d1(pipe);
 907     }
 908     else
 909     {
 910         status = usb0_function_read_buffer_c(pipe);
 911     }
 912
 913     switch (status)
 914     {
 915         case USB_FUNCTION_READING:                                      /* Continue of data read */
 916         break;
 917
 918         case USB_FUNCTION_READEND:                                      /* End of data read */
 919         case USB_FUNCTION_READSHRT:                                     /* End of data read */
 920             usb0_function_disable_brdy_int(pipe);
 921             g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
 922             g_usb0_function_pipe_status[pipe]   = DEVDRV_USBF_PIPE_DONE;
 923         break;
 924
 925         case USB_FUNCTION_READOVER:                                     /* buffer over */
 926             if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE)
 927             {
 928                 USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
 929             }
 930             else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE)
 931             {
 932                 USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
 933             }
 934             else
 935             {
 936                 USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;                 /* Clear BCLR */
 937             }
 938             usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
 939             g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
 940             g_usb0_function_pipe_status[pipe]   = DEVDRV_USBF_FIFOERROR;
 941         break;
 942
 943         case DEVDRV_USBF_FIFOERROR:                                     /* FIFO access status */
 944         default:
 945             usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
 946             g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
 947         break;
 948     }
 949
 950     return status;                                                      /* End or Err or Continue */
 951 }
 952
 953 /*******************************************************************************
 954 * Function Name: usb0_function_read_buffer_c
 955 * Description  : Reads data from the buffer allocated in the pipe specified in the argument.
 956 *              : Reads data by CPU transfer using CFIFO.
 957 * Arguments    : uint16_t pipe     ; Pipe Number
 958 * Return Value : USB_FUNCTION_READEND          ; Read end
 959 *              : USB_FUNCTION_READSHRT         ; short data
 960 *              : USB_FUNCTION_READING          ; Continue of data read
 961 *              : USB_FUNCTION_READOVER         ; buffer over
 962 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
 963 *******************************************************************************/
 964 uint16_t usb0_function_read_buffer_c (uint16_t pipe)
 965 {
 966     uint32_t count;
 967     uint32_t dtln;
 968     uint16_t buffer;
 969     uint16_t mxps;
 970     uint16_t status;
 971     uint16_t mbw;
 972
 973     mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
 974     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw);
 975
 976     if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
 977     {
 978         return DEVDRV_USBF_FIFOERROR;
 979     }
 980
 981     dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
 982     mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
 983
 984     if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
 985     {
 986         status = USB_FUNCTION_READOVER;
 987         usb0_function_set_pid_nak(pipe);                        /* Set NAK */
 988         count = g_usb0_function_data_count[pipe];
 989     }
 990     else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
 991     {
 992         status = USB_FUNCTION_READEND;
 993         usb0_function_set_pid_nak(pipe);                        /* Set NAK */
 994         count = dtln;
 995
 996         if (count == 0)
 997         {
 998             status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
 999         }
1000
1001         if ((count % mxps) != 0)
1002         {
1003             status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1004         }
1005     }
1006     else                                                        /* continue Receive data */
1007     {
1008         status = USB_FUNCTION_READING;
1009         count  = dtln;
1010
1011         if (count == 0)
1012         {
1013             status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1014             usb0_function_set_pid_nak(pipe);                    /* Set NAK */
1015         }
1016
1017         if ((count % mxps) != 0)
1018         {
1019             status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1020             usb0_function_set_pid_nak(pipe);                    /* Set NAK */
1021         }
1022     }
1023
1024     if (count == 0)                                             /* 0 length packet */
1025     {
1026         USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;                 /* Clear BCLR */
1027     }
1028     else
1029     {
1030         usb0_function_read_c_fifo(pipe, (uint16_t)count);
1031     }
1032
1033     g_usb0_function_data_count[pipe] -= count;
1034
1035     return status;                                              /* End or Err or Continue */
1036 }
1037
1038 /*******************************************************************************
1039 * Function Name: usb0_function_read_buffer_d0
1040 * Description  : Reads data from the buffer allocated in the pipe specified in
1041 *              : the argument.
1042 *              : Reads data by CPU transfer using D0FIFO.
1043 * Arguments    : uint16_t pipe     ; Pipe Number
1044 * Return Value : USB_FUNCTION_READEND          ; Read end
1045 *              : USB_FUNCTION_READSHRT         ; short data
1046 *              : USB_FUNCTION_READING          ; Continue of data read
1047 *              : USB_FUNCTION_READOVER         ; buffer over
1048 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
1049 *******************************************************************************/
1050 uint16_t usb0_function_read_buffer_d0 (uint16_t pipe)
1051 {
1052     uint32_t count;
1053     uint32_t dtln;
1054     uint16_t buffer;
1055     uint16_t mxps;
1056     uint16_t status;
1057     uint16_t mbw;
1058     uint16_t pipebuf_size;
1059
1060     mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
1061     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
1062
1063     if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
1064     {
1065         return DEVDRV_USBF_FIFOERROR;
1066     }
1067
1068     dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
1069     mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
1070
1071     if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
1072     {
1073         status = USB_FUNCTION_READOVER;
1074         usb0_function_set_pid_nak(pipe);                        /* Set NAK */
1075         count = g_usb0_function_data_count[pipe];
1076     }
1077     else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
1078     {
1079         status = USB_FUNCTION_READEND;
1080         usb0_function_set_pid_nak(pipe);                        /* Set NAK */
1081         count = dtln;
1082
1083         if (count == 0)
1084         {
1085             status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1086         }
1087
1088         if ((count % mxps) != 0)
1089         {
1090             status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1091         }
1092     }
1093     else                                                        /* continue Receive data */
1094     {
1095         status = USB_FUNCTION_READING;
1096         count  = dtln;
1097
1098         if (count == 0)
1099         {
1100             status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1101             usb0_function_set_pid_nak(pipe);                    /* Set NAK */
1102         }
1103
1104         if ((count % mxps) != 0)
1105         {
1106             status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1107             usb0_function_set_pid_nak(pipe);                    /* Set NAK */
1108         }
1109         else
1110         {
1111             pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
1112
1113             if (count != pipebuf_size)
1114             {
1115                 status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
1116                 usb0_function_set_pid_nak(pipe);                /* Set NAK */
1117             }
1118         }
1119     }
1120
1121     if (count == 0)                                             /* 0 length packet */
1122     {
1123         USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
1124     }
1125     else
1126     {
1127         usb0_function_read_d0_fifo(pipe, (uint16_t)count);
1128     }
1129
1130     g_usb0_function_data_count[pipe] -= count;
1131
1132     return status;                                              /* End or Err or Continue */
1133 }
1134
1135 /*******************************************************************************
1136 * Function Name: usb0_function_read_buffer_d1
1137 * Description  : Reads data from the buffer allocated in the pipe specified
1138 *              : in the argument.
1139 *              : Reads data by CPU transfer using D1FIFO.
1140 * Arguments    : uint16_t pipe     ; Pipe Number
1141 * Return Value : USB_FUNCTION_READEND          ; Read end
1142 *              : USB_FUNCTION_READSHRT         ; short data
1143 *              : USB_FUNCTION_READING          ; Continue of data read
1144 *              : USB_FUNCTION_READOVER         ; buffer over
1145 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
1146 *******************************************************************************/
1147 uint16_t usb0_function_read_buffer_d1 (uint16_t pipe)
1148 {
1149     uint32_t count;
1150     uint32_t dtln;
1151     uint16_t buffer;
1152     uint16_t mxps;
1153     uint16_t status;
1154     uint16_t mbw;
1155     uint16_t pipebuf_size;
1156
1157     mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
1158     buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
1159
1160     if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
1161     {
1162         return DEVDRV_USBF_FIFOERROR;
1163     }
1164
1165     dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
1166     mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
1167
1168     if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
1169     {
1170         status = USB_FUNCTION_READOVER;
1171         usb0_function_set_pid_nak(pipe);                        /* Set NAK */
1172         count = g_usb0_function_data_count[pipe];
1173     }
1174     else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
1175     {
1176         status = USB_FUNCTION_READEND;
1177         usb0_function_set_pid_nak(pipe);                        /* Set NAK */
1178         count = dtln;
1179         if (count == 0)
1180         {
1181             status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1182         }
1183
1184         if ((count % mxps) != 0)
1185         {
1186             status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1187         }
1188     }
1189     else                                                        /* continue Receive data */
1190     {
1191         status = USB_FUNCTION_READING;
1192         count  = dtln;
1193         if (count == 0)
1194         {
1195             status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1196             usb0_function_set_pid_nak(pipe);                    /* Set NAK */
1197         }
1198
1199         if ((count % mxps) != 0)
1200         {
1201             status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1202             usb0_function_set_pid_nak(pipe);                    /* Set NAK */
1203         }
1204         else
1205         {
1206             pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
1207
1208             if (count != pipebuf_size)
1209             {
1210                 status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
1211                 usb0_function_set_pid_nak(pipe);                /* Set NAK */
1212             }
1213         }
1214     }
1215
1216     if (count == 0)                                             /* 0 length packet */
1217     {
1218         USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
1219     }
1220     else
1221     {
1222         usb0_function_read_d1_fifo(pipe, (uint16_t)count);
1223     }
1224
1225     g_usb0_function_data_count[pipe] -= count;
1226
1227     return status;                                              /* End or Err or Continue */
1228 }
1229
1230 /*******************************************************************************
1231 * Function Name: usb0_function_read_dma
1232 * Description  : Reads data from the buffer allocated in the pipe specified
1233 *              : in the argument.
1234 *              : Reads data by DMA transfer using D0FIFO or D1FIFO.
1235 * Arguments    : uint16_t pipe     ; Pipe Number
1236 * Return Value : USB_FUNCTION_READEND          ; Read end
1237 *              : USB_FUNCTION_READSHRT         ; short data
1238 *              : USB_FUNCTION_READING          ; Continue of data read
1239 *              : USB_FUNCTION_READOVER         ; buffer over
1240 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
1241 *******************************************************************************/
1242 uint16_t usb0_function_read_dma (uint16_t pipe)
1243 {
1244     uint16_t status;
1245
1246     g_usb0_function_PipeIgnore[pipe] = 0;
1247     if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA)
1248     {
1249         status = usb0_function_read_dma_d0(pipe);
1250     }
1251     else
1252     {
1253         status = usb0_function_read_dma_d1(pipe);
1254     }
1255
1256     switch (status)
1257     {
1258         case USB_FUNCTION_READING:                                      /* Continue of data read */
1259         break;
1260
1261         case USB_FUNCTION_READZERO:                                     /* End of data read */
1262             usb0_function_disable_brdy_int(pipe);
1263             g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
1264         break;
1265
1266         case USB_FUNCTION_READEND:                                      /* End of data read */
1267         case USB_FUNCTION_READSHRT:                                     /* End of data read */
1268             usb0_function_disable_brdy_int(pipe);
1269
1270             if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
1271             {
1272                 g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
1273             }
1274         break;
1275
1276         case USB_FUNCTION_READOVER:                                     /* buffer over */
1277             usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
1278
1279             if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
1280             {
1281                 g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
1282             }
1283             g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
1284         break;
1285
1286         case DEVDRV_USBF_FIFOERROR:                                     /* FIFO access status */
1287         default:
1288             usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
1289             g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
1290         break;
1291     }
1292
1293     return status;                                                      /* End or Err or Continue */
1294 }
1295
1296 /*******************************************************************************
1297 * Function Name: usb0_function_read_dma_d0
1298 * Description  : Writes data in the buffer allocated in the pipe specified
1299 *              : in the argument.
1300 *              : Reads data by DMA transfer using D0FIFO.
1301 * Arguments    : uint16_t pipe     ; Pipe Number
1302 * Return Value : USB_FUNCTION_READEND          ; Read end
1303 *              : USB_FUNCTION_READSHRT         ; short data
1304 *              : USB_FUNCTION_READZERO         ; zero data
1305 *              : USB_FUNCTION_READING          ; Continue of data read
1306 *              : USB_FUNCTION_READOVER         ; buffer over
1307 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
1308 *******************************************************************************/
1309 static uint16_t usb0_function_read_dma_d0 (uint16_t pipe)
1310 {
1311     uint32_t count;
1312     uint32_t dtln;
1313     uint16_t buffer;
1314     uint16_t mxps;
1315     uint16_t status;
1316     uint16_t mbw;
1317     uint16_t dfacc = 0;
1318     uint16_t pipebuf_size;
1319
1320     g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY;
1321
1322     mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
1323
1324     if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
1325     {
1326         count  = g_usb0_function_data_count[pipe];
1327         status = USB_FUNCTION_READING;
1328     }
1329     else
1330     {
1331         buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw);
1332
1333         if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
1334         {
1335             return DEVDRV_USBF_FIFOERROR;
1336         }
1337
1338         dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
1339         mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
1340
1341         if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
1342         {
1343             status = USB_FUNCTION_READOVER;
1344             count  = g_usb0_function_data_count[pipe];
1345         }
1346         else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
1347         {
1348             status = USB_FUNCTION_READEND;
1349             count  = dtln;
1350             if (count == 0)
1351             {
1352                 status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1353             }
1354
1355             if ((count % mxps) != 0)
1356             {
1357                 status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1358             }
1359         }
1360         else                                                        /* continue Receive data */
1361         {
1362             status = USB_FUNCTION_READING;
1363             count  = dtln;
1364
1365             if (count == 0)
1366             {
1367                 status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1368             }
1369
1370             if ((count % mxps) != 0)
1371             {
1372                 status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1373             }
1374             else
1375             {
1376                 pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
1377                 if (count != pipebuf_size)
1378                 {
1379                     status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
1380                 }
1381             }
1382         }
1383     }
1384
1385     if (count == 0)                                                 /* 0 length packet */
1386     {
1387         if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
1388         {
1389             USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
1390             status = USB_FUNCTION_READZERO;                         /* Null Packet receive */
1391         }
1392         else
1393         {
1394             usb0_function_set_curpipe(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw);
1395                                                                     /* transaction counter No set */
1396                                                                     /* FRDY = 1, DTLN = 0 -> BRDY */
1397         }
1398     }
1399     else
1400     {
1401         dfacc = usb0_function_set_dfacc_d0(mbw, count);
1402
1403         if (mbw == USB_FUNCTION_BITMBW_32)
1404         {
1405             g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2;  /* 32bit transfer */
1406         }
1407         else if (mbw == USB_FUNCTION_BITMBW_16)
1408         {
1409             g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1;  /* 16bit transfer */
1410         }
1411         else
1412         {
1413             g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0;  /* 8bit transfer */
1414         }
1415
1416         g_usb0_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe;        /* not use in read operation */
1417         g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 0;           /* not use in read operation */
1418
1419         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo   = USB_FUNCTION_D0FIFO_DMA;
1420         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].dir    = USB_FUNCTION_FIFO2BUF;
1421         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
1422         g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes  = count;
1423
1424         if (status == USB_FUNCTION_READING)
1425         {
1426             g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSY;
1427         }
1428         else
1429         {
1430             g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSYEND;
1431         }
1432
1433         Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc);
1434
1435         usb0_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc);
1436
1437         RZA_IO_RegWrite_16(&USB200.D0FIFOSEL,
1438                             1,
1439                             USB_DnFIFOSEL_DREQE_SHIFT,
1440                             USB_DnFIFOSEL_DREQE);
1441     }
1442
1443     if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
1444     {
1445         g_usb0_function_data_count[pipe]   -= count;
1446         g_usb0_function_data_pointer[pipe] += count;
1447         g_usb0_function_PipeDataSize[pipe] += count;
1448     }
1449
1450     return status;                                                  /* End or Err or Continue */
1451 }
1452
1453 /*******************************************************************************
1454 * Function Name: usb0_function_read_dma_d1
1455 * Description  : Reads data from the buffer allocated in the pipe specified in
1456 *              : the argument.
1457 *              : Reads data by DMA transfer using D1FIFO.
1458 * Arguments    : uint16_t pipe     ; Pipe Number
1459 * Return Value : USB_FUNCTION_READEND          ; Read end
1460 *              : USB_FUNCTION_READSHRT         ; short data
1461 *              : USB_FUNCTION_READZERO         ; zero data
1462 *              : USB_FUNCTION_READING          ; Continue of data read
1463 *              : USB_FUNCTION_READOVER         ; buffer over
1464 *              : DEVDRV_USBF_FIFOERROR         ; FIFO status
1465 *******************************************************************************/
1466 static uint16_t usb0_function_read_dma_d1 (uint16_t pipe)
1467 {
1468     uint32_t count;
1469     uint32_t dtln;
1470     uint16_t buffer;
1471     uint16_t mxps;
1472     uint16_t status;
1473     uint16_t mbw;
1474     uint16_t dfacc=0;
1475     uint16_t pipebuf_size;
1476
1477     g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY;
1478
1479     mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
1480
1481     if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
1482     {
1483         count  = g_usb0_function_data_count[pipe];
1484         status = USB_FUNCTION_READING;
1485     }
1486     else
1487     {
1488         buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw);
1489         if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
1490         {
1491             return DEVDRV_USBF_FIFOERROR;
1492         }
1493
1494         dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
1495         mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
1496
1497         if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
1498         {
1499             status = USB_FUNCTION_READOVER;
1500             count  = g_usb0_function_data_count[pipe];
1501         }
1502         else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
1503         {
1504             status = USB_FUNCTION_READEND;
1505             count  = dtln;
1506             if (count == 0)
1507             {
1508                 status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1509             }
1510
1511             if ((count % mxps) != 0)
1512             {
1513                 status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1514             }
1515         }
1516         else                                                        /* continue Receive data */
1517         {
1518             status = USB_FUNCTION_READING;
1519             count  = dtln;
1520             if (count == 0)
1521             {
1522                 status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
1523             }
1524
1525             if ((count % mxps) != 0)
1526             {
1527                 status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
1528             }
1529             else
1530             {
1531                 pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
1532                 if (count != pipebuf_size)
1533                 {
1534                     status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
1535                 }
1536             }
1537         }
1538     }
1539
1540     if (count == 0)                                                 /* 0 length packet */
1541     {
1542         if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
1543         {
1544             USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
1545             status = USB_FUNCTION_READZERO;                         /* Null Packet receive */
1546         }
1547         else
1548         {
1549             usb0_function_set_curpipe(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw);
1550                                                                     /* transaction counter No set */
1551                                                                     /* FRDY = 1, DTLN = 0 -> BRDY */
1552         }
1553     }
1554     else
1555     {
1556         dfacc = usb0_function_set_dfacc_d1(mbw, count);
1557
1558         if (mbw == USB_FUNCTION_BITMBW_32)
1559         {
1560             g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2;  /* 32bit transfer */
1561         }
1562         else if (mbw == USB_FUNCTION_BITMBW_16)
1563         {
1564             g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1;  /* 16bit transfer */
1565         }
1566         else
1567         {
1568             g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0;  /* 8bit transfer */
1569         }
1570
1571         g_usb0_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe;        /* not use in read operation */
1572         g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 0;           /* not use in read operation */
1573
1574         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo   = USB_FUNCTION_D1FIFO_DMA;
1575         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].dir    = USB_FUNCTION_FIFO2BUF;
1576         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
1577         g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes  = count;
1578
1579         if (status == USB_FUNCTION_READING)
1580         {
1581             g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSY;
1582         }
1583         else
1584         {
1585             g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSYEND;
1586         }
1587
1588         Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc);
1589
1590         usb0_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc);
1591
1592         RZA_IO_RegWrite_16(&USB200.D1FIFOSEL,
1593                             1,
1594                             USB_DnFIFOSEL_DREQE_SHIFT,
1595                             USB_DnFIFOSEL_DREQE);
1596     }
1597
1598     if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
1599     {
1600         g_usb0_function_data_count[pipe]   -= count;
1601         g_usb0_function_data_pointer[pipe] += count;
1602         g_usb0_function_PipeDataSize[pipe] += count;
1603     }
1604
1605     return status;                                                  /* End or Err or Continue */
1606 }
1607
1608 /*******************************************************************************
1609 * Function Name: usb0_function_change_fifo_port
1610 * Description  : Allocates FIF0 specified by the argument in the pipe assigned
1611 *              : by the argument. After allocating FIF0, waits in the software
1612 *              : till the corresponding pipe becomes ready.
1613 * Arguments    : uint16_t pipe      ; Pipe Number
1614 *              : uint16_t fifosel   ; Select FIFO
1615 *              : uint16_t isel      ; FIFO Access Direction
1616 *              : uint16_t mbw       ; FIFO Port Access Bit Width
1617 * Return Value : DEVDRV_USBF_FIFOERROR         ; Error
1618 *              : Others            ; CFIFOCTR/D0FIFOCTR/D1FIFOCTR Register Value
1619 *******************************************************************************/
1620 uint16_t usb0_function_change_fifo_port (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw)
1621 {
1622     uint16_t buffer;
1623     uint32_t loop;
1624     volatile uint32_t loop2;
1625
1626     usb0_function_set_curpipe(pipe, fifosel, isel, mbw);
1627
1628     for (loop = 0; loop < 4; loop++)
1629     {
1630         switch (fifosel)
1631         {
1632             case USB_FUNCTION_CUSE:
1633                 buffer = USB200.CFIFOCTR;
1634             break;
1635
1636             case USB_FUNCTION_D0USE:
1637             case USB_FUNCTION_D0DMA:
1638                 buffer = USB200.D0FIFOCTR;
1639             break;
1640
1641             case USB_FUNCTION_D1USE:
1642             case USB_FUNCTION_D1DMA:
1643                 buffer = USB200.D1FIFOCTR;
1644             break;
1645
1646             default:
1647                 buffer = 0;
1648             break;
1649         }
1650
1651         if ((buffer & USB_FUNCTION_BITFRDY) == USB_FUNCTION_BITFRDY)
1652         {
1653             return buffer;
1654         }
1655
1656         loop2 = 25;
1657         while (loop2-- > 0)
1658         {
1659             /* wait */
1660         }
1661     }
1662
1663     return DEVDRV_USBF_FIFOERROR;
1664 }
1665
1666 /*******************************************************************************
1667 * Function Name: usb0_function_set_curpipe
1668 * Description  : Allocates FIF0 specified by the argument in the pipe assigned
1669 *              : by the argument.
1670 * Arguments    : uint16_t pipe      ; Pipe Number
1671 *              : uint16_t fifosel   ; Select FIFO
1672 *              : uint16_t isel      ; FIFO Access Direction
1673 *              : uint16_t mbw       ; FIFO Port Access Bit Width
1674 * Return Value : none
1675 *******************************************************************************/
1676 void usb0_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw)
1677 {
1678     uint16_t buffer;
1679     uint32_t loop;
1680     volatile uint32_t loop2;
1681
1682     g_usb0_function_mbw[pipe] = mbw;
1683
1684     switch (fifosel)
1685     {
1686         case USB_FUNCTION_CUSE:
1687             buffer  = USB200.CFIFOSEL;
1688             buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE);
1689             buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL);
1690             USB200.CFIFOSEL = buffer;
1691
1692             for (loop = 0; loop < 4; loop++)
1693             {
1694                 if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
1695                         (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
1696                 {
1697                     break;
1698                 }
1699
1700                 loop2 = 100;
1701
1702                 while (loop2-- > 0)
1703                 {
1704                     /* wait */
1705                 }
1706             }
1707             buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1708             buffer |= (uint16_t)(isel | pipe | mbw);
1709             USB200.CFIFOSEL = buffer;
1710
1711             for (loop = 0; loop < 4; loop++)
1712             {
1713                 if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
1714                         (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
1715                 {
1716                     break;
1717                 }
1718
1719                 loop2 = 100;
1720
1721                 while (loop2-- > 0)
1722                 {
1723                     /* wait */
1724                 }
1725             }
1726         break;
1727
1728         case USB_FUNCTION_D0DMA:
1729         case USB_FUNCTION_D0USE:
1730             buffer  = USB200.D0FIFOSEL;
1731             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
1732             USB200.D0FIFOSEL = buffer;
1733
1734             for (loop = 0; loop < 4; loop++)
1735             {
1736                 if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
1737                         (buffer & USB_FUNCTION_BITCURPIPE))
1738                 {
1739                     break;
1740                 }
1741
1742                 loop2 = 100;
1743
1744                 while (loop2-- > 0)
1745                 {
1746                     /* wait */
1747                 }
1748             }
1749             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1750             buffer |= (uint16_t)(pipe | mbw);
1751             USB200.D0FIFOSEL = buffer;
1752
1753             for (loop = 0; loop < 4; loop++)
1754             {
1755                 if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
1756                         (buffer & USB_FUNCTION_BITCURPIPE))
1757                 {
1758                     break;
1759                 }
1760
1761                 loop2 = 100;
1762                 while (loop2-- > 0)
1763                 {
1764                     /* wait */
1765                 }
1766             }
1767         break;
1768
1769         case USB_FUNCTION_D1DMA:
1770         case USB_FUNCTION_D1USE:
1771             buffer  = USB200.D1FIFOSEL;
1772             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
1773             USB200.D1FIFOSEL = buffer;
1774
1775             for (loop = 0; loop < 4; loop++)
1776             {
1777                 if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
1778                         (buffer & USB_FUNCTION_BITCURPIPE))
1779                 {
1780                     break;
1781                 }
1782
1783                 loop2 = 100;
1784
1785                 while (loop2-- > 0)
1786                 {
1787                     /* wait */
1788                 }
1789             }
1790             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1791             buffer |= (uint16_t)(pipe | mbw);
1792             USB200.D1FIFOSEL = buffer;
1793
1794             for (loop = 0; loop < 4; loop++)
1795             {
1796                 if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
1797                         (buffer & USB_FUNCTION_BITCURPIPE))
1798                 {
1799                     break;
1800                 }
1801
1802                 loop2 = 100;
1803
1804                 while (loop2-- > 0)
1805                 {
1806                     /* wait */
1807                 }
1808             }
1809         break;
1810
1811         default:
1812         break;
1813     }
1814
1815     /* Cautions !!!
1816      * Depending on the external bus speed of CPU, you may need to wait for 450ns here.
1817      * For details, please look at the data sheet.   */
1818     loop2 = 100;
1819
1820     while (loop2-- > 0)
1821     {
1822         /* wait */
1823     }
1824 }
1825
1826 /*******************************************************************************
1827 * Function Name: usb0_function_set_curpipe2
1828 * Description  : Allocates FIF0 specified by the argument in the pipe assigned
1829 *              : by the argument.
1830 * Arguments    : uint16_t pipe      ; Pipe Number
1831 *              : uint16_t fifosel   ; Select FIFO
1832 *              : uint16_t isel      ; FIFO Access Direction
1833 *              : uint16_t mbw       ; FIFO Port Access Bit Width
1834 *              : uint16_t dfacc     ; DFACC Access mode
1835 * Return Value : none
1836 *******************************************************************************/
1837 void usb0_function_set_curpipe2 (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc)
1838 {
1839     uint16_t buffer;
1840     uint32_t loop;
1841 #ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
1842     uint32_t dummy;
1843 #endif
1844     volatile uint32_t loop2;
1845
1846     g_usb0_function_mbw[pipe] = mbw;
1847
1848     switch (fifosel)
1849     {
1850         case USB_FUNCTION_CUSE:
1851             buffer  = USB200.CFIFOSEL;
1852             buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE);
1853             buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL);
1854             USB200.CFIFOSEL = buffer;
1855
1856             for (loop = 0; loop < 4; loop++)
1857             {
1858                 if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
1859                         (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
1860                 {
1861                     break;
1862                 }
1863
1864                 loop2 = 100;
1865                 while (loop2-- > 0)
1866                 {
1867                     /* wait */
1868                 }
1869             }
1870             buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1871             buffer |= (uint16_t)(isel | pipe | mbw);
1872             USB200.CFIFOSEL = buffer;
1873
1874             for (loop = 0; loop < 4; loop++)
1875             {
1876                 if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
1877                         (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
1878                 {
1879                     break;
1880                 }
1881
1882                 loop2 = 100;
1883
1884                 while (loop2-- > 0)
1885                 {
1886                     /* wait */
1887                 }
1888             }
1889         break;
1890
1891         case USB_FUNCTION_D0DMA:
1892         case USB_FUNCTION_D0USE:
1893             buffer  = USB200.D0FIFOSEL;
1894 #ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
1895             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1896
1897             if (dfacc != 0)
1898             {
1899                 buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32);
1900             }
1901 #else
1902             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
1903 #endif
1904             USB200.D0FIFOSEL = buffer;
1905
1906             for (loop = 0; loop < 4; loop++)
1907             {
1908                 if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
1909                 {
1910                     break;
1911                 }
1912
1913                 loop2 = 100;
1914
1915                 while (loop2-- > 0)
1916                 {
1917                     /* wait */
1918                 }
1919             }
1920
1921 #ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
1922             if (dfacc != 0)
1923             {
1924                 dummy = USB200.D0FIFO.UINT32;
1925             }
1926 #endif
1927             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1928             buffer |= (uint16_t)(pipe | mbw);
1929             USB200.D0FIFOSEL = buffer;
1930
1931             for (loop = 0; loop < 4; loop++)
1932             {
1933                 if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
1934                 {
1935                     break;
1936                 }
1937
1938                 loop2 = 100;
1939
1940                 while (loop2-- > 0)
1941                 {
1942                     /* wait */
1943                 }
1944             }
1945         break;
1946
1947         case USB_FUNCTION_D1DMA:
1948         case USB_FUNCTION_D1USE:
1949             buffer  = USB200.D1FIFOSEL;
1950 #ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
1951             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1952
1953             if (dfacc != 0)
1954             {
1955                 buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32);
1956             }
1957 #else
1958             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
1959 #endif
1960             USB200.D1FIFOSEL = buffer;
1961
1962             for (loop = 0; loop < 4; loop++)
1963             {
1964                 if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
1965                 {
1966                     break;
1967                 }
1968
1969                 loop2 = 100;
1970
1971                 while (loop2-- > 0)
1972                 {
1973                     /* wait */
1974                 }
1975             }
1976 #ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
1977             if (dfacc != 0)
1978             {
1979                 dummy = USB200.D1FIFO.UINT32;
1980                 loop = dummy;                   // avoid warning.
1981             }
1982 #endif
1983             buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
1984             buffer |= (uint16_t)(pipe | mbw);
1985             USB200.D1FIFOSEL = buffer;
1986
1987             for (loop = 0; loop < 4; loop++)
1988             {
1989                 if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
1990                 {
1991                     break;
1992                 }
1993
1994                 loop2 = 100;
1995
1996                 while (loop2-- > 0)
1997                 {
1998                     /* wait */
1999                 }
2000             }
2001         break;
2002
2003         default:
2004         break;
2005     }
2006
2007     /* Cautions !!!
2008      * Depending on the external bus speed of CPU, you may need to wait for 450ns here.
2009      * For details, please look at the data sheet.   */
2010     loop2 = 100;
2011
2012     while (loop2-- > 0)
2013     {
2014         /* wait */
2015     }
2016 }
2017
2018 /*******************************************************************************
2019 * Function Name: usb0_function_write_c_fifo
2020 * Description  : Writes data in CFIFO.
2021 *              : Writes data by BYTE/WORD/LONG according to access size
2022 *              : to the pipe specified by the arguments.
2023 *              : Before executing this function, allocating CFIF0 in the specified pipe
2024 *              : should be completed.
2025 *              : Before executing this function, access size to the specified pipe
2026 *              : should be fixed and set in g_usb0_function_mbw[].
2027 * Arguments    : uint16_t pipe      ; Pipe Number
2028 *              : uint16_t count     ; Data Size(Byte)
2029 * Return Value : none
2030 *******************************************************************************/
2031 static void usb0_function_write_c_fifo (uint16_t pipe, uint16_t count)
2032 {
2033     uint16_t even;
2034
2035     if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
2036     {
2037         for (even = count; even; --even)
2038         {
2039             USB200.CFIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe];
2040             g_usb0_function_data_pointer[pipe] += 1;
2041         }
2042     }
2043     else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
2044     {
2045         for (even = (uint16_t)(count / 2); even; --even)
2046         {
2047             USB200.CFIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]);
2048             g_usb0_function_data_pointer[pipe] += 2;
2049         }
2050     }
2051     else
2052     {
2053         for (even = (uint16_t)(count / 4); even; --even)
2054         {
2055             USB200.CFIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]);
2056             g_usb0_function_data_pointer[pipe] += 4;
2057         }
2058     }
2059 }
2060
2061 /*******************************************************************************
2062 * Function Name: usb0_function_read_c_fifo
2063 * Description  : Reads data from CFIFO.
2064 *              : Reads data by BYTE/WORD/LONG according to access size
2065 *              : to the pipe specified by the arguments.
2066 *              : Before executing this function, allocating CFIF0 in the specified pipe
2067 *              : should be completed.
2068 *              : Before executing this function, access size to the specified pipe
2069 *              : should be fixed and set in g_usb0_function_mbw[].
2070 * Arguments    : uint16_t pipe      ; Pipe Number
2071 *              : uint16_t count     ; Data Size(Byte)
2072 * Return Value : none
2073 *******************************************************************************/
2074 static void usb0_function_read_c_fifo (uint16_t pipe, uint16_t count)
2075 {
2076     uint16_t even;
2077
2078     if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
2079     {
2080         for (even = count; even; --even)
2081         {
2082             *g_usb0_function_data_pointer[pipe] = USB200.CFIFO.UINT8[HH];
2083             g_usb0_function_data_pointer[pipe] += 1;
2084         }
2085     }
2086     else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
2087     {
2088         for (even = (uint16_t)((count + 1) / 2); even; --even)
2089         {
2090             *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.CFIFO.UINT16[H];
2091             g_usb0_function_data_pointer[pipe] += 2;
2092         }
2093     }
2094     else
2095     {
2096         for (even = (uint16_t)((count + 3) / 4); even; --even)
2097         {
2098             *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.CFIFO.UINT32;
2099             g_usb0_function_data_pointer[pipe] += 4;
2100         }
2101     }
2102 }
2103
2104 /*******************************************************************************
2105 * Function Name: usb0_function_write_d0_fifo
2106 * Description  : Writes data in D0FIFO.
2107 *              : Writes data by BYTE/WORD/LONG according to access size
2108 *              : to the pipe specified by the arguments.
2109 *              : Before executing this function, allocating CFIF0 in the specified pipe
2110 *              : should be completed.
2111 *              : Before executing this function, access size to the specified pipe
2112 *              : should be fixed and set in g_usb0_function_mbw[].
2113 * Arguments    : uint16_t pipe      ; Pipe Number
2114 *              : uint16_t count     ; Data Size(Byte)
2115 * Return Value : none
2116 *******************************************************************************/
2117 static void usb0_function_write_d0_fifo (uint16_t pipe, uint16_t count)
2118 {
2119     uint16_t even;
2120
2121     if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
2122     {
2123         for (even = count; even; --even)
2124         {
2125             USB200.D0FIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe];
2126             g_usb0_function_data_pointer[pipe] += 1;
2127         }
2128     }
2129     else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
2130     {
2131         for (even = (uint16_t)(count / 2); even; --even)
2132         {
2133             USB200.D0FIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]);
2134             g_usb0_function_data_pointer[pipe] += 2;
2135         }
2136     }
2137     else
2138     {
2139         for (even = (uint16_t)(count / 4); even; --even)
2140         {
2141             USB200.D0FIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]);
2142             g_usb0_function_data_pointer[pipe] += 4;
2143         }
2144     }
2145 }
2146
2147 /*******************************************************************************
2148 * Function Name: usb0_function_read_d0_fifo
2149 * Description  : Reads data from D0FIFO.
2150 *              : Reads data by BYTE/WORD/LONG according to access size
2151 *              : to the pipe specified by the arguments.
2152 *              : Before executing this function, allocating DOFIF0 in the specified pipe
2153 *              : should be completed.
2154 *              : Before executing this function, access size to the specified pipe
2155 *              : should be fixed and set in g_usb0_function_mbw[].
2156 * Arguments    : uint16_t pipe      ; Pipe Number
2157 *              : uint16_t count     ; Data Size(Byte)
2158 * Return Value : none
2159 *******************************************************************************/
2160 static void usb0_function_read_d0_fifo (uint16_t pipe, uint16_t count)
2161 {
2162     uint16_t even;
2163
2164     if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
2165     {
2166         for (even = count; even; --even)
2167         {
2168             *g_usb0_function_data_pointer[pipe] = USB200.D0FIFO.UINT8[HH];
2169             g_usb0_function_data_pointer[pipe] += 1;
2170         }
2171     }
2172     else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
2173     {
2174         for (even = (uint16_t)((count + 1) / 2); even; --even)
2175         {
2176             *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.D0FIFO.UINT16[H];
2177             g_usb0_function_data_pointer[pipe] += 2;
2178         }
2179     }
2180     else
2181     {
2182         for (even = (uint16_t)((count + 3) / 4); even; --even)
2183         {
2184             *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.D0FIFO.UINT32;
2185             g_usb0_function_data_pointer[pipe] += 4;
2186         }
2187     }
2188 }
2189
2190 /*******************************************************************************
2191 * Function Name: usb0_function_write_d1_fifo
2192 * Description  : Writes data in D1FIFO.
2193 *              : Writes data by BYTE/WORD/LONG according to access size
2194 *              : to the pipe specified by the arguments.
2195 *              : Before executing this function, allocating D1FIF0 in the specified pipe
2196 *              : should be completed.
2197 *              : Before executing this function, access size to the specified pipe
2198 *              : should be fixed and set in g_usb0_function_mbw[].
2199 * Arguments    : uint16_t pipe      ; Pipe Number
2200 *              : uint16_t count     ; Data Size(Byte)
2201 * Return Value : none
2202 *******************************************************************************/
2203 static void usb0_function_write_d1_fifo (uint16_t pipe, uint16_t count)
2204 {
2205     uint16_t even;
2206
2207     if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
2208     {
2209         for (even = count; even; --even)
2210         {
2211             USB200.D1FIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe];
2212             g_usb0_function_data_pointer[pipe] += 1;
2213         }
2214     }
2215     else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
2216     {
2217         for (even = (uint16_t)(count / 2); even; --even)
2218         {
2219             USB200.D1FIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]);
2220             g_usb0_function_data_pointer[pipe] += 2;
2221         }
2222     }
2223     else
2224     {
2225         for (even = (uint16_t)(count / 4); even; --even)
2226         {
2227             USB200.D1FIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]);
2228             g_usb0_function_data_pointer[pipe] += 4;
2229         }
2230     }
2231 }
2232
2233 /*******************************************************************************
2234 * Function Name: usb0_function_read_d1_fifo
2235 * Description  : Reads data from D1FIFO.
2236 *              : Reads data by BYTE/WORD/LONG according to access size
2237 *              : to the pipe specified by the arguments.
2238 *              : Before executing this function, allocating D1FIF0 in the specified pipe
2239 *              : should be completed.
2240 *              : Before executing this function, access size to the specified pipe
2241 *              : should be fixed and set in g_usb0_function_mbw[].
2242 * Arguments    : uint16_t pipe      ; Pipe Number
2243 *              : uint16_t count     ; Data Size(Byte)
2244 * Return Value : none
2245 *******************************************************************************/
2246 static void usb0_function_read_d1_fifo (uint16_t pipe, uint16_t count)
2247 {
2248     uint16_t even;
2249
2250     if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
2251     {
2252         for (even = count; even; --even)
2253         {
2254             *g_usb0_function_data_pointer[pipe] = USB200.D1FIFO.UINT8[HH];
2255             g_usb0_function_data_pointer[pipe] += 1;
2256         }
2257     }
2258     else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
2259     {
2260         for (even = (uint16_t)((count + 1) / 2); even; --even)
2261         {
2262             *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.D1FIFO.UINT16[H];
2263             g_usb0_function_data_pointer[pipe] += 2;
2264         }
2265     }
2266     else
2267     {
2268         for (even = (uint16_t)((count + 3) / 4); even; --even)
2269         {
2270             *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.D1FIFO.UINT32;
2271             g_usb0_function_data_pointer[pipe] += 4;
2272         }
2273     }
2274 }
2275
2276 /*******************************************************************************
2277 * Function Name: usb0_function_com_get_dmasize
2278 * Description  : Calculates access width of DMA transfer by the argument to
2279 *              : return as the Return Value.
2280 * Arguments    : uint32_t trncount   : transfer byte
2281 *              : uint32_t dtptr      : transfer data pointer
2282 * Return Value : DMA transfer size    : 0   8bit
2283 *              :                      : 1  16bit
2284 *              :                      : 2  32bit
2285 *******************************************************************************/
2286 static uint32_t usb0_function_com_get_dmasize (uint32_t trncount, uint32_t dtptr)
2287 {
2288     uint32_t size;
2289
2290     if (((trncount & 0x0001) != 0) || ((dtptr & 0x00000001) != 0))
2291     {
2292         /*  When transfer byte count is odd         */
2293         /* or transfer data area is 8-bit alignment */
2294         size = 0;           /* 8bit */
2295     }
2296     else if (((trncount & 0x0003) != 0) || ((dtptr & 0x00000003) != 0))
2297     {
2298         /* When the transfer byte count is multiples of 2 */
2299         /* or the transfer data area is 16-bit alignment */
2300         size = 1;           /* 16bit */
2301     }
2302     else
2303     {
2304         /* When the transfer byte count is multiples of 4 */
2305         /* or the transfer data area is 32-bit alignment */
2306         size = 2;           /* 32bit */
2307     }
2308
2309     return size;
2310 }
2311
2312 /*******************************************************************************
2313 * Function Name: usb0_function_get_mbw
2314 * Description  : Calculates access width of DMA to return the value set in MBW.
2315 * Arguments    : uint32_t trncount   : transfer byte
2316 *              : uint32_t dtptr      : transfer data pointer
2317 * Return Value : FIFO transfer size   : USB_FUNCTION_BITMBW_8    8bit
2318 *              :                      : USB_FUNCTION_BITMBW_16  16bit
2319 *              :                      : USB_FUNCTION_BITMBW_32  32bit
2320 *******************************************************************************/
2321 uint16_t usb0_function_get_mbw (uint32_t trncount, uint32_t dtptr)
2322 {
2323     uint32_t size;
2324     uint16_t mbw;
2325
2326     size = usb0_function_com_get_dmasize(trncount, dtptr);
2327
2328     if (size == 0)
2329     {
2330         /* 8bit */
2331         mbw = USB_FUNCTION_BITMBW_8;
2332     }
2333     else if (size == 1)
2334     {
2335         /* 16bit */
2336         mbw = USB_FUNCTION_BITMBW_16;
2337     }
2338     else
2339     {
2340         /* 32bit */
2341         mbw = USB_FUNCTION_BITMBW_32;
2342     }
2343
2344     return mbw;
2345 }
2346
2347 /*******************************************************************************
2348 * Function Name: usb0_function_set_transaction_counter
2349 * Description  : Sets transaction counter by the argument(PIPEnTRN).
2350 *              : Clears transaction before setting to enable transaction counter setting.
2351 * Arguments    : uint16_t pipe     ; Pipe number
2352 *              : uint32_t bsize    : Data transfer size
2353 * Return Value : none
2354 *******************************************************************************/
2355 static void usb0_function_set_transaction_counter (uint16_t pipe, uint32_t bsize)
2356 {
2357     uint16_t mxps;
2358     uint16_t cnt;
2359
2360     if (bsize  == 0)
2361     {
2362         return;
2363     }
2364
2365     mxps = usb0_function_get_mxps(pipe);            /* Max Packet Size */
2366
2367     if ((bsize % mxps) == 0)
2368     {
2369         cnt = (uint16_t)(bsize / mxps);
2370     }
2371     else
2372     {
2373         cnt = (uint16_t)((bsize / mxps) + 1);
2374     }
2375
2376     switch (pipe)
2377     {
2378         case USB_FUNCTION_PIPE1:
2379             RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
2380                                 1,
2381                                 USB_PIPEnTRE_TRCLR_SHIFT,
2382                                 USB_PIPEnTRE_TRCLR);
2383             USB200.PIPE1TRN             = cnt;
2384             RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
2385                                 1,
2386                                 USB_PIPEnTRE_TRENB_SHIFT,
2387                                 USB_PIPEnTRE_TRENB);
2388         break;
2389
2390         case USB_FUNCTION_PIPE2:
2391             RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
2392                                 1,
2393                                 USB_PIPEnTRE_TRCLR_SHIFT,
2394                                 USB_PIPEnTRE_TRCLR);
2395             USB200.PIPE2TRN             = cnt;
2396             RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
2397                                 1,
2398                                 USB_PIPEnTRE_TRENB_SHIFT,
2399                                 USB_PIPEnTRE_TRENB);
2400         break;
2401
2402         case USB_FUNCTION_PIPE3:
2403             RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
2404                                 1,
2405                                 USB_PIPEnTRE_TRCLR_SHIFT,
2406                                 USB_PIPEnTRE_TRCLR);
2407             USB200.PIPE3TRN             = cnt;
2408             RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
2409                                 1,
2410                                 USB_PIPEnTRE_TRENB_SHIFT,
2411                                 USB_PIPEnTRE_TRENB);
2412         break;
2413
2414         case USB_FUNCTION_PIPE4:
2415             RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
2416                                 1,
2417                                 USB_PIPEnTRE_TRCLR_SHIFT,
2418                                 USB_PIPEnTRE_TRCLR);
2419             USB200.PIPE4TRN             = cnt;
2420             RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
2421                                 1,
2422                                 USB_PIPEnTRE_TRENB_SHIFT,
2423                                 USB_PIPEnTRE_TRENB);
2424         break;
2425
2426         case USB_FUNCTION_PIPE5:
2427             RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
2428                                 1,
2429                                 USB_PIPEnTRE_TRCLR_SHIFT,
2430                                 USB_PIPEnTRE_TRCLR);
2431             USB200.PIPE5TRN             = cnt;
2432             RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
2433                                 1,
2434                                 USB_PIPEnTRE_TRENB_SHIFT,
2435                                 USB_PIPEnTRE_TRENB);
2436         break;
2437
2438         case USB_FUNCTION_PIPE9:
2439             RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
2440                                 1,
2441                                 USB_PIPEnTRE_TRCLR_SHIFT,
2442                                 USB_PIPEnTRE_TRCLR);
2443             USB200.PIPE9TRN             = cnt;
2444             RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
2445                                 1,
2446                                 USB_PIPEnTRE_TRENB_SHIFT,
2447                                 USB_PIPEnTRE_TRENB);
2448         break;
2449
2450         case USB_FUNCTION_PIPEA:
2451             RZA_IO_RegWrite_16(&USB200.PIPEATRE,
2452                                 1,
2453                                 USB_PIPEnTRE_TRCLR_SHIFT,
2454                                 USB_PIPEnTRE_TRCLR);
2455             USB200.PIPEATRN             = cnt;
2456             RZA_IO_RegWrite_16(&USB200.PIPEATRE,
2457                                 1,
2458                                 USB_PIPEnTRE_TRENB_SHIFT,
2459                                 USB_PIPEnTRE_TRENB);
2460         break;
2461
2462         case USB_FUNCTION_PIPEB:
2463             RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
2464                                 1,
2465                                 USB_PIPEnTRE_TRCLR_SHIFT,
2466                                 USB_PIPEnTRE_TRCLR);
2467             USB200.PIPEBTRN             = cnt;
2468             RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
2469                                 1,
2470                                 USB_PIPEnTRE_TRENB_SHIFT,
2471                                 USB_PIPEnTRE_TRENB);
2472         break;
2473
2474         case USB_FUNCTION_PIPEC:
2475             RZA_IO_RegWrite_16(&USB200.PIPECTRE,
2476                                 1,
2477                                 USB_PIPEnTRE_TRCLR_SHIFT,
2478                                 USB_PIPEnTRE_TRCLR);
2479             USB200.PIPECTRN             = cnt;
2480             RZA_IO_RegWrite_16(&USB200.PIPECTRE,
2481                                 1,
2482                                 USB_PIPEnTRE_TRENB_SHIFT,
2483                                 USB_PIPEnTRE_TRENB);
2484         break;
2485
2486         case USB_FUNCTION_PIPED:
2487             RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
2488                                 1,
2489                                 USB_PIPEnTRE_TRCLR_SHIFT,
2490                                 USB_PIPEnTRE_TRCLR);
2491             USB200.PIPEDTRN             = cnt;
2492             RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
2493                                 1,
2494                                 USB_PIPEnTRE_TRENB_SHIFT,
2495                                 USB_PIPEnTRE_TRENB);
2496         break;
2497
2498         case USB_FUNCTION_PIPEE:
2499             RZA_IO_RegWrite_16(&USB200.PIPEETRE,
2500                                 1,
2501                                 USB_PIPEnTRE_TRCLR_SHIFT,
2502                                 USB_PIPEnTRE_TRCLR);
2503             USB200.PIPEETRN             = cnt;
2504             RZA_IO_RegWrite_16(&USB200.PIPEETRE,
2505                                 1,
2506                                 USB_PIPEnTRE_TRENB_SHIFT,
2507                                 USB_PIPEnTRE_TRENB);
2508         break;
2509
2510         case USB_FUNCTION_PIPEF:
2511             RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
2512                                 1,
2513                                 USB_PIPEnTRE_TRCLR_SHIFT,
2514                                 USB_PIPEnTRE_TRCLR);
2515             USB200.PIPEFTRN             = cnt;
2516             RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
2517                                 1,
2518                                 USB_PIPEnTRE_TRENB_SHIFT,
2519                                 USB_PIPEnTRE_TRENB);
2520         break;
2521
2522         default:
2523         break;
2524     }
2525 }
2526
2527 /*******************************************************************************
2528 * Function Name: usb0_function_clear_transaction_counter
2529 * Description  : Clears the transaction counter by the argument.
2530 *              : After executing this function, the transaction counter is invalid.
2531 * Arguments    : uint16_t pipe     ; Pipe number
2532 * Return Value : none
2533 *******************************************************************************/
2534 void usb0_function_clear_transaction_counter (uint16_t pipe)
2535 {
2536     switch (pipe)
2537     {
2538         case USB_FUNCTION_PIPE1:
2539             RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
2540                                 0,
2541                                 USB_PIPEnTRE_TRENB_SHIFT,
2542                                 USB_PIPEnTRE_TRENB);
2543             RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
2544                                 1,
2545                                 USB_PIPEnTRE_TRCLR_SHIFT,
2546                                 USB_PIPEnTRE_TRCLR);
2547         break;
2548
2549         case USB_FUNCTION_PIPE2:
2550             RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
2551                                 0,
2552                                 USB_PIPEnTRE_TRENB_SHIFT,
2553                                 USB_PIPEnTRE_TRENB);
2554             RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
2555                                 1,
2556                                 USB_PIPEnTRE_TRCLR_SHIFT,
2557                                 USB_PIPEnTRE_TRCLR);
2558         break;
2559
2560         case USB_FUNCTION_PIPE3:
2561             RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
2562                                 0,
2563                                 USB_PIPEnTRE_TRENB_SHIFT,
2564                                 USB_PIPEnTRE_TRENB);
2565             RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
2566                                 1,
2567                                 USB_PIPEnTRE_TRCLR_SHIFT,
2568                                 USB_PIPEnTRE_TRCLR);
2569         break;
2570
2571         case USB_FUNCTION_PIPE4:
2572             RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
2573                                 0,
2574                                 USB_PIPEnTRE_TRENB_SHIFT,
2575                                 USB_PIPEnTRE_TRENB);
2576             RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
2577                                 1,
2578                                 USB_PIPEnTRE_TRCLR_SHIFT,
2579                                 USB_PIPEnTRE_TRCLR);
2580         break;
2581
2582         case USB_FUNCTION_PIPE5:
2583             RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
2584                                 0,
2585                                 USB_PIPEnTRE_TRENB_SHIFT,
2586                                 USB_PIPEnTRE_TRENB);
2587             RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
2588                                 1,
2589                                 USB_PIPEnTRE_TRCLR_SHIFT,
2590                                 USB_PIPEnTRE_TRCLR);
2591         break;
2592
2593         case USB_FUNCTION_PIPE9:
2594             RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
2595                                 0,
2596                                 USB_PIPEnTRE_TRENB_SHIFT,
2597                                 USB_PIPEnTRE_TRENB);
2598             RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
2599                                 1,
2600                                 USB_PIPEnTRE_TRCLR_SHIFT,
2601                                 USB_PIPEnTRE_TRCLR);
2602         break;
2603
2604         case USB_FUNCTION_PIPEA:
2605             RZA_IO_RegWrite_16(&USB200.PIPEATRE,
2606                                 0,
2607                                 USB_PIPEnTRE_TRENB_SHIFT,
2608                                 USB_PIPEnTRE_TRENB);
2609             RZA_IO_RegWrite_16(&USB200.PIPEATRE,
2610                                 1,
2611                                 USB_PIPEnTRE_TRCLR_SHIFT,
2612                                 USB_PIPEnTRE_TRCLR);
2613         break;
2614
2615         case USB_FUNCTION_PIPEB:
2616             RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
2617                                 0,
2618                                 USB_PIPEnTRE_TRENB_SHIFT,
2619                                 USB_PIPEnTRE_TRENB);
2620             RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
2621                                 1,
2622                                 USB_PIPEnTRE_TRCLR_SHIFT,
2623                                 USB_PIPEnTRE_TRCLR);
2624         break;
2625
2626         case USB_FUNCTION_PIPEC:
2627             RZA_IO_RegWrite_16(&USB200.PIPECTRE,
2628                                 0,
2629                                 USB_PIPEnTRE_TRENB_SHIFT,
2630                                 USB_PIPEnTRE_TRENB);
2631             RZA_IO_RegWrite_16(&USB200.PIPECTRE,
2632                                 1,
2633                                 USB_PIPEnTRE_TRCLR_SHIFT,
2634                                 USB_PIPEnTRE_TRCLR);
2635         break;
2636
2637         case USB_FUNCTION_PIPED:
2638             RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
2639                                 0,
2640                                 USB_PIPEnTRE_TRENB_SHIFT,
2641                                 USB_PIPEnTRE_TRENB);
2642             RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
2643                                 1,
2644                                 USB_PIPEnTRE_TRCLR_SHIFT,
2645                                 USB_PIPEnTRE_TRCLR);
2646         break;
2647
2648         case USB_FUNCTION_PIPEE:
2649             RZA_IO_RegWrite_16(&USB200.PIPEETRE,
2650                                 0,
2651                                 USB_PIPEnTRE_TRENB_SHIFT,
2652                                 USB_PIPEnTRE_TRENB);
2653             RZA_IO_RegWrite_16(&USB200.PIPEETRE,
2654                                 1,
2655                                 USB_PIPEnTRE_TRCLR_SHIFT,
2656                                 USB_PIPEnTRE_TRCLR);
2657         break;
2658
2659         case USB_FUNCTION_PIPEF:
2660             RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
2661                                 0,
2662                                 USB_PIPEnTRE_TRENB_SHIFT,
2663                                 USB_PIPEnTRE_TRENB);
2664             RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
2665                                 1,
2666                                 USB_PIPEnTRE_TRCLR_SHIFT,
2667                                 USB_PIPEnTRE_TRCLR);
2668         break;
2669
2670         default:
2671         break;
2672     }
2673 }
2674
2675 /*******************************************************************************
2676 * Function Name: usb0_function_stop_transfer
2677 * Description  : Stops the USB transfer in the pipe specified by the argument.
2678 *              : After stopping the USB transfer, clears the buffer allocated in
2679 *              : the pipe.
2680 *              : After executing this function, allocation in FIF0 becomes USB_FUNCTION_PIPE0;
2681 *              : invalid. After executing this function, BRDY/NRDY/BEMP interrupt
2682 *              : in the corresponding pipe becomes invalid. Sequence bit is also
2683 *              : cleared.
2684 * Arguments    : uint16_t  pipe     ; Pipe Number
2685 * Return Value : none
2686 *******************************************************************************/
2687 void usb0_function_stop_transfer (uint16_t pipe)
2688 {
2689     uint16_t usefifo;
2690     uint32_t remain;
2691     uint16_t fifo;
2692
2693     usb0_function_set_pid_nak(pipe);
2694
2695     usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
2696     switch (usefifo)
2697     {
2698         case USB_FUNCTION_D0FIFO_USE:
2699             usb0_function_clear_transaction_counter(pipe);
2700             USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
2701             fifo = USB_FUNCTION_D0USE;
2702         break;
2703
2704         case USB_FUNCTION_D1FIFO_USE:
2705             usb0_function_clear_transaction_counter(pipe);
2706             USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
2707             fifo = USB_FUNCTION_D1USE;
2708         break;
2709
2710         case USB_FUNCTION_D0FIFO_DMA:
2711             remain = Userdef_USB_usb0_function_stop_dma0();
2712             usb0_function_dma_stop_d0(pipe, remain);
2713             usb0_function_clear_transaction_counter(pipe);
2714             USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
2715             fifo = USB_FUNCTION_D0DMA;
2716         break;
2717
2718         case USB_FUNCTION_D1FIFO_DMA:
2719             remain = Userdef_USB_usb0_function_stop_dma1();
2720             usb0_function_dma_stop_d1(pipe, remain);
2721             usb0_function_clear_transaction_counter(pipe);
2722             USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
2723             fifo = USB_FUNCTION_D1DMA;
2724         break;
2725
2726         default:
2727             usb0_function_clear_transaction_counter(pipe);
2728             USB200.CFIFOCTR =  USB_FUNCTION_BITBCLR;        /* Buffer Clear */
2729             fifo = USB_FUNCTION_CUSE;
2730         break;
2731     }
2732
2733     usb0_function_set_curpipe(USB_FUNCTION_PIPE0, fifo, DEVDRV_USBF_NO, USB_FUNCTION_BITMBW_16);
2734
2735     /* Interrupt of pipe set is disabled */
2736     usb0_function_disable_brdy_int(pipe);
2737     usb0_function_disable_nrdy_int(pipe);
2738     usb0_function_disable_bemp_int(pipe);
2739
2740     usb0_function_aclrm(pipe);
2741     usb0_function_set_csclr(pipe);
2742
2743     if ( g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT )
2744     {
2745         g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES;
2746     }
2747
2748 }
2749
2750 /*******************************************************************************
2751 * Function Name: usb0_function_set_dfacc_d0
2752 * Description  : Sets the DFACC setting value in D0FIFO using the transfer size.
2753 * Arguments    : uint16_t mbw     ; MBW
2754 *              : uint16_t count   ; data count
2755 * Return Value : DFACC Access mode
2756 *******************************************************************************/
2757 static uint16_t usb0_function_set_dfacc_d0 (uint16_t mbw, uint32_t count)
2758 {
2759     uint16_t dfacc = 0;
2760
2761 #ifndef __USB_FUNCTION_DF_ACC_ENABLE__
2762     RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2763                         0,
2764                         USB_DnFBCFG_DFACC_SHIFT,
2765                         USB_DnFBCFG_DFACC);
2766     RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2767                         0,
2768                         USB_DnFBCFG_TENDE_SHIFT,
2769                         USB_DnFBCFG_TENDE);
2770     dfacc = 0;
2771 #else
2772     if (mbw == USB_FUNCTION_BITMBW_32)
2773     {
2774         if ((count % 32) == 0)
2775         {
2776             /* 32byte transfer */
2777             RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2778                                 2,
2779                                 USB_DnFBCFG_DFACC_SHIFT,
2780                                 USB_DnFBCFG_DFACC);
2781             RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2782                                 0,
2783                                 USB_DnFBCFG_TENDE_SHIFT,
2784                                 USB_DnFBCFG_TENDE);
2785             dfacc = 2;
2786         }
2787         else if ((count % 16) == 0)
2788         {
2789             /* 16byte transfer */
2790             RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2791                                 1,
2792                                 USB_DnFBCFG_DFACC_SHIFT,
2793                                 USB_DnFBCFG_DFACC);
2794             RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2795                                 0,
2796                                 USB_DnFBCFG_TENDE_SHIFT,
2797                                 USB_DnFBCFG_TENDE);
2798             dfacc = 1;
2799         }
2800         else
2801         {
2802             RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2803                                 0,
2804                                 USB_DnFBCFG_DFACC_SHIFT,
2805                                 USB_DnFBCFG_DFACC);
2806             RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2807                                 0,
2808                                 USB_DnFBCFG_TENDE_SHIFT,
2809                                 USB_DnFBCFG_TENDE);
2810             dfacc = 0;
2811         }
2812     }
2813     else if (mbw == USB_FUNCTION_BITMBW_16)
2814     {
2815         RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2816                             0,
2817                             USB_DnFBCFG_DFACC_SHIFT,
2818                             USB_DnFBCFG_DFACC);
2819         RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2820                             0,
2821                             USB_DnFBCFG_TENDE_SHIFT,
2822                             USB_DnFBCFG_TENDE);
2823         dfacc = 0;
2824     }
2825     else
2826     {
2827         RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2828                             0,
2829                             USB_DnFBCFG_DFACC_SHIFT,
2830                             USB_DnFBCFG_DFACC);
2831         RZA_IO_RegWrite_16(&USB200.D0FBCFG,
2832                             0,
2833                             USB_DnFBCFG_TENDE_SHIFT,
2834                             USB_DnFBCFG_TENDE);
2835         dfacc = 0;
2836     }
2837 #endif
2838     return dfacc;
2839 }
2840
2841 /*******************************************************************************
2842 * Function Name: usb0_function_set_dfacc_d1
2843 * Description  : Set the DFACC setting value in D1FIFO using the transfer size.
2844 * Arguments    : uint16_t mbw     ; MBW
2845 *              : uint16_t count   ; data count
2846 * Return Value : DFACC Access mode
2847 *******************************************************************************/
2848 static uint16_t usb0_function_set_dfacc_d1 (uint16_t mbw, uint32_t count)
2849 {
2850     uint16_t dfacc = 0;
2851
2852 #ifndef __USB_FUNCTION_DF_ACC_ENABLE__
2853     RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2854                         0,
2855                         USB_DnFBCFG_DFACC_SHIFT,
2856                         USB_DnFBCFG_DFACC);
2857     RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2858                         0,
2859                         USB_DnFBCFG_TENDE_SHIFT,
2860                         USB_DnFBCFG_TENDE);
2861     dfacc = 0;
2862 #else
2863     if (mbw == USB_FUNCTION_BITMBW_32)
2864     {
2865         if ((count % 32) == 0)
2866         {
2867             /* 32byte transfer */
2868             RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2869                                 2,
2870                                 USB_DnFBCFG_DFACC_SHIFT,
2871                                 USB_DnFBCFG_DFACC);
2872             RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2873                                 0,
2874                                 USB_DnFBCFG_TENDE_SHIFT,
2875                                 USB_DnFBCFG_TENDE);
2876             dfacc = 2;
2877         }
2878         else if ((count % 16) == 0)
2879         {
2880             /* 16byte transfer */
2881             RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2882                                 1,
2883                                 USB_DnFBCFG_DFACC_SHIFT,
2884                                 USB_DnFBCFG_DFACC);
2885             RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2886                                 0,
2887                                 USB_DnFBCFG_TENDE_SHIFT,
2888                                 USB_DnFBCFG_TENDE);
2889             dfacc = 1;
2890         }
2891         else
2892         {
2893             RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2894                                 0,
2895                                 USB_DnFBCFG_DFACC_SHIFT,
2896                                 USB_DnFBCFG_DFACC);
2897             RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2898                                 0,
2899                                 USB_DnFBCFG_TENDE_SHIFT,
2900                                 USB_DnFBCFG_TENDE);
2901             dfacc = 0;
2902         }
2903     }
2904     else if (mbw == USB_FUNCTION_BITMBW_16)
2905     {
2906         RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2907                             0,
2908                             USB_DnFBCFG_DFACC_SHIFT,
2909                             USB_DnFBCFG_DFACC);
2910         RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2911                             0,
2912                             USB_DnFBCFG_TENDE_SHIFT,
2913                             USB_DnFBCFG_TENDE);
2914         dfacc = 0;
2915     }
2916     else
2917     {
2918         RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2919                             0,
2920                             USB_DnFBCFG_DFACC_SHIFT,
2921                             USB_DnFBCFG_DFACC);
2922         RZA_IO_RegWrite_16(&USB200.D1FBCFG,
2923                             0,
2924                             USB_DnFBCFG_TENDE_SHIFT,
2925                             USB_DnFBCFG_TENDE);
2926         dfacc = 0;
2927     }
2928 #endif
2929
2930     return dfacc;
2931 }
2932
2933 /* End of File */