Pileus Git - ~andy/linux/blob - drivers/staging/csr/csr_sdio.h

   1 #ifndef CSR_SDIO_H__
   2 #define CSR_SDIO_H__
   3 /*****************************************************************************
   4
   5             (c) Cambridge Silicon Radio Limited 2010
   6             All rights reserved and confidential information of CSR
   7
   8             Refer to LICENSE.txt included with this source for details
   9             on the license terms.
  10
  11 *****************************************************************************/
  12
  13 #include "csr_result.h"
  14
  15 /* Result Codes */
  16 #define CSR_SDIO_RESULT_INVALID_VALUE   ((CsrResult) 1) /* Invalid argument value */
  17 #define CSR_SDIO_RESULT_NO_DEVICE       ((CsrResult) 2) /* The specified device is no longer present */
  18 #define CSR_SDIO_RESULT_CRC_ERROR       ((CsrResult) 3) /* The transmitted/received data or command response contained a CRC error */
  19 #define CSR_SDIO_RESULT_TIMEOUT         ((CsrResult) 4) /* No command response or data received from device, or function enable/disable did not succeed within timeout period */
  20 #define CSR_SDIO_RESULT_NOT_RESET       ((CsrResult) 5) /* The device was not reset */
  21
  22 /* Features (for use in features member of CsrSdioFunction) */
  23 #define CSR_SDIO_FEATURE_BYTE_MODE                   0x00000001 /* Transfer sizes do not have to be a multiple of block size */
  24 #define CSR_SDIO_FEATURE_DMA_CAPABLE_MEM_REQUIRED    0x00000002 /* Bulk operations require DMA friendly memory */
  25
  26 /* CsrSdioFunctionId wildcards (for use in CsrSdioFunctionId members) */
  27 #define CSR_SDIO_ANY_MANF_ID        0xFFFF
  28 #define CSR_SDIO_ANY_CARD_ID        0xFFFF
  29 #define CSR_SDIO_ANY_SDIO_FUNCTION  0xFF
  30 #define CSR_SDIO_ANY_SDIO_INTERFACE 0xFF
  31
  32 /*----------------------------------------------------------------------------*
  33  *  NAME
  34  *      CsrSdioFunctionId
  35  *
  36  *  DESCRIPTION
  37  *      This structure describes one or more functions of a device, based on
  38  *      four qualitative measures. The CsrSdioFunctionId wildcard defines can be
  39  *      used for making the CsrSdioFunctionId match more than one function.
  40  *
  41  *  MEMBERS
  42  *      manfId - Vendor ID (or CSR_SDIO_ANY_MANF_ID).
  43  *      cardId - Device ID (or CSR_SDIO_ANY_CARD_ID).
  44  *      sdioFunction - SDIO Function number (or CSR_SDIO_ANY_SDIO_FUNCTION).
  45  *      sdioInterface - SDIO Standard Interface Code (or CSR_SDIO_ANY_SDIO_INTERFACE)
  46  *
  47  *----------------------------------------------------------------------------*/
  48 typedef struct
  49 {
  50     u16 manfId;       /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
  51     u16 cardId;       /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
  52     u8  sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
  53     u8  sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
  54 } CsrSdioFunctionId;
  55
  56 /*----------------------------------------------------------------------------*
  57  *  NAME
  58  *      CsrSdioFunction
  59  *
  60  *  DESCRIPTION
  61  *      This structure represents a single function on a device.
  62  *
  63  *  MEMBERS
  64  *      sdioId - A CsrSdioFunctionId describing this particular function. The
  65  *               subfield shall not contain any CsrSdioFunctionId wildcards. The
  66  *               subfields shall describe the specific single function
  67  *               represented by this structure.
  68  *      blockSize - Actual configured block size, or 0 if unconfigured.
  69  *      features - Bit mask with any of CSR_SDIO_FEATURE_* set.
  70  *      device - Handle of device containing the function. If two functions have
  71  *               the same device handle, they reside on the same device.
  72  *      driverData - For use by the Function Driver. The SDIO Driver shall not
  73  *                   attempt to dereference the pointer.
  74  *      priv - For use by the SDIO Driver. The Function Driver shall not attempt
  75  *             to dereference the pointer.
  76  *
  77  *
  78  *----------------------------------------------------------------------------*/
  79 typedef struct
  80 {
  81     CsrSdioFunctionId sdioId;
  82     u16         blockSize; /* Actual configured block size, or 0 if unconfigured */
  83     u32         features; /* Bit mask with any of CSR_SDIO_FEATURE_* set */
  84     void             *device; /* Handle of device containing the function */
  85     void             *driverData; /* For use by the Function Driver */
  86     void             *priv; /* For use by the SDIO Driver */
  87 } CsrSdioFunction;
  88
  89 /*----------------------------------------------------------------------------*
  90  *  NAME
  91  *      CsrSdioInsertedCallback, CsrSdioRemovedCallback
  92  *
  93  *  DESCRIPTION
  94  *      CsrSdioInsertedCallback is called when a function becomes available to
  95  *      a registered Function Driver that supports the function.
  96  *      CsrSdioRemovedCallback is called when a function is no longer available
  97  *      to a Function Driver, either because the device has been removed, or the
  98  *      Function Driver has been unregistered.
  99  *
 100  *      NOTE: These functions are implemented by the Function Driver, and are
 101  *            passed as function pointers in the CsrSdioFunctionDriver struct.
 102  *
 103  *  PARAMETERS
 104  *      function - Pointer to struct representing the function.
 105  *
 106  *----------------------------------------------------------------------------*/
 107 typedef void (*CsrSdioInsertedCallback)(CsrSdioFunction *function);
 108 typedef void (*CsrSdioRemovedCallback)(CsrSdioFunction *function);
 109
 110 /*----------------------------------------------------------------------------*
 111  *  NAME
 112  *      CsrSdioInterruptDsrCallback, CsrSdioInterruptCallback
 113  *
 114  *  DESCRIPTION
 115  *      CsrSdioInterruptCallback is called when an interrupt occurs on the
 116  *      the device associated with the specified function.
 117  *
 118  *      NOTE: These functions are implemented by the Function Driver, and are
 119  *            passed as function pointers in the CsrSdioFunctionDriver struct.
 120  *
 121  *  PARAMETERS
 122  *      function - Pointer to struct representing the function.
 123  *
 124  *  RETURNS (only CsrSdioInterruptCallback)
 125  *      A pointer to a CsrSdioInterruptDsrCallback function.
 126  *
 127  *----------------------------------------------------------------------------*/
 128 typedef void (*CsrSdioInterruptDsrCallback)(CsrSdioFunction *function);
 129 typedef CsrSdioInterruptDsrCallback (*CsrSdioInterruptCallback)(CsrSdioFunction *function);
 130
 131 /*----------------------------------------------------------------------------*
 132  *  NAME
 133  *      CsrSdioSuspendCallback, CsrSdioResumeCallback
 134  *
 135  *  DESCRIPTION
 136  *      CsrSdioSuspendCallback is called when the system is preparing to go
 137  *      into a suspended state. CsrSdioResumeCallback is called when the system
 138  *      has entered an active state again.
 139  *
 140  *      NOTE: These functions are implemented by the Function Driver, and are
 141  *            passed as function pointers in the CsrSdioFunctionDriver struct.
 142  *
 143  *  PARAMETERS
 144  *      function - Pointer to struct representing the function.
 145  *
 146  *----------------------------------------------------------------------------*/
 147 typedef void (*CsrSdioSuspendCallback)(CsrSdioFunction *function);
 148 typedef void (*CsrSdioResumeCallback)(CsrSdioFunction *function);
 149
 150 /*----------------------------------------------------------------------------*
 151  *  NAME
 152  *      CsrSdioAsyncCallback, CsrSdioAsyncDsrCallback
 153  *
 154  *  DESCRIPTION
 155  *      CsrSdioAsyncCallback is called when an asynchronous operation completes.
 156  *
 157  *      NOTE: These functions are implemented by the Function Driver, and are
 158  *            passed as function pointers in the function calls that initiate
 159  *            the operation.
 160  *
 161  *  PARAMETERS
 162  *      function - Pointer to struct representing the function.
 163  *      result - The result of the operation that completed. See the description
 164  *               of the initiating function for possible result values.
 165  *
 166  *  RETURNS (only CsrSdioAsyncCallback)
 167  *      A pointer to a CsrSdioAsyncDsrCallback function.
 168  *
 169  *----------------------------------------------------------------------------*/
 170 typedef void (*CsrSdioAsyncDsrCallback)(CsrSdioFunction *function, CsrResult result);
 171 typedef CsrSdioAsyncDsrCallback (*CsrSdioAsyncCallback)(CsrSdioFunction *function, CsrResult result);
 172
 173 /*----------------------------------------------------------------------------*
 174  *  NAME
 175  *      CsrSdioFunctionDriver
 176  *
 177  *  DESCRIPTION
 178  *      Structure representing a Function Driver.
 179  *
 180  *  MEMBERS
 181  *      inserted - Callback, see description of CsrSdioInsertedCallback.
 182  *      removed - Callback, see description of CsrSdioRemovedCallback.
 183  *      intr - Callback, see description of CsrSdioInterruptCallback.
 184  *      suspend - Callback, see description of CsrSdioSuspendCallback.
 185  *      resume - Callback, see description of CsrSdioResumeCallback.
 186  *      ids - Array of CsrSdioFunctionId describing one or more functions that
 187  *            are supported by the Function Driver.
 188  *      idsCount - Length of the ids array.
 189  *      priv - For use by the SDIO Driver. The Function Driver may initialise
 190  *             it to NULL, but shall otherwise not access the pointer or attempt
 191  *             to dereference it.
 192  *
 193  *----------------------------------------------------------------------------*/
 194 typedef struct
 195 {
 196     CsrSdioInsertedCallback  inserted;
 197     CsrSdioRemovedCallback   removed;
 198     CsrSdioInterruptCallback intr;
 199     CsrSdioSuspendCallback   suspend;
 200     CsrSdioResumeCallback    resume;
 201     CsrSdioFunctionId       *ids;
 202     u8                 idsCount;
 203     void                    *priv;          /* For use by the SDIO Driver */
 204 } CsrSdioFunctionDriver;
 205
 206 /*----------------------------------------------------------------------------*
 207  *  NAME
 208  *      CsrSdioFunctionDriverRegister
 209  *
 210  *  DESCRIPTION
 211  *      Register a Function Driver.
 212  *
 213  *  PARAMETERS
 214  *      functionDriver - Pointer to struct describing the Function Driver.
 215  *
 216  *  RETURNS
 217  *      CSR_RESULT_SUCCESS - The Function Driver was successfully
 218  *                           registered.
 219  *      CSR_RESULT_FAILURE - Unable to register the function driver,
 220  *                                because of an unspecified/unknown error. The
 221  *                                Function Driver has not been registered.
 222  *      CSR_SDIO_RESULT_INVALID_VALUE - The specified Function Driver pointer
 223  *                                      does not point at a valid Function
 224  *                                      Driver structure, or some of the members
 225  *                                      contain invalid entries.
 226  *
 227  *----------------------------------------------------------------------------*/
 228 CsrResult CsrSdioFunctionDriverRegister(CsrSdioFunctionDriver *functionDriver);
 229
 230 /*----------------------------------------------------------------------------*
 231  *  NAME
 232  *      CsrSdioFunctionDriverUnregister
 233  *
 234  *  DESCRIPTION
 235  *      Unregister a previously registered Function Driver.
 236  *
 237  *  PARAMETERS
 238  *      functionDriver - pointer to struct describing the Function Driver.
 239  *
 240  *----------------------------------------------------------------------------*/
 241 void CsrSdioFunctionDriverUnregister(CsrSdioFunctionDriver *functionDriver);
 242
 243 /*----------------------------------------------------------------------------*
 244  *  NAME
 245  *      CsrSdioFunctionEnable, CsrSdioFunctionDisable
 246  *
 247  *  DESCRIPTION
 248  *      Enable/disable the specified function by setting/clearing the
 249  *      corresponding bit in the I/O Enable register in function 0, and then
 250  *      periodically reading the related bit in the I/O Ready register until it
 251  *      is set/clear, limited by an implementation defined timeout.
 252  *
 253  *  PARAMETERS
 254  *      function - Pointer to struct representing the function.
 255  *
 256  *  RETURNS
 257  *      CSR_RESULT_SUCCESS - The specified function was enabled/disabled.
 258  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 259  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 260  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The state of the
 261  *                                  related bit in the I/O Enable register is
 262  *                                  undefined.
 263  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device, or the related
 264  *                                bit in the I/O ready register was not
 265  *                                set/cleared within the timeout period.
 266  *
 267  *      NOTE: If the SDIO R5 response is available, and either of the
 268  *            FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
 269  *            CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
 270  *            is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
 271  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 272  *            COM_CRC_ERROR bits shall be ignored.
 273  *
 274  *            If the CSPI response is available, and any of the
 275  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 276  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 277  *
 278  *----------------------------------------------------------------------------*/
 279 CsrResult CsrSdioFunctionEnable(CsrSdioFunction *function);
 280 CsrResult CsrSdioFunctionDisable(CsrSdioFunction *function);
 281
 282 /*----------------------------------------------------------------------------*
 283  *  NAME
 284  *      CsrSdioInterruptEnable, CsrSdioInterruptDisable
 285  *
 286  *  DESCRIPTION
 287  *      Enable/disable the interrupt for the specified function by
 288  *      setting/clearing the corresponding bit in the INT Enable register in
 289  *      function 0.
 290  *
 291  *  PARAMETERS
 292  *      function - Pointer to struct representing the function.
 293  *
 294  *  RETURNS
 295  *      CSR_RESULT_SUCCESS - The specified function was enabled/disabled.
 296  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 297  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 298  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The state of the
 299  *                                  related bit in the INT Enable register is
 300  *                                  unchanged.
 301  *      CSR_SDIO_RESULT_INVALID_VALUE - The specified function cannot be
 302  *                                      enabled/disabled, because it either
 303  *                                      does not exist or it is not possible to
 304  *                                      individually enable/disable functions.
 305  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device.
 306  *
 307  *      NOTE: If the SDIO R5 response is available, and either of the
 308  *            FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
 309  *            CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
 310  *            is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
 311  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 312  *            COM_CRC_ERROR bits shall be ignored.
 313  *
 314  *            If the CSPI response is available, and any of the
 315  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 316  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 317  *
 318  *----------------------------------------------------------------------------*/
 319 CsrResult CsrSdioInterruptEnable(CsrSdioFunction *function);
 320 CsrResult CsrSdioInterruptDisable(CsrSdioFunction *function);
 321
 322 /*----------------------------------------------------------------------------*
 323  *  NAME
 324  *      CsrSdioInterruptAcknowledge
 325  *
 326  *  DESCRIPTION
 327  *      Acknowledge that a signalled interrupt has been handled. Shall only
 328  *      be called once, and exactly once for each signalled interrupt to the
 329  *      corresponding function.
 330  *
 331  *  PARAMETERS
 332  *      function - Pointer to struct representing the function to which the
 333  *                 event was signalled.
 334  *
 335  *----------------------------------------------------------------------------*/
 336 void CsrSdioInterruptAcknowledge(CsrSdioFunction *function);
 337
 338 /*----------------------------------------------------------------------------*
 339  *  NAME
 340  *      CsrSdioInsertedAcknowledge, CsrSdioRemovedAcknowledge
 341  *
 342  *  DESCRIPTION
 343  *      Acknowledge that a signalled inserted/removed event has been handled.
 344  *      Shall only be called once, and exactly once for each signalled event to
 345  *      the corresponding function.
 346  *
 347  *  PARAMETERS
 348  *      function - Pointer to struct representing the function to which the
 349  *                 inserted was signalled.
 350  *      result (CsrSdioInsertedAcknowledge only)
 351  *          CSR_RESULT_SUCCESS - The Function Driver has accepted the
 352  *                                    function, and the function is attached to
 353  *                                    the Function Driver until the
 354  *                                    CsrSdioRemovedCallback is called and
 355  *                                    acknowledged.
 356  *          CSR_RESULT_FAILURE - Unable to accept the function. The
 357  *                                    function is not attached to the Function
 358  *                                    Driver, and it may be passed to another
 359  *                                    Function Driver which supports the
 360  *                                    function.
 361  *
 362  *----------------------------------------------------------------------------*/
 363 void CsrSdioInsertedAcknowledge(CsrSdioFunction *function, CsrResult result);
 364 void CsrSdioRemovedAcknowledge(CsrSdioFunction *function);
 365
 366 /*----------------------------------------------------------------------------*
 367  *  NAME
 368  *      CsrSdioSuspendAcknowledge, CsrSdioResumeAcknowledge
 369  *
 370  *  DESCRIPTION
 371  *      Acknowledge that a signalled suspend event has been handled. Shall only
 372  *      be called once, and exactly once for each signalled event to the
 373  *      corresponding function.
 374  *
 375  *  PARAMETERS
 376  *      function - Pointer to struct representing the function to which the
 377  *                 event was signalled.
 378  *      result
 379  *          CSR_RESULT_SUCCESS - Successfully suspended/resumed.
 380  *          CSR_RESULT_FAILURE - Unspecified/unknown error.
 381  *
 382  *----------------------------------------------------------------------------*/
 383 void CsrSdioSuspendAcknowledge(CsrSdioFunction *function, CsrResult result);
 384 void CsrSdioResumeAcknowledge(CsrSdioFunction *function, CsrResult result);
 385
 386 /*----------------------------------------------------------------------------*
 387  *  NAME
 388  *      CsrSdioBlockSizeSet
 389  *
 390  *  DESCRIPTION
 391  *      Set the block size to use for the function. The actual configured block
 392  *      size shall be the minimum of:
 393  *          1) Maximum block size supported by the function.
 394  *          2) Maximum block size supported by the host controller.
 395  *          3) The block size specified by the blockSize argument.
 396  *
 397  *      When this function returns, the actual configured block size is
 398  *      available in the blockSize member of the function struct.
 399  *
 400  *  PARAMETERS
 401  *      function - Pointer to struct representing the function.
 402  *      blockSize - Block size to use for the function. Valid range is 1 to
 403  *                  2048.
 404  *
 405  *  RETURNS
 406  *      CSR_RESULT_SUCCESS - The block size register on the chip
 407  *                                was updated.
 408  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 409  *      CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
 410  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 411  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The configured block
 412  *                                  size is undefined.
 413  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device.
 414  *
 415  *      NOTE: If the SDIO R5 response is available, and the FUNCTION_NUMBER
 416  *            bits is set, CSR_SDIO_RESULT_INVALID_VALUE shall be returned.
 417  *            If the ERROR bit is set (but not FUNCTION_NUMBER),
 418  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 419  *            COM_CRC_ERROR bits shall be ignored.
 420  *
 421  *            If the CSPI response is available, and any of the
 422  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 423  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 424  *
 425  *      NOTE: Setting the block size requires two individual operations. The
 426  *            implementation shall ignore the OUT_OF_RANGE bit of the SDIO R5
 427  *            response for the first operation, as the partially configured
 428  *            block size may be out of range, even if the final block size
 429  *            (after the second operation) is in the valid range.
 430  *
 431  *----------------------------------------------------------------------------*/
 432 CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, u16 blockSize);
 433
 434 /*----------------------------------------------------------------------------*
 435  *  NAME
 436  *      CsrSdioMaxBusClockFrequencySet
 437  *
 438  *  DESCRIPTION
 439  *      Set the maximum clock frequency to use for the device associated with
 440  *      the specified function. The actual configured clock frequency for the
 441  *      device shall be the minimum of:
 442  *          1) Maximum clock frequency supported by the device.
 443  *          2) Maximum clock frequency supported by the host controller.
 444  *          3) Maximum clock frequency specified for any function on the same
 445  *             device.
 446  *
 447  *      If the clock frequency exceeds 25MHz, it is the responsibility of the
 448  *      SDIO driver to enable high speed mode on the device, using the standard
 449  *      defined procedure, before increasing the frequency beyond the limit.
 450  *
 451  *      Note that the clock frequency configured affects all functions on the
 452  *      same device.
 453  *
 454  *  PARAMETERS
 455  *      function - Pointer to struct representing the function.
 456  *      maxFrequency - The maximum clock frequency for the function in Hertz.
 457  *
 458  *  RETURNS
 459  *      CSR_RESULT_SUCCESS - The maximum clock frequency was succesfully
 460  *                                set for the function.
 461  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 462  *      CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
 463  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 464  *
 465  *      NOTE: If the SDIO R5 response is available, and the FUNCTION_NUMBER
 466  *            bits is set, CSR_SDIO_RESULT_INVALID_VALUE shall be returned.
 467  *            If the ERROR bit is set (but not FUNCTION_NUMBER),
 468  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 469  *            COM_CRC_ERROR bits shall be ignored.
 470  *
 471  *            If the CSPI response is available, and any of the
 472  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 473  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 474  *
 475  *
 476  *----------------------------------------------------------------------------*/
 477 CsrResult CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, u32 maxFrequency);
 478
 479 /*----------------------------------------------------------------------------*
 480  *  NAME
 481  *      CsrSdioRead8, CsrSdioWrite8, CsrSdioRead8Async, CsrSdioWrite8Async
 482  *
 483  *  DESCRIPTION
 484  *      Read/write an 8bit value from/to the specified register address.
 485  *
 486  *  PARAMETERS
 487  *      function - Pointer to struct representing the function.
 488  *      address - Register address within the function.
 489  *      data - The data to read/write.
 490  *      callback - The function to call on operation completion.
 491  *
 492  *  RETURNS
 493  *      CSR_RESULT_SUCCESS - The data was successfully read/written.
 494  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 495  *      CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
 496  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 497  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. No data read/written.
 498  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device.
 499  *
 500  *      NOTE: If the SDIO R5 response is available, and either of the
 501  *            FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
 502  *            CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
 503  *            is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
 504  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 505  *            COM_CRC_ERROR bits shall be ignored.
 506  *
 507  *            If the CSPI response is available, and any of the
 508  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 509  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 510  *
 511  *      NOTE: The CsrSdioRead8Async and CsrSdioWrite8Async functions return
 512  *            immediately, and the supplied callback function is called when the
 513  *            operation is complete. The result value is given as an argument to
 514  *            the callback function.
 515  *
 516  *----------------------------------------------------------------------------*/
 517 CsrResult CsrSdioRead8(CsrSdioFunction *function, u32 address, u8 *data);
 518 CsrResult CsrSdioWrite8(CsrSdioFunction *function, u32 address, u8 data);
 519 void CsrSdioRead8Async(CsrSdioFunction *function, u32 address, u8 *data, CsrSdioAsyncCallback callback);
 520 void CsrSdioWrite8Async(CsrSdioFunction *function, u32 address, u8 data, CsrSdioAsyncCallback callback);
 521
 522 /*----------------------------------------------------------------------------*
 523  *  NAME
 524  *      CsrSdioRead16, CsrSdioWrite16, CsrSdioRead16Async, CsrSdioWrite16Async
 525  *
 526  *  DESCRIPTION
 527  *      Read/write a 16bit value from/to the specified register address.
 528  *
 529  *  PARAMETERS
 530  *      function - Pointer to struct representing the function.
 531  *      address - Register address within the function.
 532  *      data - The data to read/write.
 533  *      callback - The function to call on operation completion.
 534  *
 535  *  RETURNS
 536  *      CSR_RESULT_SUCCESS - The data was successfully read/written.
 537  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 538  *      CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
 539  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 540  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. Data may have been
 541  *                                  partially read/written.
 542  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device.
 543  *
 544  *      NOTE: If the SDIO R5 response is available, and either of the
 545  *            FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
 546  *            CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
 547  *            is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
 548  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 549  *            COM_CRC_ERROR bits shall be ignored.
 550  *
 551  *            If the CSPI response is available, and any of the
 552  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 553  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 554  *
 555  *      NOTE: The CsrSdioRead16Async and CsrSdioWrite16Async functions return
 556  *            immediately, and the supplied callback function is called when the
 557  *            operation is complete. The result value is given as an argument to
 558  *            the callback function.
 559  *
 560  *----------------------------------------------------------------------------*/
 561 CsrResult CsrSdioRead16(CsrSdioFunction *function, u32 address, u16 *data);
 562 CsrResult CsrSdioWrite16(CsrSdioFunction *function, u32 address, u16 data);
 563 void CsrSdioRead16Async(CsrSdioFunction *function, u32 address, u16 *data, CsrSdioAsyncCallback callback);
 564 void CsrSdioWrite16Async(CsrSdioFunction *function, u32 address, u16 data, CsrSdioAsyncCallback callback);
 565
 566 /*----------------------------------------------------------------------------*
 567  *  NAME
 568  *      CsrSdioF0Read8, CsrSdioF0Write8, CsrSdioF0Read8Async,
 569  *      CsrSdioF0Write8Async
 570  *
 571  *  DESCRIPTION
 572  *      Read/write an 8bit value from/to the specified register address in
 573  *      function 0.
 574  *
 575  *  PARAMETERS
 576  *      function - Pointer to struct representing the function.
 577  *      address - Register address within the function.
 578  *      data - The data to read/write.
 579  *      callback - The function to call on operation completion.
 580  *
 581  *  RETURNS
 582  *      CSR_RESULT_SUCCESS - The data was successfully read/written.
 583  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 584  *      CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
 585  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 586  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. No data read/written.
 587  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device.
 588  *
 589  *      NOTE: If the SDIO R5 response is available, and either of the
 590  *            FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
 591  *            CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
 592  *            is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
 593  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 594  *            COM_CRC_ERROR bits shall be ignored.
 595  *
 596  *            If the CSPI response is available, and any of the
 597  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 598  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 599  *
 600  *      NOTE: The CsrSdioF0Read8Async and CsrSdioF0Write8Async functions return
 601  *            immediately, and the supplied callback function is called when the
 602  *            operation is complete. The result value is given as an argument to
 603  *            the callback function.
 604  *
 605  *----------------------------------------------------------------------------*/
 606 CsrResult CsrSdioF0Read8(CsrSdioFunction *function, u32 address, u8 *data);
 607 CsrResult CsrSdioF0Write8(CsrSdioFunction *function, u32 address, u8 data);
 608 void CsrSdioF0Read8Async(CsrSdioFunction *function, u32 address, u8 *data, CsrSdioAsyncCallback callback);
 609 void CsrSdioF0Write8Async(CsrSdioFunction *function, u32 address, u8 data, CsrSdioAsyncCallback callback);
 610
 611 /*----------------------------------------------------------------------------*
 612  *  NAME
 613  *      CsrSdioRead, CsrSdioWrite, CsrSdioReadAsync, CsrSdioWriteAsync
 614  *
 615  *  DESCRIPTION
 616  *      Read/write a specified number of bytes from/to the specified register
 617  *      address.
 618  *
 619  *  PARAMETERS
 620  *      function - Pointer to struct representing the function.
 621  *      address - Register address within the function.
 622  *      data - The data to read/write.
 623  *      length - Number of byte to read/write.
 624  *      callback - The function to call on operation completion.
 625  *
 626  *  RETURNS
 627  *      CSR_RESULT_SUCCESS - The data was successfully read/written.
 628  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 629  *      CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
 630  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 631  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. Data may have been
 632  *                                  partially read/written.
 633  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device.
 634  *
 635  *      NOTE: If the SDIO R5 response is available, and either of the
 636  *            FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
 637  *            CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
 638  *            is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
 639  *            CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
 640  *            COM_CRC_ERROR bits shall be ignored.
 641  *
 642  *            If the CSPI response is available, and any of the
 643  *            FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
 644  *            CSR_SDIO_RESULT_INVALID_VALUE will be returned.
 645  *
 646  *      NOTE: The CsrSdioF0Read8Async and CsrSdioF0Write8Async functions return
 647  *            immediately, and the supplied callback function is called when the
 648  *            operation is complete. The result value is given as an argument to
 649  *            the callback function.
 650  *
 651  *----------------------------------------------------------------------------*/
 652 CsrResult CsrSdioRead(CsrSdioFunction *function, u32 address, void *data, u32 length);
 653 CsrResult CsrSdioWrite(CsrSdioFunction *function, u32 address, const void *data, u32 length);
 654 void CsrSdioReadAsync(CsrSdioFunction *function, u32 address, void *data, u32 length, CsrSdioAsyncCallback callback);
 655 void CsrSdioWriteAsync(CsrSdioFunction *function, u32 address, const void *data, u32 length, CsrSdioAsyncCallback callback);
 656
 657 /*----------------------------------------------------------------------------*
 658  *  NAME
 659  *      CsrSdioPowerOn, CsrSdioPowerOff
 660  *
 661  *  DESCRIPTION
 662  *      Power on/off the device.
 663  *
 664  *  PARAMETERS
 665  *      function - Pointer to struct representing the function that resides on
 666  *                 the device to power on/off.
 667  *
 668  *  RETURNS (only CsrSdioPowerOn)
 669  *      CSR_RESULT_SUCCESS - Power was succesfully reapplied and the device
 670  *                                has been reinitialised.
 671  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 672  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 673  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured during reinitialisation.
 674  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device during
 675  *                                reinitialisation.
 676  *      CSR_SDIO_RESULT_NOT_RESET - The power was not removed by the
 677  *                                  CsrSdioPowerOff call. The state of the
 678  *                                  device is unchanged.
 679  *
 680  *----------------------------------------------------------------------------*/
 681 CsrResult CsrSdioPowerOn(CsrSdioFunction *function);
 682 void CsrSdioPowerOff(CsrSdioFunction *function);
 683
 684 /*----------------------------------------------------------------------------*
 685  *  NAME
 686  *      CsrSdioHardReset
 687  *
 688  *  DESCRIPTION
 689  *      Perform a hardware reset of the device.
 690  *
 691  *  PARAMETERS
 692  *      function - Pointer to struct representing the function that resides on
 693  *                 the device to hard reset.
 694  *
 695  *  RETURNS
 696  *      CSR_RESULT_SUCCESS - Reset was succesfully performed and the device
 697  *                                has been reinitialised.
 698  *      CSR_RESULT_FAILURE - Unspecified/unknown error.
 699  *      CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
 700  *      CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured during reinitialisation.
 701  *      CSR_SDIO_RESULT_TIMEOUT - No response from the device during
 702  *                                reinitialisation.
 703  *      CSR_SDIO_RESULT_NOT_RESET - The reset was not applied because it is not
 704  *                                  supported. The state of the device is
 705  *                                  unchanged.
 706  *
 707  *----------------------------------------------------------------------------*/
 708 CsrResult CsrSdioHardReset(CsrSdioFunction *function);
 709
 710 /*----------------------------------------------------------------------------*
 711  *  NAME
 712  *      CsrSdioFunctionActive, CsrSdioFunctionIdle
 713  *
 714  *  DESCRIPTION
 715  *
 716  *  PARAMETERS
 717  *      function - Pointer to struct representing the function.
 718  *
 719  *----------------------------------------------------------------------------*/
 720 void CsrSdioFunctionActive(CsrSdioFunction *function);
 721 void CsrSdioFunctionIdle(CsrSdioFunction *function);
 722
 723 #endif