1 /* Cypress West Bridge API source file (cyasstorage.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 /*

    23 * Storage Design

    24 *

    25 * The storage module is fairly straight forward once the DMA and LOWLEVEL modules

    26 * have been designed.  The storage module simple takes requests from the user, queues the

    27 * associated DMA requests for action, and then sends the low level requests to the

    28 * West Bridge firmware.

    29 *

    30 */

    31 

    32 #include "cyashal.h"

    33 #include "cyasstorage.h"

    34 #include "cyaserr.h"

    35 #include "cyasdevice.h"

    36 #include "cyaslowlevel.h"

    37 #include "cyasdma.h"

    38 #include "cyasregs.h"

    39 

    40 /* Map a pre-V1.2 media type to the V1.2+ bus number */

    41 CyAsReturnStatus_t

    42 CyAnMapBusFromMediaType(CyAsDevice *dev_p, CyAsMediaType type, CyAsBusNumber_t *bus)

    43 {

    44     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    45     uint8_t code = (uint8_t)(1 << type) ;

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

    47         return CY_AS_ERROR_INVALID_HANDLE ;

    48 

    49     if (!CyAsDeviceIsConfigured(dev_p))

    50         return CY_AS_ERROR_NOT_CONFIGURED ;

    51 

    52     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

    53         return CY_AS_ERROR_NO_FIRMWARE ;

    54 

    55 

    56     if (dev_p->media_supported[0] & code)

    57     {

    58         if (dev_p->media_supported[1] & code)

    59         {

    60             /*

    61              * This media type could be supported on multiple buses. So, report

    62              * an address resolution error.

    63              */

    64             ret = CY_AS_ERROR_ADDRESS_RESOLUTION_ERROR ;

    65         }

    66         else

    67             *bus = 0 ;

    68     }

    69     else

    70     {

    71         if (dev_p->media_supported[1] & code)

    72             *bus = 1 ;

    73         else

    74             ret = CY_AS_ERROR_NO_SUCH_MEDIA ;

    75     }

    76 

    77     return ret ;

    78 }

    79 

    80 static uint16_t

    81 CreateAddress(CyAsBusNumber_t bus, uint32_t device, uint8_t unit)

    82 {

    83     CyAsHalAssert(bus >= 0  && bus < CY_AS_MAX_BUSES) ;

    84     CyAsHalAssert(device < 16) ;

    85 

    86     return (uint16_t)(((uint8_t)bus << 12) | (device << 8) | unit) ;

    87 }

    88 

    89 CyAsMediaType

    90 CyAsStorageGetMediaFromAddress(uint16_t v)

    91 {

    92     CyAsMediaType media = CyAsMediaMaxMediaValue ;

    93 

    94     switch(v & 0xFF)

    95     {

    96         case 0x00:

    97             break;

    98         case 0x01:

    99             media = CyAsMediaNand ;

   100             break ;

   101         case 0x02:

   102             media = CyAsMediaSDFlash ;

   103             break ;

   104         case 0x04:

   105             media = CyAsMediaMMCFlash ;

   106             break ;

   107         case 0x08:

   108             media = CyAsMediaCEATA ;

   109             break ;

   110         case 0x10:

   111             media = CyAsMediaSDIO ;

   112             break ;

   113         default:

   114             CyAsHalAssert(0) ;

   115             break ;

   116     }

   117 

   118     return media ;

   119 }

   120 

   121 CyAsBusNumber_t

   122 CyAsStorageGetBusFromAddress(uint16_t v)

   123 {

   124     CyAsBusNumber_t bus = (CyAsBusNumber_t)((v >> 12) & 0x0f) ;

   125     CyAsHalAssert(bus >= 0 && bus < CY_AS_MAX_BUSES) ;

   126     return bus ;

   127 }

   128 

   129 uint32_t

   130 CyAsStorageGetDeviceFromAddress(uint16_t v)

   131 {

   132     return (uint32_t)((v >> 8) & 0x0f) ;

   133 }

   134 

   135 static uint8_t

   136 GetUnitFromAddress(uint16_t v)

   137 {

   138     return (uint8_t)(v & 0xff) ;

   139 }

   140 

   141 static CyAsReturnStatus_t

   142 CyAsMapBadAddr(uint16_t val)

   143 {

   144     CyAsReturnStatus_t ret = CY_AS_ERROR_INVALID_RESPONSE ;

   145 

   146     switch(val)

   147     {

   148     case 0:

   149         ret = CY_AS_ERROR_NO_SUCH_BUS ;

   150         break ;

   151     case 1:

   152         ret = CY_AS_ERROR_NO_SUCH_DEVICE ;

   153         break ;

   154     case 2:

   155         ret = CY_AS_ERROR_NO_SUCH_UNIT ;

   156         break ;

   157     case 3:

   158         ret = CY_AS_ERROR_INVALID_BLOCK ;

   159         break ;

   160     }

   161 

   162     return ret ;

   163 }

   164 

   165 static void

   166 MyStorageRequestCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p,

   167                          CyAsLLRequestResponse *resp_p, CyAsReturnStatus_t ret)

   168 {

   169     uint16_t val ;

   170     uint16_t addr ;

   171     CyAsBusNumber_t bus;

   172     uint32_t device;

   173     CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

   174     CyAsDmaEndPoint *ep_p = NULL ;

   175 

   176     (void)resp_p ;

   177     (void)context ;

   178     (void)ret ;

   179 

   180     switch(CyAsLLRequestResponse_GetCode(req_p))

   181     {

   182     case CY_RQT_MEDIA_CHANGED:

   183         CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   184 

   185         /* Media has either been inserted or removed */

   186         addr = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   187 

   188         bus = CyAsStorageGetBusFromAddress(addr);

   189         device = CyAsStorageGetDeviceFromAddress(addr);

   190 

   191         /* Clear the entry for this device to force re-query later */

   192         CyAsHalMemSet(&(dev_p->storage_device_info[bus][device]), 0,

   193             sizeof(dev_p->storage_device_info[bus][device])) ;

   194 

   195         val = CyAsLLRequestResponse_GetWord(req_p, 1) ;

   196         if (dev_p->storage_event_cb_ms)

   197         {

   198             if (val == 1)

   199                 dev_p->storage_event_cb_ms(h, bus, device, CyAsStorageRemoved, 0) ;

   200             else

   201                 dev_p->storage_event_cb_ms(h, bus, device, CyAsStorageInserted, 0) ;

   202         }

   203         else if (dev_p->storage_event_cb)

   204         {

   205             if (val == 1)

   206                 dev_p->storage_event_cb(h, (CyAsMediaType)bus, CyAsStorageRemoved, 0) ; /*nxz*/

   207             else

   208                 dev_p->storage_event_cb(h, (CyAsMediaType)bus, CyAsStorageInserted, 0) ; /*nxz*/

   209         }

   210 

   211         break ;

   212 

   213     case CY_RQT_ANTIOCH_CLAIM:

   214         CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   215         if (dev_p->storage_event_cb || dev_p->storage_event_cb_ms)

   216         {

   217             val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   218             if (dev_p->storage_event_cb_ms)

   219             {

   220                 if (val & 0x0100)

   221                     dev_p->storage_event_cb_ms(h, 0, 0, CyAsStorageAntioch, 0) ;

   222                 if (val & 0x0200)

   223                     dev_p->storage_event_cb_ms(h, 1, 0, CyAsStorageAntioch, 0) ;

   224             }

   225             else

   226             {

   227                 if (val & 0x01)

   228                     dev_p->storage_event_cb(h, CyAsMediaNand, CyAsStorageAntioch, 0) ;

   229                 if (val & 0x02)

   230                     dev_p->storage_event_cb(h, CyAsMediaSDFlash, CyAsStorageAntioch, 0) ;

   231                 if (val & 0x04)

   232                     dev_p->storage_event_cb(h, CyAsMediaMMCFlash, CyAsStorageAntioch, 0) ;

   233                 if (val & 0x08)

   234                     dev_p->storage_event_cb(h, CyAsMediaCEATA, CyAsStorageAntioch, 0) ;

   235             }

   236         }

   237         break ;

   238 

   239     case CY_RQT_ANTIOCH_RELEASE:

   240         CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   241         val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   242         if (dev_p->storage_event_cb_ms)

   243         {

   244             if (val & 0x0100)

   245                 dev_p->storage_event_cb_ms(h, 0, 0, CyAsStorageProcessor, 0) ;

   246             if (val & 0x0200)

   247                 dev_p->storage_event_cb_ms(h, 1, 0, CyAsStorageProcessor, 0) ;

   248         }

   249         else if (dev_p->storage_event_cb)

   250         {

   251             if (val & 0x01)

   252                 dev_p->storage_event_cb(h, CyAsMediaNand, CyAsStorageProcessor, 0) ;

   253             if (val & 0x02)

   254                 dev_p->storage_event_cb(h, CyAsMediaSDFlash, CyAsStorageProcessor, 0) ;

   255             if (val & 0x04)

   256                 dev_p->storage_event_cb(h, CyAsMediaMMCFlash, CyAsStorageProcessor, 0) ;

   257             if (val & 0x08)

   258                 dev_p->storage_event_cb(h, CyAsMediaCEATA, CyAsStorageProcessor, 0) ;

   259         }

   260         break ;

   261 

   262 

   263     case CY_RQT_SDIO_INTR:

   264         CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   265         val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

   266         if (dev_p->storage_event_cb_ms)

   267         {

   268             if (val & 0x0100)

   269                 dev_p->storage_event_cb_ms(h, 1, 0, CyAsSdioInterrupt, 0) ;

   270             else

   271                 dev_p->storage_event_cb_ms(h, 0, 0, CyAsSdioInterrupt, 0) ;

   272 

   273         }

   274         else if (dev_p->storage_event_cb)

   275         {

   276             dev_p->storage_event_cb(h, CyAsMediaSDIO, CyAsSdioInterrupt, 0) ;

   277         }

   278         break;

   279 

   280     case CY_RQT_P2S_DMA_START:

   281         /* Do the DMA setup for the waiting operation. This event is used only in

   282          * the MTP mode firmware. */

   283         CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

   284         if (dev_p->storage_oper == CyAsOpRead)

   285         {

   286             ep_p = CY_AS_NUM_EP(dev_p, CY_AS_P2S_READ_ENDPOINT) ;

   287             CyAsDmaEndPointSetStopped(ep_p) ;

   288             CyAsDmaKickStart(dev_p, CY_AS_P2S_READ_ENDPOINT) ;

   289         }

   290         else

   291         {

   292             ep_p = CY_AS_NUM_EP(dev_p, CY_AS_P2S_WRITE_ENDPOINT) ;

   293             CyAsDmaEndPointSetStopped(ep_p) ;

   294             CyAsDmaKickStart(dev_p, CY_AS_P2S_WRITE_ENDPOINT) ;

   295         }

   296         break ;

   297 

   298     default:

   299         CyAsHalPrintMessage("Invalid request received on storage context\n") ;

   300         val = req_p->box0 ;

   301         CyAsLLSendDataResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_RESP_INVALID_REQUEST, sizeof(val), &val) ;

   302         break ;

   303     }

   304 }

   305 

   306 static CyAsReturnStatus_t

   307 IsStorageActive(CyAsDevice *dev_p)

   308 {

   309     if (!CyAsDeviceIsConfigured(dev_p))

   310         return CY_AS_ERROR_NOT_CONFIGURED ;

   311 

   312     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

   313         return CY_AS_ERROR_NO_FIRMWARE ;

   314 

   315     if (dev_p->storage_count == 0)

   316         return CY_AS_ERROR_NOT_RUNNING ;

   317 

   318     if (CyAsDeviceIsInSuspendMode(dev_p))

   319         return CY_AS_ERROR_IN_SUSPEND ;

   320 

   321     return CY_AS_ERROR_SUCCESS ;

   322 }

   323 

   324 static void

   325 CyAsStorageFuncCallback(CyAsDevice *dev_p,

   326                         uint8_t context,

   327                         CyAsLLRequestResponse *rqt,

   328                         CyAsLLRequestResponse *resp,

   329                         CyAsReturnStatus_t ret) ;

   330 

   331 static CyAsReturnStatus_t

   332 MyHandleResponseNoData(CyAsDevice* dev_p,

   333                          CyAsLLRequestResponse *req_p,

   334                          CyAsLLRequestResponse *reply_p)

   335 {

   336     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   337 

   338     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   339     {

   340         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   341         goto destroy ;

   342     }

   343 

   344     ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

   345 

   346 destroy :

   347     CyAsLLDestroyRequest(dev_p, req_p) ;

   348     CyAsLLDestroyResponse(dev_p, reply_p) ;

   349 

   350     return ret ;

   351 }

   352 

   353 static CyAsReturnStatus_t

   354 MyHandleResponseStorageStart(CyAsDevice* dev_p,

   355                          CyAsLLRequestResponse *req_p,

   356                          CyAsLLRequestResponse *reply_p,

   357                          CyAsReturnStatus_t ret)

   358 {

   359     if (ret != CY_AS_ERROR_SUCCESS)

   360         goto destroy ;

   361 

   362     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   363     {

   364         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   365         goto destroy ;

   366     }

   367 

   368     ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

   369     if (dev_p->storage_count > 0 && ret == CY_AS_ERROR_ALREADY_RUNNING)

   370         ret = CY_AS_ERROR_SUCCESS ;

   371 

   372     ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CyTrue, CyAsDirectionIn) ;

   373     if (ret != CY_AS_ERROR_SUCCESS)

   374         goto destroy ;

   375 

   376     ret = CyAsDmaSetMaxDmaSize(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CY_AS_STORAGE_EP_SIZE) ;

   377     if (ret != CY_AS_ERROR_SUCCESS)

   378         goto destroy ;

   379 

   380     ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_P2S_READ_ENDPOINT, CyTrue, CyAsDirectionOut) ;

   381     if (ret != CY_AS_ERROR_SUCCESS)

   382         goto destroy ;

   383 

   384     ret = CyAsDmaSetMaxDmaSize(dev_p, CY_AS_P2S_READ_ENDPOINT, CY_AS_STORAGE_EP_SIZE) ;

   385     if (ret != CY_AS_ERROR_SUCCESS)

   386         goto destroy ;

   387 

   388     CyAsLLRegisterRequestCallback(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, MyStorageRequestCallback) ;

   389 

   390     /* Create the request/response used for storage reads and writes. */

   391     dev_p->storage_rw_req_p  = CyAsLLCreateRequest(dev_p, 0, CY_RQT_STORAGE_RQT_CONTEXT, 5) ;

   392     if (dev_p->storage_rw_req_p == 0)

   393     {

   394         ret = CY_AS_ERROR_OUT_OF_MEMORY;

   395         goto destroy;

   396     }

   397 

   398     dev_p->storage_rw_resp_p = CyAsLLCreateResponse(dev_p, 5) ;

   399     if (dev_p->storage_rw_resp_p == 0)

   400     {

   401         CyAsLLDestroyRequest(dev_p, dev_p->storage_rw_req_p) ;

   402         ret = CY_AS_ERROR_OUT_OF_MEMORY ;

   403     }

   404 

   405 destroy :

   406     CyAsLLDestroyRequest(dev_p, req_p) ;

   407     CyAsLLDestroyResponse(dev_p, reply_p) ;

   408 

   409     /* Increment the storage count only if the above functionality succeeds.*/

   410     if (ret == CY_AS_ERROR_SUCCESS)

   411     {

   412         if (dev_p->storage_count == 0)

   413         {

   414             CyAsHalMemSet(dev_p->storage_device_info, 0, sizeof(dev_p->storage_device_info)) ;

   415             dev_p->is_storage_only_mode = CyFalse ;

   416         }

   417 

   418         dev_p->storage_count++ ;

   419     }

   420 

   421     CyAsDeviceClearSSSPending(dev_p) ;

   422 

   423     return ret ;

   424 }

   425 

   426 CyAsReturnStatus_t

   427 CyAsStorageStart(CyAsDeviceHandle handle,

   428                    CyAsFunctionCallback cb,

   429                    uint32_t client)

   430 {

   431     CyAsLLRequestResponse *req_p, *reply_p ;

   432     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   433     CyAsDevice *dev_p = (CyAsDevice *)handle ;

   434 

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

   436         return CY_AS_ERROR_INVALID_HANDLE ;

   437 

   438     if (!CyAsDeviceIsConfigured(dev_p))

   439         return CY_AS_ERROR_NOT_CONFIGURED ;

   440 

   441     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

   442         return CY_AS_ERROR_NO_FIRMWARE ;

   443 

   444     if (CyAsDeviceIsInSuspendMode(dev_p))

   445         return CY_AS_ERROR_IN_SUSPEND ;

   446 

   447     if(CyAsDeviceIsSSSPending(dev_p))

   448         return CY_AS_ERROR_STARTSTOP_PENDING ;

   449 

   450     CyAsDeviceSetSSSPending(dev_p) ;

   451 

   452     if (dev_p->storage_count == 0)

   453     {

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

   455         req_p = CyAsLLCreateRequest(dev_p, CY_RQT_START_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;

   456         if (req_p == 0)

   457         {

   458             CyAsDeviceClearSSSPending(dev_p) ;

   459             return CY_AS_ERROR_OUT_OF_MEMORY ;

   460         }

   461 

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

   463         reply_p = CyAsLLCreateResponse(dev_p, 1) ;

   464         if (reply_p == 0)

   465         {

   466             CyAsDeviceClearSSSPending(dev_p) ;

   467             CyAsLLDestroyRequest(dev_p, req_p) ;

   468             return CY_AS_ERROR_OUT_OF_MEMORY ;

   469         }

   470 

   471         if(cb == 0)

   472         {

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

   474             if (ret != CY_AS_ERROR_SUCCESS)

   475                 goto destroy ;

   476 

   477             return MyHandleResponseStorageStart(dev_p, req_p, reply_p, ret) ;

   478         }

   479         else

   480         {

   481             ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_START,

   482                 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,

   483                 req_p, reply_p, CyAsStorageFuncCallback) ;

   484 

   485             if (ret != CY_AS_ERROR_SUCCESS)

   486                 goto destroy ;

   487 

   488             /* The request and response are freed as part of the FuncCallback */

   489             return ret ;

   490         }

   491 

   492 destroy:

   493         CyAsLLDestroyRequest(dev_p, req_p) ;

   494         CyAsLLDestroyResponse(dev_p, reply_p) ;

   495     }

   496     else

   497     {

   498         dev_p->storage_count++ ;

   499         if (cb)

   500             cb(handle, ret, client, CY_FUNCT_CB_STOR_START, 0) ;

   501     }

   502 

   503     CyAsDeviceClearSSSPending(dev_p) ;

   504 

   505     return ret ;

   506 }

   507 

   508 

   509 static CyAsReturnStatus_t

   510 MyHandleResponseStorageStop(CyAsDevice* dev_p,

   511                          CyAsLLRequestResponse *req_p,

   512                          CyAsLLRequestResponse *reply_p,

   513                          CyAsReturnStatus_t ret)

   514 {

   515     if (ret != CY_AS_ERROR_SUCCESS)

   516         goto destroy ;

   517 

   518     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

   519     {

   520         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   521         goto destroy ;

   522     }

   523 

   524 destroy :

   525     CyAsLLDestroyRequest(dev_p, req_p) ;

   526     CyAsLLDestroyResponse(dev_p, reply_p) ;

   527 

   528     if (ret == CY_AS_ERROR_SUCCESS)

   529     {

   530         CyAsLLDestroyRequest(dev_p, dev_p->storage_rw_req_p) ;

   531         CyAsLLDestroyResponse(dev_p, dev_p->storage_rw_resp_p) ;

   532         dev_p->storage_count-- ;

   533     }

   534 

   535     CyAsDeviceClearSSSPending(dev_p) ;

   536 

   537     return ret ;

   538 }

   539 CyAsReturnStatus_t

   540 CyAsStorageStop(CyAsDeviceHandle handle,

   541                   CyAsFunctionCallback cb,

   542                   uint32_t client)

   543 {

   544     CyAsLLRequestResponse *req_p , *reply_p ;

   545     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   546 

   547     CyAsDevice *dev_p = (CyAsDevice *)handle ;

   548 

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

   550         return CY_AS_ERROR_INVALID_HANDLE ;

   551 

   552     ret = IsStorageActive(dev_p) ;

   553     if (ret != CY_AS_ERROR_SUCCESS)

   554         return ret ;

   555 

   556     if (CyAsDeviceIsStorageAsyncPending(dev_p))

   557         return CY_AS_ERROR_ASYNC_PENDING ;

   558 

   559     if(CyAsDeviceIsSSSPending(dev_p))

   560         return CY_AS_ERROR_STARTSTOP_PENDING ;

   561 

   562     CyAsDeviceSetSSSPending(dev_p) ;

   563 

   564     if (dev_p->storage_count == 1)

   565     {

   566 

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

   568         req_p = CyAsLLCreateRequest(dev_p, CY_RQT_STOP_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 0) ;

   569         if (req_p == 0)

   570         {

   571             CyAsDeviceClearSSSPending(dev_p) ;

   572             return CY_AS_ERROR_OUT_OF_MEMORY ;

   573         }

   574 

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

   576         reply_p = CyAsLLCreateResponse(dev_p, 1) ;

   577         if (reply_p == 0)

   578         {

   579             CyAsDeviceClearSSSPending(dev_p) ;

   580             CyAsLLDestroyRequest(dev_p, req_p) ;

   581             return CY_AS_ERROR_OUT_OF_MEMORY ;

   582         }

   583 

   584         if(cb == 0)

   585         {

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

   587             if (ret != CY_AS_ERROR_SUCCESS)

   588                 goto destroy ;

   589 

   590             return MyHandleResponseStorageStop(dev_p, req_p, reply_p, ret) ;

   591         }

   592         else

   593         {

   594             ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_STOP,

   595                 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,

   596                 req_p, reply_p, CyAsStorageFuncCallback) ;

   597 

   598             if (ret != CY_AS_ERROR_SUCCESS)

   599                 goto destroy ;

   600 

   601             /* The request and response are freed as part of the MiscFuncCallback */

   602             return ret ;

   603         }

   604 

   605 destroy:

   606         CyAsLLDestroyRequest(dev_p, req_p) ;

   607         CyAsLLDestroyResponse(dev_p, reply_p) ;

   608     }

   609     else if(dev_p->storage_count > 1)

   610     {

   611         dev_p->storage_count-- ;

   612         if (cb)

   613             cb(handle, ret, client, CY_FUNCT_CB_STOR_STOP, 0) ;

   614     }

   615 

   616     CyAsDeviceClearSSSPending(dev_p) ;

   617 

   618     return ret ;

   619 }

   620 

   621 CyAsReturnStatus_t

   622 CyAsStorageRegisterCallback(CyAsDeviceHandle handle, CyAsStorageEventCallback callback)

   623 {

   624     CyAsDevice *dev_p = (CyAsDevice *)handle ;

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

   626         return CY_AS_ERROR_INVALID_HANDLE ;

   627 

   628     if (!CyAsDeviceIsConfigured(dev_p))

   629         return CY_AS_ERROR_NOT_CONFIGURED ;

   630 

   631     if (!CyAsDeviceIsFirmwareLoaded(dev_p))

   632         return CY_AS_ERROR_NO_FIRMWARE ;

   633 

   634     if (dev_p->storage_count == 0)

   635         return CY_AS_ERROR_NOT_RUNNING ;

   636 

   637     dev_p->storage_event_cb = NULL ;

   638     dev_p->storage_event_cb_ms = callback ;

   639 

   640     return CY_AS_ERROR_SUCCESS ;

   641 }

   642 

   643 

   644 

   645 static CyAsReturnStatus_t

   646 MyHandleResponseStorageClaim(CyAsDevice* dev_p,

   647                          CyAsLLRequestResponse *req_p,

   648                          CyAsLLRequestResponse *reply_p)

   649 {

   650     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   651 

   652     if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)

   653     {

   654         ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;

   655         goto destroy ;

   656     }

   657 

   658     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_MEDIA_CLAIMED_RELEASED)

   659     {

   660         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   661         goto destroy ;

   662     }

   663 

   664     /* The response must be about the address I am trying to claim or the firmware is broken */

   665     if ((CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=

   666         CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))) ||

   667         (CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=

   668         CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))))

   669     {

   670         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   671         goto destroy ;

   672     }

   673 

   674     if (CyAsLLRequestResponse_GetWord(reply_p, 1) != 1)

   675         ret = CY_AS_ERROR_NOT_ACQUIRED ;

   676 

   677 destroy :

   678     CyAsLLDestroyRequest(dev_p, req_p) ;

   679     CyAsLLDestroyResponse(dev_p, reply_p) ;

   680 

   681     return ret ;

   682 }

   683 

   684 static CyAsReturnStatus_t

   685 MyStorageClaim(CyAsDevice *dev_p,

   686                 void* data,

   687                 CyAsBusNumber_t bus,

   688                 uint32_t device,

   689                 uint16_t req_flags,

   690                 CyAsFunctionCallback cb,

   691                 uint32_t client)

   692 {

   693     CyAsLLRequestResponse *req_p , *reply_p ;

   694     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   695 

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

   697         return CY_AS_ERROR_INVALID_HANDLE ;

   698 

   699     ret = IsStorageActive(dev_p) ;

   700     if (ret != CY_AS_ERROR_SUCCESS)

   701         return ret ;

   702 

   703     if(dev_p->mtp_count > 0)

   704         return CY_AS_ERROR_NOT_VALID_IN_MTP ;

   705 

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

   707     req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CLAIM_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;

   708     if (req_p == 0)

   709         return CY_AS_ERROR_OUT_OF_MEMORY ;

   710 

   711     CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;

   712 

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

   714     reply_p = CyAsLLCreateResponse(dev_p, 4) ;

   715     if (reply_p == 0)

   716     {

   717         CyAsLLDestroyRequest(dev_p, req_p) ;

   718         return CY_AS_ERROR_OUT_OF_MEMORY ;

   719     }

   720 

   721     if(cb == 0)

   722     {

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

   724         if (ret != CY_AS_ERROR_SUCCESS)

   725             goto destroy ;

   726 

   727         return MyHandleResponseStorageClaim(dev_p, req_p, reply_p) ;

   728     }

   729     else

   730     {

   731         ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_CLAIM,

   732             data, dev_p->func_cbs_stor, req_flags,

   733             req_p, reply_p, CyAsStorageFuncCallback) ;

   734 

   735         if (ret != CY_AS_ERROR_SUCCESS)

   736             goto destroy ;

   737 

   738         /* The request and response are freed as part of the MiscFuncCallback */

   739         return ret ;

   740     }

   741 

   742 destroy:

   743     CyAsLLDestroyRequest(dev_p, req_p) ;

   744     CyAsLLDestroyResponse(dev_p, reply_p) ;

   745 

   746     return ret ;

   747 }

   748 

   749 CyAsReturnStatus_t

   750 CyAsStorageClaim(CyAsDeviceHandle handle,

   751                    CyAsBusNumber_t bus,

   752                    uint32_t device,

   753                    CyAsFunctionCallback cb,

   754                    uint32_t client)

   755 {

   756     CyAsDevice *dev_p = (CyAsDevice *)handle ;

   757 

   758     if (bus < 0 || bus >= CY_AS_MAX_BUSES)

   759         return CY_AS_ERROR_NO_SUCH_BUS ;

   760 

   761     return MyStorageClaim(dev_p, NULL, bus, device, CY_AS_REQUEST_RESPONSE_MS, cb, client) ;

   762 }

   763 

   764 static CyAsReturnStatus_t

   765 MyHandleResponseStorageRelease(CyAsDevice* dev_p,

   766                          CyAsLLRequestResponse *req_p,

   767                          CyAsLLRequestResponse *reply_p)

   768 {

   769     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   770 

   771     if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)

   772     {

   773         ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;

   774         goto destroy ;

   775     }

   776 

   777     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_MEDIA_CLAIMED_RELEASED)

   778     {

   779         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   780         goto destroy ;

   781     }

   782 

   783     /* The response must be about the address I am trying to release or the firmware is broken */

   784     if ((CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=

   785         CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))) ||

   786         (CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=

   787         CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))))

   788     {

   789         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   790         goto destroy ;

   791     }

   792 

   793 

   794     if (CyAsLLRequestResponse_GetWord(reply_p, 1) != 0)

   795         ret = CY_AS_ERROR_NOT_RELEASED ;

   796 

   797 destroy :

   798     CyAsLLDestroyRequest(dev_p, req_p) ;

   799     CyAsLLDestroyResponse(dev_p, reply_p) ;

   800 

   801     return ret ;

   802 }

   803 

   804 static CyAsReturnStatus_t

   805 MyStorageRelease(CyAsDevice* dev_p,

   806                     void* data,

   807                     CyAsBusNumber_t bus,

   808                     uint32_t device,

   809                     uint16_t req_flags,

   810                     CyAsFunctionCallback cb,

   811                     uint32_t client)

   812 {

   813     CyAsLLRequestResponse *req_p , *reply_p ;

   814     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   815 

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

   817         return CY_AS_ERROR_INVALID_HANDLE ;

   818 

   819     ret = IsStorageActive(dev_p) ;

   820     if (ret != CY_AS_ERROR_SUCCESS)

   821         return ret ;

   822 

   823     if(dev_p->mtp_count > 0)

   824         return CY_AS_ERROR_NOT_VALID_IN_MTP ;

   825 

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

   827     req_p = CyAsLLCreateRequest(dev_p, CY_RQT_RELEASE_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;

   828     if (req_p == 0)

   829         return CY_AS_ERROR_OUT_OF_MEMORY ;

   830 

   831     CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;

   832 

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

   834     reply_p = CyAsLLCreateResponse(dev_p, 4) ;

   835     if (reply_p == 0)

   836     {

   837         CyAsLLDestroyRequest(dev_p, req_p) ;

   838         return CY_AS_ERROR_OUT_OF_MEMORY ;

   839     }

   840 

   841     if(cb == 0)

   842     {

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

   844         if (ret != CY_AS_ERROR_SUCCESS)

   845             goto destroy ;

   846 

   847         return MyHandleResponseStorageRelease(dev_p, req_p, reply_p) ;

   848     }

   849     else

   850     {

   851         ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_RELEASE,

   852             data, dev_p->func_cbs_stor, req_flags,

   853             req_p, reply_p, CyAsStorageFuncCallback) ;

   854 

   855         if (ret != CY_AS_ERROR_SUCCESS)

   856             goto destroy ;

   857 

   858         /* The request and response are freed as part of the MiscFuncCallback */

   859         return ret ;

   860     }

   861 

   862 destroy:

   863     CyAsLLDestroyRequest(dev_p, req_p) ;

   864     CyAsLLDestroyResponse(dev_p, reply_p) ;

   865 

   866     return ret ;

   867 }

   868 

   869 CyAsReturnStatus_t

   870 CyAsStorageRelease(CyAsDeviceHandle handle,

   871                    CyAsBusNumber_t bus,

   872                    uint32_t device,

   873                    CyAsFunctionCallback cb,

   874                    uint32_t client)

   875 {

   876     CyAsDevice *dev_p = (CyAsDevice *)handle ;

   877 

   878     if (bus < 0 || bus >= CY_AS_MAX_BUSES)

   879         return CY_AS_ERROR_NO_SUCH_BUS ;

   880 

   881     return MyStorageRelease(dev_p, NULL, bus, device, CY_AS_REQUEST_RESPONSE_MS, cb, client) ;

   882 }

   883 

   884 static CyAsReturnStatus_t

   885 MyHandleResponseStorageQueryBus(CyAsDevice* dev_p,

   886                          CyAsLLRequestResponse *req_p,

   887                          CyAsLLRequestResponse *reply_p,

   888                          uint32_t* count)

   889 {

   890     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

   891     uint8_t code = CyAsLLRequestResponse_GetCode(reply_p) ;

   892     uint16_t v ;

   893 

   894     if (code == CY_RESP_NO_SUCH_ADDRESS)

   895     {

   896         ret = CY_AS_ERROR_NO_SUCH_BUS ;

   897         goto destroy ;

   898     }

   899 

   900     if (code != CY_RESP_BUS_DESCRIPTOR)

   901     {

   902         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   903         goto destroy ;

   904     }

   905 

   906     /*

   907      * Verify that the response corresponds to the bus that was queried.

   908      */

   909     if (CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=

   910                 CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0)))

   911     {

   912         ret = CY_AS_ERROR_INVALID_RESPONSE ;

   913         goto destroy ;

   914     }

   915 

   916     v = CyAsLLRequestResponse_GetWord(reply_p, 1) ;

   917     if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS)

   918     {

   919         /*

   920          * This request is only for the count of devices on the bus. There

   921          * is no need to check the media type.

   922          */

   923         if (v)

   924             *count = 1 ;

   925         else

   926             *count = 0 ;

   927     }

   928     else

   929     {

   930         /*

   931          * This request is for the count of devices of a particular type. We need

   932          * to check whether the media type found matches the queried type.

   933          */

   934         CyAsMediaType queried = (CyAsMediaType)CyAsLLRequestResponse_GetWord(req_p, 1) ;

   935         CyAsMediaType found   = CyAsStorageGetMediaFromAddress(v) ;

   936 

   937         if (queried == found)

   938             *count = 1 ;

   939         else

   940             *count = 0 ;

   941     }

   942 

   943 destroy :

   944     CyAsLLDestroyRequest(dev_p, req_p) ;

   945     CyAsLLDestroyResponse(dev_p, reply_p) ;

   946 

   947     return ret ;

   948 }

   949 

   950 CyAsReturnStatus_t

   951 MyStorageQueryBus(CyAsDevice *dev_p,

   952                         CyAsBusNumber_t bus,

   953                         CyAsMediaType   type,

   954                         uint16_t req_flags,

   955                         uint32_t *count,

   956                         CyAsFunctionCallback cb,

   957                         uint32_t client)

   958 {

   959     CyAsReturnStatus_t ret ;

   960     CyAsLLRequestResponse *req_p, *reply_p ;

   961     CyAsFunctCBType cbType = CY_FUNCT_CB_STOR_QUERYBUS ;

   962 

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

   964         return CY_AS_ERROR_INVALID_HANDLE ;

   965 

   966     ret = IsStorageActive(dev_p) ;

   967     if (ret != CY_AS_ERROR_SUCCESS)

   968         return ret ;

   969 

   970     /* Create the request to send to the Antioch device */

   971     req_p = CyAsLLCreateRequest(dev_p, CY_RQT_QUERY_BUS, CY_RQT_STORAGE_RQT_CONTEXT, 2) ;

   972     if (req_p == 0)

   973         return CY_AS_ERROR_OUT_OF_MEMORY ;

   974 

   975     CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, 0, 0)) ;

   976     CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)type) ;

   977 

   978     /* Reserve space for the reply, the reply data will not exceed two words. */

   979     reply_p = CyAsLLCreateResponse(dev_p, 2) ;

   980     if (reply_p == 0)

   981     {

   982         CyAsLLDestroyRequest(dev_p, req_p) ;

   983         return CY_AS_ERROR_OUT_OF_MEMORY ;

   984     }

   985 

   986     if(cb == 0)

   987     {

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

   989         if (ret != CY_AS_ERROR_SUCCESS)

   990             goto destroy ;

   991 

   992         req_p->flags |= req_flags;

   993         return MyHandleResponseStorageQueryBus(dev_p, req_p, reply_p, count) ;

   994     }

   995     else

   996     {

   997         if (req_flags == CY_AS_REQUEST_RESPONSE_EX)

   998             cbType = CY_FUNCT_CB_STOR_QUERYMEDIA ;

   999 

  1000         ret = CyAsMiscSendRequest(dev_p, cb, client, cbType,

  1001             count, dev_p->func_cbs_stor, req_flags,

  1002             req_p, reply_p, CyAsStorageFuncCallback) ;

  1003 

  1004         if (ret != CY_AS_ERROR_SUCCESS)

  1005             goto destroy ;

  1006 

  1007         /* The request and response are freed as part of the MiscFuncCallback */

  1008         return ret ;

  1009     }

  1010 

  1011 destroy:

  1012     CyAsLLDestroyRequest(dev_p, req_p) ;

  1013     CyAsLLDestroyResponse(dev_p, reply_p) ;

  1014 

  1015     return ret ;

  1016 }

  1017 

  1018 CyAsReturnStatus_t

  1019 CyAsStorageQueryBus(CyAsDeviceHandle handle,

  1020                         CyAsBusNumber_t bus,

  1021                         uint32_t *count,

  1022                         CyAsFunctionCallback cb,

  1023                         uint32_t client)

  1024 {

  1025     CyAsDevice *dev_p = (CyAsDevice *)handle ;

  1026 

  1027     return MyStorageQueryBus(dev_p, bus, CyAsMediaMaxMediaValue, CY_AS_REQUEST_RESPONSE_MS,

  1028             count, cb, client) ;

  1029 }

  1030 

  1031 CyAsReturnStatus_t

  1032 CyAsStorageQueryMedia(CyAsDeviceHandle handle,

  1033                         CyAsMediaType type,

  1034                         uint32_t *count,

  1035                         CyAsFunctionCallback cb,

  1036                         uint32_t client)

  1037 {

  1038     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

  1039     CyAsBusNumber_t bus ;

  1040 

  1041     CyAsDevice *dev_p = (CyAsDevice *)handle ;

  1042 

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

  1044         return CY_AS_ERROR_INVALID_HANDLE ;

  1045 

  1046     ret = IsStorageActive(dev_p) ;

  1047     if (ret != CY_AS_ERROR_SUCCESS)

  1048         return ret ;

  1049 

  1050     ret = CyAnMapBusFromMediaType(dev_p, type, &bus) ;

  1051     if (ret != CY_AS_ERROR_SUCCESS)

  1052         return ret ;

  1053 

  1054     return MyStorageQueryBus(dev_p, bus, type, CY_AS_REQUEST_RESPONSE_EX,

  1055             count, cb, client) ;

  1056 }

  1057 

  1058 static CyAsReturnStatus_t

  1059 MyHandleResponseStorageQueryDevice(CyAsDevice* dev_p,

  1060                          CyAsLLRequestResponse *req_p,

  1061                          CyAsLLRequestResponse *reply_p,

  1062                          void* data_p)

  1063 {

  1064     CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

  1065     uint16_t v ;

  1066     CyAsBusNumber_t bus ;

  1067     CyAsMediaType type ;

  1068     uint32_t device ;

  1069     CyBool removable ;

  1070     CyBool writeable ;

  1071     CyBool locked ;

  1072     uint16_t block_size ;

  1073     uint32_t number_units ;

  1074     uint32_t number_eus ;

  1075 

  1076     if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)

  1077     {

  1078         ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;

  1079         goto destroy ;

  1080     }

  1081 

  1082     if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_DEVICE_DESCRIPTOR)

  1083     {

  1084         ret = CY_AS_ERROR_INVALID_RESPONSE ;

  1085         goto destroy ;

  1086     }

  1087 

  1088     /* Unpack the response */

  1089     v = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

  1090     type = CyAsStorageGetMediaFromAddress(v) ;

  1091     bus  = CyAsStorageGetBusFromAddress(v) ;

  1092     device = CyAsStorageGetDeviceFromAddress(v) ;

  1093 

  1094     block_size = CyAsLLRequestResponse_GetWord(reply_p, 1) ;

  1095 

  1096     v = CyAsLLRequestResponse_GetWord(reply_p, 2) ;

  1097     removable = (v & 0x8000) ? CyTrue : CyFalse ;

  1098     writeable = (v & 0x0100) ? CyTrue : CyFalse ;

  1099     locked = (v & 0x0200) ? CyTrue : CyFalse ;

  1100     number_units = (v & 0xff) ;

  1101 

  1102     number_eus  = (CyAsLLRequestResponse_GetWord(reply_p, 3) << 16) | CyAsLLRequestResponse_GetWord(reply_p, 4) ;

  1103 

  1104     /* Store the results based on the version of originating function */

  1105     if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS)

  1106     {

  1107         CyAsStorageQueryDeviceData  *store_p = (CyAsStorageQueryDeviceData*)data_p ;

  1108 

  1109         /* Make sure the response is about the address we asked about - if not, firmware error */

  1110         if ((bus != store_p->bus) || (device != store_p->device))

  1111         {

  1112             ret = CY_AS_ERROR_INVALID_RESPONSE ;

  1113             goto destroy ;

  1114         }

  1115 

  1116         store_p->desc_p.type = type ;

  1117         store_p->desc_p.removable = removable ;

  1118         store_p->desc_p.writeable = writeable ;

  1119         store_p->desc_p.block_size = block_size ;

  1120         store_p->desc_p.number_units = number_units ;

  1121         store_p->desc_p.locked = locked ;

  1122         store_p->desc_p.erase_unit_size = number_eus ;

  1123         dev_p->storage_device_info[bus][device] = store_p->desc_p ;

  1124     }

  1125     else

  1126     {

  1127         CyAsStorageQueryDeviceData_dep    *store_p = (CyAsStorageQueryDeviceData_dep*)data_p ;

  1128 

  1129         /* Make sure the response is about the address we asked about - if not, firmware error */

  1130         if ((type != store_p->type) || (device != store_p->device))

  1131         {

  1132             ret = CY_AS_ERROR_INVALID_RESPONSE ;

  1133             goto destroy ;

  1134         }