/*
 * Copyright (C) 2017 ALLWINNERTECH TECHNOLOGY CO., LTD. All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *    1. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *    2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the
 *       distribution.
 *    3. Neither the name of ALLWINNERTECH TECHNOLOGY CO., LTD. nor the names of
 *       its contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _DRIVER_CHIP_SDMMC_SDIO_H_
#define _DRIVER_CHIP_SDMMC_SDIO_H_

#include "card.h"

#ifdef __cplusplus
extern "C" {
#endif

#undef readl
#undef writel

#ifndef printk
#define printk  rt_kprintf
#endif

#define readl hal_readl
#define writel hal_writel

#ifdef CONFIG_USE_SDIO
/*
 * SDIO function CIS tuple (unknown to the core)
 */
struct sdio_func_tuple {
    struct sdio_func_tuple *next;
    unsigned char code;
    unsigned char size;
    unsigned char data[0];
};

//#define SDIO_DEBUG

#define SDIO_EXCLUSIVE_HOST

/* SDIO commands                         type  argument     response */
#define SD_IO_SEND_OP_COND              5       /* bcr  [23:0] OCR         R4  */
#define SD_IO_RW_DIRECT                 52      /* ac   [31:0] See below   R5  */
#define SD_IO_RW_EXTENDED               53      /* adtc [31:0] See below   R5  */

/*
 * SD_IO_RW_DIRECT argument format:
 *
 *      [31] R/W flag
 *      [30:28] Function number
 *      [27] RAW flag
 *      [25:9] Register address
 *      [7:0] Data
 */

/*
 * SD_IO_RW_EXTENDED argument format:
 *
 *      [31] R/W flag
 *      [30:28] Function number
 *      [27] Block mode
 *      [26] Increment address
 *      [25:9] Register address
 *      [8:0] Byte/block count
 */

#define R4_18V_PRESENT                  (1<<24)
#define R4_MEMORY_PRESENT               (1 << 27)

//#define CONFIG_SDIO_IRQ_SUPPORT

/*
  SDIO status in R5
  Type
    e : error bit
    s : status bit
    r : detected and set for the actual command response
    x : detected and set during command execution. the host must poll
            the card by sending status command in order to read these bits.
  Clear condition
    a : according to the card state
    b : always related to the previous command. Reception of
            a valid command will clear it (with a delay of one command)
    c : clear by read
 */

#define R5_COM_CRC_ERROR                (1 << 15)       /* er, b */
#define R5_ILLEGAL_COMMAND              (1 << 14)       /* er, b */
#define R5_ERROR                        (1 << 11)       /* erx, c */
#define R5_FUNCTION_NUMBER              (1 << 9)        /* er, c */
#define R5_OUT_OF_RANGE                 (1 << 8)        /* er, c */
#define R5_STATUS(x)                    (x & 0xCB00)
#define R5_IO_CURRENT_STATE(x)          ((x & 0x3000) >> 12) /* s, b */

/*
 * Card Common Control Registers (CCCR)
 */

#define SDIO_CCCR_CCCR                  0x00

#define SDIO_CCCR_REV_1_00              0       /* CCCR/FBR Version 1.00 */
#define SDIO_CCCR_REV_1_10              1       /* CCCR/FBR Version 1.10 */
#define SDIO_CCCR_REV_1_20              2       /* CCCR/FBR Version 1.20 */
#define  SDIO_CCCR_REV_3_00             3       /* CCCR/FBR Version 3.00 */

#define SDIO_SDIO_REV_1_00              0       /* SDIO Spec Version 1.00 */
#define SDIO_SDIO_REV_1_10              1       /* SDIO Spec Version 1.10 */
#define SDIO_SDIO_REV_1_20              2       /* SDIO Spec Version 1.20 */
#define SDIO_SDIO_REV_2_00              3       /* SDIO Spec Version 2.00 */
#define SDIO_SDIO_REV_3_00              4       /* SDIO Spec Version 3.00 */

#define SDIO_CCCR_SD                    0x01

#define SDIO_SD_REV_1_01                0       /* SD Physical Spec Version 1.01 */
#define SDIO_SD_REV_1_10                1       /* SD Physical Spec Version 1.10 */
#define SDIO_SD_REV_2_00                2       /* SD Physical Spec Version 2.00 */
#define SDIO_SD_REV_3_00                3       /* SD Physical Spev Version 3.00 */

