drivers/staging/westbridge/astoria/include/linux/westbridge/cyanusb.h

   1 /*  Cypress West Bridge API header file (cyanusb.h)
   2  ## Header for backward compatibility with previous Antioch SDK releases.
   3 ## ===========================
   4 ## Copyright (C) 2010  Cypress Semiconductor
   5 ##
   6 ## This program is free software; you can redistribute it and/or
   7 ## modify it under the terms of the GNU General Public License
   8 ## as published by the Free Software Foundation; either version 2
   9 ## of the License, or (at your option) any later version.
  10 ##
  11 ## This program is distributed in the hope that it will be useful,
  12 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ## GNU General Public License for more details.
  15 ##
  16 ## You should have received a copy of the GNU General Public License
  17 ## along with this program; if not, write to the Free Software
  18 ## Foundation, Inc., 51 Franklin Street
  19 ## Fifth Floor, Boston, MA  02110-1301, USA.
  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 cy_as_usb_inquiry_data_dep cy_an_usb_inquiry_data;
  35 typedef cy_as_usb_unknown_command_data_dep \
  36         cy_an_usb_unknown_command_data;
  37 typedef cy_as_usb_start_stop_data_dep cy_an_usb_start_stop_data;
  38 typedef cy_as_m_s_c_progress_data cy_an_m_s_c_progress_data;
  39
  40 #define cy_an_usb_nand_enum cy_as_usb_nand_enum
  41 #define cy_an_usb_sd_enum cy_as_usb_sd_enum
  42 #define cy_an_usb_mmc_enum cy_as_usb_mmc_enum
  43 #define cy_an_usb_ce_ata_enum cy_as_usb_ce_ata_enum
  44 typedef cy_as_usb_mass_storage_enum cy_an_usb_mass_storage_enum;
  45
  46 #define cy_an_usb_desc_device cy_as_usb_desc_device
  47 #define cy_an_usb_desc_device_qual cy_as_usb_desc_device_qual
  48 #define cy_an_usb_desc_f_s_configuration \
  49         cy_as_usb_desc_f_s_configuration
  50 #define cy_an_usb_desc_h_s_configuration \
  51         cy_as_usb_desc_h_s_configuration
  52 #define cy_an_usb_desc_string cy_as_usb_desc_string
  53 typedef cy_as_usb_desc_type cy_an_usb_desc_type;
  54
  55 #define cy_an_usb_in    cy_as_usb_in
  56 #define cy_an_usb_out   cy_as_usb_out
  57 #define cy_an_usb_in_out        cy_as_usb_in_out
  58 typedef cy_as_usb_end_point_dir cy_an_usb_end_point_dir;
  59
  60
  61 #define cy_an_usb_control cy_as_usb_control
  62 #define cy_an_usb_iso cy_as_usb_iso
  63 #define cy_an_usb_bulk cy_as_usb_bulk
  64 #define cy_an_usb_int cy_as_usb_int
  65 typedef cy_as_usb_end_point_type cy_an_usb_end_point_type;
  66
  67
  68 typedef cy_as_usb_enum_control_dep cy_an_usb_enum_control;
  69 typedef cy_as_usb_end_point_config cy_an_usb_end_point_config;
  70
  71 #define cy_an_usb_m_s_unit0     cy_as_usb_m_s_unit0
  72 #define cy_an_usb_m_s_unit1     cy_as_usb_m_s_unit1
  73 #define cy_an_usb_m_s_both cy_as_usb_m_s_both
  74 typedef cy_as_usb_m_s_type_t cy_an_usb_m_s_type_t;
  75
  76 #define cy_an_event_usb_suspend cy_as_event_usb_suspend
  77 #define cy_an_event_usb_resume cy_as_event_usb_resume
  78 #define cy_an_event_usb_reset cy_as_event_usb_reset
  79 #define cy_an_event_usb_set_config cy_as_event_usb_set_config
  80 #define cy_an_event_usb_speed_change cy_as_event_usb_speed_change
  81 #define cy_an_event_usb_setup_packet cy_as_event_usb_setup_packet
  82 #define cy_an_event_usb_status_packet cy_as_event_usb_status_packet
  83 #define cy_an_event_usb_inquiry_before  cy_as_event_usb_inquiry_before
  84 #define cy_an_event_usb_inquiry_after cy_as_event_usb_inquiry_after
  85 #define cy_an_event_usb_start_stop cy_as_event_usb_start_stop
  86 #define cy_an_event_usb_unknown_storage cy_as_event_usb_unknown_storage
  87 #define cy_an_event_usb_m_s_c_progress cy_as_event_usb_m_s_c_progress
  88 typedef cy_as_usb_event cy_an_usb_event;
  89
  90 typedef cy_as_usb_event_callback_dep cy_an_usb_event_callback;
  91
  92 typedef cy_as_usb_io_callback cy_an_usb_io_callback;
  93 typedef cy_as_usb_function_callback cy_an_usb_function_callback;
  94
  95 /******* USB Functions ********************/
  96
  97 /* Sync Usb Start */
  98 extern cy_an_return_status_t
  99 cy_an_usb_start(
 100         cy_an_device_handle             handle
 101         );
 102 #define cy_an_usb_start(handle) \
 103         cy_as_usb_start((cy_as_device_handle)(handle), 0, 0)
 104
 105 /*Async Usb Start */
 106 extern cy_an_return_status_t
 107 cy_an_usb_start_e_x(
 108         cy_an_device_handle             handle,
 109         cy_an_function_callback         cb,
 110         uint32_t                        client
 111         );
 112 #define cy_an_usb_start_e_x(h, cb, client) \
 113         cy_as_usb_start((cy_as_device_handle)(h), \
 114         (cy_as_function_callback)(cb), (client))
 115
 116 /* Sync Usb Stop */
 117 extern cy_an_return_status_t
 118 cy_an_usb_stop(
 119         cy_an_device_handle             handle
 120         );
 121 #define cy_an_usb_stop(handle) \
 122         cy_as_usb_stop((cy_as_device_handle)(handle), 0, 0)
 123
 124 /*Async Usb Stop */
 125 extern cy_an_return_status_t
 126 cy_an_usb_stop_e_x(
 127         cy_an_device_handle             handle,
 128         cy_an_function_callback         cb,
 129         uint32_t                        client
 130         );
 131 #define cy_an_usb_stop_e_x(h, cb, client) \
 132         cy_as_usb_stop((cy_as_device_handle)(h), \
 133         (cy_as_function_callback)(cb), (client))
 134
 135 /* Register USB event callback */
 136 EXTERN cy_an_return_status_t
 137 cy_an_usb_register_callback(
 138         cy_an_device_handle             handle,
 139         cy_an_usb_event_callback                callback
 140         );
 141 #define cy_an_usb_register_callback(h, cb) \
 142         cy_as_usb_register_callback_dep((cy_as_device_handle)(h), \
 143         (cy_as_usb_event_callback_dep)(cb))
 144
 145 /*Sync Usb connect */
 146 EXTERN cy_an_return_status_t
 147 cy_an_usb_connect(
 148         cy_an_device_handle             handle
 149         );
 150 #define cy_an_usb_connect(handle) \
 151         cy_as_usb_connect((cy_as_device_handle)(handle), 0, 0)
 152
 153 /*Async Usb connect */
 154 extern cy_an_return_status_t
 155 cy_an_usb_connect_e_x(
 156         cy_an_device_handle             handle,
 157         cy_an_function_callback         cb,
 158         uint32_t                        client
 159         );
 160 #define cy_an_usb_connect_e_x(h, cb, client)            \
 161         cy_as_usb_connect((cy_as_device_handle)(h), \
 162         (cy_as_function_callback)(cb), (client))
 163
 164 /*Sync Usb disconnect */
 165 EXTERN cy_an_return_status_t
 166 cy_an_usb_disconnect(
 167         cy_an_device_handle             handle
 168         );
 169 #define cy_an_usb_disconnect(handle) \
 170         cy_as_usb_disconnect((cy_as_device_handle)(handle), 0, 0)
 171
 172 /*Async Usb disconnect */
 173 extern cy_an_return_status_t
 174 cy_an_usb_disconnect_e_x(
 175         cy_an_device_handle             handle,
 176         cy_an_function_callback         cb,
 177         uint32_t                        client
 178         );
 179 #define cy_an_usb_disconnect_e_x(h, cb, client) \
 180         cy_as_usb_disconnect((cy_as_device_handle)(h), \
 181         (cy_as_function_callback)(cb), (client))
 182
 183 /* Sync version of set enum config */
 184 EXTERN cy_an_return_status_t
 185 cy_an_usb_set_enum_config(
 186         cy_an_device_handle     handle,
 187         cy_an_usb_enum_control *config_p
 188         );
 189 #define cy_an_usb_set_enum_config(handle, config_p) \
 190         cy_as_usb_set_enum_config_dep((cy_as_device_handle)(handle), \
 191         (cy_as_usb_enum_control_dep *)(config_p), 0, 0)
 192
 193 /* Async version of set enum config */
 194 extern cy_an_return_status_t
 195 cy_an_usb_set_enum_config_e_x(
 196         cy_an_device_handle             handle,
 197         cy_an_usb_enum_control *config_p,
 198         cy_an_function_callback         cb,
 199         uint32_t                        client
 200         );
 201 #define cy_an_usb_set_enum_config_e_x(h, config_p, cb, client) \
 202         cy_as_usb_set_enum_config_dep((cy_as_device_handle)(h), \
 203         (cy_as_usb_enum_control_dep *)(config_p),        \
 204                 (cy_as_function_callback)(cb), (client))
 205
 206 /* Sync version of get enum config */
 207 EXTERN cy_an_return_status_t
 208 cy_an_usb_get_enum_config(
 209         cy_an_device_handle             handle,
 210         cy_an_usb_enum_control *config_p
 211         );
 212 #define cy_an_usb_get_enum_config(handle, config_p) \
 213         cy_as_usb_get_enum_config_dep((cy_as_device_handle)(handle), \
 214         (cy_as_usb_enum_control_dep *)(config_p), 0, 0)
 215
 216 /* Async version of get enum config */
 217 extern cy_an_return_status_t
 218 cy_an_usb_get_enum_config_e_x(
 219         cy_an_device_handle             handle,
 220         cy_an_usb_enum_control *config_p,
 221         cy_an_function_callback         cb,
 222         uint32_t                        client
 223         );
 224 #define cy_an_usb_get_enum_config_e_x(h, config_p, cb, client) \
 225         cy_as_usb_get_enum_config_dep((cy_as_device_handle)(h), \
 226         (cy_as_usb_enum_control_dep *)(config_p),        \
 227         (cy_as_function_callback)(cb), (client))
 228
 229 /* Sync Version of Set descriptor */
 230 EXTERN cy_an_return_status_t
 231 cy_an_usb_set_descriptor(
 232         cy_an_device_handle             handle,
 233         cy_an_usb_desc_type                     type,
 234         uint8_t                         index,
 235         void *desc_p,
 236         uint16_t                        length
 237         );
 238 #define cy_an_usb_set_descriptor(handle, type, index, desc_p, length) \
 239         cy_as_usb_set_descriptor((cy_as_device_handle)(handle), \
 240         (cy_as_usb_desc_type)(type), (index), (desc_p), (length), 0, 0)
 241
 242 /* Async Version of Set descriptor */
 243 extern cy_an_return_status_t
 244 cy_an_usb_set_descriptor_e_x(
 245         cy_an_device_handle             handle,
 246         cy_an_usb_desc_type                     type,
 247         uint8_t                         index,
 248         void *desc_p,
 249         uint16_t                        length,
 250         cy_an_function_callback         cb,
 251         uint32_t                        client
 252         );
 253 #define cy_an_usb_set_descriptor_e_x\
 254         (h, type, index, desc_p, length, cb, client) \
 255         cy_as_usb_set_descriptor((cy_as_device_handle)(h), \
 256         (cy_as_usb_desc_type)(type), (index), (desc_p), (length), \
 257                 (cy_as_function_callback)(cb), (client))
 258
 259 /* Only version of clear descriptors */
 260 EXTERN cy_an_return_status_t
 261 cy_an_usb_clear_descriptors(
 262         cy_an_device_handle             handle,
 263                 cy_an_function_callback                 cb,
 264                 uint32_t                                                client
 265         );
 266 #define cy_an_usb_clear_descriptors(h, cb, client) \
 267         cy_as_usb_clear_descriptors((cy_as_device_handle)(h), \
 268         (cy_as_function_callback)(cb), (client))
 269
 270 /* Sync version of get descriptor*/
 271 EXTERN cy_an_return_status_t
 272 cy_an_usb_get_descriptor(
 273         cy_an_device_handle     handle,
 274         cy_an_usb_desc_type             type,
 275         uint8_t                 index,
 276         void *desc_p,
 277         uint32_t *length_p
 278         );
 279 #define cy_an_usb_get_descriptor(h, type, index, desc_p, length_p)      \
 280         cy_as_usb_get_descriptor_dep((cy_as_device_handle)(h), \
 281         (cy_as_usb_desc_type)(type), (index), (desc_p), (length_p))
 282
 283 typedef cy_as_get_descriptor_data cy_an_get_descriptor_data;
 284
 285 /* Async version of get descriptor */
 286 extern cy_an_return_status_t
 287 cy_an_usb_get_descriptor_e_x(
 288         cy_an_device_handle             handle,
 289         cy_an_usb_desc_type                     type,
 290         uint8_t                         index,
 291         cy_an_get_descriptor_data *data,
 292         cy_an_function_callback         cb,
 293         uint32_t                        client
 294         );
 295 #define cy_an_usb_get_descriptor_e_x\
 296         (h, type, index, data, cb, client) \
 297         cy_as_usb_get_descriptor((cy_as_device_handle)(h), \
 298         (cy_as_usb_desc_type)(type), (index), \
 299         (cy_as_get_descriptor_data *)(data), \
 300                 (cy_as_function_callback)(cb), (client))
 301
 302 EXTERN cy_an_return_status_t
 303 cy_an_usb_set_physical_configuration(
 304         cy_an_device_handle             handle,
 305         uint8_t                 config
 306         );
 307 #define cy_an_usb_set_physical_configuration(h, config) \
 308         cy_as_usb_set_physical_configuration\
 309         ((cy_as_device_handle)(h), (config))
 310
 311 EXTERN cy_an_return_status_t
 312 cy_an_usb_set_end_point_config(
 313         cy_an_device_handle                     handle,
 314         cy_an_end_point_number_t                ep,
 315         cy_an_usb_end_point_config *config_p
 316         );
 317 #define cy_an_usb_set_end_point_config(h, ep, config_p) \
 318         cy_as_usb_set_end_point_config((cy_as_device_handle)(h), \
 319         (cy_as_end_point_number_t)(ep), \
 320         (cy_as_usb_end_point_config *)(config_p))
 321
 322 EXTERN cy_an_return_status_t
 323 cy_an_usb_get_end_point_config(
 324         cy_an_device_handle             handle,
 325         cy_an_end_point_number_t                ep,
 326         cy_an_usb_end_point_config *config_p
 327         );
 328 #define cy_an_usb_get_end_point_config(h, ep, config_p) \
 329         cy_as_usb_get_end_point_config((cy_as_device_handle)(h), \
 330         (cy_as_end_point_number_t)(ep), \
 331         (cy_as_usb_end_point_config *)(config_p))
 332
 333 /* Sync version of commit */
 334 EXTERN cy_an_return_status_t
 335 cy_an_usb_commit_config(
 336         cy_an_device_handle             handle
 337         );
 338 #define cy_an_usb_commit_config(handle) \
 339         cy_as_usb_commit_config((cy_as_device_handle)(handle), 0, 0)
 340
 341 /* Async version of commit */
 342 extern cy_an_return_status_t
 343 cy_an_usb_commit_config_e_x(
 344         cy_an_device_handle             handle,
 345         cy_an_function_callback         cb,
 346         uint32_t                        client
 347         );
 348 #define cy_an_usb_commit_config_e_x(h, cb, client)      \
 349         cy_as_usb_commit_config((cy_as_device_handle)(h), \
 350         (cy_as_function_callback)(cb), (client))
 351
 352 EXTERN cy_an_return_status_t
 353 cy_an_usb_read_data(
 354         cy_an_device_handle             handle,
 355         cy_an_end_point_number_t                ep,
 356         cy_bool                         pktread,
 357         uint32_t                        dsize,
 358         uint32_t *dataread,
 359         void *data
 360         );
 361 #define cy_an_usb_read_data(h, ep, pkt, dsize, dataread, data_p) \
 362         cy_as_usb_read_data((cy_as_device_handle)(h), \
 363         (cy_as_end_point_number_t)(ep), (pkt), (dsize), \
 364         (dataread), (data_p))
 365
 366 EXTERN cy_an_return_status_t
 367 cy_an_usb_read_data_async(
 368         cy_an_device_handle             handle,
 369         cy_an_end_point_number_t                ep,
 370         cy_bool                         pktread,
 371         uint32_t                        dsize,
 372         void *data,
 373         cy_an_usb_io_callback           callback
 374         );
 375 #define cy_an_usb_read_data_async(h, ep, pkt, dsize, data_p, cb) \
 376         cy_as_usb_read_data_async((cy_as_device_handle)(h), \
 377         (cy_as_end_point_number_t)(ep), (pkt), (dsize), (data_p), \
 378                 (cy_as_usb_io_callback)(cb))
 379
 380 EXTERN cy_an_return_status_t
 381 cy_an_usb_write_data(
 382         cy_an_device_handle             handle,
 383         cy_an_end_point_number_t                ep,
 384         uint32_t                        dsize,
 385         void *data
 386         );
 387 #define cy_an_usb_write_data(h, ep, dsize, data_p) \
 388         cy_as_usb_write_data((cy_as_device_handle)(h), \
 389         (cy_as_end_point_number_t)(ep), (dsize), (data_p))
 390
 391 EXTERN cy_an_return_status_t
 392 cy_an_usb_write_data_async(
 393         cy_an_device_handle             handle,
 394         cy_an_end_point_number_t                ep,
 395         uint32_t                        dsize,
 396         void *data,
 397         cy_bool                         spacket,
 398         cy_an_usb_io_callback           callback
 399         );
 400 #define cy_an_usb_write_data_async(h, ep, dsize, data_p, spacket, cb) \
 401         cy_as_usb_write_data_async((cy_as_device_handle)(h), \
 402         (cy_as_end_point_number_t)(ep), (dsize), (data_p), (spacket), \
 403                 (cy_as_usb_io_callback)(cb))
 404
 405 EXTERN cy_an_return_status_t
 406 cy_an_usb_cancel_async(
 407         cy_an_device_handle             handle,
 408         cy_an_end_point_number_t                ep
 409         );
 410 #define cy_an_usb_cancel_async(h, ep) \
 411         cy_as_usb_cancel_async((cy_as_device_handle)(h), \
 412         (cy_as_end_point_number_t)(ep))
 413
 414 /* Sync version of set stall */
 415 EXTERN cy_an_return_status_t
 416 cy_an_usb_set_stall(
 417         cy_an_device_handle             handle,
 418         cy_an_end_point_number_t                ep,
 419         cy_an_usb_function_callback             cb,
 420         uint32_t                        client
 421 );
 422 #define cy_an_usb_set_stall(h, ep, cb, client)  \
 423         cy_as_usb_set_stall_dep((cy_as_device_handle)(h), \
 424         (cy_as_end_point_number_t)(ep), \
 425         (cy_as_usb_function_callback)(cb), (client))
 426
 427 /* Async version of set stall */
 428 extern cy_an_return_status_t
 429 cy_an_usb_set_stall_e_x(
 430         cy_an_device_handle             handle,
 431         cy_an_end_point_number_t                ep,
 432         cy_an_function_callback         cb,
 433         uint32_t                        client
 434 );
 435 #define cy_an_usb_set_stall_e_x(h, ep, cb, client)      \
 436         cy_as_usb_set_stall((cy_as_device_handle)(h), \
 437         (cy_as_end_point_number_t)(ep), \
 438         (cy_as_function_callback)(cb), (client))
 439
 440 /*Sync version of clear stall */
 441 EXTERN cy_an_return_status_t
 442 cy_an_usb_clear_stall(
 443         cy_an_device_handle             handle,
 444         cy_an_end_point_number_t                ep,
 445         cy_an_usb_function_callback             cb,
 446         uint32_t                        client
 447         );
 448 #define cy_an_usb_clear_stall(h, ep, cb, client)        \
 449         cy_as_usb_clear_stall_dep((cy_as_device_handle)(h), \
 450         (cy_as_end_point_number_t)(ep), \
 451         (cy_as_usb_function_callback)(cb), (client))
 452
 453 /*Sync version of clear stall */
 454 extern cy_an_return_status_t
 455 cy_an_usb_clear_stall_e_x(
 456         cy_an_device_handle             handle,
 457         cy_an_end_point_number_t                ep,
 458         cy_an_function_callback         cb,
 459         uint32_t                        client
 460         );
 461 #define cy_an_usb_clear_stall_e_x(h, ep, cb, client) \
 462         cy_as_usb_clear_stall((cy_as_device_handle)(h), \
 463         (cy_as_end_point_number_t)(ep), \
 464         (cy_as_function_callback)(cb), (client))
 465
 466 /* Sync get stall */
 467 EXTERN cy_an_return_status_t
 468 cy_an_usb_get_stall(
 469         cy_an_device_handle             handle,
 470         cy_an_end_point_number_t                ep,
 471         cy_bool *stall_p
 472         );
 473 #define cy_an_usb_get_stall(handle, ep, stall_p) \
 474         cy_as_usb_get_stall((cy_as_device_handle)(handle), \
 475         (cy_as_end_point_number_t)(ep), (stall_p), 0, 0)
 476
 477 /* Async get stall */
 478 extern cy_an_return_status_t
 479 cy_an_usb_get_stall_e_x(
 480         cy_an_device_handle             handle,
 481         cy_an_end_point_number_t                ep,
 482         cy_bool *stall_p,
 483         cy_an_function_callback         cb,
 484         uint32_t                        client
 485         );
 486 #define cy_an_usb_get_stall_e_x(h, ep, stall_p, cb, client)     \
 487         cy_as_usb_get_stall((cy_as_device_handle)(h), \
 488         (cy_as_end_point_number_t)(ep), (stall_p), \
 489         (cy_as_function_callback)(cb), (client))
 490
 491 /* Sync version of Set Nak */
 492 EXTERN cy_an_return_status_t
 493 cy_an_usb_set_nak(
 494         cy_an_device_handle             handle,
 495         cy_an_end_point_number_t                ep,
 496         cy_an_usb_function_callback             cb,
 497         uint32_t                        client
 498 );
 499
 500 #define cy_an_usb_set_nak(h, ep, cb, client) \
 501         cy_as_usb_set_nak_dep((cy_as_device_handle)(h), \
 502         (cy_as_end_point_number_t)(ep), \
 503         (cy_as_usb_function_callback)(cb), (client))
 504
 505 /* Async version of Set Nak */
 506 extern cy_an_return_status_t
 507 cy_an_usb_set_nak_e_x(
 508         cy_an_device_handle             handle,
 509         cy_an_end_point_number_t                ep,
 510         cy_an_function_callback         cb,
 511         uint32_t                        client
 512 );
 513 #define cy_an_usb_set_nak_e_x(h, ep, cb, client) \
 514         cy_as_usb_set_nak((cy_as_device_handle)(h), \
 515         (cy_as_end_point_number_t)(ep), \
 516         (cy_as_function_callback)(cb), (client))
 517
 518 /* Sync version of clear nak */
 519 EXTERN cy_an_return_status_t
 520 cy_an_usb_clear_nak(
 521         cy_an_device_handle             handle,
 522         cy_an_end_point_number_t                ep,
 523         cy_an_usb_function_callback             cb,
 524         uint32_t                        client
 525         );
 526 #define cy_an_usb_clear_nak(h, ep, cb, client) \
 527         cy_as_usb_clear_nak_dep((cy_as_device_handle)(h), \
 528         (cy_as_end_point_number_t)(ep), \
 529         (cy_as_usb_function_callback)(cb), (client))
 530
 531 /* Sync version of clear nak */
 532 extern cy_an_return_status_t
 533 cy_an_usb_clear_nak_e_x(
 534         cy_an_device_handle             handle,
 535         cy_an_end_point_number_t                ep,
 536         cy_an_function_callback         cb,
 537         uint32_t                        client
 538         );
 539 #define cy_an_usb_clear_nak_e_x(h, ep, cb, client) \
 540         cy_as_usb_clear_nak((cy_as_device_handle)(h), \
 541         (cy_as_end_point_number_t)(ep), \
 542         (cy_as_function_callback)(cb), (client))
 543
 544 /* Sync Get NAK */
 545 EXTERN cy_an_return_status_t
 546 cy_an_usb_get_nak(
 547         cy_an_device_handle                     handle,
 548         cy_an_end_point_number_t                ep,
 549         cy_bool *nak_p
 550 );
 551 #define cy_an_usb_get_nak(handle, ep, nak_p) \
 552         cy_as_usb_get_nak((cy_as_device_handle)(handle), \
 553         (cy_as_end_point_number_t)(ep), (nak_p), 0, 0)
 554
 555 /* Async Get NAK */
 556 EXTERN cy_an_return_status_t
 557 cy_an_usb_get_nak_e_x(
 558         cy_an_device_handle                     handle,
 559         cy_an_end_point_number_t                ep,
 560         cy_bool *nak_p,
 561         cy_an_function_callback         cb,
 562         uint32_t                                client
 563 );
 564 #define cy_an_usb_get_nak_e_x(h, ep, nak_p, cb, client) \
 565         cy_as_usb_get_nak((cy_as_device_handle)(h), \
 566         (cy_as_end_point_number_t)(ep), (nak_p), \
 567         (cy_as_function_callback)(cb), (client))
 568
 569 /* Sync remote wakup */
 570 EXTERN cy_an_return_status_t
 571 cy_an_usb_signal_remote_wakeup(
 572                 cy_an_device_handle                     handle
 573                 );
 574 #define cy_an_usb_signal_remote_wakeup(handle) \
 575         cy_as_usb_signal_remote_wakeup((cy_as_device_handle)(handle), 0, 0)
 576
 577 /* Async remote wakup */
 578 EXTERN cy_an_return_status_t
 579 cy_an_usb_signal_remote_wakeup_e_x(
 580                 cy_an_device_handle                     handle,
 581                 cy_an_function_callback         cb,
 582                 uint32_t                                        client
 583                 );
 584 #define cy_an_usb_signal_remote_wakeup_e_x(h, cb, client)       \
 585         cy_as_usb_signal_remote_wakeup((cy_as_device_handle)(h), \
 586         (cy_as_function_callback)(cb), (client))
 587
 588 /* Only version of SetMSReportThreshold */
 589 EXTERN cy_an_return_status_t
 590 cy_an_usb_set_m_s_report_threshold(
 591                 cy_an_device_handle                     handle,
 592                 uint32_t                                        wr_sectors,
 593                 uint32_t                                        rd_sectors,
 594                 cy_an_function_callback         cb,
 595                 uint32_t                                        client
 596                 );
 597 #define cy_an_usb_set_m_s_report_threshold\
 598         (h, wr_cnt, rd_cnt, cb, client) \
 599         cy_as_usb_set_m_s_report_threshold((cy_as_device_handle)(h), \
 600         wr_cnt, rd_cnt, (cy_as_function_callback)(cb), (client))
 601
 602 /* Select storage partitions to be enumerated. */
 603 EXTERN cy_an_return_status_t
 604 cy_an_usb_select_m_s_partitions(
 605                 cy_an_device_handle                             handle,
 606                 cy_an_media_type                                   media,
 607                 uint32_t                                                device,
 608                 cy_an_usb_m_s_type_t                             type,
 609                 cy_an_function_callback                 cb,
 610                 uint32_t                                                client
 611                 );
 612 #define cy_an_usb_select_m_s_partitions(h, media, dev, type, cb, client) \
 613         cy_as_usb_select_m_s_partitions_dep((cy_as_device_handle)(h), \
 614         (cy_as_media_type)(media), (dev),               \
 615         (cy_as_usb_m_s_type_t)(type), (cy_as_function_callback)(cb), (client))
 616
 617 #include "cyas_cplus_end.h"
 618 #endif /*__doxygen__*/
 619 #endif  /*_INCLUDED_CYANUSB_H_*/