1 /* Cypress West Bridge API source file (cyasusb.c)

     2 ## ===========================

     3 ##

     4 ##  Copyright Cypress Semiconductor Corporation, 2006-2009,

     5 ##  All Rights Reserved

     6 ##  UNPUBLISHED, LICENSED SOFTWARE.

     7 ##

     8 ##  CONFIDENTIAL AND PROPRIETARY INFORMATION

     9 ##  WHICH IS THE PROPERTY OF CYPRESS.

    10 ##

    11 ##  Use of this file is governed

    12 ##  by the license agreement included in the file

    13 ##

    14 ##     <install>/license/license.txt

    15 ##

    16 ##  where <install> is the Cypress software

    17 ##  installation root directory path.

    18 ##

    19 ## ===========================

    20 */

    21 

    22 #include "cyashal.h"

    23 #include "cyasusb.h"

    24 #include "cyaserr.h"

    25 #include "cyasdma.h"

    26 #include "cyaslowlevel.h"

    27 #include "cyaslep2pep.h"

    28 #include "cyasregs.h"

    29 #include "cyasstorage.h"

    30 

    31 extern CyAsMediaType

    32 CyAsStorageGetMediaFromAddress(uint16_t v) ;

    33 

    34 extern CyAsBusNumber_t

    35 CyAsStorageGetBusFromAddress(uint16_t v) ;

    36 

    37 extern uint32_t

    38 CyAsStorageGetDeviceFromAddress(uint16_t v) ;

    39 

    40 static CyAsReturnStatus_t

    41 CyAsUsbAckSetupPacket(

    42                       CyAsDeviceHandle                  handle,         /* Handle to the West Bridge device */

    43                       CyAsFunctionCallback              cb,             /* The callback if async call */

    44                       uint32_t                          client          /* Client supplied data */

    45                       ) ;

    46 

    47 static void

    48 CyAsUsbFuncCallback(

    49                     CyAsDevice *dev_p,

    50                     uint8_t context,

    51                     CyAsLLRequestResponse *rqt,

    52                     CyAsLLRequestResponse *resp,

    53                     CyAsReturnStatus_t ret) ;

    54 /*

    55 * Reset the USB EP0 state

    56 */

    57 static void

    58 CyAsUsbResetEP0State(CyAsDevice *dev_p)

    59 {

    60     CyAsLogDebugMessage(6, "CyAsUsbResetEP0State called") ;

    61 

    62     CyAsDeviceClearAckDelayed(dev_p) ;

    63     CyAsDeviceClearSetupPacket(dev_p) ;

    64     if (CyAsDeviceIsUsbAsyncPending(dev_p, 0))

    65         CyAsUsbCancelAsync((CyAsDeviceHandle)dev_p, 0) ;

    66 

    67     dev_p->usb_pending_buffer = 0 ;

    68 }

    69 

    70 /*

    71 * External function to map logical endpoints to physical endpoints

    72 */

    73 static CyAsReturnStatus_t

    74 IsUsbActive(CyAsDevice *dev_p)

    75 {

    76     if (!CyAsDeviceIsConfigured(dev_p))

    77         return CY_AS_ERROR_NOT_CONFIGURED ;

    78 

    79     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

    80         return CY_AS_ERROR_NO_FIRMWARE ;

    81 

    82     if (dev_p->usb_count == 0)

    83         return CY_AS_ERROR_NOT_RUNNING ;

    84 

    85     if (CyAsDeviceIsInSuspendMode(dev_p))

    86         return CY_AS_ERROR_IN_SUSPEND ;

    87 

    88     return CY_AS_ERROR_SUCCESS ;

    89 }

    90 

    91 static void

    92 UsbAckCallback(CyAsDeviceHandle h,

    93                CyAsReturnStatus_t status,

    94                uint32_t client,

    95                CyAsFunctCBType  type,

    96                void* data)

    97 {

    98     CyAsDevice *dev_p = (CyAsDevice *)h ;

    99 

   100     (void)client ;

   101     (void)status ;

   102     (void)data ;

   103 

   104     CyAsHalAssert(type == CY_FUNCT_CB_NODATA) ;

   105 

   106     if (dev_p->usb_pending_buffer)

   107     {

   108         CyAsUsbIoCallback cb ;

   109 

   110         cb = dev_p->usb_cb[0] ;

   111         dev_p->usb_cb[0] = 0 ;

   112         CyAsDeviceClearUsbAsyncPending(dev_p, 0) ;

   113         if (cb)

   114             cb(h, 0, dev_p->usb_pending_size, dev_p->usb_pending_buffer, dev_p->usb_error) ;

   115 

   116         dev_p->usb_pending_buffer = 0 ;

   117     }

   118 

   119     CyAsDeviceClearSetupPacket(dev_p) ;

   120 }

   121 

   122 static void

   123 MyUsbRequestCallbackUsbEvent(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

   124 {

   125     uint16_t ev ;

   126     uint16_t val ;

   127     CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   128 

   129     ev = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   130     switch(ev)

   131     {

   132     case 0:             /* Reserved */

   133         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

   134         break ;

   135 

   136     case 1:             /* Reserved */

   137         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

   138         break ;

   139 

   140     case 2:             /* USB Suspend */

   141         dev_p->usb_last_event = CyAsEventUsbSuspend ;

   142         if (dev_p->usb_event_cb_ms)

   143             dev_p->usb_event_cb_ms(h, CyAsEventUsbSuspend, 0) ;

   144         else if (dev_p->usb_event_cb)

   145             dev_p->usb_event_cb(h, CyAsEventUsbSuspend, 0) ;

   146         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   147         break;

   148 

   149     case 3:             /* USB Resume */

   150         dev_p->usb_last_event = CyAsEventUsbResume ;

   151         if (dev_p->usb_event_cb_ms)

   152             dev_p->usb_event_cb_ms(h, CyAsEventUsbResume, 0) ;

   153         else if (dev_p->usb_event_cb)

   154             dev_p->usb_event_cb(h, CyAsEventUsbResume, 0) ;

   155         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   156         break ;

   157 

   158     case 4:             /* USB Reset */

   159         /*

   160         * If we get a USB reset, the USB host did not understand our response

   161         * or we timed out for some reason.  Reset our internal state to be ready for

   162         * another set of enumeration based requests.

   163         */

   164         if (CyAsDeviceIsAckDelayed(dev_p))

   165         {

   166             CyAsUsbResetEP0State(dev_p) ;

   167         }

   168 

   169         dev_p->usb_last_event = CyAsEventUsbReset ;

   170         if (dev_p->usb_event_cb_ms)

   171             dev_p->usb_event_cb_ms(h, CyAsEventUsbReset, 0) ;

   172         else if (dev_p->usb_event_cb)

   173             dev_p->usb_event_cb(h, CyAsEventUsbReset, 0) ;

   174 

   175         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   176         CyAsDeviceClearUsbHighSpeed(dev_p) ;

   177         CyAsUsbSetDmaSizes(dev_p) ;

   178         dev_p->usb_max_tx_size = 0x40 ;

   179         CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x40) ;

   180         break ;

   181 

   182     case 5:             /* USB Set Configuration */

   183         val = CyAsLLRequestResponse_GetWord(req_p, 1) ;                 /* The configuration to set */

   184         dev_p->usb_last_event = CyAsEventUsbSetConfig ;

   185         if (dev_p->usb_event_cb_ms)

   186             dev_p->usb_event_cb_ms(h, CyAsEventUsbSetConfig, &val) ;

   187         else if (dev_p->usb_event_cb)

   188             dev_p->usb_event_cb(h, CyAsEventUsbSetConfig, &val) ;

   189         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   190         break ;

   191 

   192     case 6:             /* USB Speed change */

   193         val = CyAsLLRequestResponse_GetWord(req_p, 1) ;                 /* Connect speed */

   194         dev_p->usb_last_event = CyAsEventUsbSpeedChange ;

   195         if (dev_p->usb_event_cb_ms)

   196             dev_p->usb_event_cb_ms(h, CyAsEventUsbSpeedChange, &val) ;

   197         else if (dev_p->usb_event_cb)

   198             dev_p->usb_event_cb(h, CyAsEventUsbSpeedChange, &val) ;

   199         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   200         CyAsDeviceSetUsbHighSpeed(dev_p) ;

   201         CyAsUsbSetDmaSizes(dev_p) ;

   202         dev_p->usb_max_tx_size = 0x200 ;

   203         CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x200) ;

   204         break ;

   205 

   206     case 7:             /* USB Clear Feature */

   207         val = CyAsLLRequestResponse_GetWord(req_p, 1) ;                 /* EP Number */

   208         if (dev_p->usb_event_cb_ms)

   209             dev_p->usb_event_cb_ms(h, CyAsEventUsbClearFeature, &val) ;

   210         if (dev_p->usb_event_cb)

   211             dev_p->usb_event_cb(h, CyAsEventUsbClearFeature, &val) ;

   212         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   213         break ;

   214 

   215     default:

   216         CyAsHalPrintMessage("Invalid event type\n") ;

   217         CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_USB_INVALID_EVENT, sizeof(ev), &ev) ;

   218         break ;

   219     }

   220 }

   221 

   222 static void

   223 MyUsbRequestCallbackUsbData(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

   224 {

   225     CyAsEndPointNumber_t ep ;

   226     uint8_t type ;

   227     uint16_t len ;

   228     uint16_t val ;

   229     CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   230 

   231     val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   232     ep = (CyAsEndPointNumber_t)((val >> 13) & 0x01) ;

   233     len = (val & 0x1ff) ;

   234 

   235     CyAsHalAssert(len <= 64) ;

   236     CyAsLLRequestResponse_Unpack(req_p, 1, len, dev_p->usb_ep_data) ;

   237 

   238     type = (uint8_t)((val >> 14) & 0x03) ;

   239     if (type == 0)

   240     {

   241         if (CyAsDeviceIsAckDelayed(dev_p))

   242         {

   243             /*

   244             * A setup packet has arrived while we are processing a previous setup packet.

   245             * Reset our state with respect to EP0 to be ready to process the new packet.

   246             */

   247             CyAsUsbResetEP0State(dev_p) ;

   248         }

   249 

   250         if (len != 8)

   251             CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

   252         else

   253         {

   254             CyAsDeviceClearEp0Stalled(dev_p) ;

   255             CyAsDeviceSetSetupPacket(dev_p) ;

   256             CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   257             if (dev_p->usb_event_cb_ms)

   258                 dev_p->usb_event_cb_ms(h, CyAsEventUsbSetupPacket, dev_p->usb_ep_data) ;

   259             else

   260                 dev_p->usb_event_cb(h, CyAsEventUsbSetupPacket, dev_p->usb_ep_data) ;

   261 

   262             if ((!CyAsDeviceIsAckDelayed(dev_p)) && (!CyAsDeviceIsEp0Stalled(dev_p)))

   263             {

   264                 CyAsUsbAckSetupPacket(h, UsbAckCallback, 0) ;

   265             }

   266         }

   267     }

   268     else if (type == 2)

   269     {

   270         if (len != 0)

   271             CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

   272         else

   273         {

   274             if (dev_p->usb_event_cb_ms)

   275                 dev_p->usb_event_cb_ms(h, CyAsEventUsbStatusPacket, 0) ;

   276             else

   277                 dev_p->usb_event_cb(h, CyAsEventUsbStatusPacket, 0) ;

   278 

   279             CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   280         }

   281     }

   282     else if (type == 1)

   283     {

   284         /*

   285         * We need to hand the data associated with these endpoints to the DMA

   286         * module.

   287         */

   288         CyAsDmaReceivedData(dev_p, ep, len, dev_p->usb_ep_data) ;

   289         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   290     }

   291 }

   292 

   293 static void

   294 MyUsbRequestCallbackInquiry(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

   295 {

   296     CyAsUsbInquiryData_dep cbdata ;

   297     CyAsUsbInquiryData cbdata_ms ;

   298     void *data ;

   299     uint16_t val ;

   300     CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   301     uint8_t def_inq_data[64] ;

   302     uint8_t evpd ;

   303     uint8_t codepage ;

   304     CyBool updated ;

   305     uint16_t length ;

   306 

   307     CyAsBusNumber_t bus ;

   308     uint32_t        device ;

   309     CyAsMediaType   media ;

   310 

   311     val    = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   312     bus    = CyAsStorageGetBusFromAddress(val) ;

   313     device = CyAsStorageGetDeviceFromAddress(val) ;

   314     media  = CyAsStorageGetMediaFromAddress(val) ;

   315 

   316     val      = CyAsLLRequestResponse_GetWord(req_p, 1) ;

   317     evpd     = (uint8_t)((val >> 8) & 0x01) ;

   318     codepage = (uint8_t)(val & 0xff) ;

   319 

   320     length = CyAsLLRequestResponse_GetWord(req_p, 2) ;

   321     data   = (void *)def_inq_data ;

   322 

   323     updated = CyFalse ;

   324 

   325     if (dev_p->usb_event_cb_ms)

   326     {

   327         cbdata_ms.bus = bus ;

   328         cbdata_ms.device = device ;

   329         cbdata_ms.updated = updated ;

   330         cbdata_ms.evpd = evpd ;

   331         cbdata_ms.codepage = codepage ;

   332         cbdata_ms.length = length ;

   333         cbdata_ms.data = data ;

   334 

   335         CyAsHalAssert(cbdata_ms.length <= sizeof(def_inq_data)) ;

   336         CyAsLLRequestResponse_Unpack(req_p, 3, cbdata_ms.length, cbdata_ms.data) ;

   337 

   338         dev_p->usb_event_cb_ms(h, CyAsEventUsbInquiryBefore, &cbdata_ms) ;

   339 

   340         updated = cbdata_ms.updated;

   341         data    = cbdata_ms.data ;

   342         length  = cbdata_ms.length ;

   343     }

   344     else if (dev_p->usb_event_cb)

   345     {

   346         cbdata.media = media ;

   347         cbdata.updated = updated ;

   348         cbdata.evpd = evpd ;

   349         cbdata.codepage = codepage ;

   350         cbdata.length = length ;

   351         cbdata.data = data ;

   352 

   353         CyAsHalAssert(cbdata.length <= sizeof(def_inq_data)) ;

   354         CyAsLLRequestResponse_Unpack(req_p, 3, cbdata.length, cbdata.data) ;

   355 

   356         dev_p->usb_event_cb(h, CyAsEventUsbInquiryBefore, &cbdata) ;

   357 

   358         updated = cbdata.updated ;

   359         data    = cbdata.data ;

   360         length  = cbdata.length ;

   361     }

   362 

   363     if (updated && length > 192)

   364         CyAsHalPrintMessage("An inquiry result from a CyAsEventUsbInquiryBefore event was greater than 192 bytes.") ;

   365 

   366     /* Now send the reply with the data back to the West Bridge device */

   367     if (updated && length <= 192)

   368     {

   369         /*

   370         * The callback function modified the inquiry data, ship the data back

   371         * to the West Bridge firmware.

   372         */

   373         CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_INQUIRY_DATA, length, data) ;

   374     }

   375     else

   376     {

   377         /*

   378         * The callback did not modify the data, just acknowledge that we

   379         * processed the request

   380         */

   381         CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ;

   382     }

   383 

   384     if (dev_p->usb_event_cb_ms)

   385         dev_p->usb_event_cb_ms(h, CyAsEventUsbInquiryAfter, &cbdata_ms) ;

   386     else if (dev_p->usb_event_cb)

   387         dev_p->usb_event_cb(h, CyAsEventUsbInquiryAfter, &cbdata) ;

   388 }

   389 

   390 static void

   391 MyUsbRequestCallbackStartStop(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

   392 {

   393     CyAsBusNumber_t bus ;

   394     CyAsMediaType media ;

   395     uint32_t device ;

   396     uint16_t val ;

   397 

   398     if (dev_p->usb_event_cb_ms || dev_p->usb_event_cb)

   399     {

   400         CyBool loej ;

   401         CyBool start ;

   402         CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   403 

   404         val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   405         bus = CyAsStorageGetBusFromAddress(val) ;

   406         device = CyAsStorageGetDeviceFromAddress(val) ;

   407         media = CyAsStorageGetMediaFromAddress(val) ;

   408 

   409         val = CyAsLLRequestResponse_GetWord(req_p, 1) ;

   410         loej = (val & 0x02) ? CyTrue : CyFalse ;

   411         start = (val & 0x01) ? CyTrue: CyFalse ;

   412 

   413         if (dev_p->usb_event_cb_ms)

   414         {

   415             CyAsUsbStartStopData cbdata_ms ;

   416 

   417             cbdata_ms.bus = bus ;

   418             cbdata_ms.device = device ;

   419             cbdata_ms.loej = loej ;

   420             cbdata_ms.start = start ;

   421             dev_p->usb_event_cb_ms(h, CyAsEventUsbStartStop, &cbdata_ms) ;

   422         }

   423         else if (dev_p->usb_event_cb)

   424         {

   425             CyAsUsbStartStopData_dep cbdata ;

   426 

   427             cbdata.media = media ;

   428             cbdata.loej = loej ;

   429             cbdata.start = start ;

   430             dev_p->usb_event_cb(h, CyAsEventUsbStartStop, &cbdata) ;

   431         }

   432     }

   433     CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ;

   434 }

   435 

   436 static void

   437 MyUsbRequestCallbackUknownCBW(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

   438 {

   439     uint16_t val ;

   440     CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   441     uint8_t buf[16] ;

   442 

   443     uint8_t response[4] ;

   444     uint16_t reqlen ;

   445     void *request ;

   446     uint8_t status ;

   447     uint8_t key ;

   448     uint8_t asc ;

   449     uint8_t ascq ;

   450 

   451     val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   452     status = 1 ;                                            /* Failed by default */

   453     key = 0x05 ;                                            /* Invalid command */

   454     asc = 0x20 ;                                            /* Invalid command */

   455     ascq = 0x00 ;                                   /* Invalid command */

   456     reqlen = CyAsLLRequestResponse_GetWord(req_p, 1) ;

   457     request = buf ;

   458 

   459     CyAsHalAssert(reqlen <= sizeof(buf)) ;

   460     CyAsLLRequestResponse_Unpack(req_p, 2, reqlen, request) ;

   461 

   462     if (dev_p->usb_event_cb_ms)

   463     {

   464         CyAsUsbUnknownCommandData cbdata_ms ;

   465         cbdata_ms.bus = CyAsStorageGetBusFromAddress(val) ;

   466         cbdata_ms.device = CyAsStorageGetDeviceFromAddress(val) ;

   467         cbdata_ms.reqlen = reqlen ;

   468         cbdata_ms.request = request ;

   469         cbdata_ms.status = status ;

   470         cbdata_ms.key = key ;

   471         cbdata_ms.asc = asc ;

   472         cbdata_ms.ascq = ascq ;

   473 

   474         dev_p->usb_event_cb_ms(h, CyAsEventUsbUnknownStorage, &cbdata_ms) ;

   475         status = cbdata_ms.status ;

   476         key = cbdata_ms.key ;

   477         asc = cbdata_ms.asc ;

   478         ascq = cbdata_ms.ascq ;

   479     }

   480     else if (dev_p->usb_event_cb)

   481     {

   482         CyAsUsbUnknownCommandData_dep cbdata ;

   483         cbdata.media = CyAsStorageGetMediaFromAddress(val) ;

   484         cbdata.reqlen = reqlen ;

   485         cbdata.request = request ;

   486         cbdata.status = status ;

   487         cbdata.key = key ;

   488         cbdata.asc = asc ;

   489         cbdata.ascq = ascq ;

   490 

   491         dev_p->usb_event_cb(h, CyAsEventUsbUnknownStorage, &cbdata) ;

   492         status = cbdata.status ;

   493         key = cbdata.key ;

   494         asc = cbdata.asc ;

   495         ascq = cbdata.ascq ;

   496     }

   497 

   498     response[0] = status ;

   499     response[1] = key ;

   500     response[2] = asc ;

   501     response[3] = ascq ;

   502     CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_UNKNOWN_SCSI_COMMAND, sizeof(response), response) ;

   503 }

   504 

   505 static void

   506 MyUsbRequestCallbackMSCProgress(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

   507 {

   508     uint16_t val1, val2 ;

   509     CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   510 

   511     if ((dev_p->usb_event_cb) || (dev_p->usb_event_cb_ms))

   512     {

   513         CyAsMSCProgressData cbdata ;

   514 

   515         val1 = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   516         val2 = CyAsLLRequestResponse_GetWord(req_p, 1) ;

   517         cbdata.wr_count = (uint32_t)((val1 << 16) | val2) ;

   518 

   519         val1 = CyAsLLRequestResponse_GetWord(req_p, 2) ;

   520         val2 = CyAsLLRequestResponse_GetWord(req_p, 3) ;

   521         cbdata.rd_count = (uint32_t)((val1 << 16) | val2) ;

   522 

   523         if (dev_p->usb_event_cb)

   524             dev_p->usb_event_cb(h, CyAsEventUsbMSCProgress, &cbdata) ;

   525         else

   526             dev_p->usb_event_cb_ms(h, CyAsEventUsbMSCProgress, &cbdata) ;

   527     }

   528 

   529     CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   530 }

   531 

   532 /*

   533 * This function processes the requests delivered from the firmware within the West Bridge

   534 * device that are delivered in the USB context.  These requests generally are EP0 and

   535 * EP1 related requests or USB events.

   536 */

   537 static void

   538 MyUsbRequestCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p, CyAsLLRequestResponse *resp_p,

   539                      CyAsReturnStatus_t ret)

   540 {

   541     uint16_t val ;

   542     uint8_t code = CyAsLLRequestResponse_GetCode(req_p) ;

   543 

   544     (void)resp_p ;

   545     (void)context ;

   546     (void)ret ;

   547 

   548     switch(code)

   549     {

   550     case CY_RQT_USB_EVENT:

   551         MyUsbRequestCallbackUsbEvent(dev_p, req_p) ;

   552         break ;

   553 

   554     case CY_RQT_USB_EP_DATA:

   555         dev_p->usb_last_event = CyAsEventUsbSetupPacket ;

   556         MyUsbRequestCallbackUsbData(dev_p, req_p) ;

   557         break ;

   558 

   559     case CY_RQT_SCSI_INQUIRY_COMMAND:

   560         dev_p->usb_last_event = CyAsEventUsbInquiryAfter ;

   561         MyUsbRequestCallbackInquiry(dev_p, req_p) ;

   562         break ;

   563 

   564     case CY_RQT_SCSI_START_STOP_COMMAND:

   565         dev_p->usb_last_event = CyAsEventUsbStartStop ;

   566         MyUsbRequestCallbackStartStop(dev_p, req_p) ;

   567         break ;

   568 

   569     case CY_RQT_SCSI_UNKNOWN_COMMAND:

   570         dev_p->usb_last_event = CyAsEventUsbUnknownStorage ;

   571         MyUsbRequestCallbackUknownCBW(dev_p, req_p) ;

   572         break ;

   573 

   574     case CY_RQT_USB_ACTIVITY_UPDATE:

   575         dev_p->usb_last_event = CyAsEventUsbMSCProgress ;

   576         MyUsbRequestCallbackMSCProgress(dev_p, req_p) ;

   577         break ;

   578 

   579     default:

   580         CyAsHalPrintMessage("Invalid request received on USB context\n") ;

   581         val = req_p->box0 ;

   582         CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_INVALID_REQUEST, sizeof(val), &val) ;

   583         break ;

   584     }

   585 }

   586 

   587 static CyAsReturnStatus_t

   588 MyHandleResponseUsbStart(CyAsDevice* dev_p,

   589                          CyAsLLRequestResponse *req_p,

   590                          CyAsLLRequestResponse *reply_p,

   591                          CyAsReturnStatus_t ret)

   592 {

   593     if (ret != CY_AS_ERROR_SUCCESS)

   594         goto destroy ;

   595 

   596     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   597     {

   598         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   599         goto destroy ;

   600     }

   601 

   602     ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

   603     if (ret != CY_AS_ERROR_SUCCESS)

   604         goto destroy ;

   605 

   606     /*

   607     * Mark EP 0 and EP1 as 64 byte endpoints

   608     */

   609     CyAsDmaSetMaxDmaSize(dev_p, 0, 64) ;

   610     CyAsDmaSetMaxDmaSize(dev_p, 1, 64) ;

   611 

   612     dev_p->usb_count++ ;

   613 

   614 destroy :

   615     CyAsLLDestroyRequest(dev_p, req_p) ;

   616     CyAsLLDestroyResponse(dev_p, reply_p) ;

   617 

   618     if (ret != CY_AS_ERROR_SUCCESS)

   619     {

   620         CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;

   621         CyAsLLRegisterRequestCallback(dev_p, CY_RQT_USB_RQT_CONTEXT, 0) ;

   622     }

   623 

   624     CyAsDeviceClearUSSPending(dev_p) ;

   625 

   626     return ret ;

   627 

   628 }

   629 

   630 /*

   631 * This function starts the USB stack.  The stack is reference counted so if the stack is already

   632 * started, this function just increments the count.  If the stack has not been started, a start

   633 * request is sent to the West Bridge device.

   634 *

   635 * Note: Starting the USB stack does not cause the USB signals to be connected to the USB pins.  To do

   636 *       this and therefore initiate enumeration, CyAsUsbConnect() must be called.

   637 */

   638 CyAsReturnStatus_t

   639 CyAsUsbStart(CyAsDeviceHandle handle,

   640                CyAsFunctionCallback cb,

   641                uint32_t client)

   642 {

   643     CyAsLLRequestResponse *req_p, *reply_p ;

   644     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   645 

   646     CyAsDevice*dev_p ;

   647 

   648     CyAsLogDebugMessage(6, "CyAsUsbStart called") ;

   649 

   650     dev_p = (CyAsDevice *)handle ;

   651     if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

   652         return CY_AS_ERROR_INVALID_HANDLE ;

   653 

   654     if (!CyAsDeviceIsConfigured(dev_p))

   655         return CY_AS_ERROR_NOT_CONFIGURED ;

   656 

   657     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

   658         return CY_AS_ERROR_NO_FIRMWARE ;

   659 

   660     if (CyAsDeviceIsInSuspendMode(dev_p))

   661         return CY_AS_ERROR_IN_SUSPEND ;

   662 

   663     if (CyAsDeviceIsInCallback(dev_p))

   664         return CY_AS_ERROR_INVALID_IN_CALLBACK ;

   665 

   666     if(CyAsDeviceIsUSSPending(dev_p))

   667         return CY_AS_ERROR_STARTSTOP_PENDING ;

   668 

   669     CyAsDeviceSetUSSPending(dev_p) ;

   670 

   671     if (dev_p->usb_count == 0)

   672     {

   673         /*

   674         * Since we are just starting the stack, mark USB as not connected to the

   675         * remote host

   676         */

   677         CyAsDeviceClearUsbConnected(dev_p) ;

   678         dev_p->usb_phy_config = 0 ;

   679 

   680         /* Queue for 1.0 Async Requests, kept for backwards compatibility */

   681         dev_p->usb_func_cbs = CyAsCreateCBQueue(CYAS_USB_FUNC_CB) ;

   682         if(dev_p->usb_func_cbs == 0)

   683         {

   684             CyAsDeviceClearUSSPending(dev_p) ;

   685             return CY_AS_ERROR_OUT_OF_MEMORY ;

   686         }

   687 

   688         /* Reset the EP0 state */

   689         CyAsUsbResetEP0State(dev_p) ;

   690 

   691         /*

   692         * We register here becuase the start request may cause events to occur before the

   693         * response to the start request.

   694         */

   695         CyAsLLRegisterRequestCallback(dev_p, CY_RQT_USB_RQT_CONTEXT, MyUsbRequestCallback) ;

   696 

   697         /* Create the request to send to the West Bridge device */

   698         req_p = CyAsLLCreateRequest(dev_p, CY_RQT_START_USB, CY_RQT_USB_RQT_CONTEXT, 0) ;

   699         if (req_p == 0)

   700         {

   701             CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;

   702             dev_p->usb_func_cbs = 0 ;

   703             CyAsDeviceClearUSSPending(dev_p) ;

   704             return CY_AS_ERROR_OUT_OF_MEMORY ;

   705         }

   706 

   707         /* Reserve space for the reply, the reply data will not exceed one word */

   708         reply_p = CyAsLLCreateResponse(dev_p, 1) ;

   709         if (reply_p == 0)

   710         {

   711             CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;

   712             dev_p->usb_func_cbs = 0 ;

   713             CyAsLLDestroyRequest(dev_p, req_p) ;

   714             CyAsDeviceClearUSSPending(dev_p) ;

   715             return CY_AS_ERROR_OUT_OF_MEMORY ;

   716         }

   717 

   718         if(cb == 0)

   719         {

   720             ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;

   721             if (ret != CY_AS_ERROR_SUCCESS)

   722                 goto destroy ;

   723 

   724             return MyHandleResponseUsbStart(dev_p, req_p, reply_p, ret) ;

   725         }

   726         else

   727         {

   728             ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_START,

   729                 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,

   730                 CyAsUsbFuncCallback) ;

   731 

   732             if (ret != CY_AS_ERROR_SUCCESS)

   733                 goto destroy ;

   734 

   735             return ret ;

   736         }

   737 

   738 destroy:

   739         CyAsLLDestroyRequest(dev_p, req_p) ;

   740         CyAsLLDestroyResponse(dev_p, reply_p) ;

   741     }

   742     else

   743     {

   744         dev_p->usb_count++ ;

   745         if (cb)

   746             cb(handle, ret, client, CY_FUNCT_CB_USB_START, 0) ;

   747     }

   748 

   749     CyAsDeviceClearUSSPending(dev_p) ;

   750 

   751     return ret ;

   752 }

   753 

   754 void

   755 CyAsUsbReset(CyAsDevice *dev_p)

   756 {

   757     int i ;

   758 

   759     CyAsDeviceClearUsbConnected(dev_p) ;

   760 

   761     for(i = 0 ; i < sizeof(dev_p->usb_config)/sizeof(dev_p->usb_config[0]) ; i++)

   762     {

   763         /*

   764          * Cancel all pending USB read/write operations, as it is possible

   765          * that the USB stack comes up in a different configuration with a

   766          * different set of endpoints.

   767          */

   768         if (CyAsDeviceIsUsbAsyncPending(dev_p, i))

   769             CyAsUsbCancelAsync(dev_p, (CyAsEndPointNumber_t)i) ;

   770 

   771         dev_p->usb_cb[i] = 0 ;

   772         dev_p->usb_config[i].enabled = CyFalse ;

   773     }

   774 

   775     dev_p->usb_phy_config = 0 ;

   776 }

   777 

   778 /*

   779  * This function does all the API side clean-up associated with CyAsUsbStop,

   780  * without any communication with firmware. This needs to be done when the

   781  * device is being reset while the USB stack is active.

   782  */

   783 void

   784 CyAsUsbCleanup(CyAsDevice *dev_p)

   785 {

   786     if (dev_p->usb_count)

   787     {

   788         CyAsUsbResetEP0State(dev_p) ;

   789         CyAsUsbReset(dev_p) ;

   790         CyAsHalMemSet(dev_p->usb_config, 0, sizeof(dev_p->usb_config)) ;

   791         CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;

   792 

   793         dev_p->usb_count = 0 ;

   794     }

   795 }

   796 

   797 static CyAsReturnStatus_t

   798 MyHandleResponseUsbStop(CyAsDevice* dev_p,

   799                          CyAsLLRequestResponse *req_p,

   800                          CyAsLLRequestResponse *reply_p,

   801                          CyAsReturnStatus_t ret)

   802 {

   803     if (ret != CY_AS_ERROR_SUCCESS)

   804         goto destroy ;

   805 

   806     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   807     {

   808         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   809         goto destroy ;

   810     }

   811 

   812     ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

   813     if (ret != CY_AS_ERROR_SUCCESS)

   814         goto destroy ;

   815 

   816     /*

   817      * We sucessfully shutdown the stack, so decrement to make the count

   818      * zero.

   819      */

   820     CyAsUsbCleanup(dev_p) ;

   821 

   822 destroy :

   823     CyAsLLDestroyRequest(dev_p, req_p) ;

   824     CyAsLLDestroyResponse(dev_p, reply_p) ;

   825 

   826     if (ret != CY_AS_ERROR_SUCCESS)

   827         CyAsLLRegisterRequestCallback(dev_p, CY_RQT_USB_RQT_CONTEXT, 0) ;

   828 

   829     CyAsDeviceClearUSSPending(dev_p) ;

   830 

   831     return ret ;

   832 }

   833 

   834 /*

   835 * This function stops the USB stack.  The USB stack is reference counted so first is reference count is

   836 * decremented.  If the reference count is then zero, a request is sent to the West Bridge device to stop the USB

   837 * stack on the West Bridge device.

   838 */

   839 CyAsReturnStatus_t

   840 CyAsUsbStop(CyAsDeviceHandle handle,

   841               CyAsFunctionCallback cb,

   842               uint32_t client)

   843 {

   844     CyAsLLRequestResponse *req_p = 0, *reply_p = 0 ;

   845     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   846 

   847     CyAsDevice*dev_p ;

   848 

   849     CyAsLogDebugMessage(6, "CyAsUsbStop called") ;

   850 

   851     dev_p = (CyAsDevice *)handle ;

   852     if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

   853         return CY_AS_ERROR_INVALID_HANDLE ;

   854 

   855     ret = IsUsbActive(dev_p) ;

   856     if (ret != CY_AS_ERROR_SUCCESS)

   857         return ret ;

   858 

   859     if (CyAsDeviceIsUsbConnected(dev_p))

   860         return CY_AS_ERROR_USB_CONNECTED ;

   861 

   862     if (CyAsDeviceIsInCallback(dev_p))

   863         return CY_AS_ERROR_INVALID_IN_CALLBACK ;

   864 

   865     if(CyAsDeviceIsUSSPending(dev_p))

   866         return CY_AS_ERROR_STARTSTOP_PENDING ;

   867 

   868     CyAsDeviceSetUSSPending(dev_p) ;

   869 

   870     if (dev_p->usb_count == 1)

   871     {

   872         /* Create the request to send to the West Bridge device */

   873         req_p = CyAsLLCreateRequest(dev_p, CY_RQT_STOP_USB, CY_RQT_USB_RQT_CONTEXT, 0) ;

   874         if (req_p == 0)

   875         {

   876             ret = CY_AS_ERROR_OUT_OF_MEMORY ;

   877             goto destroy ;

   878         }

   879 

   880         /* Reserve space for the reply, the reply data will not exceed one word */

   881         reply_p = CyAsLLCreateResponse(dev_p, 1) ;

   882         if (reply_p == 0)

   883         {

   884             ret = CY_AS_ERROR_OUT_OF_MEMORY ;

   885             goto destroy ;

   886         }

   887 

   888         if(cb == 0)

   889         {

   890             ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;

   891             if (ret != CY_AS_ERROR_SUCCESS)

   892                 goto destroy ;

   893 

   894             return MyHandleResponseUsbStop(dev_p, req_p, reply_p, ret) ;

   895         }

   896         else

   897         {

   898             ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_STOP,

   899                 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,

   900                 CyAsUsbFuncCallback) ;

   901 

   902             if (ret != CY_AS_ERROR_SUCCESS)

   903                 goto destroy ;

   904 

   905             return ret ;

   906         }

   907 

   908 destroy:

   909         CyAsLLDestroyRequest(dev_p, req_p) ;

   910         CyAsLLDestroyResponse(dev_p, reply_p) ;

   911     }

   912     else if (dev_p->usb_count > 1)

   913     {

   914         /*

   915          * Reset all LEPs to inactive state, after cleaning up any

   916          * pending async read/write calls.

   917          */

   918         CyAsUsbReset(dev_p) ;

   919         dev_p->usb_count-- ;

   920 

   921         if (cb)

   922             cb(handle, ret, client, CY_FUNCT_CB_USB_STOP, 0) ;

   923     }

   924 

   925     CyAsDeviceClearUSSPending(dev_p) ;

   926 

   927     return ret ;

   928 }

   929 

   930 /*

   931 * This function registers a callback to be called when USB events are processed

   932 */

   933 CyAsReturnStatus_t

   934 CyAsUsbRegisterCallback(CyAsDeviceHandle handle, CyAsUsbEventCallback callback)

   935 {

   936     CyAsDevice*dev_p ;

   937 

   938     CyAsLogDebugMessage(6, "CyAsUsbRegisterCallback called") ;

   939 

   940     dev_p = (CyAsDevice *)handle ;

   941     if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

   942         return CY_AS_ERROR_INVALID_HANDLE ;

   943 

   944     if (!CyAsDeviceIsConfigured(dev_p))

   945         return CY_AS_ERROR_NOT_CONFIGURED ;

   946 

   947     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

   948         return CY_AS_ERROR_NO_FIRMWARE ;

   949 

   950     dev_p->usb_event_cb = NULL ;

   951     dev_p->usb_event_cb_ms = callback ;

   952     return CY_AS_ERROR_SUCCESS ;

   953 }

   954 

   955 

   956 static CyAsReturnStatus_t

   957 MyHandleResponseNoData(CyAsDevice* dev_p,

   958                          CyAsLLRequestResponse *req_p,

   959                          CyAsLLRequestResponse *reply_p)

   960 {

   961     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   962 

   963     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   964         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   965     else

   966         ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

   967 

   968     CyAsLLDestroyRequest(dev_p, req_p) ;

   969     CyAsLLDestroyResponse(dev_p, reply_p) ;

   970 

   971     return ret ;

   972 }

   973 

   974 static CyAsReturnStatus_t

   975 MyHandleResponseConnect(CyAsDevice* dev_p,

   976                        CyAsLLRequestResponse *req_p,

   977                        CyAsLLRequestResponse *reply_p,

   978                        CyAsReturnStatus_t ret)

   979 {

   980     if (ret != CY_AS_ERROR_SUCCESS)

   981         goto destroy ;

   982 

   983     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   984     {

   985         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   986         goto destroy ;

   987     }

   988 

   989     ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

   990     if (ret == CY_AS_ERROR_SUCCESS)

   991         CyAsDeviceSetUsbConnected(dev_p) ;

   992 

   993 destroy :

   994     CyAsLLDestroyRequest(dev_p, req_p) ;

   995     CyAsLLDestroyResponse(dev_p, reply_p) ;

   996 

   997     return ret ;

   998 }

   999 

  1000 

  1001 /*

  1002 * This method asks the West Bridge device to connect the internal USB D+ and D- signals to the USB

  1003 * pins, thus starting the enumeration processes if the external pins are connnected to a USB host.

  1004 * If the external pins are not connect to a USB host, enumeration will begin as soon as the USB

  1005 * pins are connected to a host.

  1006 */

  1007 CyAsReturnStatus_t

  1008 CyAsUsbConnect(CyAsDeviceHandle handle,

  1009                  CyAsFunctionCallback cb,

  1010                  uint32_t client)

  1011 {

  1012     CyAsLLRequestResponse *req_p , *reply_p ;

  1013     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

  1014 

  1015     CyAsDevice*dev_p ;

  1016 

  1017     CyAsLogDebugMessage(6, "CyAsUsbConnect called") ;

  1018 

  1019     dev_p = (CyAsDevice *)handle ;

  1020     if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

  1021         return CY_AS_ERROR_INVALID_HANDLE ;

  1022 

  1023     ret = IsUsbActive(dev_p) ;

  1024     if (ret != CY_AS_ERROR_SUCCESS)

  1025         return ret ;

  1026 

  1027     if (CyAsDeviceIsInCallback(dev_p))

  1028         return CY_AS_ERROR_INVALID_IN_CALLBACK ;

  1029 

  1030     /* Create the request to send to the West Bridge device */

  1031     req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1) ;

  1032     if (req_p == 0)

  1033         return CY_AS_ERROR_OUT_OF_MEMORY ;

  1034 

  1035     /* 1 = Connect request */

  1036     CyAsLLRequestResponse_SetWord(req_p, 0, 1) ;

  1037 

  1038     /* Reserve space for the reply, the reply data will not exceed one word */

  1039     reply_p = CyAsLLCreateResponse(dev_p, 1) ;

  1040     if (reply_p == 0)

  1041     {

  1042         CyAsLLDestroyRequest(dev_p, req_p) ;

  1043         return CY_AS_ERROR_OUT_OF_MEMORY ;

  1044     }

  1045 

  1046     if(cb == 0)

  1047     {

  1048         ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;

  1049         if (ret != CY_AS_ERROR_SUCCESS)

  1050             goto destroy ;

  1051 

  1052         return MyHandleResponseConnect(dev_p, req_p, reply_p, ret) ;

  1053     }

  1054     else

  1055     {

  1056         ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_CONNECT,

  1057             0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,

  1058             CyAsUsbFuncCallback) ;

  1059 

  1060         if (ret != CY_AS_ERROR_SUCCESS)

  1061             goto destroy ;

  1062 

  1063         return ret ;

  1064     }

  1065 

  1066 destroy:

  1067     CyAsLLDestroyRequest(dev_p, req_p) ;

  1068     CyAsLLDestroyResponse(dev_p, reply_p) ;

  1069 

  1070     return ret ;

  1071 }

  1072 

  1073 static CyAsReturnStatus_t

  1074 MyHandleResponseDisconnect(CyAsDevice* dev_p,

  1075                        CyAsLLRequestResponse *req_p,

  1076                        CyAsLLRequestResponse *reply_p,

  1077                        CyAsReturnStatus_t ret)

  1078 {

  1079     if (ret != CY_AS_ERROR_SUCCESS)

  1080         goto destroy ;

  1081 

  1082     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

  1083     {

  1084         ret = CY_AS_ERROR_INVALID_RESPONSE ;

  1085         goto destroy ;

  1086     }

  1087 

  1088     ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

  1089     if (ret == CY_AS_ERROR_SUCCESS)

  1090         CyAsDeviceClearUsbConnected(dev_p) ;

  1091 

  1092 destroy :

  1093     CyAsLLDestroyRequest(dev_p, req_p) ;

  1094     CyAsLLDestroyResponse(dev_p, reply_p) ;

  1095 

  1096     return ret ;

  1097 }

  1098 /*

  1099 * This method forces a disconnect of the D+ and D- pins external to the West Bridge device from the

  1100 * D+ and D- signals internally, effectively disconnecting the West Bridge device from any connectec

  1101 * USB host.

  1102 */

  1103 CyAsReturnStatus_t

  1104 CyAsUsbDisconnect(CyAsDeviceHandle handle,

  1105                     CyAsFunctionCallback cb,

  1106                     uint32_t client)

  1107 {

  1108     CyAsLLRequestResponse *req_p , *reply_p ;

  1109     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

  1110 

  1111     CyAsDevice*dev_p ;

  1112 

  1113     CyAsLogDebugMessage(6, "CyAsUsbDisconnect called") ;

  1114 

  1115     dev_p = (CyAsDevice *)handle ;

  1116     if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

  1117         return CY_AS_ERROR_INVALID_HANDLE ;

  1118 

  1119     ret = IsUsbActive(dev_p) ;

  1120     if (ret != CY_AS_ERROR_SUCCESS)

  1121         return ret ;

  1122 

  1123     if (CyAsDeviceIsInCallback(dev_p))

  1124         return CY_AS_ERROR_INVALID_IN_CALLBACK ;

  1125 

  1126     if (!CyAsDeviceIsUsbConnected(dev_p))

  1127         return CY_AS_ERROR_USB_NOT_CONNECTED ;

  1128 

  1129     /* Create the request to send to the West Bridge device */

  1130     req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1) ;

  1131     if (req_p == 0)

  1132         return CY_AS_ERROR_OUT_OF_MEMORY ;

  1133 

  1134     CyAsLLRequestResponse_SetWord(req_p, 0, 0) ;