#define SDIO_CCCR_IOEx                  0x02
#define SDIO_CCCR_IORx                  0x03
#define SDIO_CCCR_IENx                  0x04    /* Function/Master Interrupt Enable */
#define SDIO_CCCR_INTx                  0x05    /* Function Interrupt Pending */
#define SDIO_CCCR_ABORT                 0x06    /* function abort/card reset */
#define SDIO_CCCR_IF                    0x07    /* bus interface controls */

#define SDIO_BUS_WIDTH_1BIT             0x00
#define SDIO_BUS_WIDTH_4BIT             0x02
#define SDIO_BUS_ECSI                   0x20    /* Enable continuous SPI interrupt */
#define SDIO_BUS_SCSI                   0x40    /* Support continuous SPI interrupt */

#define SDIO_BUS_ASYNC_INT              0x20

#define SDIO_BUS_CD_DISABLE             0x80    /* disable pull-up on DAT3 (pin 1) */

#define SDIO_CCCR_CAPS                  0x08

#define SDIO_CCCR_CAP_SDC               0x01    /* can do CMD52 while data transfer */
#define SDIO_CCCR_CAP_SMB               0x02    /* can do multi-block xfers (CMD53) */
#define SDIO_CCCR_CAP_SRW               0x04    /* supports read-wait protocol */
#define SDIO_CCCR_CAP_SBS               0x08    /* supports suspend/resume */
#define SDIO_CCCR_CAP_S4MI              0x10    /* interrupt during 4-bit CMD53 */
#define SDIO_CCCR_CAP_E4MI              0x20    /* enable ints during 4-bit CMD53 */
#define SDIO_CCCR_CAP_LSC               0x40    /* low speed card */
#define SDIO_CCCR_CAP_4BLS              0x80    /* 4 bit low speed card */

#define SDIO_CCCR_CIS                   0x09    /* common CIS pointer (3 bytes) */

/* Following 4 regs are valid only if SBS is set */
#define SDIO_CCCR_SUSPEND               0x0c
#define SDIO_CCCR_SELx                  0x0d
#define SDIO_CCCR_EXECx                 0x0e
#define SDIO_CCCR_READYx                0x0f

#define SDIO_CCCR_BLKSIZE               0x10

#define SDIO_CCCR_POWER                 0x12

#define SDIO_POWER_SMPC                 0x01    /* Supports Master Power Control */
#define SDIO_POWER_EMPC                 0x02    /* Enable Master Power Control */

#define SDIO_CCCR_SPEED                 0x13

#define SDIO_SPEED_SHS                  0x01    /* Supports High-Speed mode */
#define SDIO_SPEED_BSS_SHIFT            1
#define SDIO_SPEED_BSS_MASK             (7<<SDIO_SPEED_BSS_SHIFT)
#define SDIO_SPEED_SDR12                (0<<SDIO_SPEED_BSS_SHIFT)
#define SDIO_SPEED_SDR25                (1<<SDIO_SPEED_BSS_SHIFT)
#define SDIO_SPEED_SDR50                (2<<SDIO_SPEED_BSS_SHIFT)
#define SDIO_SPEED_SDR104               (3<<SDIO_SPEED_BSS_SHIFT)
#define SDIO_SPEED_DDR50                (4<<SDIO_SPEED_BSS_SHIFT)
#define SDIO_SPEED_EHS                  SDIO_SPEED_SDR25    /* Enable High-Speed */

#define SDIO_CCCR_UHS                   0x14
#define SDIO_UHS_SDR50                  0x01
#define SDIO_UHS_SDR104                 0x02
#define SDIO_UHS_DDR50                  0x04

#define SDIO_CCCR_DRIVE_STRENGTH        0x15
#define SDIO_SDTx_MASK                  0x07
#define SDIO_DRIVE_SDTA                 (1<<0)
#define SDIO_DRIVE_SDTC                 (1<<1)
#define SDIO_DRIVE_SDTD                 (1<<2)
#define SDIO_DRIVE_DTSx_MASK            0x03
#define SDIO_DRIVE_DTSx_SHIFT           4
#define SDIO_DTSx_SET_TYPE_B            (0 << SDIO_DRIVE_DTSx_SHIFT)
#define SDIO_DTSx_SET_TYPE_A            (1 << SDIO_DRIVE_DTSx_SHIFT)
#define SDIO_DTSx_SET_TYPE_C            (2 << SDIO_DRIVE_DTSx_SHIFT)
#define SDIO_DTSx_SET_TYPE_D            (3 << SDIO_DRIVE_DTSx_SHIFT)

