omap3530/beagle_drivers/wb/api/include/cyanusb.h
changeset 27 117faf51deac
equal deleted inserted replaced
26:b7e488c49d0d 27:117faf51deac
       
     1 /*  Cypress West Bridge API header file (cyanusb.h)
       
     2  ## Header for backward compatibility with previous Antioch SDK releases.
       
     3  ## ===========================
       
     4  ##
       
     5  ##  Copyright Cypress Semiconductor Corporation, 2006-2009,
       
     6  ##  All Rights Reserved
       
     7  ##  UNPUBLISHED, LICENSED SOFTWARE.
       
     8  ##
       
     9  ##  CONFIDENTIAL AND PROPRIETARY INFORMATION
       
    10  ##  WHICH IS THE PROPERTY OF CYPRESS.
       
    11  ##
       
    12  ##  Use of this file is governed
       
    13  ##  by the license agreement included in the file
       
    14  ##
       
    15  ##     <install>/license/license.txt
       
    16  ##
       
    17  ##  where <install> is the Cypress software
       
    18  ##  installation root directory path.
       
    19  ##
       
    20  ## ===========================
       
    21 */
       
    22 
       
    23 #ifndef _INCLUDED_CYANUSB_H_
       
    24 #define _INCLUDED_CYANUSB_H_
       
    25 
       
    26 #if !defined(__doxygen__)
       
    27 
       
    28 #include "cyanmisc.h"
       
    29 #include "cyasusb.h"
       
    30 #include "cyas_cplus_start.h"
       
    31 
       
    32 #define CY_AN_MAX_USB_DESCRIPTOR_SIZE				(CY_AS_MAX_USB_DESCRIPTOR_SIZE)
       
    33 
       
    34 typedef CyAsUsbInquiryData_dep CyAnUsbInquiryData;
       
    35 typedef CyAsUsbUnknownCommandData_dep CyAnUsbUnknownCommandData ;
       
    36 typedef CyAsUsbStartStopData_dep CyAnUsbStartStopData ;
       
    37 typedef CyAsMSCProgressData CyAnMSCProgressData ;
       
    38 
       
    39 #define CyAnUsbNandEnum         CyAsUsbNandEnum
       
    40 #define CyAnUsbSDEnum           CyAsUsbSDEnum
       
    41 #define CyAnUsbMMCEnum          CyAsUsbMMCEnum
       
    42 #define CyAnUsbCEATAEnum        CyAsUsbCEATAEnum
       
    43 typedef CyAsUsbMassStorageEnum  CyAnUsbMassStorageEnum;
       
    44 
       
    45 #define CyAnUsbDescDevice		CyAsUsbDescDevice
       
    46 #define CyAnUsbDescDeviceQual		CyAsUsbDescDeviceQual
       
    47 #define CyAnUsbDescFSConfiguration	CyAsUsbDescFSConfiguration
       
    48 #define CyAnUsbDescHSConfiguration	CyAsUsbDescHSConfiguration
       
    49 #define CyAnUsbDescString               CyAsUsbDescString
       
    50 typedef CyAsUsbDescType CyAnUsbDescType ;
       
    51 
       
    52 #define CyAnUsbIn	CyAsUsbIn
       
    53 #define CyAnUsbOut	CyAsUsbOut
       
    54 #define CyAnUsbInOut	CyAsUsbInOut
       
    55 typedef CyAsUsbEndPointDir CyAnUsbEndPointDir ;
       
    56 
       
    57 
       
    58 #define CyAnUsbControl  CyAsUsbControl
       
    59 #define CyAnUsbIso      CyAsUsbIso
       
    60 #define CyAnUsbBulk     CyAsUsbBulk
       
    61 #define CyAnUsbInt      CyAsUsbInt
       
    62 typedef CyAsUsbEndPointType CyAnUsbEndPointType ;
       
    63 
       
    64 
       
    65 typedef CyAsUsbEnumControl_dep CyAnUsbEnumControl ;
       
    66 typedef CyAsUsbEndPointConfig CyAnUsbEndPointConfig ;
       
    67 
       
    68 #define CyAnUsbMSUnit0                  CyAsUsbMSUnit0
       
    69 #define CyAnUsbMSUnit1                  CyAsUsbMSUnit1
       
    70 #define CyAnUsbMSBoth                   CyAsUsbMSBoth
       
    71 typedef CyAsUsbMSType_t CyAnUsbMSType_t ;
       
    72 
       
    73 #define CyAnEventUsbSuspend		CyAsEventUsbSuspend
       
    74 #define CyAnEventUsbResume		CyAsEventUsbResume
       
    75 #define CyAnEventUsbReset		CyAsEventUsbReset
       
    76 #define CyAnEventUsbSetConfig		CyAsEventUsbSetConfig
       
    77 #define CyAnEventUsbSpeedChange		CyAsEventUsbSpeedChange
       
    78 #define CyAnEventUsbSetupPacket		CyAsEventUsbSetupPacket
       
    79 #define CyAnEventUsbStatusPacket	CyAsEventUsbStatusPacket
       
    80 #define CyAnEventUsbInquiryBefore	CyAsEventUsbInquiryBefore
       
    81 #define CyAnEventUsbInquiryAfter        CyAsEventUsbInquiryAfter
       
    82 #define CyAnEventUsbStartStop           CyAsEventUsbStartStop
       
    83 #define CyAnEventUsbUnknownStorage	CyAsEventUsbUnknownStorage
       
    84 #define CyAnEventUsbMSCProgress         CyAsEventUsbMSCProgress
       
    85 typedef CyAsUsbEvent CyAnUsbEvent;
       
    86 
       
    87 typedef CyAsUsbEventCallback_dep CyAnUsbEventCallback ;
       
    88 
       
    89 typedef CyAsUsbIoCallback CyAnUsbIoCallback;
       
    90 typedef CyAsUsbFunctionCallback CyAnUsbFunctionCallback;
       
    91 
       
    92 /******* USB Functions ********************/
       
    93 
       
    94 /* Sync Usb Start */
       
    95 extern CyAnReturnStatus_t
       
    96 CyAnUsbStart(
       
    97 	CyAnDeviceHandle		handle
       
    98 	) ;
       
    99 #define CyAnUsbStart(handle) CyAsUsbStart((CyAsDeviceHandle)(handle), 0, 0)
       
   100 
       
   101 /*Async Usb Start */
       
   102 extern CyAnReturnStatus_t
       
   103 CyAnUsbStartEX(
       
   104 	CyAnDeviceHandle		handle,
       
   105 	CyAnFunctionCallback		cb,
       
   106 	uint32_t			client
       
   107 	) ;
       
   108 #define CyAnUsbStartEX(h, cb, client) CyAsUsbStart((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   109 
       
   110 /* Sync Usb Stop */
       
   111 extern CyAnReturnStatus_t
       
   112 CyAnUsbStop(
       
   113 	CyAnDeviceHandle		handle
       
   114 	) ;
       
   115 #define CyAnUsbStop(handle) CyAsUsbStop((CyAsDeviceHandle)(handle), 0, 0)
       
   116 
       
   117 /*Async Usb Stop */
       
   118 extern CyAnReturnStatus_t
       
   119 CyAnUsbStopEX(
       
   120 	CyAnDeviceHandle		handle,
       
   121 	CyAnFunctionCallback		cb,
       
   122 	uint32_t			client
       
   123 	) ;
       
   124 #define CyAnUsbStopEX(h, cb, client) CyAsUsbStop((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   125 
       
   126 /* Register USB event callback */
       
   127 EXTERN CyAnReturnStatus_t
       
   128 CyAnUsbRegisterCallback(
       
   129 	CyAnDeviceHandle		handle,
       
   130 	CyAnUsbEventCallback		callback
       
   131 	) ;
       
   132 #define CyAnUsbRegisterCallback(h, cb) 		\
       
   133     CyAsUsbRegisterCallback_dep((CyAsDeviceHandle)(h), (CyAsUsbEventCallback_dep)(cb))
       
   134 
       
   135 /*Sync Usb connect */
       
   136 EXTERN CyAnReturnStatus_t
       
   137 CyAnUsbConnect(
       
   138 	CyAnDeviceHandle		handle
       
   139 	) ;
       
   140 #define CyAnUsbConnect(handle) CyAsUsbConnect((CyAsDeviceHandle)(handle), 0, 0)
       
   141 
       
   142 /*Async Usb connect */
       
   143 extern CyAnReturnStatus_t
       
   144 CyAnUsbConnectEX(
       
   145 	CyAnDeviceHandle		handle,
       
   146 	CyAnFunctionCallback		cb,
       
   147 	uint32_t			client
       
   148 	) ;
       
   149 #define CyAnUsbConnectEX(h, cb, client)		\
       
   150     CyAsUsbConnect((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   151 
       
   152 /*Sync Usb disconnect */
       
   153 EXTERN CyAnReturnStatus_t
       
   154 CyAnUsbDisconnect(
       
   155 	CyAnDeviceHandle		handle
       
   156 	) ;
       
   157 #define CyAnUsbDisconnect(handle) CyAsUsbDisconnect((CyAsDeviceHandle)(handle), 0, 0)
       
   158 
       
   159 /*Async Usb disconnect */
       
   160 extern CyAnReturnStatus_t
       
   161 CyAnUsbDisconnectEX(
       
   162 	CyAnDeviceHandle		handle,
       
   163 	CyAnFunctionCallback		cb,
       
   164 	uint32_t			client
       
   165 	) ;
       
   166 #define CyAnUsbDisconnectEX(h, cb, client)	\
       
   167     CyAsUsbDisconnect((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   168 
       
   169 /* Sync version of set enum config */
       
   170 EXTERN CyAnReturnStatus_t
       
   171 CyAnUsbSetEnumConfig(
       
   172 	CyAnDeviceHandle	handle,
       
   173 	CyAnUsbEnumControl *	config_p
       
   174 	) ;
       
   175 #define CyAnUsbSetEnumConfig(handle, config_p) \
       
   176     CyAsUsbSetEnumConfig_dep((CyAsDeviceHandle)(handle), (CyAsUsbEnumControl_dep *)(config_p), 0, 0)
       
   177 
       
   178 /* Async version of set enum config */
       
   179 extern CyAnReturnStatus_t
       
   180 CyAnUsbSetEnumConfigEX(
       
   181 	CyAnDeviceHandle		handle,
       
   182 	CyAnUsbEnumControl *		config_p,
       
   183 	CyAnFunctionCallback		cb,
       
   184 	uint32_t			client
       
   185 	) ;
       
   186 #define CyAnUsbSetEnumConfigEX(h, config_p, cb, client)						\
       
   187     CyAsUsbSetEnumConfig_dep((CyAsDeviceHandle)(h), (CyAsUsbEnumControl_dep *)(config_p), 	\
       
   188 	    (CyAsFunctionCallback)(cb), (client))
       
   189 
       
   190 /* Sync version of get enum config */
       
   191 EXTERN CyAnReturnStatus_t
       
   192 CyAnUsbGetEnumConfig(
       
   193 	CyAnDeviceHandle		handle,
       
   194 	CyAnUsbEnumControl *	config_p
       
   195 	) ;
       
   196 #define CyAnUsbGetEnumConfig(handle, config_p) \
       
   197     CyAsUsbGetEnumConfig_dep((CyAsDeviceHandle)(handle), (CyAsUsbEnumControl_dep *)(config_p), 0, 0)
       
   198 
       
   199 /* Async version of get enum config */
       
   200 extern CyAnReturnStatus_t
       
   201 CyAnUsbGetEnumConfigEX(
       
   202 	CyAnDeviceHandle		handle,
       
   203 	CyAnUsbEnumControl *		config_p,
       
   204 	CyAnFunctionCallback		cb,
       
   205 	uint32_t			client
       
   206 	) ;
       
   207 #define CyAnUsbGetEnumConfigEX(h, config_p, cb, client)						\
       
   208     CyAsUsbGetEnumConfig_dep((CyAsDeviceHandle)(h), (CyAsUsbEnumControl_dep *)(config_p), 	\
       
   209 	    (CyAsFunctionCallback)(cb), (client))
       
   210 
       
   211 /* Sync Version of Set descriptor */
       
   212 EXTERN CyAnReturnStatus_t
       
   213 CyAnUsbSetDescriptor(
       
   214 	CyAnDeviceHandle		handle,
       
   215 	CyAnUsbDescType			type,
       
   216 	uint8_t				index,
       
   217 	void *				desc_p,
       
   218 	uint16_t			length
       
   219 	) ;
       
   220 #define CyAnUsbSetDescriptor(handle, type, index, desc_p, length) \
       
   221     CyAsUsbSetDescriptor((CyAsDeviceHandle)(handle), (CyAsUsbDescType)(type), (index), (desc_p), (length), 0, 0)
       
   222 
       
   223 /* Async Version of Set descriptor */
       
   224 extern CyAnReturnStatus_t
       
   225 CyAnUsbSetDescriptorEX(
       
   226 	CyAnDeviceHandle		handle,
       
   227 	CyAnUsbDescType			type,
       
   228 	uint8_t				index,
       
   229 	void *				desc_p,
       
   230 	uint16_t			length,
       
   231 	CyAnFunctionCallback		cb,
       
   232 	uint32_t			client
       
   233 	) ;
       
   234 #define CyAnUsbSetDescriptorEX(h, type, index, desc_p, length, cb, client)				\
       
   235     CyAsUsbSetDescriptor((CyAsDeviceHandle)(h), (CyAsUsbDescType)(type), (index), (desc_p), (length),	\
       
   236 	    (CyAsFunctionCallback)(cb), (client))
       
   237 
       
   238 /* Only version of clear descriptors */
       
   239 EXTERN CyAnReturnStatus_t
       
   240 CyAnUsbClearDescriptors(
       
   241 	CyAnDeviceHandle		handle,
       
   242         CyAnFunctionCallback            cb,
       
   243         uint32_t                        client
       
   244 	) ;
       
   245 #define CyAnUsbClearDescriptors(h, cb, client)                                                          \
       
   246     CyAsUsbClearDescriptors((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   247 
       
   248 /* Sync version of get descriptor*/
       
   249 EXTERN CyAnReturnStatus_t
       
   250 CyAnUsbGetDescriptor(
       
   251 	CyAnDeviceHandle	handle,
       
   252 	CyAnUsbDescType		type,
       
   253 	uint8_t			index,
       
   254 	void *			desc_p,
       
   255 	uint32_t *		length_p
       
   256 	) ;
       
   257 #define CyAnUsbGetDescriptor(h, type, index, desc_p, length_p)	\
       
   258     CyAsUsbGetDescriptor_dep((CyAsDeviceHandle)(h), (CyAsUsbDescType)(type), (index), (desc_p), (length_p))
       
   259 
       
   260 typedef CyAsGetDescriptorData CyAnGetDescriptorData ;
       
   261 
       
   262 /* Async version of get descriptor */
       
   263 extern CyAnReturnStatus_t
       
   264 CyAnUsbGetDescriptorEX(
       
   265 	CyAnDeviceHandle		handle,
       
   266 	CyAnUsbDescType			type,
       
   267 	uint8_t				index,
       
   268 	CyAnGetDescriptorData *		data,
       
   269 	CyAnFunctionCallback		cb,
       
   270 	uint32_t			client
       
   271 	) ;
       
   272 #define CyAnUsbGetDescriptorEX(h, type, index, data, cb, client)						   \
       
   273     CyAsUsbGetDescriptor((CyAsDeviceHandle)(h), (CyAsUsbDescType)(type), (index), (CyAsGetDescriptorData *)(data), \
       
   274 	    (CyAsFunctionCallback)(cb), (client))
       
   275 
       
   276 EXTERN CyAnReturnStatus_t
       
   277 CyAnUsbSetPhysicalConfiguration(
       
   278     CyAnDeviceHandle		handle,
       
   279     uint8_t			config
       
   280     ) ;
       
   281 #define CyAnUsbSetPhysicalConfiguration(h, config)	\
       
   282     CyAsUsbSetPhysicalConfiguration((CyAsDeviceHandle)(h), (config))
       
   283 
       
   284 EXTERN CyAnReturnStatus_t
       
   285 CyAnUsbSetEndPointConfig(
       
   286     CyAnDeviceHandle			handle,
       
   287     CyAnEndPointNumber_t		ep,
       
   288     CyAnUsbEndPointConfig *		config_p
       
   289 	) ;
       
   290 #define CyAnUsbSetEndPointConfig(h, ep, config_p)	\
       
   291     CyAsUsbSetEndPointConfig((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbEndPointConfig *)(config_p))
       
   292 
       
   293 EXTERN CyAnReturnStatus_t
       
   294 CyAnUsbGetEndPointConfig(
       
   295 	CyAnDeviceHandle		handle,
       
   296 	CyAnEndPointNumber_t		ep,
       
   297 	CyAnUsbEndPointConfig *		config_p
       
   298 	) ;
       
   299 #define CyAnUsbGetEndPointConfig(h, ep, config_p)	\
       
   300     CyAsUsbGetEndPointConfig((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbEndPointConfig *)(config_p))
       
   301 
       
   302 /* Sync version of commit */
       
   303 EXTERN CyAnReturnStatus_t
       
   304 CyAnUsbCommitConfig(
       
   305 	CyAnDeviceHandle		handle
       
   306 	) ;
       
   307 #define CyAnUsbCommitConfig(handle) CyAsUsbCommitConfig((CyAsDeviceHandle)(handle), 0, 0)
       
   308 
       
   309 /* Async version of commit */
       
   310 extern CyAnReturnStatus_t
       
   311 CyAnUsbCommitConfigEX(
       
   312 	CyAnDeviceHandle		handle,
       
   313 	CyAnFunctionCallback		cb,
       
   314 	uint32_t			client
       
   315 	) ;
       
   316 #define CyAnUsbCommitConfigEX(h, cb, client)	\
       
   317     CyAsUsbCommitConfig((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   318 
       
   319 EXTERN CyAnReturnStatus_t
       
   320 CyAnUsbReadData(
       
   321 	CyAnDeviceHandle		handle,
       
   322 	CyAnEndPointNumber_t		ep,
       
   323 	CyBool				pktread,
       
   324 	uint32_t			dsize,
       
   325 	uint32_t *			dataread,
       
   326 	void *				data
       
   327 	) ;
       
   328 #define CyAnUsbReadData(h, ep, pkt, dsize, dataread, data_p)	\
       
   329     CyAsUsbReadData((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (pkt), (dsize), (dataread), (data_p))
       
   330 
       
   331 EXTERN CyAnReturnStatus_t
       
   332 CyAnUsbReadDataAsync(
       
   333 	CyAnDeviceHandle		handle,
       
   334 	CyAnEndPointNumber_t		ep,
       
   335 	CyBool				pktread,
       
   336 	uint32_t			dsize,
       
   337 	void *				data,
       
   338 	CyAnUsbIoCallback		callback
       
   339 	) ;
       
   340 #define CyAnUsbReadDataAsync(h, ep, pkt, dsize, data_p, cb)						\
       
   341     CyAsUsbReadDataAsync((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (pkt), (dsize), (data_p),	\
       
   342 	    (CyAsUsbIoCallback)(cb))
       
   343 
       
   344 EXTERN CyAnReturnStatus_t
       
   345 CyAnUsbWriteData(
       
   346 	CyAnDeviceHandle		handle,
       
   347 	CyAnEndPointNumber_t		ep,
       
   348 	uint32_t			dsize,
       
   349 	void *				data
       
   350 	) ;
       
   351 #define CyAnUsbWriteData(h, ep, dsize, data_p)		\
       
   352     CyAsUsbWriteData((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (dsize), (data_p))
       
   353 
       
   354 EXTERN CyAnReturnStatus_t
       
   355 CyAnUsbWriteDataAsync(
       
   356 	CyAnDeviceHandle		handle,
       
   357 	CyAnEndPointNumber_t		ep,
       
   358 	uint32_t			dsize,
       
   359 	void *				data,
       
   360 	CyBool				spacket,
       
   361 	CyAnUsbIoCallback		callback
       
   362 	) ;
       
   363 #define CyAnUsbWriteDataAsync(h, ep, dsize, data_p, spacket, cb)						\
       
   364     CyAsUsbWriteDataAsync((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (dsize), (data_p), (spacket),	\
       
   365 	    (CyAsUsbIoCallback)(cb))
       
   366 
       
   367 EXTERN CyAnReturnStatus_t
       
   368 CyAnUsbCancelAsync(
       
   369 	CyAnDeviceHandle		handle,
       
   370 	CyAnEndPointNumber_t		ep
       
   371 	) ;
       
   372 #define CyAnUsbCancelAsync(h, ep) CyAsUsbCancelAsync((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep))
       
   373 
       
   374 /* Sync version of set stall */
       
   375 EXTERN CyAnReturnStatus_t
       
   376 CyAnUsbSetStall(
       
   377 	CyAnDeviceHandle		handle,
       
   378 	CyAnEndPointNumber_t		ep,
       
   379 	CyAnUsbFunctionCallback		cb,
       
   380 	uint32_t			client
       
   381 ) ;
       
   382 #define CyAnUsbSetStall(h, ep, cb, client)	\
       
   383     CyAsUsbSetStall_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
       
   384 
       
   385 /* Async version of set stall */
       
   386 extern CyAnReturnStatus_t
       
   387 CyAnUsbSetStallEX(
       
   388 	CyAnDeviceHandle		handle,
       
   389 	CyAnEndPointNumber_t		ep,
       
   390 	CyAnFunctionCallback		cb,
       
   391 	uint32_t			client
       
   392 ) ;
       
   393 #define CyAnUsbSetStallEX(h, ep, cb, client)	\
       
   394     CyAsUsbSetStall((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
       
   395 
       
   396 /*Sync version of clear stall */
       
   397 EXTERN CyAnReturnStatus_t
       
   398 CyAnUsbClearStall(
       
   399 	CyAnDeviceHandle		handle,
       
   400 	CyAnEndPointNumber_t		ep,
       
   401 	CyAnUsbFunctionCallback		cb,
       
   402 	uint32_t			client
       
   403 	) ;
       
   404 #define CyAnUsbClearStall(h, ep, cb, client)	\
       
   405     CyAsUsbClearStall_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
       
   406 
       
   407 /*Sync version of clear stall */
       
   408 extern CyAnReturnStatus_t
       
   409 CyAnUsbClearStallEX(
       
   410 	CyAnDeviceHandle		handle,
       
   411 	CyAnEndPointNumber_t		ep,
       
   412 	CyAnFunctionCallback		cb,
       
   413 	uint32_t			client
       
   414 	) ;
       
   415 #define CyAnUsbClearStallEX(h, ep, cb, client)	\
       
   416     CyAsUsbClearStall((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
       
   417 
       
   418 /* Sync get stall */
       
   419 EXTERN CyAnReturnStatus_t
       
   420 CyAnUsbGetStall(
       
   421 	CyAnDeviceHandle		handle,
       
   422 	CyAnEndPointNumber_t		ep,
       
   423 	CyBool *			stall_p
       
   424 	) ;
       
   425 #define CyAnUsbGetStall(handle, ep, stall_p) \
       
   426     CyAsUsbGetStall((CyAsDeviceHandle)(handle), (CyAsEndPointNumber_t)(ep), (stall_p), 0, 0)
       
   427 
       
   428 /* Async get stall */
       
   429 extern CyAnReturnStatus_t
       
   430 CyAnUsbGetStallEX(
       
   431 	CyAnDeviceHandle		handle,
       
   432 	CyAnEndPointNumber_t		ep,
       
   433 	CyBool *			stall_p,
       
   434 	CyAnFunctionCallback		cb,
       
   435 	uint32_t			client
       
   436 	) ;
       
   437 #define CyAnUsbGetStallEX(h, ep, stall_p, cb, client)	\
       
   438     CyAsUsbGetStall((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (stall_p), (CyAsFunctionCallback)(cb), (client))
       
   439 
       
   440 /* Sync version of Set Nak */
       
   441 EXTERN CyAnReturnStatus_t
       
   442 CyAnUsbSetNak(
       
   443 	CyAnDeviceHandle		handle,
       
   444 	CyAnEndPointNumber_t		ep,
       
   445 	CyAnUsbFunctionCallback		cb,
       
   446 	uint32_t			client
       
   447 ) ;
       
   448 
       
   449 #define CyAnUsbSetNak(h, ep, cb, client)		\
       
   450     CyAsUsbSetNak_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
       
   451 
       
   452 /* Async version of Set Nak */
       
   453 extern CyAnReturnStatus_t
       
   454 CyAnUsbSetNakEX(
       
   455 	CyAnDeviceHandle		handle,
       
   456 	CyAnEndPointNumber_t		ep,
       
   457 	CyAnFunctionCallback		cb,
       
   458 	uint32_t			client
       
   459 ) ;
       
   460 #define CyAnUsbSetNakEX(h, ep, cb, client)		\
       
   461     CyAsUsbSetNak((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
       
   462 
       
   463 /* Sync version of clear nak */
       
   464 EXTERN CyAnReturnStatus_t
       
   465 CyAnUsbClearNak(
       
   466 	CyAnDeviceHandle		handle,
       
   467 	CyAnEndPointNumber_t		ep,
       
   468 	CyAnUsbFunctionCallback		cb,
       
   469 	uint32_t			client
       
   470 	) ;
       
   471 #define CyAnUsbClearNak(h, ep, cb, client)		\
       
   472     CyAsUsbClearNak_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
       
   473 
       
   474 /* Sync version of clear nak */
       
   475 extern CyAnReturnStatus_t
       
   476 CyAnUsbClearNakEX(
       
   477 	CyAnDeviceHandle		handle,
       
   478 	CyAnEndPointNumber_t		ep,
       
   479 	CyAnFunctionCallback		cb,
       
   480 	uint32_t			client
       
   481 	) ;
       
   482 #define CyAnUsbClearNakEX(h, ep, cb, client)		\
       
   483     CyAsUsbClearNak((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
       
   484 
       
   485 /* Sync Get NAK */
       
   486 EXTERN CyAnReturnStatus_t
       
   487 CyAnUsbGetNak(
       
   488     CyAnDeviceHandle		    handle,
       
   489     CyAnEndPointNumber_t	    ep,
       
   490     CyBool *			    nak_p
       
   491 ) ;
       
   492 #define CyAnUsbGetNak(handle, ep, nak_p) \
       
   493     CyAsUsbGetNak((CyAsDeviceHandle)(handle), (CyAsEndPointNumber_t)(ep), (nak_p), 0, 0)
       
   494 
       
   495 /* Async Get NAK */
       
   496 EXTERN CyAnReturnStatus_t
       
   497 CyAnUsbGetNakEX(
       
   498     CyAnDeviceHandle		    handle,
       
   499     CyAnEndPointNumber_t	    ep,
       
   500     CyBool *			    nak_p,
       
   501     CyAnFunctionCallback	    cb,
       
   502     uint32_t			    client
       
   503 ) ;
       
   504 #define CyAnUsbGetNakEX(h, ep, nak_p, cb, client)	\
       
   505     CyAsUsbGetNak((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (nak_p), (CyAsFunctionCallback)(cb), (client))
       
   506 
       
   507 /* Sync remote wakup */
       
   508 EXTERN CyAnReturnStatus_t
       
   509 CyAnUsbSignalRemoteWakeup(
       
   510         CyAnDeviceHandle            handle
       
   511         ) ;
       
   512 #define CyAnUsbSignalRemoteWakeup(handle) CyAsUsbSignalRemoteWakeup((CyAsDeviceHandle)(handle), 0, 0)
       
   513 
       
   514 /* Async remote wakup */
       
   515 EXTERN CyAnReturnStatus_t
       
   516 CyAnUsbSignalRemoteWakeupEX(
       
   517         CyAnDeviceHandle            handle,
       
   518         CyAnFunctionCallback        cb,
       
   519         uint32_t                    client
       
   520         ) ;
       
   521 #define CyAnUsbSignalRemoteWakeupEX(h, cb, client)	\
       
   522     CyAsUsbSignalRemoteWakeup((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
       
   523 
       
   524 /* Only version of SetMSReportThreshold */
       
   525 EXTERN CyAnReturnStatus_t
       
   526 CyAnUsbSetMSReportThreshold(
       
   527         CyAnDeviceHandle            handle,
       
   528         uint32_t                    wr_sectors,
       
   529         uint32_t                    rd_sectors,
       
   530         CyAnFunctionCallback        cb,
       
   531         uint32_t                    client
       
   532         ) ;
       
   533 #define CyAnUsbSetMSReportThreshold(h, wr_cnt, rd_cnt, cb, client)              \
       
   534     CyAsUsbSetMSReportThreshold((CyAsDeviceHandle)(h), wr_cnt, rd_cnt, (CyAsFunctionCallback)(cb), (client))
       
   535 
       
   536 /* Select storage partitions to be enumerated. */
       
   537 EXTERN CyAnReturnStatus_t
       
   538 CyAnUsbSelectMSPartitions (
       
   539         CyAnDeviceHandle                handle,
       
   540         CyAnMediaType                   media,
       
   541         uint32_t                        device,
       
   542         CyAnUsbMSType_t                 type,
       
   543         CyAnFunctionCallback            cb,
       
   544         uint32_t                        client
       
   545         ) ;
       
   546 #define CyAnUsbSelectMSPartitions(h, media, dev, type, cb, client)                              \
       
   547     CyAsUsbSelectMSPartitions_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(media), (dev),        \
       
   548                 (CyAsUsbMSType_t)(type), (CyAsFunctionCallback)(cb), (client))
       
   549 
       
   550 #include "cyas_cplus_end.h"
       
   551 #endif /*__doxygen__*/
       
   552 #endif	/*_INCLUDED_CYANUSB_H_*/