/*-
 * Copyright (c) 2017 Ilya Bakulin
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
#include "cam_sdio.h"

/* Use CMD52 to read or write a single byte */
int
sdio_rw_direct(struct cam_device *dev,
               uint8_t func_number,
               uint32_t addr,
               uint8_t is_write,
               uint8_t *data, uint8_t *resp) {
        union ccb *ccb;
        uint32_t flags;
        uint32_t arg;
        int retval = 0;

        ccb = cam_getccb(dev);
        if (ccb == NULL) {
                warnx("%s: error allocating CCB", __func__);
                return (-1);
        }
        bzero(&(&ccb->ccb_h)[1],
              sizeof(union ccb) - sizeof(struct ccb_hdr));

        flags = MMC_RSP_R5 | MMC_CMD_AC;
        arg = SD_IO_RW_FUNC(func_number) | SD_IO_RW_ADR(addr);
        if (is_write)
                arg |= SD_IO_RW_WR | SD_IO_RW_RAW | SD_IO_RW_DAT(*data);

        cam_fill_mmcio(&ccb->mmcio,
                       /*retries*/ 0,
                       /*cbfcnp*/ NULL,
                       /*flags*/ CAM_DIR_NONE,
                       /*mmc_opcode*/ SD_IO_RW_DIRECT,
                       /*mmc_arg*/ arg,
                       /*mmc_flags*/ flags,
                       /*mmc_data*/ 0,
                       /*timeout*/ 5000);

        if (((retval = cam_send_ccb(dev, ccb)) < 0)
            || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
                const char warnstr[] = "error sending command";

                if (retval < 0)
                        warn(warnstr);
                else
                        warnx(warnstr);
                return (-1);
        }

        *resp = ccb->mmcio.cmd.resp[0] & 0xFF;
        cam_freeccb(ccb);
        return (retval);
}

/*
 * CMD53 -- IO_RW_EXTENDED
 * Use to read or write memory blocks
 *
 * is_increment=1: FIFO mode
 * blk_count > 0: block mode
 */
int
sdio_rw_extended(struct cam_device *dev,
                 uint8_t func_number,
                 uint32_t addr,
                 uint8_t is_write,
                 caddr_t data, size_t datalen,
                 uint8_t is_increment,
                 uint16_t blk_count) {
        union ccb *ccb;
        uint32_t flags;
        uint32_t arg;
        uint32_t cam_flags;
        uint8_t resp;
        struct mmc_data mmcd;
        int retval = 0;

        if (blk_count != 0) {
                warnx("%s: block mode is not supported yet", __func__);
                return (-1);
        }

        ccb = cam_getccb(dev);
        if (ccb == NULL) {
                warnx("%s: error allocating CCB", __func__);
                return (-1);
        }
        bzero(&(&ccb->ccb_h)[1],
              sizeof(union ccb) - sizeof(struct ccb_hdr));

        flags = MMC_RSP_R5 | MMC_CMD_ADTC;
        arg = SD_IO_RW_FUNC(func_number) | SD_IO_RW_ADR(addr) |
                SD_IOE_RW_LEN(datalen);

        if (is_increment)
                arg |= SD_IO_RW_INCR;

        mmcd.data = data;
        mmcd.len = datalen;
        mmcd.xfer_len = 0; /* not used by MMCCAM */
        mmcd.mrq = NULL; /* not used by MMCCAM */

        if (is_write) {
                arg |= SD_IO_RW_WR;
                cam_flags = CAM_DIR_OUT;
                mmcd.flags = MMC_DATA_WRITE;
        } else {
                cam_flags = CAM_DIR_IN;
                mmcd.flags = MMC_DATA_READ;
        }
        cam_fill_mmcio(&ccb->mmcio,
                       /*retries*/ 0,
                       /*cbfcnp*/ NULL,
                       /*flags*/ cam_flags,
                       /*mmc_opcode*/ SD_IO_RW_EXTENDED,
                       /*mmc_arg*/ arg,
                       /*mmc_flags*/ flags,
                       /*mmc_data*/ &mmcd,
                       /*timeout*/ 5000);

        if (((retval = cam_send_ccb(dev, ccb)) < 0)
            || ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)) {
                const char warnstr[] = "error sending command";

                if (retval < 0)
                        warn(warnstr);
                else
                        warnx(warnstr);
                return (-1);
        }

        resp = ccb->mmcio.cmd.resp[0] & 0xFF;
        if (resp != 0)
                warn("Response from CMD53 is not 0?!");
        cam_freeccb(ccb);
        return (retval);
}


int
sdio_read_bool_for_func(struct cam_device *dev, uint32_t addr, uint8_t func_number, uint8_t *is_enab) {
        uint8_t resp;
        int ret;

        ret = sdio_rw_direct(dev, 0, addr, 0, NULL, &resp);
        if (ret < 0)
                return ret;

        *is_enab = (resp & (1 << func_number)) > 0 ? 1 : 0;

        return (0);
}