/*
 * Function Basic Registers (FBR)
 */
#define SDIO_FBR_BASE(f)                ((f) * 0x100) /* base of function f's FBRs */

#define SDIO_FBR_STD_IF                 0x00

#define SDIO_FBR_SUPPORTS_CSA           0x40    /* supports Code Storage Area */
#define SDIO_FBR_ENABLE_CSA             0x80    /* enable Code Storage Area */

#define SDIO_FBR_STD_IF_EXT             0x01
#define SDIO_FBR_POWER                  0x02
#define SDIO_FBR_POWER_SPS              0x01    /* Supports Power Selection */
#define SDIO_FBR_POWER_EPS              0x02    /* Enable (low) Power Selection */
#define SDIO_FBR_CIS                    0x09    /* CIS pointer (3 bytes) */
#define SDIO_FBR_CSA                    0x0C    /* CSA pointer (3 bytes) */
#define SDIO_FBR_CSA_DATA               0x0F
#define SDIO_FBR_BLKSIZE                0x10    /* block size (2 bytes) */

/* Misc. helper definitions */
#define FN(x)                           (x)
#define FN0                             FN(0)
#define FN1                             FN(1)
#define FN2                             FN(2)
#define FN3                             FN(3)
#define FN4                             FN(4)
#define FN5                             FN(5)
#define FN6                             FN(6)
#define FN7                             FN(7)

struct mmc_card;

typedef struct mmc_card sdio_t;

/**
 *  sdio_readb - read a single byte from a SDIO function
 *  @card: SDIO to access
 *  @addr: address to read
 *  @err_ret: optional status value from transfer
 *
 *  Reads a single byte from the address space of a given SDIO
 *  function. If there is a problem reading the address, 0xff
 *  is returned and @err_ret will contain the error code.
 */
extern uint8_t
sdio_readb(struct mmc_card *card, uint32_t func_num, uint32_t addr,
           int32_t *err_ret);

/**
 *  sdio_writeb - write a single byte to a SDIO function
 *  @card: SDIO to access
 *  @b: byte to write
 *  @addr: address to write to
 *  @err_ret: optional status value from transfer
 *
 *  Writes a single byte to the address space of a given SDIO
 *  function. @err_ret will contain the status of the actual
 *  transfer.
 */
extern void
sdio_writeb(struct mmc_card *card, uint32_t func_num, const uint8_t b,
            uint32_t addr, int32_t  *err_ret);

/**
 *  sdio_readw - read a 16 bit integer from a SDIO function
 *  @func: SDIO function to access
 *  @addr: address to read
 *  @err_ret: optional status value from transfer
 *
 *  Reads a 16 bit integer from the address space of a given SDIO
 *  function. If there is a problem reading the address, 0xffff
 *  is returned and @err_ret will contain the error code.
 */
extern uint16_t sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret);
/**
 *  sdio_writew - write a 16 bit integer to a SDIO function
 *  @func: SDIO function to access
 *  @b: integer to write
 *  @addr: address to write to
 *  @err_ret: optional status value from transfer
 *
 *  Writes a 16 bit integer to the address space of a given SDIO
 *  function. @err_ret will contain the status of the actual
 *  transfer.
 */
extern void sdio_writew(struct sdio_func *func, uint16_t b, unsigned int addr, int *err_ret);
/**
 *  sdio_readl - read a 32 bit integer from a SDIO function
 *  @func: SDIO function to access
 *  @addr: address to read
 *  @err_ret: optional status value from transfer
 *
 *  Reads a 32 bit integer from the address space of a given SDIO
 *  function. If there is a problem reading the address,
 *  0xffffffff is returned and @err_ret will contain the error
 *  code.
 */
extern uint32_t sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret);
/**
 *  sdio_writel - write a 32 bit integer to a SDIO function
 *  @func: SDIO function to access
 *  @b: integer to write
 *  @addr: address to write to
 *  @err_ret: optional status value from transfer
 *
 *  Writes a 32 bit integer to the address space of a given SDIO
 *  function. @err_ret will contain the status of the actual
 *  transfer.
 */
extern void sdio_writel(struct sdio_func *func, uint32_t b, unsigned int addr, int *err_ret);

