ssv6xxx/bridge/sdiobridge.c

/*
 * 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 <linux/gpio.h>
#include <linux/pm_runtime.h>
#include <linux/printk.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/version.h>
#include <hwif/sdio/sdio_def.h>
#include "sdiobridge.h"
#include "debug.h"
#define BLOCKSIZE 0x40
#define RXBUFLENGTH 1024*3
#define RXBUFSIZE 512
enum ssvcabrio_int
{
    SSVCABRIO_INT_RX = 0x00000001,
    SSVCABRIO_INT_TX = 0x00000002,
    SSVCABRIO_INT_GPIO = 0x00000004,
    SSVCABRIO_INT_SYS = 0x00000008,
};
#define CHECK_RET(_fun) \
 do { \
  if (0 != _fun) \
   printk("File = %s\nLine = %d\nFunc=%s\nDate=%s\nTime=%s\n", __FILE__, __LINE__, __FUNCTION__, __DATE__, __TIME__); \
 } while (0)
static unsigned int ssv_sdiobridge_ioctl_major = 0;
static unsigned int num_of_dev = 1;
static struct cdev ssv_sdiobridge_ioctl_cdev;
static struct class *fc;
static struct ssv_sdiobridge_glue *glue;
struct ssv_rxbuf
{
    struct list_head list;
    u32 rxsize;
    u8 rxdata[RXBUFLENGTH];
};
static const struct sdio_device_id ssv_sdiobridge_devices[] =
{
    {SDIO_DEVICE(MANUFACTURER_SSV_CODE, (MANUFACTURER_ID_CABRIO_BASE | 0x0))},
    {}
};
MODULE_DEVICE_TABLE(sdio, ssv_sdiobridge_devices);
static long ssv_sdiobridge_ioctl_getFuncfocus(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->out_data_len < 1)
    {
        retval = -1;
    }
    else
    {
        u8 out_data = glue->funcFocus;
        if ( isCompat )
        {
            CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),&out_data,sizeof(out_data)));
        }
        else
        {
            CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data, &out_data, sizeof(out_data)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_setFuncfocus(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    int retval =0;
    if ( pcmd_data->out_data_len < 0)
    {
        retval = -EFAULT;
        dev_err(glue->dev, "%s : input length must < 0",__FUNCTION__);
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(&glue->funcFocus,(int __user *)compat_ptr((unsigned long)pcmd_data->in_data),sizeof(glue->funcFocus)));
        }
        else
        {
            CHECK_RET(copy_from_user(&glue->funcFocus,(int __user *)pcmd_data->in_data,sizeof(glue->funcFocus)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_getBusWidth(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    if ( pcmd_data->out_data_len < 1)
    {
        retval = -1;
    }
    else
    {
        u8 out_data = 1;
        if ( func->card->host->ios.bus_width != MMC_BUS_WIDTH_1 )
        {
            out_data = 4;
        }
        if ( isCompat )
        {
            CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),&out_data,sizeof(out_data)));
        }
        else
        {
            CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,&out_data,sizeof(out_data)));
        }
    }
    return retval;
}
#if 0
static long ssv_sdiobridge_ioctl_setBusWidth(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    int retval =0;
    struct ssv_sdiobridge_cmd *pData;
    u8 inData[1];
    copy_from_user(pData,(int __user *)arg,sizeof(*pData));
    if ( isCompat )
    {
        copy_from_user(&cmd_data,(int __user *)compat_ptr((unsigned long)pucmd_data),sizeof(*pucmd_data));
    }
    else
    {
        copy_from_user(&cmd_data,(int __user *)pucmd_data,sizeof(*pucmd_data));
    }
    if ( pData->in_data_len < 0)
    {
        retval = -EFAULT;
        dev_err(glue->dev, "%s : input length must > 1",__FUNCTION__);
    }
    else
    {
        if ( pData->in_data == 1 )
        {
            if ( (func->card->host->caps & MMC_CAP_4_BIT_DATA) && !(func->card->cccr.low_speed && !func->card->cccr.wide_bus) )
            {
                extern void mmc_set_bus_width(struct mmc_host *host, unsigned int width);
                u8 ctrl = sdio_f0_readb(func,SDIO_CCCR_IF,&retval);
                if (retval)
                    return retval;
                if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
                    return 0;
                ctrl &= ~SDIO_BUS_WIDTH_4BIT;
                ctrl |= SDIO_BUS_ASYNC_INT;
                sdio_f0_writeb(func,ctrl,SDIO_CCCR_IF,&retval);
                if (retval)
                    return retval;
                mmc_set_bus_width(func->card->host, MMC_BUS_WIDTH_1);
            }
        }
        else
        {
            if ( func->card->host->ios.bus_width != MMC_BUS_WIDTH_4 )
            {
            }
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_getBlockMode(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->out_data_len < 1)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),&out_data,sizeof(out_data));
        }
        else
        {
            copy_to_user((int __user *)pucmd_data->out_data,&out_data,sizeof(out_data));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_setBlockMode(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->in_data_len < 1)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            copy_from_user(&glue->blockMode,(int __user *)pucmd_data->in_data,sizeof(glue->blockMode));
        }
    }
    return retval;
}
#endif
static long ssv_sdiobridge_ioctl_getBlockSize(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->out_data_len < 2)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),&glue->blockSize,sizeof(glue->blockSize)));
        }
        else
        {
            CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,&glue->blockSize,sizeof(glue->blockSize)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_setBlockSize(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    if ( pcmd_data->in_data_len < 2)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(&glue->blockSize,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(glue->blockSize)));
        }
        else
        {
            CHECK_RET(copy_from_user(&glue->blockSize,(int __user *)pucmd_data->in_data,sizeof(glue->blockSize)));
        }
        dev_err(glue->dev,"%s: blockSize [%d]\n",__FUNCTION__,glue->blockSize);
        sdio_claim_host(func);
        sdio_set_block_size(func,glue->blockSize);
        sdio_release_host(func);
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_readByte(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    if ( pcmd_data->out_data_len < 4)
    {
        retval = -1;
    }
    else
    {
        u32 address;
        u8 out_data;
        int ret = 0;
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(&address,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(address)));
        }
        else
        {
            CHECK_RET(copy_from_user(&address,(int __user *)pucmd_data->in_data,sizeof(address)));
        }
        sdio_claim_host(func);
        if ( glue->funcFocus == 0 )
        {
            out_data = sdio_f0_readb(func, address, &ret);
        }
        else
        {
            out_data = sdio_readb(func, address, &ret);
        }
        sdio_release_host(func);
        dev_err(glue->dev,"%s: [%X] [%02X] ret:[%d]\n",__FUNCTION__,address,out_data,ret);
        if ( !ret )
        {
            if ( isCompat )
            {
                CHECK_RET(copy_to_user((void *)compat_ptr((unsigned long)pucmd_data->out_data),&out_data,sizeof(out_data)));
            }
            else
            {
                CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,&out_data,sizeof(out_data)));
            }
        }
        else
        {
            dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
            retval = -1;
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_writeByte(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    if ( pcmd_data->in_data_len < 5)
    {
        retval = -1;
    }
    else
    {
        u8 tmp[5];
        u32 address;
        u8 data;
        int ret = 0;
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(tmp,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(tmp)));
        }
        else
        {
            CHECK_RET(copy_from_user(tmp,(int __user *)pucmd_data->in_data,sizeof(tmp)));
        }
        address = *((u32 *)tmp);
        data = tmp[4];
        sdio_claim_host(func);
        if ( glue->funcFocus == 0 )
        {
            sdio_f0_writeb(func,data, address, &ret);
        }
        else
        {
            sdio_writeb(func,data, address, &ret);
        }
        sdio_release_host(func);
        if ( ret )
        {
            dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
            retval = -1;
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_getMultiByteIOPort(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->out_data_len < 4)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),&glue->dataIOPort,sizeof(glue->dataIOPort)));
        }
        else
        {
            CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,&glue->dataIOPort,sizeof(glue->dataIOPort)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_setMultiByteIOPort(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->in_data_len < 4)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(&glue->dataIOPort,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(glue->dataIOPort)));
        }
        else
        {
            CHECK_RET(copy_from_user(&glue->dataIOPort,(int __user *)pucmd_data->in_data,sizeof(glue->dataIOPort)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_readMultiByte(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    u8 *tmpdata;
    int ret;
    int readsize;
    tmpdata = kzalloc(pcmd_data->out_data_len, GFP_KERNEL);
    if ( tmpdata == NULL )
    {
        dev_err(glue->dev,"%s: error : alloc buf error size:%d",__FUNCTION__,pcmd_data->out_data_len);
        return -1;
    }
    readsize = sdio_align_size(func,pcmd_data->out_data_len);
    sdio_claim_host(func);
    ret = sdio_memcpy_fromio(func, tmpdata,glue->dataIOPort, readsize );
    sdio_release_host(func);
    if (unlikely(glue->dump))
    {
        printk(KERN_DEBUG "%s: READ data address[%08x] len[%d] readsize[%d]\n",__FUNCTION__,glue->dataIOPort,(int)pcmd_data->out_data_len,readsize);
        print_hex_dump(KERN_DEBUG, "ssv_sdio: READ ",
                       DUMP_PREFIX_OFFSET, 16, 1,
                       tmpdata, pcmd_data->out_data_len, false);
    }
    if ( !ret )
    {
        if ( isCompat )
        {
            CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),tmpdata,pcmd_data->out_data_len));
        }
        else
        {
            CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,tmpdata,pcmd_data->out_data_len));
        }
    }
    else
    {
        dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
        retval = -1;
    }
    kfree(tmpdata);
    dev_err(glue->dev,"%s(): %d\n", __FUNCTION__, ret);
    return retval;
}
static long ssv_sdiobridge_ioctl_writeMultiByte(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    u8 *tmpdata;
    int ret;
    int readsize ;
    tmpdata = kzalloc(pcmd_data->in_data_len, GFP_KERNEL);
    if ( tmpdata == NULL )
    {
        dev_err(glue->dev,"%s: error : alloc buf error size:%d",__FUNCTION__,pcmd_data->out_data_len);
        return -1;
    }
    if ( isCompat )
    {
        CHECK_RET(copy_from_user(tmpdata,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),pcmd_data->in_data_len));
    }
    else
    {
        CHECK_RET(copy_from_user(tmpdata,(int __user *)pucmd_data->in_data,pcmd_data->in_data_len));
    }
    readsize = sdio_align_size(func,pcmd_data->in_data_len);
    if (unlikely(glue->dump))
    {
        printk(KERN_DEBUG "%s: READ data address[%08x] len[%d] readsize[%d]\n",__FUNCTION__,glue->dataIOPort,(int)pcmd_data->in_data_len,readsize);
        print_hex_dump(KERN_DEBUG, "ssv_sdio: WRITE ",
                       DUMP_PREFIX_OFFSET, 16, 1,
                       tmpdata, pcmd_data->in_data_len, false);
    }
    sdio_claim_host(func);
    ret = sdio_memcpy_toio(func, glue->dataIOPort,tmpdata, readsize);
    sdio_release_host(func);
    if ( ret )
    {
        dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
        retval = -1;
    }
    kfree(tmpdata);
    return retval;
}
static long ssv_sdiobridge_ioctl_getMultiByteRegIOPort(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->out_data_len < 4)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),&glue->regIOPort,sizeof(glue->regIOPort)));
        }
        else
        {
            CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,&glue->regIOPort,sizeof(glue->regIOPort)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_setMultiByteRegIOPort(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    long retval =0;
    if ( pcmd_data->in_data_len < 4)
    {
        retval = -1;
    }
    else
    {
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(&glue->regIOPort,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(glue->regIOPort)));
        }
        else
        {
            CHECK_RET(copy_from_user(&glue->regIOPort,(int __user *)pucmd_data->in_data,sizeof(glue->regIOPort)));
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_readReg(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    if ( pcmd_data->in_data_len < 4 || pcmd_data->out_data_len < 4)
    {
        retval = -1;
    }
    else
    {
        u8 tmpdata[4];
        int ret = 0;
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(tmpdata,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(tmpdata)));
        }
        else
        {
            CHECK_RET(copy_from_user(tmpdata,(int __user *)pucmd_data->in_data,sizeof(tmpdata)));
        }
        sdio_claim_host(func);
        dev_err(glue->dev,"%s: read reg 1 [%02X][%02X][%02X][%02X]\n",__FUNCTION__,tmpdata[0],tmpdata[1],tmpdata[2],tmpdata[3]);
        ret = sdio_memcpy_toio(func, glue->regIOPort, tmpdata, 4);
        ret = sdio_memcpy_fromio(func, tmpdata, glue->regIOPort, 4);
        sdio_release_host(func);
        dev_err(glue->dev,"%s: read reg 2 [%02X][%02X][%02X][%02X] ret:%d\n",__FUNCTION__,tmpdata[0],tmpdata[1],tmpdata[2],tmpdata[3],ret);
        if ( !ret )
        {
            if ( isCompat )
            {
                CHECK_RET(copy_to_user((int __user *)compat_ptr((unsigned long)pucmd_data->out_data),tmpdata,sizeof(tmpdata)));
            }
            else
            {
                CHECK_RET(copy_to_user((int __user *)pucmd_data->out_data,tmpdata,sizeof(tmpdata)));
            }
        }
        else
        {
            dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
            retval = -1;
        }
    }
    return retval;
}
static long ssv_sdiobridge_ioctl_writeReg(struct ssv_sdiobridge_glue *glue,unsigned int cmd, struct ssv_sdiobridge_cmd *pcmd_data,struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    long retval =0;
    if ( pcmd_data->in_data_len < 8)
    {
        retval = -1;
    }
    else
    {
        u8 tmpdata[8];
        int ret = 0;
        if ( isCompat )
        {
            CHECK_RET(copy_from_user(tmpdata,(int __user *)compat_ptr((unsigned long)pucmd_data->in_data),sizeof(tmpdata)));
        }
        else
        {
            CHECK_RET(copy_from_user(tmpdata,(int __user *)pucmd_data->in_data,sizeof(tmpdata)));
        }
        dev_err(glue->dev,"%s: write reg ADR[%02X%02X%02X%02X] [%02X][%02X][%02X][%02X]\n",__FUNCTION__,tmpdata[3],tmpdata[2],tmpdata[1],tmpdata[0],
            tmpdata[7], tmpdata[6], tmpdata[5], tmpdata[4]);
        sdio_claim_host(func);
        ret = sdio_memcpy_toio(func, glue->regIOPort, tmpdata, 8);
        sdio_release_host(func);
        if ( ret )
        {
            dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
            retval = -1;
        }
    }
    return retval;
}
static int ssv_sdiobridge_device_open(struct inode *inode, struct file *filp)
{
    dev_err(glue->dev,"%s():\n", __FUNCTION__);
    filp->private_data = glue;
    return 0;
}
static int ssv_sdiobridge_device_close(struct inode *inode, struct file *filp)
{
    dev_err(glue->dev,"%s():\n", __FUNCTION__);
    return 0;
}
static long ssv_sdiobridge_device_ioctl_process(struct ssv_sdiobridge_glue *glue, unsigned int cmd, struct ssv_sdiobridge_cmd *pucmd_data,bool isCompat)
{
    struct ssv_sdiobridge_cmd cmd_data;
    long retval=0;
    if ( isCompat )
    {
        CHECK_RET(copy_from_user(&cmd_data,(int __user *)pucmd_data,sizeof(*pucmd_data)));
    }
    else
    {
        CHECK_RET(copy_from_user(&cmd_data,(int __user *)pucmd_data,sizeof(*pucmd_data)));
    }
#if 0
#ifdef __x86_64
    dev_err(glue->dev,"%s: isCompat[%d] [%lX] [%lX] [%X] \n",__FUNCTION__,isCompat,IOCTL_SSVSDIO_GET_FUNCTION_FOCUS,IOCTL_SSVSDIO_READ_DATA,cmd);
#else
    dev_err(glue->dev,"%s: isCompat[%d] [%X] [%X] [%X] \n",__FUNCTION__,isCompat,IOCTL_SSVSDIO_GET_FUNCTION_FOCUS,IOCTL_SSVSDIO_READ_DATA,cmd);
#endif
#endif
    switch (cmd)
    {
        case IOCTL_SSVSDIO_GET_FUNCTION_FOCUS:
            retval = ssv_sdiobridge_ioctl_getFuncfocus(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_SET_FUNCTION_FOCUS:
            retval = ssv_sdiobridge_ioctl_setFuncfocus(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_GET_BUS_WIDTH:
            retval = ssv_sdiobridge_ioctl_getBusWidth(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
#if 0
        case IOCTL_SSVSDIO_SET_BUS_WIDTH:
            retval = ssv_sdiobridge_ioctl_setBusWidth(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_GET_BUS_CLOCK:
            break;
        case IOCTL_SSVSDIO_SET_BUS_CLOCK:
            break;
        case IOCTL_SSVSDIO_GET_BLOCK_MODE:
            retval = ssv_sdiobridge_ioctl_getBlockMode(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_SET_BLOCK_MODE:
            retval = ssv_sdiobridge_ioctl_setBlockMode(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
#endif
        case IOCTL_SSVSDIO_GET_BLOCKLEN:
            retval = ssv_sdiobridge_ioctl_getBlockSize(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_SET_BLOCKLEN:
            retval = ssv_sdiobridge_ioctl_setBlockSize(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_READ_BYTE:
            retval = ssv_sdiobridge_ioctl_readByte(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_WRITE_BYTE:
            retval = ssv_sdiobridge_ioctl_writeByte(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_GET_MULTI_BYTE_IO_PORT:
            retval = ssv_sdiobridge_ioctl_getMultiByteIOPort(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_SET_MULTI_BYTE_IO_PORT:
            retval = ssv_sdiobridge_ioctl_setMultiByteIOPort(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_READ_MULTI_BYTE:
            retval = ssv_sdiobridge_ioctl_readMultiByte(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_WRITE_MULTI_BYTE:
            retval = ssv_sdiobridge_ioctl_writeMultiByte(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_GET_MULTI_BYTE_REG_IO_PORT:
            retval = ssv_sdiobridge_ioctl_getMultiByteRegIOPort(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_SET_MULTI_BYTE_REG_IO_PORT:
            retval = ssv_sdiobridge_ioctl_setMultiByteRegIOPort(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_READ_REG:
            retval = ssv_sdiobridge_ioctl_readReg(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
        case IOCTL_SSVSDIO_WRITE_REG:
            retval = ssv_sdiobridge_ioctl_writeReg(glue,cmd,&cmd_data,pucmd_data,isCompat);
            break;
    }
    return retval;
}
static long ssv_sdiobridge_device_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct ssv_sdiobridge_glue *glue =filp->private_data;
    long retval=0;
    struct ssv_sdiobridge_cmd *pucmd_data;
    pucmd_data = (struct ssv_sdiobridge_cmd *)arg;
    retval = ssv_sdiobridge_device_ioctl_process( glue,cmd,pucmd_data,true);
    return retval;
}
static long ssv_sdiobridge_device_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct ssv_sdiobridge_glue *glue =filp->private_data;
    long retval=0;
    struct ssv_sdiobridge_cmd *pucmd_data;
    pucmd_data = (struct ssv_sdiobridge_cmd *)arg;
    retval = ssv_sdiobridge_device_ioctl_process( glue,cmd,pucmd_data,false);
    return retval;
}
static bool ssv_sdiobridge_have_data(struct ssv_sdiobridge_glue *glue)
{
    dev_err(glue->dev,"%s(): !list_empty(&glue->rxreadybuf)[%d]\n", __FUNCTION__,!list_empty(&glue->rxreadybuf));
    return !list_empty(&glue->rxreadybuf);
}
static ssize_t ssv_sdiobridge_device_read(struct file *filp,
        char *buffer,
        size_t length,
        loff_t *offset)
{
    struct ssv_sdiobridge_glue *glue =filp->private_data;
    struct ssv_rxbuf *bf;
    int copylength;
    dev_err(glue->dev,"%s():\n", __FUNCTION__);
    spin_lock_bh(&glue->rxbuflock);
    if (list_empty(&glue->rxreadybuf))
    {
        spin_unlock_bh(&glue->rxbuflock);
        dev_err(glue->dev,"%s():no data for read \n", __FUNCTION__);
#if 1
        if ( wait_event_interruptible(glue->read_wq, ssv_sdiobridge_have_data(glue))!=0)
        {
            dev_err(glue->dev,"%s():not get data ?? \n", __FUNCTION__);
            return -1;
        }
#else
        wait_event(glue->read_wq,ssv_sdiobridge_have_data(glue));
#endif
        spin_lock_bh(&glue->rxbuflock);
        if (list_empty(&glue->rxreadybuf))
        {
            spin_unlock_bh(&glue->rxbuflock);
            dev_err(glue->dev,"%s():stop ?? \n", __FUNCTION__);
            return -1;
        }
    }
    bf = list_first_entry(&glue->rxreadybuf, struct ssv_rxbuf, list);
    list_del(&bf->list);
    spin_unlock_bh(&glue->rxbuflock);
    copylength = min(bf->rxsize,(u32)length);
    CHECK_RET(copy_to_user((int __user *)buffer,bf->rxdata,copylength));
    dev_err(glue->dev,"%s():get rx data : data len:[%d], user read len:[%d],real read len:[%d] \n", __FUNCTION__,bf->rxsize,(u32)length,copylength);
    spin_lock_bh(&glue->rxbuflock);
    list_add_tail(&bf->list, &glue->rxbuf);
    spin_unlock_bh(&glue->rxbuflock);
    return copylength;
}
static ssize_t ssv_sdiobridge_device_write(struct file *filp,
        const char *buff,
        size_t len,
        loff_t *off)
{
    struct ssv_sdiobridge_glue *glue =filp->private_data;
    struct sdio_func *func = dev_to_sdio_func(glue->dev);
    u8 *tmpdata;
    int ret;
    dev_err(glue->dev,"%s():\n", __FUNCTION__);
    tmpdata = kzalloc(len, GFP_KERNEL);
    if ( tmpdata == NULL )
    {
        dev_err(glue->dev,"%s: error : alloc buf error size:%d",__FUNCTION__,(u32)len);
        return -1;
    }
    CHECK_RET(copy_from_user(tmpdata,(int __user *)buff,len));
    if (unlikely(glue->dump))
    {
        printk(KERN_DEBUG "%s: WRITE data address[%08x] len[%d] readsize[%d]\n",__FUNCTION__,glue->dataIOPort,(int)len,sdio_align_size(func,len));
        print_hex_dump(KERN_DEBUG, "ssv_sdio: WRITE ",
                       DUMP_PREFIX_OFFSET, 16, 1,
                       tmpdata, len, false);
    }
    sdio_claim_host(func);
    ret = sdio_memcpy_toio(func, glue->dataIOPort,tmpdata, sdio_align_size(func,len));
    sdio_release_host(func);
    kfree(tmpdata);
    if ( ret )
    {
        dev_err(glue->dev,"%s: error : %d",__FUNCTION__,ret);
        return -1;
    }
    return len;
}
struct file_operations fops =
{
    .owner = THIS_MODULE,
    .read = ssv_sdiobridge_device_read,
    .write = ssv_sdiobridge_device_write,
    .open = ssv_sdiobridge_device_open,
    .release = ssv_sdiobridge_device_close,
    .compat_ioctl = ssv_sdiobridge_device_compat_ioctl,
    .unlocked_ioctl = ssv_sdiobridge_device_ioctl
};
static void ssv_sdiobridge_irq_process(struct sdio_func *func,
                                       struct ssv_sdiobridge_glue *glue)
{
    int err_ret;
    u8 status;
    sdio_claim_host(func);
    status = sdio_readb(func, REG_INT_STATUS, &err_ret);
    if ( status & SSVCABRIO_INT_RX )
    {
        struct ssv_rxbuf *bf;
        int readsize;
        spin_lock_bh(&glue->rxbuflock);
        if (list_empty(&glue->rxbuf))
        {
            spin_unlock_bh(&glue->rxbuflock);
            sdio_release_host(func);
            dev_err(glue->dev, "ssv_sdiobridge_irq_process no avaible rx buf list??\n");
            return;
        }
        else
        {
            bf = list_first_entry(&glue->rxbuf, struct ssv_rxbuf, list);
            list_del(&bf->list);
        }
        spin_unlock_bh(&glue->rxbuflock);
        bf->rxsize = (int)(sdio_readb(func, REG_CARD_PKT_LEN_0, &err_ret)&0xff);
        dev_err(glue->dev, "sdio read rx size[%08x] 0x10[%02x]\n",bf->rxsize, sdio_readb(func, REG_CARD_PKT_LEN_0, &err_ret)&0xff);
        bf->rxsize = bf->rxsize | ((sdio_readb(func, REG_CARD_PKT_LEN_1, &err_ret)&0xff)<<0x8);
        readsize = sdio_align_size(func,bf->rxsize);
        dev_err(glue->dev, "sdio read rx size[%08x] 0x11[%02x] readsize[%d]\n",bf->rxsize, sdio_readb(func, REG_CARD_PKT_LEN_1, &err_ret)&0xff,readsize);
        err_ret = sdio_memcpy_fromio(func, bf->rxdata, glue->dataIOPort, readsize);
        sdio_release_host(func);
        dev_err(glue->dev, "ssv_sdiobridge_irq_process read 53, %d bytes  ret:[%d]\n", readsize,err_ret );
        if (unlikely(glue->dump))
        {
            printk(KERN_DEBUG "ssv_sdiobridge_irq_process: READ data address[%08x] len[%d] readsize[%d]\n",glue->dataIOPort,(int)bf->rxsize,readsize);
            print_hex_dump(KERN_DEBUG, "ssv_sdio: READ ",
                           DUMP_PREFIX_OFFSET, 16, 1,
                           bf->rxdata, bf->rxsize, false);
        }
        if (WARN_ON(err_ret))
        {
            dev_err(glue->dev, "ssv_sdiobridge_irq_process read failed (%d)\n", err_ret);
            spin_lock_bh(&glue->rxbuflock);
            list_add_tail(&bf->list, &glue->rxbuf);
            spin_unlock_bh(&glue->rxbuflock);
        }
        else
        {
            spin_lock_bh(&glue->rxbuflock);
            list_add_tail(&bf->list, &glue->rxreadybuf);
            wake_up(&glue->read_wq);
            spin_unlock_bh(&glue->rxbuflock);
        }
    }
    else
    {
        sdio_release_host(func);
    }
}
static void ssv_sdiobridge_irq_handler(struct sdio_func *func)
{
    struct ssv_sdiobridge_glue *glue = sdio_get_drvdata(func);
    dev_err(&func->dev, "ssv_sdiobridge_irq_handler\n");
    WARN_ON(glue == NULL);
    if ( glue != NULL )
    {
        atomic_set(&glue->irq_handling, 1);
        ssv_sdiobridge_irq_process(func,glue);
        atomic_set(&glue->irq_handling, 0);
        wake_up(&glue->irq_wq);
    }
}
static void ssv_sdiobridge_irq_enable(struct sdio_func *func,
                                      struct ssv_sdiobridge_glue *glue)
{
    int ret;
    func = dev_to_sdio_func(glue->dev);
    sdio_claim_host(func);
    dev_err(glue->dev, "ssv_sdiobridge_irq_enable\n");
    ret = sdio_claim_irq(func, ssv_sdiobridge_irq_handler);
    if (ret)
        dev_err(glue->dev, "Failed to claim sdio irq: %d\n", ret);
    sdio_release_host(func);
}
static bool ssv_sdiobridge_is_on_irq(struct ssv_sdiobridge_glue *glue)
{
    return !atomic_read(&glue->irq_handling);
}
static void ssv_sdiobridge_irq_disable(struct ssv_sdiobridge_glue *glue,bool iswaitirq)
{
    struct sdio_func *func;
    int ret;
    dev_err(glue->dev, "ssv_sdiobridge_irq_disable1\n");
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        dev_err(glue->dev, "ssv_sdiobridge_irq_disable2 [%d]\n",atomic_read(&glue->irq_handling));
        if (atomic_read(&glue->irq_handling)&&iswaitirq)
        {
            dev_err(glue->dev, "ssv_sdiobridge_irq_disable3\n");
            sdio_release_host(func);
            ret = wait_event_interruptible(glue->irq_wq,
                                           ssv_sdiobridge_is_on_irq(glue));
            dev_err(glue->dev, "ssv_sdiobridge_irq_disable4 ret[%d]\n",ret);
            if (ret)
                return;
            sdio_claim_host(func);
        }
        dev_err(glue->dev, "ssv_sdiobridge_irq_disable5\n");
        ret = sdio_release_irq(func);
        if (ret)
            dev_err(glue->dev, "Failed to release sdio irq: %d\n", ret);
        dev_err(glue->dev, "ssv_sdiobridge_irq_disable6\n");
        sdio_release_host(func);
    }
}
#if 0
static void ssv_sdiobridge_irq_sync(struct device *child)
{
    struct ssv_sdiobridge_glue *glue = dev_get_drvdata(child->parent);
    struct sdio_func *func;
    int ret;
    if ( glue != NULL )
    {
        func = dev_to_sdio_func(glue->dev);
        sdio_claim_host(func);
        if (atomic_read(&glue->irq_handling))
        {
            sdio_release_host(func);
            ret = wait_event_interruptible(glue->irq_wq,
                                           ssv_sdiobridge_is_on_irq(glue));
            if (ret)
                return;
            sdio_claim_host(func);
        }
        sdio_release_host(func);
    }
}
#endif
static void ssv_sdiobridge_read_parameter(struct sdio_func *func,
        struct ssv_sdiobridge_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 [%lx]\n",
            glue->dataIOPort,glue->regIOPort,(long unsigned int)IOCTL_SSVSDIO_GET_BLOCKLEN);
    sdio_set_block_size(func,glue->blockSize);
    sdio_release_host(func);
}
static int ssv_sdiobridge_init_buf(struct ssv_sdiobridge_glue *glue)
{
    u32 bsize,i,error;
    struct ssv_rxbuf *bf;
    init_waitqueue_head(&glue->read_wq);
    spin_lock_init(&glue->rxbuflock);
    INIT_LIST_HEAD(&glue->rxbuf);
    INIT_LIST_HEAD(&glue->rxreadybuf);
    bsize = sizeof(struct ssv_rxbuf) * RXBUFSIZE;
    glue->bufaddr = kzalloc(bsize, GFP_KERNEL);
    if (glue->bufaddr == NULL)
    {
        error = -ENOMEM;
        goto fail;
    }
    bf = glue->bufaddr;
    for (i = 0; i < RXBUFSIZE; i++, bf++)
    {
        list_add_tail(&bf->list, &glue->rxbuf);
    }
    return 0;
fail:
    return error;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)
static char *ssv_sdiobridge_devnode(struct device *dev, umode_t *mode)
#else
static char *ssv_sdiobridge_devnode(struct device *dev, mode_t *mode)
#endif
{
    if (!mode)
        return NULL;
    *mode = 0666;
    return NULL;
}
extern int ssv_devicetype;
static int __devinit ssv_sdiobridge_probe(struct sdio_func *func,
        const struct sdio_device_id *id)
{
    mmc_pm_flag_t mmcflags;
    int ret = -ENOMEM;
    dev_t dev;
    int alloc_ret = 0;
    int cdev_ret = 0;
    int err_ret;
    if (ssv_devicetype != 1) {
        printk(KERN_INFO "Not using SSV6200 bridge SDIO driver.\n");
        return -ENODEV;
    }
    printk(KERN_INFO "=======================================\n");
    printk(KERN_INFO "==           RUN SDIO BRIDGE         ==\n");
    printk(KERN_INFO "=======================================\n");
    printk(KERN_INFO "ssv_sdiobridge_probe func->num:%d",func->num);
    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;
    }
    glue->blockMode = false;
    glue->blockSize = BLOCKSIZE;
    glue->autoAckInt = true;
    glue->dump = false;
    glue->funcFocus = 1;
    ssv_sdiobridge_init_buf(glue);
    glue->dev = &func->dev;
    func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
    func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
    mmcflags = sdio_get_host_pm_caps(func);
    dev_err(glue->dev, "sdio PM caps = 0x%x\n", mmcflags);
    sdio_set_drvdata(func, glue);
    pm_runtime_put_noidle(&func->dev);
    ssv_sdiobridge_read_parameter(func,glue);
    dev = MKDEV(ssv_sdiobridge_ioctl_major, 0);
    alloc_ret = alloc_chrdev_region(&dev, 0, num_of_dev, FILE_DEVICE_SSVSDIO_NAME);
    if (alloc_ret)
        goto error;
    ssv_sdiobridge_ioctl_major = MAJOR(dev);
    cdev_init(&ssv_sdiobridge_ioctl_cdev, &fops);
    cdev_ret = cdev_add(&ssv_sdiobridge_ioctl_cdev, dev, num_of_dev);
    if (cdev_ret)
        goto error;
    fc=class_create(THIS_MODULE, FILE_DEVICE_SSVSDIO_NAME);
    fc->devnode = ssv_sdiobridge_devnode;
    device_create(fc, NULL, dev, NULL, "%s", FILE_DEVICE_SSVSDIO_NAME);
    dev_err(glue->dev, "%s driver(major: %d) installed.\n", FILE_DEVICE_SSVSDIO_NAME, ssv_sdiobridge_ioctl_major);
    init_waitqueue_head(&glue->irq_wq);
    ssv_sdiobridge_irq_enable(func,glue);
    sdio_claim_host(func);
#ifdef CONFIG_SSV_SDIO_EXT_INT
    sdio_writeb(func,(~(SSVCABRIO_INT_RX)|SSVCABRIO_INT_GPIO)&0x7, 0x04, &err_ret);
#else
    sdio_writeb(func,(~(SSVCABRIO_INT_RX|SSVCABRIO_INT_GPIO))&0x7, 0x04, &err_ret);
#endif
    sdio_release_host(func);
    return 0;
error:
    if (cdev_ret == 0)
        cdev_del(&ssv_sdiobridge_ioctl_cdev);
    if (alloc_ret == 0)
        unregister_chrdev_region(dev, num_of_dev);
    kfree(glue);
out:
    return ret;
}
static void __devexit ssv_sdiobridge_remove(struct sdio_func *func)
{
    struct ssv_sdiobridge_glue *glue = sdio_get_drvdata(func);
    dev_t dev;
    int err_ret;
    sdio_claim_host(func);
#ifdef CONFIG_SSV_SDIO_EXT_INT
    sdio_writeb(func,0, 0x04, &err_ret);
#else
    sdio_writeb(func,SSVCABRIO_INT_GPIO, 0x04, &err_ret);
#endif
    sdio_release_host(func);
    ssv_sdiobridge_irq_disable(glue,false);
    dev = MKDEV(ssv_sdiobridge_ioctl_major, 0);
    device_destroy(fc,dev);
    class_destroy(fc);
    cdev_del(&ssv_sdiobridge_ioctl_cdev);
    unregister_chrdev_region(dev, num_of_dev);
    pm_runtime_get_noresume(&func->dev);
    if ( glue )
    {
        dev_err(glue->dev, "ssv_sdiobridge_remove");
        if (glue->bufaddr)
        {
            kfree(glue->bufaddr);
        }
        kfree(glue);
        glue = NULL;
    }
    sdio_set_drvdata(func, NULL);
}
#ifdef CONFIG_PM
static int ssv_sdiobridge_suspend(struct device *dev)
{
    int ret = 0;
    return ret;
}
static int ssv_sdiobridge_resume(struct device *dev)
{
    dev_dbg(dev, "ssvcabrio resume\n");
    return 0;
}
static const struct dev_pm_ops ssv_sdiobridge_pm_ops =
{
    .suspend = ssv_sdiobridge_suspend,
    .resume = ssv_sdiobridge_resume,
};
#endif
static struct sdio_driver ssv_sdio_bridge_driver =
{
    .name = "ssv_sdio_bridge",
    .id_table = ssv_sdiobridge_devices,
    .probe = ssv_sdiobridge_probe,
    .remove = __devexit_p(ssv_sdiobridge_remove),
#ifdef CONFIG_PM
    .drv = {
        .pm = &ssv_sdiobridge_pm_ops,
    },
#endif
};
EXPORT_SYMBOL(ssv_sdio_bridge_driver);
#if 1
static int __init ssv_sdiobridge_init(void)
{
    printk(KERN_INFO "ssv_sdiobridge_init\n");
    return sdio_register_driver(&ssv_sdio_bridge_driver);
}
static void __exit ssv_sdiobridge_exit(void)
{
    printk(KERN_INFO "ssv_sdiobridge_exit\n");
    sdio_unregister_driver(&ssv_sdio_bridge_driver);
}
module_init(ssv_sdiobridge_init);
module_exit(ssv_sdiobridge_exit);
#endif
MODULE_LICENSE("GPL");
MODULE_AUTHOR("iComm Semiconductor Co., Ltd");