/*
 * Copyright (c) 2015 South Silicon Valley Microelectronics Inc.
 * Copyright (c) 2015 iComm Corporation
 *
 * This program is free software: you can redistribute it and/or modify 
 * it under the terms of the GNU General Public License as published by 
 * the Free Software Foundation, either version 3 of the License, or 
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/irq.h>
#include <linux/module.h>
#include <linux/vmalloc.h>
#include <linux/platform_device.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/sdio_func.h>
#include <linux/mmc/sdio_ids.h>
#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
#include "sdio_def.h"
#include <linux/pm_runtime.h>
#include <linux/version.h>
#include <linux/firmware.h>
#include <linux/reboot.h>
#ifdef CONFIG_FW_ALIGNMENT_CHECK
#include <linux/skbuff.h>
#endif
#define SDIO_USE_SLOW_CLOCK 
#define LOW_SPEED_SDIO_CLOCK (25000000)
#define HIGH_SPEED_SDIO_CLOCK (50000000)
static struct ssv6xxx_platform_data wlan_data;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,0)
#include <linux/printk.h>
#else
#include <linux/kernel.h>
#endif
#include <ssv6200.h>
#define MAX_RX_FRAME_SIZE 0x900
#define SSV_VENDOR_ID 0x3030
#define SSV_CABRIO_DEVID 0x3030
#define ENABLE_FW_SELF_CHECK 1
#define FW_BLOCK_SIZE 0x8000
#define CHECKSUM_BLOCK_SIZE 1024
#define FW_CHECKSUM_INIT (0x12345678)
#define FW_STATUS_REG ADR_TX_SEG
#define FW_STATUS_MASK (0x00FF0000)
#ifdef CONFIG_PM
static int ssv6xxx_sdio_trigger_pmu(struct device *dev);
static void ssv6xxx_sdio_reset(struct device *child);
#else
static void ssv6xxx_sdio_reset(struct device *child) { ; }
#endif
static void ssv6xxx_high_sdio_clk(struct sdio_func *func);
static void ssv6xxx_low_sdio_clk(struct sdio_func *func);
extern void *ssv6xxx_ifdebug_info[];
extern int ssv_devicetype;
extern void ssv6xxx_deinit_prepare(void);  
static int ssv6xxx_sdio_status = 0;
u32 sdio_sr_bhvr = SUSPEND_RESUME_0;
EXPORT_SYMBOL(sdio_sr_bhvr);

static DEFINE_MUTEX(reboot_lock);
u32 shutdown_flags = SSV_SYS_REBOOT;

struct ssv6xxx_sdio_glue
{
    struct device *dev;
    struct platform_device *core;
#ifdef CONFIG_FW_ALIGNMENT_CHECK
    struct sk_buff *dmaSkb;
#endif
#ifdef CONFIG_PM
    struct sk_buff *cmd_skb;
#endif
    unsigned int dataIOPort;
    unsigned int regIOPort;
    irq_handler_t irq_handler;
    void *irq_dev;
    bool dev_ready;
};
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
static const struct sdio_device_id ssv6xxx_sdio_devices[] __devinitconst =
#else
static const struct sdio_device_id ssv6xxx_sdio_devices[] =
#endif
{
    { SDIO_DEVICE(SSV_VENDOR_ID, SSV_CABRIO_DEVID) },
    {}
};
MODULE_DEVICE_TABLE(sdio, ssv6xxx_sdio_devices);
static bool ssv6xxx_is_ready (struct device *child)
{
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
        return false;
    return glue->dev_ready;
}
static int ssv6xxx_sdio_cmd52_read(struct device *child, u32 addr,
        u32 *value)
{
    int ret = -1;
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        *value = sdio_readb(func, addr, &ret);
        sdio_release_host(func);
    }
    return ret;
}
static int ssv6xxx_sdio_cmd52_write(struct device *child, u32 addr,
        u32 value)
{
    int ret = -1;
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        sdio_writeb(func, value, addr, &ret);
        sdio_release_host(func);
    }
    return ret;
}
static int __must_check ssv6xxx_sdio_read_reg(struct device *child, u32 addr,
        u32 *buf)
{
    int ret = (-1);
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func ;
    u8 data[4];
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        data[0] = (addr >> ( 0 )) &0xff;
        data[1] = (addr >> ( 8 )) &0xff;
        data[2] = (addr >> ( 16 )) &0xff;
        data[3] = (addr >> ( 24 )) &0xff;
        ret = sdio_memcpy_toio(func, glue->regIOPort, data, 4);
        if (WARN_ON(ret))
        {
            dev_err(child->parent, "sdio read reg write address failed (%d)\n", ret);
            goto io_err;
        }
        ret = sdio_memcpy_fromio(func, data, glue->regIOPort, 4);
        if (WARN_ON(ret))
        {
            dev_err(child->parent, "sdio read reg from I/O failed (%d)\n",ret);
         goto io_err;
      }
        if(ret == 0)
        {
            *buf = (data[0]&0xff);
            *buf = *buf | ((data[1]&0xff)<<( 8 ));
            *buf = *buf | ((data[2]&0xff)<<( 16 ));
            *buf = *buf | ((data[3]&0xff)<<( 24 ));
        }
        else
            *buf = 0xffffffff;
io_err:
        sdio_release_host(func);
    }
    else
    {
        dev_err(child->parent, "sdio read reg glue == NULL!!!\n");
    }
    return ret;
}
#ifdef ENABLE_WAKE_IO_ISR_WHEN_HCI_ENQUEUE
static int ssv6xxx_sdio_trigger_tx_rx (struct device *child)
{
    int ret = (-1);
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    struct mmc_host *host;
    if (glue == NULL)
        return ret;
    func = dev_to_sdio_func(glue->dev);
    host = func->card->host;
    mmc_signal_sdio_irq(host);
    return 0;
}
#endif
static int __must_check ssv6xxx_sdio_write_reg(struct device *child, u32 addr,
        u32 buf)
{
    int ret = (-1);
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    u8 data[8];
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        dev_dbg(child->parent, "sdio write reg addr 0x%x, 0x%x\n",addr, buf);
        sdio_claim_host(func);
        data[0] = (addr >> ( 0 )) &0xff;
        data[1] = (addr >> ( 8 )) &0xff;
        data[2] = (addr >> ( 16 )) &0xff;
        data[3] = (addr >> ( 24 )) &0xff;
        data[4] = (buf >> ( 0 )) &0xff;
        data[5] = (buf >> ( 8 )) &0xff;
        data[6] = (buf >> ( 16 )) &0xff;
        data[7] = (buf >> ( 24 )) &0xff;
        ret = sdio_memcpy_toio(func, glue->regIOPort, data, 8);
        sdio_release_host(func);
#ifdef __x86_64
        udelay(50);
#endif
    }
    else
    {
        dev_err(child->parent, "sdio write reg glue == NULL!!!\n");
    }
    return ret;
}
static int ssv6xxx_sdio_write_sram(struct device *child, u32 addr, u8 *data, u32 size)
{
    int ret = -1;
    struct ssv6xxx_sdio_glue *glue;
    struct sdio_func *func=NULL;
    glue = dev_get_drvdata(child->parent);
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
        return ret;
    func = dev_to_sdio_func(glue->dev);
    sdio_claim_host(func);
    do {
        if (ssv6xxx_sdio_write_reg(child,0xc0000860,addr)) ;
        sdio_writeb(func, 0x2, REG_Fn1_STATUS, &ret);
        if (unlikely(ret)) break;
        ret = sdio_memcpy_toio(func, glue->dataIOPort, data, size);
        if (unlikely(ret)) return ret;
        sdio_writeb(func, 0, REG_Fn1_STATUS, &ret);
        if (unlikely(ret)) return ret;
    } while (0);
    sdio_release_host(func);
    return ret;
}
void * ssv6xxx_open_firmware(char *user_mainfw)
{
    struct file *fp;
    fp = filp_open(user_mainfw, O_RDONLY, 0);
    if (IS_ERR(fp))
    {
        printk("ssv6xxx_open_firmware failed!!\n");
        fp = NULL;
    }
    return fp;
}
int ssv6xxx_read_fw_block(char *buf, int len, void *image)
{
 struct file *fp = (struct file *)image;
 int rdlen;
 if (!image)
  return 0;
 rdlen = kernel_read(fp, fp->f_pos, buf, len);
 if (rdlen > 0)
  fp->f_pos += rdlen;
 return rdlen;
}
void ssv6xxx_close_firmware(void *image)
{
 if (image)
  filp_close((struct file *)image, NULL);
}
static int ssv6xxx_sdio_load_firmware_openfile(struct device *child, u8 *firmware_name)
{
    int ret = 0;
    struct ssv6xxx_sdio_glue *glue;
    u8 *fw_buffer = NULL;
    u32 sram_addr = 0x00000000;
    u32 block_count = 0;
    u32 res_size=0,len=0,tolen=0;
    void *fw_fp=NULL;
#ifdef ENABLE_FW_SELF_CHECK
    u32 checksum = FW_CHECKSUM_INIT;
    u32 fw_checksum,fw_clkcnt;
    u32 retry_count = 3;
    u32 *fw_data32;
#else
    int writesize=0;
    u32 retry_count = 1;
#endif
    u32 word_count,i;
    u32 j,jblk;
    #ifndef SDIO_USE_SLOW_CLOCK
    struct sdio_func *func=NULL;
    struct mmc_card *card = NULL;
    struct mmc_host *host = NULL;
    #endif
    glue = dev_get_drvdata(child->parent);
    if ( (wlan_data.is_enabled != false)
        || (glue != NULL)
        || (glue->dev_ready != false))
    {
        #ifndef SDIO_USE_SLOW_CLOCK
        func = dev_to_sdio_func(glue->dev);
        card = func->card;
        host = card->host;
        #endif
        fw_fp = ssv6xxx_open_firmware(firmware_name);
        if (!fw_fp) {
            printk("failed to find firmware (%s)\n", firmware_name);
            ret = -1;
            goto out;
        }
        fw_buffer = (u8 *)kzalloc(FW_BLOCK_SIZE, GFP_KERNEL);
        if (fw_buffer == NULL) {
            printk("Failed to allocate buffer for firmware.\n");
            goto out;
        }
        do {
            u32 clk_en;
            if(1){
            if(ssv6xxx_sdio_write_reg(child, ADR_BRG_SW_RST, 0x0));
            if(ssv6xxx_sdio_write_reg(child, ADR_BOOT, 0x01));
            if(ssv6xxx_sdio_read_reg(child, ADR_PLATFORM_CLOCK_ENABLE, &clk_en));
            if(ssv6xxx_sdio_write_reg(child, ADR_PLATFORM_CLOCK_ENABLE, clk_en | (1 << 2)));
            }
            printk("Writing firmware to SSV6XXX...\n");
            memset(fw_buffer, 0xA5, FW_BLOCK_SIZE);
            while ((len = ssv6xxx_read_fw_block((char*)fw_buffer, FW_BLOCK_SIZE, fw_fp))) {
                tolen += len;
                if(len < FW_BLOCK_SIZE){
                    res_size = len;
                    break;
                }
                if(0)
                {
                    jblk = len / 128;
                    for(j=0;j<jblk;j++)
                    {
                        ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)(fw_buffer+j*128), 128);
                        if (ret){
                            printk("ssv6xxx_sdio_write_sram failed!!\n");
                            break;
                        }
                        sram_addr += 128;
                    }
                }else{
                    ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)fw_buffer, FW_BLOCK_SIZE);
                    if (ret)
                        break;
                    sram_addr += FW_BLOCK_SIZE;
                }
                word_count = (len / sizeof(u32));
                fw_data32 = (u32 *)fw_buffer;
                for (i = 0; i < word_count; i++){
                    checksum += fw_data32[i];
                }
                memset(fw_buffer, 0xA5, FW_BLOCK_SIZE);
            }
            if(res_size)
            {
                u32 cks_blk_cnt,cks_blk_res;
                cks_blk_cnt = res_size / CHECKSUM_BLOCK_SIZE;
                cks_blk_res = res_size % CHECKSUM_BLOCK_SIZE;
                if(0)
                {
                    jblk = ((cks_blk_cnt+1)*CHECKSUM_BLOCK_SIZE)/128;
                    for(j=0;j<jblk;j++){
                        ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)(fw_buffer+j*128), 128);
                        sram_addr += 128;
                    }
                }else{
                    ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)fw_buffer, (cks_blk_cnt+1)*CHECKSUM_BLOCK_SIZE);
                }
                word_count = (cks_blk_cnt * CHECKSUM_BLOCK_SIZE / sizeof(u32));
                fw_data32 = (u32 *)fw_buffer;
                for (i = 0; i < word_count; i++)
                    checksum += *fw_data32++;
                if(cks_blk_res)
                {
                    word_count = (CHECKSUM_BLOCK_SIZE / sizeof(u32));
                    for (i = 0; i < word_count; i++) {
                        checksum += *fw_data32++;
                    }
                }
            }
            checksum = ((checksum >> 24) + (checksum >> 16) + (checksum >> 8) + checksum) & 0x0FF;
            checksum <<= 16;
            if (ret == 0) {
                block_count = tolen / CHECKSUM_BLOCK_SIZE;
                res_size = tolen % CHECKSUM_BLOCK_SIZE;
                if(res_size)
                    block_count++;
                if(ssv6xxx_sdio_write_reg(child, FW_STATUS_REG, (block_count << 16)));
                if(ssv6xxx_sdio_read_reg(child, FW_STATUS_REG, &fw_clkcnt));
                printk("(block_count << 16) = %x,reg =%x\n",(block_count << 16),fw_clkcnt);
                if(ssv6xxx_sdio_write_reg(child, ADR_BRG_SW_RST, 0x1));
                printk("Firmware \"%s\" loaded\n", firmware_name);
                msleep(50);
                if(ssv6xxx_sdio_read_reg(child, FW_STATUS_REG, &fw_checksum));
                fw_checksum = fw_checksum & FW_STATUS_MASK;
                if (fw_checksum == checksum) {
                    if(ssv6xxx_sdio_write_reg(child, FW_STATUS_REG, (~checksum & FW_STATUS_MASK)));
                    ret = 0;
                    printk("Firmware check OK.%04x = %04x\n", fw_checksum, checksum);
                    break;
                } else {
                    printk("FW checksum error: %04x != %04x\n", fw_checksum, checksum);
                    ret = -1;
                }
            } else {
                printk("Firmware \"%s\" download failed. (%d)\n", firmware_name, ret);
                ret = -1;
            }
        } while (--retry_count);
        if (ret)
            goto out;
        ret = 0;
    }
out:
    if(fw_fp)
        ssv6xxx_close_firmware(fw_fp);
    if (fw_buffer != NULL)
        kfree(fw_buffer);
    msleep(50);
    return ret;
}
int ssv6xxx_get_firmware(struct device *dev,
            char *user_mainfw,
            const struct firmware **mainfw)
{
    int ret;
    BUG_ON(mainfw == NULL);
    if (*user_mainfw) {
        ret = request_firmware(mainfw, user_mainfw, dev);
        if (ret) {
            dev_err(dev, "couldn't find main firmware %s\n",user_mainfw);
            goto fail;
        }
        if (*mainfw)
            return 0;
    }
fail:
    if (*mainfw) {
        release_firmware(*mainfw);
        *mainfw = NULL;
    }
    return -ENOENT;
}
static int ssv6xxx_sdio_load_firmware_request(struct device *child ,u8 *firmware_name)
{
    int ret = 0;
    const struct firmware *ssv6xxx_fw = NULL;
    struct ssv6xxx_sdio_glue *glue;
    u8 *fw_buffer = NULL;
    u32 sram_addr = 0x00000000;
    u32 block_count = 0;
    u32 block_idx = 0;
    u32 res_size;
    u8 *fw_data;
#ifdef ENABLE_FW_SELF_CHECK
    u32 checksum = FW_CHECKSUM_INIT;
    u32 fw_checksum;
    u32 retry_count = 3;
    u32 *fw_data32;
#else
    int writesize=0;
    u32 retry_count = 1;
#endif
    #ifndef SDIO_USE_SLOW_CLOCK
    struct sdio_func *func=NULL;
    struct mmc_card *card = NULL;
    struct mmc_host *host = NULL;
    #endif
    glue = dev_get_drvdata(child->parent);
    if ( (wlan_data.is_enabled != false)
        || (glue != NULL)
        || (glue->dev_ready != false))
    {
        #ifndef SDIO_USE_SLOW_CLOCK
        func = dev_to_sdio_func(glue->dev);
        card = func->card;
        host = card->host;
        #endif
        ret = ssv6xxx_get_firmware(glue->dev, firmware_name, &ssv6xxx_fw);
        if (ret) {
            pr_err("failed to find firmware (%d)\n", ret);
            goto out;
        }
        fw_buffer = (u8 *)kzalloc(FW_BLOCK_SIZE, GFP_KERNEL);
        if (fw_buffer == NULL) {
            pr_err("Failed to allocate buffer for firmware.\n");
            goto out;
        }
#ifdef ENABLE_FW_SELF_CHECK
        block_count = ssv6xxx_fw->size / CHECKSUM_BLOCK_SIZE;
        res_size = ssv6xxx_fw->size % CHECKSUM_BLOCK_SIZE;
        {
            int word_count = (int)(block_count * CHECKSUM_BLOCK_SIZE / sizeof(u32));
            int i;
            fw_data32 = (u32 *)ssv6xxx_fw->data;
            for (i = 0; i < word_count; i++)
                checksum += fw_data32[i];
            if(res_size)
            {
                memset(fw_buffer, 0xA5, CHECKSUM_BLOCK_SIZE);
                memcpy(fw_buffer, &ssv6xxx_fw->data[block_count * CHECKSUM_BLOCK_SIZE], res_size);
                word_count = (int)(CHECKSUM_BLOCK_SIZE / sizeof(u32));
                fw_data32 = (u32 *)fw_buffer;
                for (i = 0; i < word_count; i++) {
                    checksum += fw_data32[i];
                }
            }
        }
        checksum = ((checksum >> 24) + (checksum >> 16) + (checksum >> 8) + checksum) & 0x0FF;
        checksum <<= 16;
#endif
        do {
            u32 clk_en;
            if(ssv6xxx_sdio_write_reg(child, ADR_BRG_SW_RST, 0x0));
            if(ssv6xxx_sdio_write_reg(child, ADR_BOOT, 0x01));
            if(ssv6xxx_sdio_read_reg(child, ADR_PLATFORM_CLOCK_ENABLE, &clk_en));
            if(ssv6xxx_sdio_write_reg(child, ADR_PLATFORM_CLOCK_ENABLE, clk_en | (1 << 2)));
#ifdef ENABLE_FW_SELF_CHECK
            block_count = ssv6xxx_fw->size / FW_BLOCK_SIZE;
            res_size = ssv6xxx_fw->size % FW_BLOCK_SIZE;
            printk("Writing %d blocks to SSV6XXX...", block_count);
            for (block_idx = 0, fw_data = (u8 *)ssv6xxx_fw->data, sram_addr = 0;block_idx < block_count;
                block_idx++, fw_data += FW_BLOCK_SIZE, sram_addr += FW_BLOCK_SIZE) {
                memcpy(fw_buffer, fw_data, FW_BLOCK_SIZE);
                ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)fw_buffer, FW_BLOCK_SIZE);
                if (ret)
                    break;
            }
            if(res_size)
            {
                memset(fw_buffer, 0xA5, FW_BLOCK_SIZE);
                memcpy(fw_buffer, &ssv6xxx_fw->data[block_count * FW_BLOCK_SIZE], res_size);
                ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)fw_buffer, ((res_size/CHECKSUM_BLOCK_SIZE)+1)*CHECKSUM_BLOCK_SIZE);
            }
#else
            block_count = ssv6xxx_fw->size / FW_BLOCK_SIZE;
            res_size = ssv6xxx_fw->size % FW_BLOCK_SIZE;
            writesize = sdio_align_size(func,res_size);
            printk("Writing %d blocks to SSV6XXX...", block_count);
            for (block_idx = 0, fw_data = (u8 *)ssv6xxx_fw->data, sram_addr = 0;block_idx < block_count;
                block_idx++, fw_data += FW_BLOCK_SIZE, sram_addr += FW_BLOCK_SIZE) {
                memcpy(fw_buffer, fw_data, FW_BLOCK_SIZE);
                ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)fw_buffer, FW_BLOCK_SIZE);
                if (ret)
                    break;
            }
            if(res_size)
            {
                memcpy(fw_buffer, &ssv6xxx_fw->data[block_count * FW_BLOCK_SIZE], res_size);
                ret = ssv6xxx_sdio_write_sram(child, sram_addr, (u8 *)fw_buffer, writesize);
            }
#endif
            if (ret == 0) {
#ifdef ENABLE_FW_SELF_CHECK
                block_count = ssv6xxx_fw->size / CHECKSUM_BLOCK_SIZE;
                res_size = ssv6xxx_fw->size % CHECKSUM_BLOCK_SIZE;
                if(res_size)
                    block_count++;
                if(ssv6xxx_sdio_write_reg(child, FW_STATUS_REG, (block_count << 16)));
#endif
                if(ssv6xxx_sdio_write_reg(child, ADR_BRG_SW_RST, 0x1));
                printk("Firmware \"%s\" loaded\n", firmware_name);
#ifdef ENABLE_FW_SELF_CHECK
                msleep(50);
                if(ssv6xxx_sdio_read_reg(child, FW_STATUS_REG, &fw_checksum));
                fw_checksum = fw_checksum & FW_STATUS_MASK;
                if (fw_checksum == checksum) {
                    if(ssv6xxx_sdio_write_reg(child, FW_STATUS_REG, (~checksum & FW_STATUS_MASK)));
                    ret = 0;
                    printk("Firmware check OK.\n");
                    break;
                } else {
                    printk("FW checksum error: %04x != %04x\n", fw_checksum, checksum);
                    ret = -1;
                }
#endif
            } else {
                printk("Firmware \"%s\" download failed. (%d)\n", firmware_name, ret);
                ret = -1;
            }
        } while (--retry_count);
        if (ret)
            goto out;
        ret = 0;
    }
out:
    if (ssv6xxx_fw)
        release_firmware(ssv6xxx_fw);
    if (fw_buffer != NULL)
        kfree(fw_buffer);
    msleep(50);
    return ret;
}
static int ssv6xxx_sdio_load_firmware(struct device *child ,u8 *firmware_name, u8 openfile)
{
 int ret = -1;
 struct ssv6xxx_sdio_glue *glue;
 struct sdio_func *func;
 glue = dev_get_drvdata(child->parent);
    if(openfile)
        ret = ssv6xxx_sdio_load_firmware_openfile(child,firmware_name);
    else
        ret = ssv6xxx_sdio_load_firmware_request(child,firmware_name);
 if(glue != NULL)
 {
  func = dev_to_sdio_func(glue->dev);
  ssv6xxx_high_sdio_clk(func);
 }
 return ret;
}
static int ssv6xxx_sdio_irq_getstatus(struct device *child,int *status)
{
    int ret = (-1);
    struct ssv6xxx_sdio_glue *glue;
    struct sdio_func *func;
    glue = dev_get_drvdata(child->parent);
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        *status = sdio_readb(func, REG_INT_STATUS, &ret);
        sdio_release_host(func);
    }
    return ret;
}
#if 0
static void _sdio_hexdump(const u8 *buf,
                             size_t len)
{
    size_t i;
    printk("\n-----------------------------\n");
    printk("hexdump(len=%lu):\n", (unsigned long) len);
    {
        for (i = 0; i < len; i++){
            printk(" %02x", buf[i]);
            if((i+1)%40 ==0)
                printk("\n");
        }
    }
    printk("\n-----------------------------\n");
}
#endif
static int __must_check ssv6xxx_sdio_read(struct device *child,
        void *buf, size_t *size)
{
    int ret = (-1), readsize = 0;
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func ;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        *size = (uint)sdio_readb(func, REG_CARD_PKT_LEN_0, &ret);
        if (ret)
            dev_err(child->parent, "sdio read hight len failed ret[%d]\n",ret);
        if (ret == 0)
        {
            *size = *size | ((uint)sdio_readb(func, REG_CARD_PKT_LEN_1, &ret)<<0x8);
            if (ret)
                dev_err(child->parent, "sdio read low len failed ret[%d]\n",ret);
        }
        if (ret == 0)
        {
            readsize = sdio_align_size(func,*size);
            ret = sdio_memcpy_fromio(func, buf, glue->dataIOPort, readsize);
            if (ret)
                dev_err(child->parent, "sdio read failed size ret[%d]\n",ret);
        }
        sdio_release_host(func);
    }
#if 0
    if(*size > 1500)
        _sdio_hexdump(buf,*size);
#endif
    return ret;
}
static int __must_check ssv6xxx_sdio_write(struct device *child,
        void *buf, size_t len,u8 queue_num)
{
    int ret = (-1);
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    int writesize;
    void *tempPointer;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
#ifdef CONFIG_FW_ALIGNMENT_CHECK
#ifdef CONFIG_ARM64
        if (((u64)buf) & 3) {
#else
        if (((u32)buf) & 3) {
#endif
            memcpy(glue->dmaSkb->data,buf,len);
            tempPointer = glue->dmaSkb->data;
        }
        else
#endif
            tempPointer = buf;
#if 0
        if(len > 1500)
            _sdio_hexdump(buf,len);
#endif
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        writesize = sdio_align_size(func,len);
        do
        {
            ret = sdio_memcpy_toio(func, glue->dataIOPort, tempPointer, writesize);
            if ( ret == -EILSEQ || ret == -ETIMEDOUT )
            {
                ret = -1;
                break;
            }
            else
            {
                if(ret)
                    dev_err(glue->dev,"Unexpected return value ret=[%d]\n",ret);
            }
        }
        while( ret == -EILSEQ || ret == -ETIMEDOUT);
        sdio_release_host(func);
        if (ret)
            dev_err(glue->dev, "sdio write failed (%d)\n", ret);
    }
    return ret;
}
static void ssv6xxx_sdio_irq_handler(struct sdio_func *func)
{
    int status;
    struct ssv6xxx_sdio_glue *glue = sdio_get_drvdata(func);
    struct ssv6xxx_platform_data *pwlan_data = &wlan_data;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
        return;
    if ( glue != NULL && glue->irq_handler != NULL )
    {
        atomic_set(&pwlan_data->irq_handling, 1);
        sdio_release_host(func);
        if ( glue->irq_handler != NULL )
            status = glue->irq_handler(0,glue->irq_dev);
        sdio_claim_host(func);
        atomic_set(&pwlan_data->irq_handling, 0);
    }
}
static void ssv6xxx_sdio_irq_setmask(struct device *child,int mask)
{
    int err_ret;
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        sdio_writeb(func,mask, REG_INT_MASK, &err_ret);
        sdio_release_host(func);
    }
}
static void ssv6xxx_sdio_irq_trigger(struct device *child)
{
    int err_ret;
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        sdio_writeb(func,0x2, REG_INT_TRIGGER, &err_ret);
        sdio_release_host(func);
    }
}
static int ssv6xxx_sdio_irq_getmask(struct device *child, u32 *mask)
{
    u8 imask = 0;
    int ret = (-1);
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        imask = sdio_readb(func,REG_INT_MASK, &ret);
        *mask = imask;
        sdio_release_host(func);
    }
    return ret;
}
static void ssv6xxx_sdio_irq_enable(struct device *child)
{
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    int ret;
    struct ssv6xxx_platform_data *pwlan_data = &wlan_data;
    if ( (pwlan_data->is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        ret = sdio_claim_irq(func, ssv6xxx_sdio_irq_handler);
        if (ret)
            dev_err(child->parent, "Failed to claim sdio irq: %d\n", ret);
        sdio_release_host(func);
    }
    
    printk("ssv6xxx_sdio_irq_enable\n");
}
static void ssv6xxx_sdio_irq_disable(struct device *child,bool iswaitirq)
{
    struct ssv6xxx_sdio_glue *glue = NULL;
    struct sdio_func *func;
    struct ssv6xxx_platform_data *pwlan_data = &wlan_data;
    int ret;
    printk("ssv6xxx_sdio_irq_disable\n");
    if ( (wlan_data.is_enabled == false)
        || (child->parent == NULL))
  return;
    glue = dev_get_drvdata(child->parent);
    if ( (glue == NULL)
        || (glue->dev_ready == false)
        || (glue->dev == NULL))
        return;
    {
        func = dev_to_sdio_func(glue->dev);
        if(func == NULL){
            printk("func == NULL\n");
            return;
        }
        sdio_claim_host(func);
        while(atomic_read(&pwlan_data->irq_handling)){
            sdio_release_host(func);
      schedule_timeout(HZ / 10);
      sdio_claim_host(func);
        }
        ret = sdio_release_irq(func);
        if (ret)
            dev_err(child->parent, "Failed to release sdio irq: %d\n", ret);
        sdio_release_host(func);
    }
}
static void ssv6xxx_sdio_irq_request(struct device *child,irq_handler_t irq_handler,void *irq_dev)
{
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    bool isIrqEn = false;
    if ( (wlan_data.is_enabled == false)
        || (glue == NULL)
        || (glue->dev_ready == false))
  return;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        glue->irq_handler = irq_handler;
        glue->irq_dev = irq_dev;
        if (isIrqEn )
        {
            ssv6xxx_sdio_irq_enable(child);
        }
    }
}
static void ssv6xxx_sdio_read_parameter(struct sdio_func *func,
        struct ssv6xxx_sdio_glue *glue)
{
    int err_ret;
    sdio_claim_host(func);
    glue->dataIOPort = 0;
    glue->dataIOPort = glue->dataIOPort | (sdio_readb(func, REG_DATA_IO_PORT_0, &err_ret) << ( 8*0 ));
    glue->dataIOPort = glue->dataIOPort | (sdio_readb(func, REG_DATA_IO_PORT_1, &err_ret) << ( 8*1 ));
    glue->dataIOPort = glue->dataIOPort | (sdio_readb(func, REG_DATA_IO_PORT_2, &err_ret) << ( 8*2 ));
    glue->regIOPort = 0;
    glue->regIOPort = glue->regIOPort | (sdio_readb(func, REG_REG_IO_PORT_0, &err_ret) << ( 8*0 ));
    glue->regIOPort = glue->regIOPort | (sdio_readb(func, REG_REG_IO_PORT_1, &err_ret) << ( 8*1 ));
    glue->regIOPort = glue->regIOPort | (sdio_readb(func, REG_REG_IO_PORT_2, &err_ret) << ( 8*2 ));
    dev_err(&func->dev, "dataIOPort 0x%x regIOPort 0x%x\n",glue->dataIOPort,glue->regIOPort);
#ifdef CONFIG_PLATFORM_SDIO_BLOCK_SIZE
    err_ret = sdio_set_block_size(func,CONFIG_PLATFORM_SDIO_BLOCK_SIZE);
#else
    err_ret = sdio_set_block_size(func,SDIO_DEF_BLOCK_SIZE);
#endif
    if (err_ret != 0) {
        printk("SDIO setting SDIO_DEF_BLOCK_SIZE fail!!\n");
    }
#ifdef CONFIG_PLATFORM_SDIO_OUTPUT_TIMING
    sdio_writeb(func, CONFIG_PLATFORM_SDIO_OUTPUT_TIMING,REG_OUTPUT_TIMING_REG, &err_ret);
#else
    sdio_writeb(func, SDIO_DEF_OUTPUT_TIMING,REG_OUTPUT_TIMING_REG, &err_ret);
#endif
    sdio_writeb(func, 0x00,REG_Fn1_STATUS, &err_ret);
#if 0
    sdio_writeb(func,SDIO_TX_ALLOC_SIZE_SHIFT|SDIO_TX_ALLOC_ENABLE,REG_SDIO_TX_ALLOC_SHIFT, &err_ret);
#endif
    sdio_release_host(func);
}
static void ssv6xxx_do_sdio_wakeup(struct sdio_func *func)
{
 int err_ret;
 if(func != NULL)
 {
  sdio_claim_host(func);
  sdio_writeb(func, 0x01, REG_PMU_WAKEUP, &err_ret);
  mdelay(10);
  sdio_writeb(func, 0x00, REG_PMU_WAKEUP, &err_ret);
  sdio_release_host(func);
 }
}
static void ssv6xxx_sdio_pmu_wakeup(struct device *child)
{
 struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
 struct sdio_func *func;
 if (glue != NULL) {
  func = dev_to_sdio_func(glue->dev);
  ssv6xxx_do_sdio_wakeup(func);
 }
}
static bool ssv6xxx_sdio_support_scatter(struct device *child)
{
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    bool support = false;
    do{
        if(!glue){
            dev_err(child->parent, "ssv6xxx_sdio_enable_scatter glue == NULL!!!\n");
            break;
        }
        func = dev_to_sdio_func(glue->dev);
#if LINUX_VERSION_CODE > KERNEL_VERSION(3,0,0)
        if (func->card->host->max_segs < MAX_SCATTER_ENTRIES_PER_REQ) {
            dev_err(child->parent, "host controller only supports scatter of :%d entries, driver need: %d\n",
   func->card->host->max_segs,
   MAX_SCATTER_ENTRIES_PER_REQ);
            break;
     }
        support = true;
#endif
    }while(0);
    return support;
}
static void ssv6xxx_sdio_setup_scat_data(struct sdio_scatter_req *scat_req,
     struct mmc_data *data)
{
 struct scatterlist *sg;
 int i;
 data->blksz = SDIO_DEF_BLOCK_SIZE;
 data->blocks = scat_req->len / SDIO_DEF_BLOCK_SIZE;
 printk("scatter: (%s)  (block len: %d, block count: %d) , (tot:%d,sg:%d)\n",
     (scat_req->req & SDIO_WRITE) ? "WR" : "RD",
     data->blksz, data->blocks, scat_req->len,
     scat_req->scat_entries);
 data->flags = (scat_req->req & SDIO_WRITE) ? MMC_DATA_WRITE :
          MMC_DATA_READ;
 sg = scat_req->sgentries;
 sg_init_table(sg, scat_req->scat_entries);
 for (i = 0; i < scat_req->scat_entries; i++, sg++) {
  printk("%d: addr:0x%p, len:%d\n",
      i, scat_req->scat_list[i].buf,
      scat_req->scat_list[i].len);
  sg_set_buf(sg, scat_req->scat_list[i].buf,
      scat_req->scat_list[i].len);
 }
 data->sg = scat_req->sgentries;
 data->sg_len = scat_req->scat_entries;
}
static inline void ssv6xxx_sdio_set_cmd53_arg(u32 *arg, u8 rw, u8 func,
          u8 mode, u8 opcode, u32 addr,
          u16 blksz)
{
 *arg = (((rw & 1) << 31) |
  ((func & 0x7) << 28) |
  ((mode & 1) << 27) |
  ((opcode & 1) << 26) |
  ((addr & 0x1FFFF) << 9) |
  (blksz & 0x1FF));
}
static int ssv6xxx_sdio_rw_scatter(struct device *child,
          struct sdio_scatter_req *scat_req)
{
    struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
 struct mmc_request mmc_req;
 struct mmc_command cmd;
 struct mmc_data data;
 u8 opcode, rw;
 int status = 1;
    do{
        if(!glue){
            dev_err(child->parent, "ssv6xxx_sdio_enable_scatter glue == NULL!!!\n");
            break;
        }
        func = dev_to_sdio_func(glue->dev);
     memset(&mmc_req, 0, sizeof(struct mmc_request));
     memset(&cmd, 0, sizeof(struct mmc_command));
     memset(&data, 0, sizeof(struct mmc_data));
     ssv6xxx_sdio_setup_scat_data(scat_req, &data);
     opcode = 0;
     rw = (scat_req->req & SDIO_WRITE) ? CMD53_ARG_WRITE : CMD53_ARG_READ;
     ssv6xxx_sdio_set_cmd53_arg(&cmd.arg, rw, func->num,
          CMD53_ARG_BLOCK_BASIS, opcode, glue->dataIOPort,
          data.blocks);
     cmd.opcode = SD_IO_RW_EXTENDED;
     cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
     mmc_req.cmd = &cmd;
     mmc_req.data = &data;
     mmc_set_data_timeout(&data, func->card);
     mmc_wait_for_req(func->card->host, &mmc_req);
     status = cmd.error ? cmd.error : data.error;
        if (cmd.error)
      return cmd.error;
     if (data.error)
      return data.error;
    }while(0);
 return status;
}
static void ssv6xxx_set_sdio_clk(struct sdio_func *func,u32 sdio_hz)
{
 struct mmc_host *host;
 host = func->card->host;
 if(sdio_hz < host->f_min )
  sdio_hz = host->f_min;
 else if(sdio_hz > host->f_max)
  sdio_hz = host->f_max;
 printk("%s:set sdio clk %dHz\n", __FUNCTION__,sdio_hz);
    sdio_claim_host(func);
    host->ios.clock = sdio_hz;
    host->ops->set_ios(host, &host->ios);
    mdelay(20);
    sdio_release_host(func);
}
static void ssv6xxx_low_sdio_clk(struct sdio_func *func)
{
 ssv6xxx_set_sdio_clk(func,LOW_SPEED_SDIO_CLOCK);
}
static void ssv6xxx_high_sdio_clk(struct sdio_func *func)
{
#ifndef SDIO_USE_SLOW_CLOCK
 ssv6xxx_set_sdio_clk(func,HIGH_SPEED_SDIO_CLOCK);
#endif
}
static struct ssv6xxx_hwif_ops sdio_ops =
{
    .read = ssv6xxx_sdio_read,
    .write = ssv6xxx_sdio_write,
    .readreg = ssv6xxx_sdio_read_reg,
    .writereg = ssv6xxx_sdio_write_reg,
#ifdef ENABLE_WAKE_IO_ISR_WHEN_HCI_ENQUEUE
    .trigger_tx_rx = ssv6xxx_sdio_trigger_tx_rx,
#endif
    .irq_getmask = ssv6xxx_sdio_irq_getmask,
    .irq_setmask = ssv6xxx_sdio_irq_setmask,
    .irq_enable = ssv6xxx_sdio_irq_enable,
    .irq_disable = ssv6xxx_sdio_irq_disable,
    .irq_getstatus = ssv6xxx_sdio_irq_getstatus,
    .irq_request = ssv6xxx_sdio_irq_request,
    .irq_trigger = ssv6xxx_sdio_irq_trigger,
    .pmu_wakeup = ssv6xxx_sdio_pmu_wakeup,
    .load_fw = ssv6xxx_sdio_load_firmware,
    .cmd52_read = ssv6xxx_sdio_cmd52_read,
    .cmd52_write = ssv6xxx_sdio_cmd52_write,
    .support_scatter = ssv6xxx_sdio_support_scatter,
    .rw_scatter = ssv6xxx_sdio_rw_scatter,
    .is_ready = ssv6xxx_is_ready,
    .write_sram = ssv6xxx_sdio_write_sram,
    .interface_reset = ssv6xxx_sdio_reset,
};
#ifdef CONFIG_PCIEASPM
#include <linux/pci.h>
#include <linux/pci-aspm.h>
static int cabrio_sdio_pm_check(struct sdio_func *func)
{
 struct pci_dev *pci_dev = NULL;
 struct mmc_card *card = func->card;
 struct mmc_host *host = card->host;
 if (strcmp(host->parent->bus->name, "pci"))
 {
  dev_info(&func->dev, "SDIO host is not PCI device, but \"%s\".", host->parent->bus->name);
  return 0;
 }
 for_each_pci_dev(pci_dev) {
  if ( ((pci_dev->class >> 8) != PCI_CLASS_SYSTEM_SDHCI)
   && ( (pci_dev->driver == NULL)
    || (strcmp(pci_dev->driver->name, "sdhci-pci") != 0)))
   continue;
  if (pci_is_pcie(pci_dev)) {
   u8 aspm;
   int pos;
   pos = pci_pcie_cap(pci_dev);
         if (pos) {
             struct pci_dev *parent = pci_dev->bus->self;
             pci_read_config_byte(pci_dev, pos + PCI_EXP_LNKCTL, &aspm);
             aspm &= ~(PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
             pci_write_config_byte(pci_dev, pos + PCI_EXP_LNKCTL, aspm);
             pos = pci_pcie_cap(parent);
             pci_read_config_byte(parent, pos + PCI_EXP_LNKCTL, &aspm);
             aspm &= ~(PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1);
             pci_write_config_byte(parent, pos + PCI_EXP_LNKCTL, aspm);
             dev_info(&pci_dev->dev, "Clear PCI-E device and its parent link state L0S and L1 and CLKPM.\n");
         }
  }
 }
 return 0;
}
#endif
static int ssv6xxx_sdio_power_on(struct ssv6xxx_platform_data * pdata, struct sdio_func *func)
{
 int ret = 0;
 if (pdata->is_enabled == true)
  return 0;
    printk("ssv6xxx_sdio_power_on\n");
 sdio_claim_host(func);
 ret = sdio_enable_func(func);
 sdio_release_host(func);
 if (ret) {
  printk("Unable to enable sdio func: %d)\n", ret);
  return ret;
 }
 msleep(10);
 pdata->is_enabled = true;
 return ret;
}
static int ssv6xxx_sdio_power_off(struct ssv6xxx_platform_data * pdata, struct sdio_func *func)
{
 int ret;
 if (pdata->is_enabled == false)
  return 0;
    printk("ssv6xxx_sdio_power_off\n");
 sdio_claim_host(func);
 ret = sdio_disable_func(func);
 sdio_release_host(func);
 if (ret)
  return ret;
 pdata->is_enabled = false;
 return ret;
}
int ssv6xxx_get_dev_status(void)
{
 return ssv6xxx_sdio_status;
}
EXPORT_SYMBOL(ssv6xxx_get_dev_status);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
static int __devinit ssv6xxx_sdio_probe(struct sdio_func *func,
        const struct sdio_device_id *id)
#else
static int ssv6xxx_sdio_probe(struct sdio_func *func,
        const struct sdio_device_id *id)
#endif
{
    struct ssv6xxx_platform_data *pwlan_data = &wlan_data;
    struct ssv6xxx_sdio_glue *glue;
    int ret = -ENOMEM;
    const char *chip_family = "ssv6200";
    if (ssv_devicetype != 0) {
        printk(KERN_INFO "Not using SSV6200 normal SDIO driver.\n");
        return -ENODEV;
    }
    printk(KERN_INFO "=======================================\n");
    printk(KERN_INFO "==           RUN SDIO                ==\n");
    printk(KERN_INFO "=======================================\n");
    if (func->num != 0x01)
        return -ENODEV;
    glue = kzalloc(sizeof(*glue), GFP_KERNEL);
    if (!glue)
    {
        dev_err(&func->dev, "can't allocate glue\n");
        goto out;
    }
    ssv6xxx_sdio_status = 1;
 ssv6xxx_low_sdio_clk(func);
#ifdef CONFIG_FW_ALIGNMENT_CHECK
    glue->dmaSkb=__dev_alloc_skb(SDIO_DMA_BUFFER_LEN , GFP_KERNEL);
#endif
#ifdef CONFIG_PM
    glue->cmd_skb=__dev_alloc_skb(SDIO_COMMAND_BUFFER_LEN , GFP_KERNEL);
#endif
    memset(pwlan_data, 0, sizeof(struct ssv6xxx_platform_data));
    atomic_set(&pwlan_data->irq_handling, 0);
    glue->dev = &func->dev;
    func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
    func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
    glue->dev_ready = true;
    pwlan_data->vendor = func->vendor;
    pwlan_data->device = func->device;
    dev_err(glue->dev, "vendor = 0x%x device = 0x%x\n", pwlan_data->vendor,pwlan_data->device);
    #ifdef CONFIG_PCIEASPM
    cabrio_sdio_pm_check(func);
    #endif
    pwlan_data->ops = &sdio_ops;
    sdio_set_drvdata(func, glue);
#ifdef CONFIG_PM
        ssv6xxx_do_sdio_wakeup(func);
#endif
    ssv6xxx_sdio_power_on(pwlan_data, func);
    ssv6xxx_sdio_read_parameter(func,glue);
    glue->core = platform_device_alloc(chip_family, -1);
    if (!glue->core)
    {
        dev_err(glue->dev, "can't allocate platform_device");
        ret = -ENOMEM;
        goto out_free_glue;
    }
    glue->core->dev.parent = &func->dev;
    ret = platform_device_add_data(glue->core, pwlan_data,
                                   sizeof(*pwlan_data));
    if (ret)
    {
        dev_err(glue->dev, "can't add platform data\n");
        goto out_dev_put;
    }
    ret = platform_device_add(glue->core);
    if (ret)
    {
        dev_err(glue->dev, "can't add platform device\n");
        goto out_dev_put;
    }
    ssv6xxx_sdio_irq_setmask(&glue->core->dev,0xff);
#if 0
    ssv6xxx_sdio_irq_enable(&glue->core->dev);
#else
#endif
#if 0
    glue->dev->platform_data = (void *)pwlan_data;
    ret = ssv6xxx_dev_probe(glue->dev);
    if (ret)
    {
        dev_err(glue->dev, "failed to initial ssv6xxx device !!\n");
        platform_device_del(glue->core);
        goto out_dev_put;
    }
#endif
    ssv6xxx_ifdebug_info[0] = (void *)&glue->core->dev;
    ssv6xxx_ifdebug_info[1] = (void *)glue->core;
    ssv6xxx_ifdebug_info[2] = (void *)&sdio_ops;
    return 0;
out_dev_put:
    platform_device_put(glue->core);
out_free_glue:
    kfree(glue);
out:
    return ret;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
static void __devexit ssv6xxx_sdio_remove(struct sdio_func *func)
#else
static void ssv6xxx_sdio_remove(struct sdio_func *func)
#endif
{
    struct ssv6xxx_sdio_glue *glue = sdio_get_drvdata(func);
    struct ssv6xxx_platform_data *pwlan_data = &wlan_data;
    printk("ssv6xxx_sdio_remove..........\n");
    ssv6xxx_sdio_status = 0;
    if ( glue )
    {
        printk("ssv6xxx_sdio_remove - ssv6xxx_sdio_irq_disable\n");
        ssv6xxx_sdio_irq_disable(&glue->core->dev,false);
        glue->dev_ready = false;
#if 0
        ssv6xxx_dev_remove(glue->dev);
#endif
        ssv6xxx_low_sdio_clk(func);
#ifdef CONFIG_FW_ALIGNMENT_CHECK
  if(glue->dmaSkb != NULL)
         dev_kfree_skb(glue->dmaSkb);
#endif
        printk("ssv6xxx_sdio_remove - disable mask\n");
        ssv6xxx_sdio_irq_setmask(&glue->core->dev,0xff);
#ifdef CONFIG_PM
        ssv6xxx_sdio_trigger_pmu(glue->dev);
        if(glue->cmd_skb != NULL)
            dev_kfree_skb(glue->cmd_skb);
#endif
        ssv6xxx_sdio_power_off(pwlan_data, func);
        printk("platform_device_del \n");
        platform_device_del(glue->core);
        printk("platform_device_put \n");
        platform_device_put(glue->core);
        kfree(glue);
    }
    sdio_set_drvdata(func, NULL);
    printk("ssv6xxx_sdio_remove leave..........\n");
}
#ifdef CONFIG_PM
static int ssv6xxx_sdio_trigger_pmu(struct device *dev)
{
    struct sdio_func *func = dev_to_sdio_func(dev);
    struct ssv6xxx_sdio_glue *glue = sdio_get_drvdata(func);
    struct cfg_host_cmd *host_cmd;
    int writesize;
    int ret = 0;
    void *tempPointer;
#ifdef SSV_WAKEUP_HOST
    if(ssv6xxx_sdio_write_reg(dev, ADR_RX_FLOW_MNG, M_ENG_MACRX|(M_ENG_CPU<<4)|(M_ENG_HWHCI<<8)));
    if(ssv6xxx_sdio_write_reg(dev, ADR_RX_FLOW_DATA, M_ENG_MACRX|(M_ENG_CPU<<4)|(M_ENG_HWHCI<<8)));
    if(ssv6xxx_sdio_write_reg(dev, ADR_MRX_FLT_TB0+6*4, (sc->mac_deci_tbl[6]|1)));
#else
    if(ssv6xxx_sdio_write_reg(dev, ADR_RX_FLOW_MNG, M_ENG_MACRX|(M_ENG_TRASH_CAN<<4)));
    if(ssv6xxx_sdio_write_reg(dev, ADR_RX_FLOW_DATA, M_ENG_MACRX|(M_ENG_TRASH_CAN<<4)));
    if(ssv6xxx_sdio_write_reg(dev, ADR_RX_FLOW_CTRL, M_ENG_MACRX|(M_ENG_TRASH_CAN<<4)));
#endif
    host_cmd = (struct cfg_host_cmd *)glue->cmd_skb->data;
    host_cmd->c_type = HOST_CMD;
    host_cmd->RSVD0 = 0;
    host_cmd->h_cmd = (u8)SSV6XXX_HOST_CMD_PS;
    host_cmd->len = sizeof(struct cfg_host_cmd);
#ifdef SSV_WAKEUP_HOST
    host_cmd->dummy = sc->ps_aid;
#else
 host_cmd->dummy = 0;
#endif
    {
        tempPointer = glue->cmd_skb->data;
        sdio_claim_host(func);
        writesize = sdio_align_size(func,sizeof(struct cfg_host_cmd));
        do
        {
            ret = sdio_memcpy_toio(func, glue->dataIOPort, tempPointer, writesize);
            if ( ret == -EILSEQ || ret == -ETIMEDOUT )
            {
                ret = -1;
                break;
            }
            else
            {
                if(ret)
                    dev_err(glue->dev,"Unexpected return value ret=[%d]\n",ret);
            }
        }
        while( ret == -EILSEQ || ret == -ETIMEDOUT);
        sdio_release_host(func);
        if (ret)
            dev_err(glue->dev, "sdio write failed (%d)\n", ret);
    }
    return ret;
}
static void ssv6xxx_sdio_reset(struct device *child)
{
 struct ssv6xxx_sdio_glue *glue = dev_get_drvdata(child->parent);
 struct sdio_func *func = dev_to_sdio_func(glue->dev);
 printk("%s\n", __FUNCTION__);
 if(glue == NULL || glue->dev == NULL || func == NULL)
  return;
    ssv6xxx_sdio_trigger_pmu(glue->dev);
 ssv6xxx_do_sdio_wakeup( func);
}
#ifdef AML_WIFI_MAC
extern void sdio_reinit(void);
extern void extern_wifi_set_enable(int is_on);
#endif
static int ssv6xxx_sdio_suspend(struct device *dev)
{
    struct sdio_func *func = dev_to_sdio_func(dev);
     mmc_pm_flag_t flags = sdio_get_host_pm_caps(func);
#ifdef AML_WIFI_MAC
    if (!(flags & MMC_PM_KEEP_POWER) || sdio_sr_bhvr == SUSPEND_RESUME_1) {
        printk("%s : module will not get power support during suspend. %u\n", __func__, sdio_sr_bhvr);
        ssv6xxx_deinit_prepare();
        ssv6xxx_sdio_remove(func);
        mdelay(100);
        extern_wifi_set_enable(0);
        mdelay(10);
        return 0;
    }else
#endif
    {
        int ret = 0;
        dev_info(dev, "%s: suspend: PM flags = 0x%x\n",
                 sdio_func_id(func), flags);
     ssv6xxx_low_sdio_clk(func);
        ret = ssv6xxx_sdio_trigger_pmu(dev);
        if (ret)
            printk("ssv6xxx_sdio_trigger_pmu fail!!\n");
        if (!(flags & MMC_PM_KEEP_POWER))
        {
         dev_err(dev, "%s: cannot remain alive while host is suspended\n",
                    sdio_func_id(func));
        }
        ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
        if (ret)
         return ret;
        mdelay(10);
#ifdef SSV_WAKEUP_HOST
        ret = sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ);
#endif
#if 0
        if (softc->wow_enabled)
        {
            sdio_flags = sdio_get_host_pm_caps(func);
            if (!(sdio_flags & MMC_PM_KEEP_POWER))
            {
                dev_err(dev, "can't keep power while host "
                        "is suspended\n");
                ret = -EINVAL;
                goto out;
            }
            ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
            if (ret)
            {
                dev_err(dev, "error while trying to keep power\n");
                goto out;
            }
        }else{
            ssv6xxx_sdio_irq_disable(&glue->core->dev,true);
        }
#endif
        return ret;
    }
}
static int ssv6xxx_sdio_resume(struct device *dev)
{
 struct sdio_func *func = dev_to_sdio_func(dev);
#ifdef AML_WIFI_MAC
    mmc_pm_flag_t flags = sdio_get_host_pm_caps(func);
	mdelay(100);
    if (!(flags & MMC_PM_KEEP_POWER) || sdio_sr_bhvr == SUSPEND_RESUME_1) {
        printk("%s : module is reset, run probe now !! %u\n", __func__, sdio_sr_bhvr);
        extern_wifi_set_enable(1);
        mdelay(100);
        sdio_reinit();
        mdelay(150);
        ssv6xxx_sdio_probe(func, NULL);
        return 0;
    }else
#endif
 {
     printk("ssv6xxx_sdio_resume\n");
     {
      ssv6xxx_do_sdio_wakeup(func);
            mdelay(10);
      ssv6xxx_high_sdio_clk(func);
            mdelay(10);
     }
    }
    return 0;
}
static const struct dev_pm_ops ssv6xxx_sdio_pm_ops =
{
    .suspend = ssv6xxx_sdio_suspend,
    .resume = ssv6xxx_sdio_resume,
};
#endif


#ifdef AML_WIFI_MAC
static void ssv6xxx_sdio_shutdown(struct device *dev)
{
	struct sdio_func *func = dev_to_sdio_func(dev);
	printk("%s  shutdown_flags:%d \n", __func__,shutdown_flags);
	switch(shutdown_flags){
		case SSV_SYS_REBOOT :
		case SSV_SYS_HALF:
				printk("%s ,system reboot  ..\n", __func__);
				break;
		case SSV_SYS_POWER_OFF :
				printk("%s ,system shutdown .. \n", __func__);
				ssv6xxx_deinit_prepare();
				ssv6xxx_sdio_remove(func);
				mdelay(100);
				extern_wifi_set_enable(0);
				mdelay(100);
				break;
		default:
			printk("%s,unknown event code ..", __func__);
	}

}

static int ssv6xxx_reboot_notify(struct notifier_block *nb,
			       unsigned long event, void *p)
{

	printk("%s, code = %ld \n",__FUNCTION__,event);
	switch (event){
		case SYS_DOWN:
			shutdown_flags = SYS_DOWN;
			break;
		case SYS_HALT:
			shutdown_flags = SYS_HALT;
			break;
		case SYS_POWER_OFF:
			shutdown_flags = SYS_POWER_OFF;
			break;
		default:
			shutdown_flags = event;
			break;
	}
	return NOTIFY_DONE;
}
static struct notifier_block ssv6xxx_reboot_notifier = {
	.notifier_call = ssv6xxx_reboot_notify,
	.next = NULL,
	.priority = 0,
};
#endif

struct sdio_driver ssv6xxx_sdio_driver =
{
    .name = "SSV6XXX_SDIO",
    .id_table = ssv6xxx_sdio_devices,
    .probe = ssv6xxx_sdio_probe,
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
    .remove = __devexit_p(ssv6xxx_sdio_remove),
#else
    .remove = ssv6xxx_sdio_remove,
#endif
#ifdef CONFIG_PM
    .drv = {
        .pm = &ssv6xxx_sdio_pm_ops, 
#ifdef AML_WIFI_MAC
	.shutdown = ssv6xxx_sdio_shutdown,
#endif
    },
#endif
};
EXPORT_SYMBOL(ssv6xxx_sdio_driver);
#if (defined(CONFIG_SSV_SUPPORT_ANDROID)||defined(CONFIG_SSV_BUILD_AS_ONE_KO))
int ssv6xxx_sdio_init(void)
#else
static int __init ssv6xxx_sdio_init(void)
#endif
{
    printk(KERN_INFO "ssv6xxx_sdio_init\n");
#ifdef AML_WIFI_MAC
	register_reboot_notifier(&ssv6xxx_reboot_notifier);
#endif
    return sdio_register_driver(&ssv6xxx_sdio_driver);
}
#if (defined(CONFIG_SSV_SUPPORT_ANDROID)||defined(CONFIG_SSV_BUILD_AS_ONE_KO))
void ssv6xxx_sdio_exit(void)
#else
static void __exit ssv6xxx_sdio_exit(void)
#endif
{
    printk(KERN_INFO "ssv6xxx_sdio_exit\n");
#ifdef AML_WIFI_MAC
	unregister_reboot_notifier(&ssv6xxx_reboot_notifier);
#endif 
    sdio_unregister_driver(&ssv6xxx_sdio_driver);
}
#if (defined(CONFIG_SSV_SUPPORT_ANDROID)||defined(CONFIG_SSV_BUILD_AS_ONE_KO))
EXPORT_SYMBOL(ssv6xxx_sdio_init);
EXPORT_SYMBOL(ssv6xxx_sdio_exit);
#else
module_init(ssv6xxx_sdio_init);
module_exit(ssv6xxx_sdio_exit);
#endif
MODULE_LICENSE("GPL");