/**
 *  memcpy_fromio - read a chunk of memory from a SDIO function
 *  @dst: buffer to store the data
 *  @addr: address to begin reading from
 *  @count: number of bytes to read
 *
 *  Reads from the address space of a given SDIO function. Return
 *  value indicates if the transfer succeeded or not.
 */
extern int
sdio_memcpy_fromio(struct mmc_card *card, unsigned int func_num, void *dst,
                   unsigned int addr, int count);

/**
 *  memcpy_toio - write a chunk of memory to a SDIO function
 *  @addr: address to start writing to
 *  @src: buffer that contains the data to write
 *  @count: number of bytes to write
 *
 *  Writes to the address space of a given SDIO function. Return
 *  value indicates if the transfer succeeded or not.
 */
extern int
sdio_memcpy_toio(struct mmc_card *card, unsigned int func_num, unsigned int addr,
                 const void *src, int count);

/**
 *    sdio_claim_irq - claim the IRQ for a SDIO function
 *    @card: SDIO card
 *    @func_num: function num
 *    @handler: IRQ handler callback
 *
 *    Claim and activate the IRQ for the given SDIO function. The provided
 *    handler will be called when that IRQ is asserted.  The host is always
 *    claimed already when the handler is called so the handler must not
 *    call sdio_claim_host() nor sdio_release_host().
 */
//extern int sdio_claim_irq(struct mmc_card *card, unsigned int func_num,
//                          sdio_irq_handler_t *handler);
extern int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler);

/**
 *    sdio_release_irq - release the IRQ for a SDIO function
 *    @card: SDIO card
 *    @func_num: function num
 *
 *    Disable and release the IRQ for the given SDIO function.
 */
//extern int sdio_release_irq(struct mmc_card *card, unsigned int func_num);
extern int sdio_release_irq(struct sdio_func *func);

/**
 *  sdio_align_size - pads a transfer size to a more optimal value
 *  @func: SDIO function
 *  @sz: original transfer size
 *
 *  Pads the original data size with a number of extra bytes in
 *  order to avoid controller bugs and/or performance hits
 *  (e.g. some controllers revert to PIO for certain sizes).
 *
 *  If possible, it will also adjust the size so that it can be
 *  handled in just a single request.
 *
 *  Returns the improved size, which might be unmodified.
 */
//unsigned int sdio_align_size(struct mmc_card *card, unsigned int sz);
unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz);

/**
 *  claim_host - exclusively claim a bus for a certain SDIO function
 *  @func: SDIO function that will be accessed
 *
 *  Claim a bus for a set of operations. The SDIO function given
 *  is used to figure out which bus is relevant.
 */
#ifdef SDIO_EXCLUSIVE_HOST
extern void sdio_claim_host(struct mmc_card *card);
#else
static inline void sdio_claim_host(struct mmc_card *card) {
#ifdef SDIO_DEBUG
    if (card->_bus_refs)
        BUG_ON(1); /* check when need debug */
    card->_bus_refs++;
#endif
}
#endif

/**
 *  release_host - release a bus for a certain SDIO function
 *  @func: SDIO function that was accessed
 *
 *  Release a bus, allowing others to claim the bus for their
 *  operations.
 */
#ifdef SDIO_EXCLUSIVE_HOST
extern void sdio_release_host(struct mmc_card *card);
#else
static inline void sdio_release_host(struct mmc_card *card) {
#ifdef SDIO_DEBUG
    card->_bus_refs--;
    if (card->_bus_refs)
        BUG_ON(1); /* check when need debug */
#endif
}
#endif

static inline void sdio_lock(struct mmc_card *card) {
    sdio_claim_host(card);
}

static inline void sdio_unlock(struct mmc_card *card) {
    sdio_release_host(card);
}

extern int32_t sdio_set_block_size(struct mmc_card *card, uint32_t fn_num,
                               uint32_t blksz);
extern int32_t sdio_enable_func(struct mmc_card *card, uint32_t func_num);
extern int32_t sdio_disable_func(struct mmc_card *card, uint32_t func_num);
extern int32_t sdio_pm(sdio_t *card, int32_t suspend);

extern void sdio_test(void);
extern int mmc_io_rw_direct(struct mmc_card *card, int32_t write, uint32_t fn, uint32_t addr, uint8_t in, uint8_t *out);

extern struct sdio_func ** get_mmc_card_func(uint8_t card_id);

#endif /* CONFIG_USE_SDIO */

#ifdef __cplusplus
}
#endif

#endif /* _DRIVER_CHIP_SDMMC_SDIO_H_ */