target_firmware/magpie_fw_dev/target/hif/k2_fw_usb_api.c

   1 /*
   2  * Copyright (c) 2013 Qualcomm Atheros, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted (subject to the limitations in the
   7  * disclaimer below) provided that the following conditions are met:
   8  *
   9  *  * Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  *  * Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  *  * Neither the name of Qualcomm Atheros nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
  22  * GRANTED BY THIS LICENSE.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
  23  * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
  24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  31  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  32  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  33  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 #include "usb_defs.h"
  36 #include "usb_type.h"
  37 #include "usb_pre.h"
  38 #include "usb_extr.h"
  39 #include "usb_std.h"
  40 #include "reg_defs.h"
  41 #include "athos_api.h"
  42 #include "usbfifo_api.h"
  43
  44
  45 #include "sys_cfg.h"
  46
  47 typedef void (* USBFIFO_recv_command)(VBUF *cmd);
  48 void _fw_usb_suspend_reboot();
  49
  50 extern Action      eUsbCxFinishAction;
  51 extern CommandType eUsbCxCommand;
  52 extern BOOLEAN     UsbChirpFinish;
  53 extern USB_FIFO_CONFIG usbFifoConf;
  54
  55 USBFIFO_recv_command m_origUsbfifoRecvCmd = NULL;
  56
  57 #if SYSTEM_MODULE_USB
  58 #define vUsb_ep0end(void)                                   \
  59 {                                                           \
  60     eUsbCxCommand = CMD_VOID;                               \
  61     USB_BYTE_REG_WRITE(ZM_CX_CONFIG_STATUS_OFFSET, 0x01);   \
  62 }
  63
  64 #define vUsb_ep0fail(void)  USB_BYTE_REG_WRITE(ZM_CX_CONFIG_STATUS_OFFSET, 0x04)
  65
  66 #define vUsb_rst()                                              \
  67 {                                                               \
  68     USB_BYTE_REG_WRITE(ZM_INTR_SOURCE_7_OFFSET,                 \
  69         (USB_BYTE_REG_READ(ZM_INTR_SOURCE_7_OFFSET)&~BIT1));    \
  70     UsbChirpFinish = FALSE;                                     \
  71 }
  72
  73 #define vUsb_suspend()  USB_BYTE_REG_WRITE(ZM_INTR_SOURCE_7_OFFSET, \
  74                             (USB_BYTE_REG_READ(ZM_INTR_SOURCE_7_OFFSET)&~BIT2))
  75
  76 #define vUsb_resm() USB_BYTE_REG_WRITE(ZM_INTR_SOURCE_7_OFFSET,     \
  77                         (USB_BYTE_REG_READ(ZM_INTR_SOURCE_7_OFFSET)&~BIT3))
  78
  79 void _fw_usbfifo_recv_command(VBUF *buf)
  80 {
  81     A_UINT8 *cmd_data;
  82     A_UINT32 tmp;
  83
  84     cmd_data = (A_UINT8 *)(buf->desc_list->buf_addr + buf->desc_list->data_offset);
  85     tmp = *((A_UINT32 *)cmd_data);
  86     if ( tmp == 0xFFFFFFFF ) {
  87         _fw_usb_suspend_reboot();
  88     } else {
  89         m_origUsbfifoRecvCmd(buf);
  90     }
  91 }
  92
  93 void _fw_usbfifo_init(USB_FIFO_CONFIG *pConfig)
  94 {
  95     m_origUsbfifoRecvCmd = pConfig->recv_command;
  96
  97     usbFifoConf.get_command_buf = pConfig->get_command_buf;
  98     usbFifoConf.recv_command    = _fw_usbfifo_recv_command;
  99     usbFifoConf.get_event_buf   = pConfig->get_event_buf;
 100     usbFifoConf.send_event_done = pConfig->send_event_done;
 101 }
 102
 103 #define CHECK_SOF_LOOP_CNT    50
 104
 105 void _fw_usb_suspend_reboot()
 106 {
 107     volatile uint32_t gpio_in = 0;
 108     volatile uint32_t pupd = 0;
 109     volatile uint32_t t = 0;
 110     volatile uint32_t sof_no=0,sof_no_new=0;
 111     /* Set GO_TO_SUSPEND bit to USB main control register */
 112     vUsb_suspend();
 113     A_PRINTF("!USB suspend\n\r");
 114
 115     // keep the record of suspend
 116 #if defined(PROJECT_MAGPIE)
 117     *((volatile uint32_t*)WATCH_DOG_MAGIC_PATTERN_ADDR) = SUS_MAGIC_PATTERN;
 118 #elif defined(PROJECT_K2)
 119     HAL_WORD_REG_WRITE(MAGPIE_REG_RST_STATUS_ADDR, SUS_MAGIC_PATTERN);
 120 #endif /* #if defined(PROJECT_MAGPIE) */
 121
 122     /* Reset USB FIFO */
 123     A_USB_RESET_FIFO();
 124
 125     /* Turn off power */
 126     A_USB_POWER_OFF();
 127
 128     DEBUG_SYSTEM_STATE = (DEBUG_SYSTEM_STATE&(~0xffff)) | 0x1000;
 129
 130     // reset ep3/ep4 fifo in case there is data which might affect resuming
 131 //  HAL_BYTE_REG_WRITE(0x100ae, (HAL_BYTE_REG_READ(0x100ae)|0x10));
 132 //  HAL_BYTE_REG_WRITE(0x100ae, (HAL_BYTE_REG_READ(0x100af)|0x10));
 133
 134     {
 135         // config gpio to input before goto suspend
 136
 137         //disable JTAG/ICE
 138         //jtag = HAL_WORD_REG_READ(0x10004054);
 139         //HAL_WORD_REG_WRITE(0x10004054, (jtag|BIT17));
 140
 141                 //disable SPI
 142         //spi = HAL_WORD_REG_READ(0x50040);
 143         //HAL_WORD_REG_WRITE(0x50040, (spi&~(BIT8)));
 144
 145                 //set all GPIO to input
 146         gpio_in = HAL_WORD_REG_READ(0x1000404c);
 147         HAL_WORD_REG_WRITE(0x1000404c, 0x0);
 148
 149                 //set PU/PD for all GPIO except two UART pins
 150         pupd = HAL_WORD_REG_READ(0x10004088);
 151         HAL_WORD_REG_WRITE(0x10004088, 0xA982AA6A);
 152     }
 153
 154     sof_no= HAL_WORD_REG_READ(0x10004);
 155     for (t = 0; t < CHECK_SOF_LOOP_CNT; t++)
 156     {
 157         A_DELAY_USECS(1000);    //delay 1ms
 158         sof_no_new = HAL_WORD_REG_READ(0x10004);
 159
 160         if(sof_no_new == sof_no)
 161             break;
 162
 163         sof_no = sof_no_new;
 164     }
 165
 166     /*
 167      * Reset "printf" module patch point(RAM to ROM) when K2 warm start or suspend,
 168      * which fixed the error issue cause by redownload another different firmware.
 169      */
 170     _indir_tbl.cmnos.printf._printf = save_cmnos_printf;
 171
 172     ///////////////////////////////////////////////////////////////
 173     // setting the go suspend here, power down right away...
 174     if (t != CHECK_SOF_LOOP_CNT)   // not time out
 175         HAL_WORD_REG_WRITE(0x10000, HAL_WORD_REG_READ(0x10000)|(0x8));
 176     ///////////////////////////////////////////////////////////////
 177
 178     DEBUG_SYSTEM_STATE = (DEBUG_SYSTEM_STATE&(~0xffff)) | 0x1100;
 179
 180 #if 0 // pll unstable, h/w bug?
 181     HAL_WORD_REG_WRITE(0x50040, (0x300|6|(1>>1)<<12));
 182     A_UART_HWINIT((40*1000*1000)/1, 19200);
 183 #endif
 184     {
 185         // restore gpio setting
 186         //HAL_WORD_REG_WRITE(0x10004054, jtag);
 187         //HAL_WORD_REG_WRITE(0x50040, spi);
 188         HAL_WORD_REG_WRITE(0x1000404c, gpio_in);
 189         HAL_WORD_REG_WRITE(0x10004088, pupd);
 190     }
 191     DEBUG_SYSTEM_STATE = (DEBUG_SYSTEM_STATE&(~0xffff)) | 0x1200;
 192
 193     {
 194         // since we still need to touch mac_base address after resuming back, so that
 195         // reset mac can't be done in ResetFifo function, move to here...
 196         // whole mac control reset.... (bit1)
 197         HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, (BIT1) );
 198         HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, (HAL_WORD_REG_READ(MAGPIE_REG_RST_PWDN_CTRL_ADDR)|BIT0));
 199         HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, 0x0 );
 200         A_DELAY_USECS(1000);
 201     }
 202
 203     //A_PRINTF("reg(0x10020)=(%x)\n", HAL_WORD_REG_READ(0x10020));
 204     // disable ep3 int enable, so that resume back won't send wdt magic pattern out!!!
 205     mUSB_STATUS_IN_INT_DISABLE();
 206
 207     MAGPIE_REG_USB_RX0_SWAP_DATA = 0x1;
 208     MAGPIE_REG_USB_TX0_SWAP_DATA = 0x1;
 209     MAGPIE_REG_USB_RX1_SWAP_DATA = 0x1;
 210     MAGPIE_REG_USB_RX2_SWAP_DATA = 0x1;
 211
 212     if (((DEBUG_SYSTEM_STATE&~(0x0000ffff))>>16 == 0x5342)) {
 213         /* UART_SEL and SPI_SEL */
 214         HAL_WORD_REG_WRITE(0x50040, (0x300|0|(1>>1)<<12));
 215     }
 216
 217     /* Jump to boot code */
 218     A_USB_JUMP_BOOT();
 219
 220 }
 221
 222 /*
 223  * -- patch usb_fw_task --
 224  * . usb zero length interrupt should not clear by s/w, h/w will handle that
 225  * . complete suspend handle, configure gpio, turn off related function,
 226  *   slow down the pll for stable issue
 227  */
 228 void _fw_usb_fw_task(void)
 229 {
 230     register uint8_t usb_interrupt_level1;
 231     register uint8_t usb_interrupt_level2;
 232
 233     usb_interrupt_level1 = USB_BYTE_REG_READ(ZM_INTR_GROUP_OFFSET);
 234 #if 0 // these endpoints are handled by DMA
 235     if (usb_interrupt_level1 & BIT5)            //Group Byte 5
 236     {
 237         vUsb_Data_In();
 238     }
 239 #endif
 240     if (usb_interrupt_level1 & BIT4)
 241     {
 242         usb_interrupt_level2 = USB_BYTE_REG_READ(ZM_INTR_SOURCE_4_OFFSET);
 243         if( usb_interrupt_level2 & BIT6)
 244             A_USB_REG_OUT();//vUsb_Reg_Out();
 245     }
 246
 247     if (usb_interrupt_level1 & BIT6)
 248     {
 249         //zfGenWatchDogEvent();
 250     usb_interrupt_level2 = USB_BYTE_REG_READ(ZM_INTR_SOURCE_6_OFFSET);
 251         if( usb_interrupt_level2 & BIT6)
 252              A_USB_STATUS_IN();//vUsb_Status_In();
 253     }
 254
 255     if (usb_interrupt_level1 & BIT0)            //Group Byte 0
 256     {
 257         //usb_interrupt_level2 = ZM_INTR_SOURCE_0_REG;
 258         usb_interrupt_level2 = USB_BYTE_REG_READ(ZM_INTR_SOURCE_0_OFFSET);
 259
 260         // refer to FUSB200, p 48, offset:21H, bit7 description, should clear the command abort interrupt first!?
 261         if (usb_interrupt_level2 & BIT7)
 262         {
 263             //ZM_INTR_SOURCE_0_REG &= 0x7f;       // Handle command abort
 264             USB_BYTE_REG_WRITE(ZM_INTR_SOURCE_0_OFFSET, (USB_BYTE_REG_READ(ZM_INTR_SOURCE_0_OFFSET)& ~BIT7));
 265             A_PRINTF("![SOURCE_0] bit7 on\n\r");
 266         }
 267
 268         if (usb_interrupt_level2 & BIT1)
 269         {
 270             //A_PRINTF("![USB] ep0 IN in \n\r");
 271             A_USB_EP0_TX();                       // USB EP0 tx interrupt
 272         }
 273         if (usb_interrupt_level2 & BIT2)
 274         {
 275             //A_PRINTF("![USB] ep0 OUT in\n\r");
 276             A_USB_EP0_RX();                       // USB EP0 rx interrupt
 277         }
 278         if (usb_interrupt_level2 & BIT0)
 279         {
 280             //A_PRINTF("![USB] ep0 SETUP in\n\r");
 281             A_USB_EP0_SETUP();
 282             //vWriteUSBFakeData();
 283         }
 284 //        else if (usb_interrupt_level2 & BIT3)
 285         if (usb_interrupt_level2 & BIT3)
 286         {
 287             vUsb_ep0end();
 288 //            A_PRINTF("![SOURCE_0] ep0 CMD_END\n\r");
 289         }
 290         if (usb_interrupt_level2 & BIT4)
 291         {
 292             vUsb_ep0fail();
 293 //            A_PRINTF("![SOURCE_0] ep0 CMD_FAIL\n\r");
 294         }
 295         if (eUsbCxFinishAction == ACT_STALL)
 296         {
 297             // set CX_STL to stall Endpoint0 & will also clear FIFO0
 298             USB_BYTE_REG_WRITE(ZM_CX_CONFIG_STATUS_OFFSET, 0x04);
 299 //            A_PRINTF("![USB] ZM_CX_CONFIG_STATUS_REG = 0x04\n\r");
 300         }
 301         else if (eUsbCxFinishAction == ACT_DONE)
 302         {
 303             // set CX_DONE to indicate the transmistion of control frame
 304             USB_BYTE_REG_WRITE(ZM_CX_CONFIG_STATUS_OFFSET, 0x01);
 305         }
 306         eUsbCxFinishAction = ACT_IDLE;
 307     }
 308
 309     if (usb_interrupt_level1 & BIT7)            //Group Byte 7
 310     {
 311         //usb_interrupt_level2 = ZM_INTR_SOURCE_7_REG;
 312         usb_interrupt_level2 = USB_BYTE_REG_READ(ZM_INTR_SOURCE_7_OFFSET);
 313
 314 #if 0
 315         if (usb_interrupt_level2 & BIT7)
 316         {
 317             vUsb_Data_Out0Byte();
 318 //            A_PRINTF("![SOURCE_7] bit7 on, clear it\n\r");
 319         }
 320         if (usb_interrupt_level2 & BIT6)
 321         {
 322             vUsb_Data_In0Byte();
 323 //            A_PRINTF("![SOURCE_7] bit6 on, clear it\n\r");
 324         }
 325 #endif
 326
 327         if (usb_interrupt_level2 & BIT1)
 328         {
 329             vUsb_rst();
 330             //USB_BYTE_REG_WRITE(ZM_INTR_SOURCE_7_REG, (USB_BYTE_REG_READ(ZM_INTR_SOURCE_7_OFFSET)&~0x2));
 331             A_PRINTF("!USB reset\n\r");
 332 //            A_PRINTF("![0x1012c]: %\n\r", USB_WORD_REG_READ(0x12c));
 333         }
 334         if (usb_interrupt_level2 & BIT2)
 335         {
 336            // TBD: the suspend resume code should put here, Ryan, 07/18
 337            //
 338            //  issue, jump back to rom code and what peripherals should we reset here?
 339            //
 340            _fw_usb_suspend_reboot();
 341         }
 342         if (usb_interrupt_level2 & BIT3)
 343         {
 344             vUsb_resm();
 345             A_PRINTF("!USB resume\n\r");
 346         }
 347     }
 348
 349 }
 350
 351
 352 void _fw_usb_reset_fifo(void)
 353 {
 354     volatile uint32_t   *reg_data;
 355
 356     HAL_BYTE_REG_WRITE(0x100ae, (HAL_BYTE_REG_READ(0x100ae)|0x10));
 357     HAL_BYTE_REG_WRITE(0x100af, (HAL_BYTE_REG_READ(0x100af)|0x10));
 358
 359     // disable ep3 int enable, so that resume back won't send wdt magic pattern out!!!
 360     mUSB_STATUS_IN_INT_DISABLE();
 361
 362     // update magic pattern to indicate this is a suspend
 363     // k2: MAGPIE_REG_RST_WDT_TIMER_CTRL_ADDR
 364     // magpie: MAGPIE_REG_RST_STATUS_ADDR
 365     HAL_WORD_REG_WRITE(MAGPIE_REG_RST_STATUS_ADDR, SUS_MAGIC_PATTERN);
 366
 367     /*
 368      * Before USB suspend, USB DMA must be reset(refer to Otus)
 369      * Otus runs the following statements only
 370      * HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, BIT0|BIT2 );
 371      * HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, 0x0 );
 372      * K2 must run the following statements additionally
 373      * reg_data = (A_UINT32 *)(USB_CTRL_BASE_ADDRESS + 0x118);
 374      * *reg_data = 0x00000000;
 375      * *reg_data = 0x00000001;
 376      * because of Hardware bug in K2
 377      */
 378     reg_data = (uint32_t *)(USB_CTRL_BASE_ADDRESS + 0x118);
 379     *reg_data = 0x00000000;
 380
 381     // reset both usb(bit2)/wlan(bit1) dma
 382     HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, (BIT2) );
 383     HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, (HAL_WORD_REG_READ(MAGPIE_REG_RST_PWDN_CTRL_ADDR)|BIT0));
 384     HAL_WORD_REG_WRITE( MAGPIE_REG_RST_PWDN_CTRL_ADDR, 0x0 );
 385
 386     *reg_data = 0x00000001;
 387
 388     /* MAC warem reset */
 389     //reg_data = (uint32_t *)(K2_REG_MAC_BASE_ADDR + 0x7000);
 390     //*reg_data = 0x00000001;
 391
 392     //A_DELAY_USECS(1);
 393
 394     //*reg_data = 0x00000000;
 395
 396     //while (*reg_data)   ;
 397
 398     A_PRINTF("\n change clock to 22 and go to suspend now!");
 399
 400     /* UART_SEL */
 401     HAL_WORD_REG_WRITE(0x50040, (0x200|0|(1>>1)<<12));
 402     A_UART_HWINIT((22*1000*1000), 19200);
 403 }
 404
 405 /*
 406  *  -- usb1.1 ep6 fix --
 407  */
 408 extern uint16_t       u8UsbConfigValue;
 409 extern uint16_t       u8UsbInterfaceValue;
 410 extern uint16_t       u8UsbInterfaceAlternateSetting;
 411 extern SetupPacket    ControlCmd;
 412 extern void vUsbClrEPx(void);
 413
 414 void vUSBFIFO_EP6Cfg_FS_patch(void)
 415 {
 416 #if (FS_C1_I0_A0_EP_NUMBER >= 6)
 417     int i;
 418
 419     //EP0X06
 420     mUsbEPMap(EP6, FS_C1_I0_A0_EP6_MAP);
 421     mUsbFIFOMap(FS_C1_I0_A0_EP6_FIFO_START, FS_C1_I0_A0_EP6_FIFO_MAP);
 422     mUsbFIFOConfig(FS_C1_I0_A0_EP6_FIFO_START, FS_C1_I0_A0_EP6_FIFO_CONFIG);
 423
 424     for(i = FS_C1_I0_A0_EP6_FIFO_START + 1 ;
 425         i < FS_C1_I0_A0_EP6_FIFO_START + FS_C1_I0_A0_EP6_FIFO_NO ; i ++)
 426     {
 427         mUsbFIFOConfig(i, (FS_C1_I0_A0_EP6_FIFO_CONFIG & (~BIT7)) );
 428     }
 429
 430     mUsbEPMxPtSzHigh(EP6, FS_C1_I0_A0_EP6_DIRECTION, (FS_C1_I0_A0_EP6_MAX_PACKET & 0x7ff));
 431     mUsbEPMxPtSzLow(EP6, FS_C1_I0_A0_EP6_DIRECTION, (FS_C1_I0_A0_EP6_MAX_PACKET & 0x7ff));
 432     mUsbEPinHighBandSet(EP6 , FS_C1_I0_A0_EP6_DIRECTION, FS_C1_I0_A0_EP6_MAX_PACKET);
 433 #endif
 434 }
 435
 436 void vUsbFIFO_EPxCfg_FS_patch(void)
 437 {
 438     switch (u8UsbConfigValue)
 439     {
 440         #if (FS_CONFIGURATION_NUMBER >= 1)
 441         // Configuration 0X01
 442         case 0X01:
 443             switch (u8UsbInterfaceValue)
 444             {
 445                 #if (FS_C1_INTERFACE_NUMBER >= 1)
 446                 // Interface 0
 447                 case 0:
 448                     switch (u8UsbInterfaceAlternateSetting)
 449                     {
 450
 451                         #if (FS_C1_I0_ALT_NUMBER >= 1)
 452                         // AlternateSetting 0
 453                         case 0:
 454
 455                                                         // snapped....
 456
 457                                                         // patch up this ep6_fs config
 458                             vUSBFIFO_EP6Cfg_FS_patch();
 459
 460                             break;
 461
 462                         #endif
 463                         default:
 464                             break;
 465                     }
 466                     break;
 467                 #endif
 468                 default:
 469                     break;
 470             }
 471             break;
 472         #endif
 473         default:
 474             break;
 475     }
 476     //mCHECK_STACK();
 477 }
 478
 479
 480 BOOLEAN bSet_configuration_patch(void)
 481 {
 482     //A_PRINTF("bSet_configuration...\n\r");
 483
 484         bSet_configuration();
 485
 486     if (mLOW_BYTE(mDEV_REQ_VALUE()) == 0)
 487     {
 488                 // snapped....
 489                 ;
 490     }
 491     else
 492     {
 493         if (mUsbHighSpeedST())                  // First judge HS or FS??
 494         {
 495                         // snapped....
 496                         ;
 497         }
 498         else
 499         {
 500                         // snapped....
 501                         vUsbFIFO_EPxCfg_FS_patch();
 502         }
 503
 504                 // snapped....
 505     }
 506
 507     eUsbCxFinishAction = ACT_DONE;
 508     return TRUE;
 509 }
 510
 511
 512 /*
 513  * -- support more than 64 bytes command on ep3 --
 514  */
 515 void vUsb_Status_In_patch(void)
 516 {
 517     uint16_t count;
 518     uint16_t remainder;
 519     u16_t RegBufLen;
 520     BOOLEAN cmdEnd = FALSE;
 521
 522     static u16_t mBufLen;
 523     static VBUF *evntbuf = NULL;
 524     static volatile u32_t *regaddr;
 525     static BOOLEAN cmd_is_new = TRUE;
 526
 527     if( cmd_is_new )
 528     {
 529         evntbuf = usbFifoConf.get_event_buf();
 530         if ( evntbuf != NULL )
 531         {
 532             regaddr = (u32_t *)VBUF_GET_DATA_ADDR(evntbuf);
 533             mBufLen = evntbuf->buf_length;
 534         }
 535         else
 536         {
 537             mUSB_STATUS_IN_INT_DISABLE();
 538             goto ERR_DONE;
 539         }
 540
 541     }
 542
 543 //    if( mBufLen>bUSB_EP_MAX_PKT_SIZE_64 )
 544 //        A_PRINTF("EP3 send %d bytes to host \n", mBufLen);
 545
 546 //    while(1)
 547     {
 548         if( mBufLen > bUSB_EP_MAX_PKT_SIZE_64 ) {
 549             RegBufLen = bUSB_EP_MAX_PKT_SIZE_64;
 550             mBufLen -= bUSB_EP_MAX_PKT_SIZE_64;
 551         }
 552         // TODO: 64 byes... controller supposed will take care of zero-length?
 553         else {
 554             RegBufLen = mBufLen;
 555             cmdEnd = TRUE;
 556         }
 557
 558         /* INT use EP3 */
 559         for(count = 0; count < (RegBufLen / 4); count++)
 560         {
 561             USB_WORD_REG_WRITE(ZM_EP3_DATA_OFFSET, *regaddr);
 562             regaddr++;
 563         }
 564
 565         remainder = RegBufLen % 4;
 566
 567         if (remainder)
 568         {
 569             switch(remainder)
 570             {
 571             case 3:
 572                 USB_WORD_REG_WRITE(ZM_CBUS_FIFO_SIZE_OFFSET, 0x7);
 573                 break;
 574             case 2:
 575                 USB_WORD_REG_WRITE(ZM_CBUS_FIFO_SIZE_OFFSET, 0x3);
 576                 break;
 577             case 1:
 578                 USB_WORD_REG_WRITE(ZM_CBUS_FIFO_SIZE_OFFSET, 0x1);
 579                 break;
 580             }
 581
 582             USB_WORD_REG_WRITE(ZM_EP3_DATA_OFFSET, *regaddr);
 583
 584             // Restore CBus FIFO size to word size
 585             USB_WORD_REG_WRITE(ZM_CBUS_FIFO_SIZE_OFFSET, 0xF);
 586         }
 587
 588         mUSB_EP3_XFER_DONE();
 589
 590 //        if( mBufLen<=bUSB_EP_MAX_PKT_SIZE_64 )
 591 //            break;
 592     }
 593
 594     if ( evntbuf != NULL && cmdEnd )
 595     {
 596         usbFifoConf.send_event_done(evntbuf);
 597         cmd_is_new = TRUE;
 598     }
 599
 600 ERR_DONE:
 601     ;
 602 }
 603
 604 extern uint16_t *u8UsbDeviceDescriptor;
 605 extern uint16_t *u8ConfigDescriptorEX;
 606 extern uint16_t *pu8DescriptorEX;
 607 extern uint16_t u16TxRxCounter;
 608 extern BOOLEAN bGet_descriptor(void);
 609
 610 uint16_t DeviceDescriptorPatch[9];
 611 uint16_t ConfigDescriptorPatch[30];
 612
 613
 614 #define BCD_DEVICE                  6
 615 #define BCD_DEVICE_FW_SIGNATURE     0xffff
 616 #define EP3_TRANSFER_TYPE_OFFSET    17
 617 #define EP3_INT_INTERVAL            19
 618 #define EP4_TRANSFER_TYPE_OFFSET    21
 619 #define EP4_INT_INTERVAL            22
 620
 621 BOOLEAN bGet_descriptor_patch(void)
 622 {
 623     int i;
 624     switch (mDEV_REQ_VALUE_HIGH()) {
 625     case 1:
 626         ath_hal_memcpy(DeviceDescriptorPatch,
 627             u8UsbDeviceDescriptor, sizeof(DeviceDescriptorPatch));
 628
 629         DeviceDescriptorPatch[BCD_DEVICE] = BCD_DEVICE_FW_SIGNATURE;
 630
 631         pu8DescriptorEX = DeviceDescriptorPatch;
 632         u16TxRxCounter = mTABLE_LEN(DeviceDescriptorPatch[0]);
 633         break;
 634     case 2:
 635         /* Copy ConfigDescriptor */
 636         ath_hal_memcpy(ConfigDescriptorPatch,
 637             u8ConfigDescriptorEX, sizeof(ConfigDescriptorPatch));
 638
 639         /* place holder for EPx patches */
 640
 641         switch (mDEV_REQ_VALUE_LOW())
 642         {
 643         case 0x00:      // configuration no: 0
 644             pu8DescriptorEX = ConfigDescriptorPatch;
 645             u16TxRxCounter = ConfigDescriptorPatch[1];
 646             //u16TxRxCounter = 46;
 647             break;
 648         default:
 649             return FALSE;
 650         }
 651         break;
 652     default:
 653         return bGet_descriptor();
 654     }
 655
 656     if (u16TxRxCounter > mDEV_REQ_LENGTH())
 657         u16TxRxCounter = mDEV_REQ_LENGTH();
 658
 659     A_USB_EP0_TX_DATA();
 660     return TRUE;
 661 }
 662
 663 extern BOOLEAN bStandardCommand(void);
 664
 665 BOOLEAN bStandardCommand_patch(void)
 666 {
 667     if (mDEV_REQ_REQ() == USB_SET_CONFIGURATION) {
 668         A_USB_SET_CONFIG();
 669
 670 #if ENABLE_SWAP_DATA_MODE
 671         // SWAP FUNCTION should be enabled while DMA engine is not working,
 672         // the best place to enable it is before we trigger the DMA
 673         MAGPIE_REG_USB_RX0_SWAP_DATA = 0x1;
 674         MAGPIE_REG_USB_TX0_SWAP_DATA = 0x1;
 675
 676         #if SYSTEM_MODULE_HP_EP5
 677             MAGPIE_REG_USB_RX1_SWAP_DATA = 0x1;
 678         #endif
 679
 680         #if SYSTEM_MODULE_HP_EP6
 681             MAGPIE_REG_USB_RX2_SWAP_DATA = 0x1;
 682         #endif
 683
 684 #endif //ENABLE_SWAP_DATA_MODE
 685         return TRUE;
 686     }
 687     else {
 688         return bStandardCommand();
 689     }
 690 }
 691
 692 #endif
 693
 694