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

   1 /*  Cypress West Bridge API header file (cyanstorage.h)
   2  ## Header for backward compatibility with previous releases of Antioch SDK.
   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_CYANSTORAGE_H_
  24 #define _INCLUDED_CYANSTORAGE_H_
  25 #ifndef __doxygen__
  26
  27 #include "cyanmedia.h"
  28 #include "cyanmisc.h"
  29 #include "cyasstorage.h"
  30 #include "cyas_cplus_start.h"
  31
  32 #define CY_AN_LUN_PHYSICAL_DEVICE (CY_AS_LUN_PHYSICAL_DEVICE)
  33 #define CY_AN_STORAGE_EP_SIZE (CY_AS_STORAGE_EP_SIZE)
  34
  35 #define cy_an_storage_antioch   cy_as_storage_antioch
  36 #define cy_an_storage_processor cy_as_storage_processor
  37 #define cy_an_storage_removed   cy_as_storage_removed
  38 #define cy_an_storage_inserted  cy_as_storage_inserted
  39 #define cy_an_sdio_interrupt    cy_as_sdio_interrupt
  40 typedef cy_as_storage_event     cy_an_storage_event;
  41
  42 #define cy_an_op_read    cy_as_op_read
  43 #define cy_an_op_write   cy_as_op_write
  44 typedef cy_as_oper_type cy_an_oper_type;
  45
  46 typedef cy_as_device_desc cy_an_device_desc;
  47
  48 typedef cy_as_unit_desc cy_an_unit_desc;
  49
  50 typedef cy_as_storage_callback_dep \
  51         cy_an_storage_callback;
  52
  53 typedef cy_as_storage_event_callback_dep \
  54         cy_an_storage_event_callback;
  55
  56 #define cy_an_sd_reg_OCR cy_as_sd_reg_OCR
  57 #define cy_an_sd_reg_CID cy_as_sd_reg_CID
  58 #define cy_an_sd_reg_CSD cy_as_sd_reg_CSD
  59 typedef cy_as_sd_card_reg_type \
  60         cy_an_sd_card_reg_type;
  61
  62 typedef cy_as_storage_query_device_data_dep \
  63         cy_an_storage_query_device_data;
  64
  65 typedef cy_as_storage_query_unit_data_dep \
  66         cy_an_storage_query_unit_data;
  67
  68 typedef cy_as_storage_sd_reg_read_data \
  69         cy_an_storage_sd_reg_read_data;
  70
  71 #define CY_AN_SD_REG_OCR_LENGTH (CY_AS_SD_REG_OCR_LENGTH)
  72 #define CY_AN_SD_REG_CID_LENGTH (CY_AS_SD_REG_CID_LENGTH)
  73 #define CY_AN_SD_REG_CSD_LENGTH (CY_AS_SD_REG_CSD_LENGTH)
  74 #define CY_AN_SD_REG_MAX_RESP_LENGTH \
  75         (CY_AS_SD_REG_MAX_RESP_LENGTH)
  76
  77 /**** API Functions ******/
  78
  79 /* Sync version of Storage Start */
  80 EXTERN cy_an_return_status_t
  81 cy_an_storage_start(
  82         cy_an_device_handle             handle
  83         );
  84 #define cy_an_storage_start(handle) \
  85         cy_as_storage_start((cy_as_device_handle)(handle), 0, 0)
  86
  87 /* Async version of Storage Start */
  88 EXTERN cy_an_return_status_t
  89 cy_an_storage_start_e_x(
  90         cy_an_device_handle     handle,
  91         cy_an_function_callback cb,
  92         uint32_t                client
  93         );
  94 #define cy_an_storage_start_e_x(h, cb, client) \
  95         cy_as_storage_start((cy_as_device_handle)(h), \
  96                 (cy_as_function_callback)(cb), (client))
  97
  98 /* Sync version of Storage Stop */
  99 EXTERN cy_an_return_status_t
 100 cy_an_storage_stop(
 101         cy_an_device_handle             handle
 102         );
 103 #define cy_an_storage_stop(handle) \
 104         cy_as_storage_stop((cy_as_device_handle)(handle), 0, 0)
 105
 106 /* Async version of Storage Stop */
 107 EXTERN cy_an_return_status_t
 108 cy_an_storage_stop_e_x(
 109         cy_an_device_handle     handle,
 110         cy_an_function_callback cb,
 111         uint32_t                client
 112         );
 113 #define cy_an_storage_stop_e_x(h, cb, client)           \
 114         cy_as_storage_stop((cy_as_device_handle)(h), \
 115                 (cy_as_function_callback)(cb), (client))
 116
 117 /* Register Call back api */
 118 EXTERN cy_an_return_status_t
 119 cy_an_storage_register_callback(
 120         cy_an_device_handle                     handle,
 121         cy_an_storage_event_callback    callback
 122         );
 123 #define cy_an_storage_register_callback(h, cb)          \
 124         cy_as_storage_register_callback_dep((cy_as_device_handle)(h), \
 125         (cy_as_storage_event_callback_dep)(cb))
 126
 127 /* Sync version of Storage Claim */
 128 EXTERN cy_an_return_status_t
 129 cy_an_storage_claim(
 130         cy_an_device_handle             handle,
 131         cy_an_media_type                        type
 132         );
 133 #define cy_an_storage_claim(h, type)                    \
 134         cy_as_storage_claim_dep((cy_as_device_handle)(h), \
 135         (cy_as_media_type)(type))
 136
 137 /* Async version of Storage Claim */
 138 EXTERN cy_an_return_status_t
 139 cy_an_storage_claim_e_x(
 140         cy_an_device_handle             handle,
 141         cy_an_media_type *type,
 142         cy_an_function_callback         cb,
 143         uint32_t                        client
 144         );
 145 #define cy_an_storage_claim_e_x(h, type_p, cb, client)          \
 146         cy_as_storage_claim_dep_EX((cy_as_device_handle)(h), \
 147         (cy_as_media_type *)(type_p), \
 148         (cy_as_function_callback)(cb), (client))
 149
 150 /* Sync Version of Storage Release */
 151 EXTERN cy_an_return_status_t
 152 cy_an_storage_release(
 153         cy_an_device_handle             handle,
 154         cy_an_media_type                        type
 155         );
 156 #define cy_an_storage_release(h, type)                  \
 157         cy_as_storage_release_dep((cy_as_device_handle)(h), \
 158         (cy_as_media_type)(type))
 159
 160 /* Async Version of Storage Release */
 161 EXTERN cy_an_return_status_t
 162 cy_an_storage_release_e_x(
 163         cy_an_device_handle             handle,
 164         cy_an_media_type *type,
 165         cy_an_function_callback         cb,
 166         uint32_t                        client
 167         );
 168 #define cy_an_storage_release_e_x(h, type_p, cb, client)        \
 169         cy_as_storage_release_dep_EX((cy_as_device_handle)(h), \
 170         (cy_as_media_type *)(type_p), \
 171         (cy_as_function_callback)(cb), (client))
 172
 173 /* Sync version of Query Media */
 174 EXTERN cy_an_return_status_t
 175 cy_an_storage_query_media(
 176         cy_an_device_handle             handle,
 177         cy_an_media_type                        type,
 178         uint32_t *count
 179         );
 180 #define cy_an_storage_query_media(handle, type, count) \
 181         cy_as_storage_query_media((cy_as_device_handle)(handle), \
 182         (cy_as_media_type)(type), (count), 0, 0)
 183
 184 /* Async version of Query Media */
 185 EXTERN cy_an_return_status_t
 186 cy_an_storage_query_media_e_x(
 187         cy_an_device_handle             handle,
 188         cy_an_media_type                        type,
 189         uint32_t *count,
 190         cy_an_function_callback         cb,
 191         uint32_t                        client
 192         );
 193 #define cy_an_storage_query_media_e_x(h, type, count, cb, client) \
 194         cy_as_storage_query_media((cy_as_device_handle)(h), \
 195         (cy_as_media_type)(type), (count), \
 196         (cy_as_function_callback)(cb), (client))
 197
 198 /* Sync version of Query device */
 199 EXTERN cy_an_return_status_t
 200 cy_an_storage_query_device(
 201         cy_an_device_handle             handle,
 202         cy_an_media_type                        type,
 203         uint32_t                        device,
 204         cy_an_device_desc *desc_p
 205         );
 206 #define cy_an_storage_query_device(h, type, device, desc_p) \
 207         cy_as_storage_query_device_dep((cy_as_device_handle)(h), \
 208         (cy_as_media_type)(type), (device), (cy_as_device_desc *)(desc_p))
 209
 210 /* Async version of Query device */
 211 EXTERN cy_an_return_status_t
 212 cy_an_storage_query_device_e_x(
 213         cy_an_device_handle             handle,
 214         cy_an_storage_query_device_data *data,
 215         cy_an_function_callback         cb,
 216         uint32_t                        client
 217         );
 218 #define cy_an_storage_query_device_e_x(h, data, cb, client) \
 219         cy_as_storage_query_device_dep_EX((cy_as_device_handle)(h), \
 220         (cy_as_storage_query_device_data_dep *)(data),  \
 221                 (cy_as_function_callback)(cb), (client))
 222
 223 /* Sync version of Query Unit */
 224 EXTERN cy_an_return_status_t
 225 cy_an_storage_query_unit(
 226         cy_an_device_handle             handle,
 227         cy_an_media_type                        type,
 228         uint32_t                        device,
 229         uint32_t                        unit,
 230         cy_an_unit_desc *desc_p
 231         );
 232 #define cy_an_storage_query_unit(h, type, device, unit, desc_p) \
 233         cy_as_storage_query_unit_dep((cy_as_device_handle)(h), \
 234         (cy_as_media_type)(type), (device), \
 235         (unit), (cy_as_unit_desc *)(desc_p))
 236
 237 /* Async version of Query Unit */
 238 EXTERN cy_an_return_status_t
 239 cy_an_storage_query_unit_e_x(
 240         cy_an_device_handle             handle,
 241         cy_an_storage_query_unit_data *data_p,
 242         cy_an_function_callback         cb,
 243         uint32_t                        client
 244         );
 245 #define cy_an_storage_query_unit_e_x(h, data_p, cb, client)     \
 246         cy_as_storage_query_unit_dep_EX((cy_as_device_handle)(h), \
 247         (cy_as_storage_query_unit_data_dep *)(data_p),  \
 248         (cy_as_function_callback)(cb), (client))
 249
 250 /* Sync version of device control */
 251 EXTERN cy_an_return_status_t
 252 cy_an_storage_device_control(
 253                 cy_an_device_handle     handle,
 254                 cy_bool  card_detect_en,
 255                 cy_bool  write_prot_en
 256                 );
 257 #define cy_an_storage_device_control(handle, \
 258         card_detect_en, write_prot_en) \
 259         cy_as_storage_device_control_dep((cy_as_device_handle)(handle), \
 260         (card_detect_en), (write_prot_en), 0, 0)
 261
 262 /* Async version of device control */
 263 EXTERN cy_an_return_status_t
 264 cy_an_storage_device_control_e_x(
 265                 cy_an_device_handle                             handle,
 266                 cy_bool                 card_detect_en,
 267                 cy_bool                 write_prot_en,
 268         cy_an_function_callback         cb,
 269         uint32_t                        client
 270                 );
 271 #define cy_an_storage_device_control_e_x(h, det_en, prot_en, cb, client) \
 272         cy_as_storage_device_control_dep((cy_as_device_handle)(h), (det_en), \
 273         (prot_en), (cy_as_function_callback)(cb), (client))
 274
 275 /* Sync Read */
 276 EXTERN cy_an_return_status_t
 277 cy_an_storage_read(
 278         cy_an_device_handle             handle,
 279         cy_an_media_type                        type,
 280         uint32_t                        device,
 281         uint32_t                        unit,
 282         uint32_t                        block,
 283         void *data_p,
 284         uint16_t                        num_blocks
 285         );
 286 #define cy_an_storage_read(h, type, device, unit, block, data_p, nblks) \
 287         cy_as_storage_read_dep((cy_as_device_handle)(h), \
 288         (cy_as_media_type)(type), (device), (unit), \
 289         (block), (data_p), (nblks))
 290
 291 /* Async Read */
 292 EXTERN cy_an_return_status_t
 293 cy_an_storage_read_async(
 294         cy_an_device_handle             handle,
 295         cy_an_media_type                        type,
 296         uint32_t                        device,
 297         uint32_t                        unit,
 298         uint32_t                        block,
 299         void *data_p,
 300         uint16_t                        num_blocks,
 301         cy_an_storage_callback          callback
 302         );
 303 #define cy_an_storage_read_async(h, type, device, unit, \
 304         block, data_p, nblks, cb)                               \
 305         cy_as_storage_read_async_dep((cy_as_device_handle)(h), \
 306         (cy_as_media_type)(type), (device), (unit), (block), \
 307                 (data_p), (nblks), (cy_as_storage_callback_dep)(cb))
 308
 309 /* Sync Write */
 310 EXTERN cy_an_return_status_t
 311 cy_an_storage_write(
 312         cy_an_device_handle             handle,
 313         cy_an_media_type                        type,
 314         uint32_t                        device,
 315         uint32_t                        unit,
 316         uint32_t                        block,
 317         void *data_p,
 318         uint16_t                        num_blocks
 319         );
 320 #define cy_an_storage_write(h, type, device, unit, \
 321         block, data_p, nblks)   \
 322         cy_as_storage_write_dep((cy_as_device_handle)(h), \
 323         (cy_as_media_type)(type), (device), (unit), \
 324         (block), (data_p), (nblks))
 325
 326 /* Async Write */
 327 EXTERN cy_an_return_status_t
 328 cy_an_storage_write_async(
 329         cy_an_device_handle             handle,
 330         cy_an_media_type                        type,
 331         uint32_t                        device,
 332         uint32_t                        unit,
 333         uint32_t                        block,
 334         void *data_p,
 335         uint16_t                        num_blocks,
 336         cy_an_storage_callback          callback
 337         );
 338 #define cy_an_storage_write_async(h, type, device, unit, \
 339         block, data_p, nblks, cb) \
 340         cy_as_storage_write_async_dep((cy_as_device_handle)(h), \
 341         (cy_as_media_type)(type), (device), (unit), (block), \
 342                 (data_p), (nblks), (cy_as_storage_callback_dep)(cb))
 343
 344 /* Cancel Async */
 345 EXTERN cy_an_return_status_t
 346 cy_an_storage_cancel_async(
 347         cy_an_device_handle             handle
 348         );
 349 #define cy_an_storage_cancel_async(h) \
 350         cy_as_storage_cancel_async((cy_as_device_handle)(h))
 351
 352 /* Sync SD Register Read*/
 353 EXTERN cy_an_return_status_t
 354 cy_an_storage_sd_register_read(
 355                 cy_an_device_handle               handle,
 356         cy_an_media_type                  type,
 357         uint8_t                           device,
 358         cy_an_sd_card_reg_type           reg_type,
 359         uint8_t                            read_len,
 360         uint8_t                           *data_p
 361                 );
 362 #define cy_an_storage_sd_register_read(h, type, device, \
 363         reg_type, len, data_p) \
 364         cy_as_storage_sd_register_read_dep((cy_as_device_handle)(h), \
 365         (cy_as_media_type)(type), (device),      \
 366         (cy_as_sd_card_reg_type)(reg_type), (len), (data_p))
 367
 368 /*Async SD Register Read*/
 369 EXTERN cy_an_return_status_t
 370 cy_an_storage_sd_register_read_e_x(
 371                 cy_an_device_handle               handle,
 372         cy_an_media_type                  type,
 373         uint8_t                           device,
 374         cy_an_sd_card_reg_type           reg_type,
 375         cy_an_storage_sd_reg_read_data *data_p,
 376         cy_an_function_callback   cb,
 377         uint32_t                                  client
 378                 );
 379 #define cy_an_storage_sd_register_read_e_x(h, type, device, \
 380         reg_type, data_p, cb, client) \
 381         cy_as_storage_sd_register_read_dep_EX((cy_as_device_handle)(h), \
 382         (cy_as_media_type)(type), (device),     \
 383         (cy_as_sd_card_reg_type)(reg_type), \
 384         (cy_as_storage_sd_reg_read_data *)(data_p),     \
 385         (cy_as_function_callback)(cb), (client))
 386
 387 /* Create partition on storage device */
 388 EXTERN cy_an_return_status_t
 389 cy_an_storage_create_p_partition(
 390                 cy_an_device_handle      handle,
 391                 cy_an_media_type                media,
 392                 uint32_t                         device,
 393                 uint32_t                         size,
 394                 cy_an_function_callback cb,
 395                 uint32_t                         client);
 396 #define cy_an_storage_create_p_partition(h, media, dev, \
 397         size, cb, client) \
 398         cy_as_storage_create_p_partition_dep((cy_as_device_handle)(h), \
 399         (cy_as_media_type)(media), (dev), \
 400         (size), (cy_as_function_callback)(cb), (client))
 401
 402 /* Remove partition on storage device */
 403 EXTERN cy_an_return_status_t
 404 cy_an_storage_remove_p_partition(
 405                 cy_an_device_handle             handle,
 406                 cy_an_media_type                   media,
 407                 uint32_t                                device,
 408                 cy_an_function_callback cb,
 409                 uint32_t                                client);
 410 #define cy_an_storage_remove_p_partition\
 411 (h, media, dev, cb, client)      \
 412         cy_as_storage_remove_p_partition_dep((cy_as_device_handle)(h), \
 413         (cy_as_media_type)(media), (dev),          \
 414                         (cy_as_function_callback)(cb), (client))
 415
 416 #include "cyas_cplus_end.h"
 417 #endif /*__doxygen__ */
 418
 419 #endif