int
sdio_set_bool_for_func(struct cam_device *dev, uint32_t addr, uint8_t func_number, int enable) {
        uint8_t resp;
        int ret;
        uint8_t is_enabled;

        ret = sdio_rw_direct(dev, 0, addr, 0, NULL, &resp);
        if (ret != 0)
                return ret;

        is_enabled = resp & (1 << func_number);
        if ((is_enabled !=0 && enable == 1) || (is_enabled == 0 && enable == 0))
                return 0;

        if (enable)
                resp |= 1 << func_number;
        else
                resp &= ~ (1 << func_number);

        ret = sdio_rw_direct(dev, 0, addr, 1, &resp, &resp);

        return ret;
}

/* Conventional I/O functions */
uint8_t
sdio_read_1(struct cam_device *dev, uint8_t func_number, uint32_t addr, int *ret) {
        uint8_t val;
        *ret = sdio_rw_direct(dev, func_number, addr, 0, NULL, &val);
        return val;
}

int
sdio_write_1(struct cam_device *dev, uint8_t func_number, uint32_t addr, uint8_t val) {
        uint8_t _val;
        return sdio_rw_direct(dev, func_number, addr, 0, &val, &_val);
}

uint16_t
sdio_read_2(struct cam_device *dev, uint8_t func_number, uint32_t addr, int *ret) {
        uint16_t val;
        *ret = sdio_rw_extended(dev, func_number, addr,
                                /* is_write */ 0,
                                /* data */ (caddr_t) &val,
                                /* datalen */ sizeof(val),
                                /* is_increment */ 1,
                                /* blk_count */ 0
                );
        return val;
}


int
sdio_write_2(struct cam_device *dev, uint8_t func_number, uint32_t addr, uint16_t val) {
        return sdio_rw_extended(dev, func_number, addr,
                                /* is_write */ 1,
                                /* data */ (caddr_t) &val,
                                /* datalen */ sizeof(val),
                                /* is_increment */ 1,
                                /* blk_count */ 0
                );
}

uint32_t
sdio_read_4(struct cam_device *dev, uint8_t func_number, uint32_t addr, int *ret) {
        uint32_t val;
        *ret = sdio_rw_extended(dev, func_number, addr,
                                /* is_write */ 0,
                                /* data */ (caddr_t) &val,
                                /* datalen */ sizeof(val),
                                /* is_increment */ 1,
                                /* blk_count */ 0
                );
        return val;
}


int
sdio_write_4(struct cam_device *dev, uint8_t func_number, uint32_t addr, uint32_t val) {
        return sdio_rw_extended(dev, func_number, addr,
                                /* is_write */ 1,
                                /* data */ (caddr_t) &val,
                                /* datalen */ sizeof(val),
                                /* is_increment */ 1,
                                /* blk_count */ 0
                );
}

/* Higher-level wrappers for certain management operations */
int
sdio_is_func_ready(struct cam_device *dev, uint8_t func_number, uint8_t *is_enab) {
        return sdio_read_bool_for_func(dev, SD_IO_CCCR_FN_READY, func_number, is_enab);
}

int
sdio_is_func_enabled(struct cam_device *dev, uint8_t func_number, uint8_t *is_enab) {
        return sdio_read_bool_for_func(dev, SD_IO_CCCR_FN_ENABLE, func_number, is_enab);
}

int
sdio_func_enable(struct cam_device *dev, uint8_t func_number, int enable) {
        return sdio_set_bool_for_func(dev, SD_IO_CCCR_FN_ENABLE, func_number, enable);
}

int
sdio_is_func_intr_enabled(struct cam_device *dev, uint8_t func_number, uint8_t *is_enab) {
        return sdio_read_bool_for_func(dev, SD_IO_CCCR_INT_ENABLE, func_number, is_enab);
}

int
sdio_func_intr_enable(struct cam_device *dev, uint8_t func_number, int enable) {
        return sdio_set_bool_for_func(dev, SD_IO_CCCR_INT_ENABLE, func_number, enable);
}

int
sdio_card_set_bus_width(struct cam_device *dev, enum mmc_bus_width bw) {
        int ret;
        uint8_t ctl_val;
        ret = sdio_rw_direct(dev, 0, SD_IO_CCCR_BUS_WIDTH, 0, NULL, &ctl_val);
        if (ret < 0) {
                warn("Error getting CCCR_BUS_WIDTH value");
                return ret;
        }
        ctl_val &= ~0x3;
        switch (bw) {
        case bus_width_1:
                /* Already set to 1-bit */
                break;
        case bus_width_4:
                ctl_val |= CCCR_BUS_WIDTH_4;
                break;
        case bus_width_8:
                warn("Cannot do 8-bit on SDIO yet");
                return -1;
                break;
        }
        ret = sdio_rw_direct(dev, 0, SD_IO_CCCR_BUS_WIDTH, 1, &ctl_val, &ctl_val);
        if (ret < 0) {
                warn("Error setting CCCR_BUS_WIDTH value");
                return ret;
        }
        return ret;
}

int
sdio_func_read_cis(struct cam_device *dev, uint8_t func_number,
                   uint32_t cis_addr, struct cis_info *info) {
        uint8_t tuple_id, tuple_len, tuple_count;
        uint32_t addr;

        char *cis1_info[4];
        int start, i, ch, count, ret;
        char cis1_info_buf[256];

        tuple_count = 0; /* Use to prevent infinite loop in case of parse errors */
        memset(cis1_info_buf, 0, 256);
        do {
                addr = cis_addr;
                tuple_id = sdio_read_1(dev, 0, addr++, &ret);
                if (tuple_id == SD_IO_CISTPL_END)
                        break;
                if (tuple_id == 0) {
                        cis_addr++;
                        continue;
                }
                tuple_len = sdio_read_1(dev, 0, addr++, &ret);
                if (tuple_len == 0 && tuple_id != 0x00) {
                        warn("Parse error: 0-length tuple %02X\n", tuple_id);
                        return -1;
                }

                switch (tuple_id) {
                case SD_IO_CISTPL_VERS_1:
                        addr += 2;
                        for (count = 0, start = 0, i = 0;
                             (count < 4) && ((i + 4) < 256); i++) {
                                ch = sdio_read_1(dev, 0, addr + i, &ret);
                                printf("count=%d, start=%d, i=%d, Got %c (0x%02x)\n", count, start, i, ch, ch);
                                if (ch == 0xff)
                                        break;
                                cis1_info_buf[i] = ch;
                                if (ch == 0) {
                                        cis1_info[count] =
                                                cis1_info_buf + start;
                                        start = i + 1;
                                        count++;
                                }
                        }
                        printf("Card info:");
                        for (i=0; i<4; i++)
                                if (cis1_info[i])
                                        printf(" %s", cis1_info[i]);
                        printf("\n");
                        break;
                case SD_IO_CISTPL_MANFID:
                        info->man_id =  sdio_read_1(dev, 0, addr++, &ret);
                        info->man_id |= sdio_read_1(dev, 0, addr++, &ret) << 8;

                        info->prod_id =  sdio_read_1(dev, 0, addr++, &ret);
                        info->prod_id |= sdio_read_1(dev, 0, addr++, &ret) << 8;
                        break;
                case SD_IO_CISTPL_FUNCID:
                        /* not sure if we need to parse it? */
                        break;
                case SD_IO_CISTPL_FUNCE:
                        if (tuple_len < 4) {
                                printf("FUNCE is too short: %d\n", tuple_len);
                                break;
                        }
                        if (func_number == 0) {
                                /* skip extended_data */
                                addr++;
                                info->max_block_size  = sdio_read_1(dev, 0, addr++, &ret);
                                info->max_block_size |= sdio_read_1(dev, 0, addr++, &ret) << 8;
                        } else {
                                info->max_block_size  = sdio_read_1(dev, 0, addr + 0xC, &ret);
                                info->max_block_size |= sdio_read_1(dev, 0, addr + 0xD, &ret) << 8;
                        }
                        break;
                default:
                        warnx("Skipping tuple ID %02X len %02X\n", tuple_id, tuple_len);
                }
                cis_addr += tuple_len + 2;
                tuple_count++;
        } while (tuple_count < 20);

        return 0;
}

uint32_t
sdio_get_common_cis_addr(struct cam_device *dev) {
        uint32_t addr;
        int ret;

        addr =  sdio_read_1(dev, 0, SD_IO_CCCR_CISPTR, &ret);
        addr |= sdio_read_1(dev, 0, SD_IO_CCCR_CISPTR + 1, &ret) << 8;
        addr |= sdio_read_1(dev, 0, SD_IO_CCCR_CISPTR + 2, &ret) << 16;

        if (addr < SD_IO_CIS_START || addr > SD_IO_CIS_START + SD_IO_CIS_SIZE) {
                warn("Bad CIS address: %04X\n", addr);
                addr = 0;
        }

        return addr;
}

void sdio_card_reset(struct cam_device *dev) {
        int ret;
        uint8_t ctl_val;
        ret = sdio_rw_direct(dev, 0, SD_IO_CCCR_CTL, 0, NULL, &ctl_val);
        if (ret < 0)
                errx(1, "Error getting CCCR_CTL value");
        ctl_val |= CCCR_CTL_RES;
        ret = sdio_rw_direct(dev, 0, SD_IO_CCCR_CTL, 1, &ctl_val, &ctl_val);
        if (ret < 0)
                errx(1, "Error setting CCCR_CTL value");
}