static long tpa6132_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
mutex_lock(&tpa6132_lock);
switch (cmd) {
case TPA6132_ENABLE:
ret = blockmux_set(tpa6132_iomux_block, tpa6132_block_config, NORMAL);
if (0 > ret) {
loge("%s: set iomux to gpio normal error", __FUNCTION__);
goto err_exit;
}
gpio_set_value(pdata->gpio_tpa6132_en, 1);
break;
case TPA6132_DISABLE:
gpio_set_value(pdata->gpio_tpa6132_en, 0);
ret = blockmux_set(tpa6132_iomux_block, tpa6132_block_config, LOWPOWER);
if (0 > ret) {
loge("%s: set iomux to gpio lowpower error", __FUNCTION__);
goto err_exit;
}
break;
default:
loge("%s: invalid command %d", __FUNCTION__, _IOC_NR(cmd));
ret = -EINVAL;
break;
}
err_exit:
mutex_unlock(&tpa6132_lock);
return ret;
}
static void mshci_hi_sdio_set_power(struct platform_device *dev, int val)
{
struct mshci_host *host = platform_get_drvdata(dev);
struct himci_host * hi_host = (struct himci_host *)(host->private);
/*int ret = -1;*/
u32 loop_count = 1000; /* wait 10S */
u32 i = 0;
himci_assert(host);
himci_assert(hi_host);
for (i = 0; i < loop_count; i++) {
if (MMC_HOST_BUSY == host->working || host->mrq) {
msleep(10);
} else {
break;
}
}
#if 0
if (val) {
printk("%s:val=%d, set io to normal mode\n", __func__, val);
host->mmc->ios.power_mode = MMC_POWER_UP;
host->mmc->ios.timing = MMC_TIMING_LEGACY;
host->mmc->ios.bus_width = MMC_BUS_WIDTH_1;
host->mmc->ios.clock = 0;
host->mmc->ops->set_ios(host->mmc, &host->mmc->ios);
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
if (ret) {
himci_error("failed to blockmux_set");
}
msleep(10);
host->mmc->ios.power_mode = MMC_POWER_ON;
host->mmc->ios.clock = 400000;
host->mmc->ops->set_ios(host->mmc, &host->mmc->ios);
//to do w00215368
//blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
} else {
printk("%s:val=%d, set io to lowpower mode\n", __func__, val);
host->mmc->ios.clock = 0;
host->mmc->ios.power_mode = MMC_POWER_OFF;
host->mmc->ios.bus_width = MMC_BUS_WIDTH_1;
host->mmc->ios.timing = MMC_TIMING_LEGACY;
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, LOWPOWER);
if (ret) {
himci_error("failed to blockmux_set");
}
}
#endif
}
static int st_host_wake_resume(struct platform_device *pdev)
{
int ret;
unsigned long irq_flags = 0;
pr_err("%s", __func__);
if (test_bit(ST_HOST_WAKE, &flags) && test_bit(IRQ_WAKE, &flags)) {
ret = blockmux_set(btuart4_block, btuart4_config, NORMAL);
if (ret) {
pr_info("%s: btuart4_block blockmux set err %d\r\n", __func__, ret);
return ret;
}
#ifdef IRQ_WAKEUP
ret = disable_irq_wake(hwi->host_wake_irq);
if (ret < 0) {
pr_err("%s: couldn't disable ST_HOST_WAKE as wakeup interrupt %d", __func__, ret);
}
#endif
clear_bit(IRQ_WAKE, &flags);
}
return 0;
}
static int hi_mci_resume(struct platform_device *dev)
{
int ret = 0;
struct mshci_host *ms_host = NULL;
struct himci_host *hi_host = NULL;
int cbp_flag = 0;
int cbp_ret = 0;
unsigned int oldclock = 0;
ms_host = platform_get_drvdata(dev);
if (!ms_host) {
printk(KERN_WARNING "the return value of platform_get_drvdata is NULL !\n");
return -1;
}
hi_host = mshci_priv(ms_host);
cbp_ret = get_hw_config_int("modem/viacbp82d", &cbp_flag, NULL);
if ((!cbp_ret) || (0 == cbp_flag)) {
pr_info("%s has no cbp support\n", __func__);
}
if ((1 == hi_host->pdev->id)&&(cbp_flag)){
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
if (ret) {
himci_error("failed to blockmux_set");
}
}
printk(KERN_INFO "hi_mci_resume is called \n");
mshci_resume_host(ms_host);
if (ms_host->quirks & MSHCI_QUIRK_WLAN_DETECTION) {
if (ms_host->mmc->ios.power_mode != MMC_POWER_OFF) {
ret = mmc_sdio_resume_ext(ms_host->mmc);
if (ret) {
printk("%s, sdio resume error\n", __func__);
return ret;
}
}
}
if ((1 == hi_host->pdev->id)&&(cbp_flag)){
if (ms_host->mmc->ios.power_mode != MMC_POWER_OFF) {
pr_info("%s cbp resume sdio maxclock = %d, cur_clk=%d\n", __func__, ms_host->max_clk, ms_host->clock);
ms_host->mmc->ios.clock = ms_host->mmc->f_max;
ms_host->mmc->ops->set_ios(ms_host->mmc, &ms_host->mmc->ios);
ms_host->mmc->ops->enable_sdio_irq(ms_host->mmc, 1);
}
cbp_host_waked = 1;
cbp_notifier_call_chain(1, NULL);
}
if(0 == hi_host->pdev->id)
{
g_ulmmc_suspend_flag = false;
/*emmc resume 完毕*/
printk("mmc_blk_resume, clr g_ulmmc_suspend_flag.\n");
}
return ret;
}
static void adxl34x_disable(struct adxl34x *ac)
{
short buf[3];
mutex_lock(&ac->mutex);
if (!ac->disabled) {
ac->disabled = 1;
/* must unmask interrupt before cancel work or it will cause unstable */
AC_WRITE(ac, INT_ENABLE, 0);
mutex_unlock(&ac->mutex);
/* ret =cancel_work_sync(&ac->work); */
flush_work(&ac->work);
mutex_lock(&ac->mutex);
/*
* A '0' places the ADXL34x into standby mode
* with minimum power consumption.
*/
/* make sure interrupt is cleared */
AC_READ(ac, INT_SOURCE);
ac->read_block(ac->bus, DATAX0, DATAZ1 - DATAX0 + 1,
(unsigned char *)buf);
AC_WRITE(ac, POWER_CTL, 0);
if (blockmux_set(ac->gpio_block, ac->gpio_block_config, LOWPOWER))
dev_err(&ac->bus->dev, "%s, blockmux_set gpio config err\n",
__func__);
}
mutex_unlock(&ac->mutex);
}
static void K3_gps_bcm_shutdown(struct platform_device *pdev)
{
GPS_BCM_INFO *gps_bcm = platform_get_drvdata(pdev);
#ifdef CONFIG_MACH_K3V2OEM1
int ret = 0;
#endif
if (!gps_bcm) {
dev_err(&pdev->dev, "gps_bcm is NULL\n");
return;
}
printk("[%s] +\n", __func__);
gpio_set_value(gps_bcm->gpioid_en, 0);
gpio_set_value(gps_bcm->gpioid_ret, 0);
#ifdef CONFIG_MACH_K3V2OEM1
if ((gps_bcm->piomux_block) && (gps_bcm->pblock_config)) {
ret = blockmux_set(gps_bcm->piomux_block, gps_bcm->pblock_config, LOWPOWER);
if (ret)
dev_err(&pdev->dev, "Set gps iomux to LOWPOWER failed, ret=%d\n", ret);
}
clk_disable(gps_bcm->clk);
clk_put(gps_bcm->clk);
#else
gpio_set_value(gps_bcm->gpioid_ret, 0);
gpio_free(gps_bcm->gpioid_power);
#endif
printk("[%s] -\n", __func__);
}
static halReturn_t HalGpioConfigStatus(enum iomux_func status)
{
int ret = 0;
struct iomux_block *pMhlGpioBlock = NULL;
struct block_config *pMhlGpioBlockConfig = NULL;
/* get gpio block*/
pMhlGpioBlock = iomux_get_block(MHL_GPIO_BLOCK_NAME);
if (IS_ERR(pMhlGpioBlock))
{
SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE,"HalGpioSetResource: Get GPIO Block Failed\n");
return HAL_RET_FAILURE;
}
/* get gpio block config*/
pMhlGpioBlockConfig = iomux_get_blockconfig(MHL_GPIO_BLOCK_NAME);
if (IS_ERR(pMhlGpioBlockConfig))
{
SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE,"HalGpioSetResource: get GPIO Block Config Failed\n");
return HAL_RET_FAILURE;
}
/* config gpio work mode*/
ret = blockmux_set(pMhlGpioBlock, pMhlGpioBlockConfig, status);
if (ret)
{
SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE,"HalGpioConfigStatus: Config GPIO Block Failed\n");
return HAL_RET_FAILURE;
}
return HAL_RET_SUCCESS;
}
static int __devexit k3_bq24161_charger_remove(struct i2c_client *client)
{
struct k3_bq24161_device_info *di = i2c_get_clientdata(client);
/**********ADD BY 00186176 begin****************/
hiusb_charger_unregiste_notifier(&di->nb);
/**********ADD BY 00186176 END****************/
sysfs_remove_group(&client->dev.kobj, &k3_bq24161_attr_group);
cancel_delayed_work(&di->bq24161_charger_work);
flush_scheduled_work();
#if BQ2416X_USE_WAKE_LOCK
wake_lock_destroy(&di->charger_wake_lock);
#endif
gpio_free(di->gpio);
#ifdef CONFIG_GPIO_BAT
if (blockmux_set(di->piomux_block, di->pblock_config, LOWPOWER))
dev_err(&client->dev, "blockmux_set LOWPOWER failed\n");
/*blockmux_set(di->piomux_block_interrupt, di->pblock_config_interrupt, LOWPOWER);*/
#endif
kfree(di);
return 0;
}
int st_host_wake_suspend(void)
{
int ret;
unsigned long irq_flags = 0;
pr_info("%s", __func__);
if (test_bit(ST_HOST_WAKE, &flags) && (!test_bit(IRQ_WAKE, &flags))) {
//enable_irq(hwi->host_wake_irq);
ret = blockmux_set(btuart4_block, btuart4_config, LOWPOWER);
if (ret) {
pr_info("%s : btuart4_block blockmux set err %d\r\n", __func__, ret);
return ret;
}
spin_lock_irqsave(&irq_enable_lock, irq_flags);
suspend_flag = true;
spin_unlock_irqrestore(&irq_enable_lock, irq_flags);
#ifdef IRQ_WAKEUP
ret = enable_irq_wake(hwi->host_wake_irq);
if (ret < 0) {
pr_err("%s: couldn't enable ST_HOST_WAKE as wakeup interrupt %d", __func__, ret);
}
#endif
set_bit(IRQ_WAKE, &flags);
pr_info("enabled the host_wake irq");
}
return 0;
}
void hiusb_otg_and_phy_cleanup(void)
{
int i;
SOC_PERI_SCTRL_SC_PERIPH_CTRL4_UNION ao_sctrl_ctrl8;
/* clk_disable(); */
clk_disable(g_hiusb_info->clk_usbotg_off);
#if defined(CHIP_BB_HI6210)/*B020 Modify*/
#else
clk_disable(g_hiusb_info->clk_picophy);
#endif
/* ctrl 8 */
ao_sctrl_ctrl8.value = readl(SOC_PERI_SCTRL_SC_PERIPH_CTRL4_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
ao_sctrl_ctrl8.reg.pico_siddq = 1;
writel(ao_sctrl_ctrl8.value , SOC_PERI_SCTRL_SC_PERIPH_CTRL4_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
/* rst */
for (i=0;hiusb_rst[i].addr != 0; i++) {
writel(hiusb_rst[i].value, hiusb_rst[i].addr);
udelay(hiusb_rst[i].udelay);
pr_debug("%s rst addr:0x%8.8x value:0x%8.8x udelay:%d\n",
__func__,
hiusb_rst[i].addr,
hiusb_rst[i].value,
hiusb_rst[i].udelay);
}
blockmux_set(g_hiusb_info->usb_block, g_hiusb_info->usb_config, NORMAL);
pr_info("%s -.\n", __func__);
return;
}
void hiusb_otg_and_phy_setup(int mode)
{
int i;
SOC_PERI_SCTRL_SC_PERIPH_CTRL4_UNION ao_sctrl_ctrl8;
SOC_PERI_SCTRL_SC_PERIPH_CTRL5_UNION ao_sctrl_ctrl9;
blockmux_set(g_hiusb_info->usb_block, g_hiusb_info->usb_config, NORMAL);
/* nrst */
for (i=0;hiusb_nrst[i].addr != 0; i++) {
writel(hiusb_nrst[i].value, hiusb_nrst[i].addr);
udelay(hiusb_nrst[i].udelay);
pr_debug("%s nrst addr:0x%8.8x value:0x%8.8x udelay:%d\n",
__func__,
hiusb_nrst[i].addr,
hiusb_nrst[i].value,
hiusb_nrst[i].udelay);
}
/* ctrl 9 */
ao_sctrl_ctrl9.value = readl(SOC_PERI_SCTRL_SC_PERIPH_CTRL5_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
ao_sctrl_ctrl9.reg.picophy_bc_mode = 0;
if ((g_hiusb_info->quirks & HIUSB_QUIRKS_PMUIRQ) == 0) {
if (mode == 1) {
ao_sctrl_ctrl9.reg.picophy_iddig = 1;
} else {
ao_sctrl_ctrl9.reg.picophy_iddig = 0;
}
} else {
ao_sctrl_ctrl9.reg.picophy_iddig = 1;
}
#if defined(CHIP_BB_HI6210)
ao_sctrl_ctrl9.reg.usbotg_res_sel = 1;
#endif
writel(ao_sctrl_ctrl9.value , SOC_PERI_SCTRL_SC_PERIPH_CTRL5_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
/* ctrl 8 */
ao_sctrl_ctrl8.value = readl(SOC_PERI_SCTRL_SC_PERIPH_CTRL4_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
ao_sctrl_ctrl8.reg.pico_siddq = 0;
ao_sctrl_ctrl8.reg.pico_ogdisable = 0;
ao_sctrl_ctrl8.reg.pico_vbusvldextsel = 1;
ao_sctrl_ctrl8.reg.pico_vbusvldext = 1;
writel(ao_sctrl_ctrl8.value , SOC_PERI_SCTRL_SC_PERIPH_CTRL4_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
udelay(60);
writel(0x703334d8, SOC_PERI_SCTRL_SC_PERIPH_CTRL8_ADDR(IO_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR)));
// clk_enable();
clk_enable(g_hiusb_info->clk_usbotg_off);
#if defined(CHIP_BB_HI6210)/*B020 Modify*/
#else
clk_enable(g_hiusb_info->clk_picophy);
#endif
pr_info("%s .\n", __func__);
return;
}
void LCD_IOMUX_SET(struct k3_panel_info *pinfo, int mode)
{
BUG_ON(pinfo == NULL);
if (blockmux_set(pinfo->lcd_block, pinfo->lcd_block_config, mode) != 0) {
k3fb_loge("failed to set iomux_lcd normal mode!\n");
}
}
void PWM_IOMUX_SET(struct k3_panel_info *pinfo, int mode)
{
BUG_ON(pinfo == NULL);
if (blockmux_set(pinfo->pwm_block, pinfo->pwm_block_config, (mode)) != 0) {
k3fb_loge("failed to set iomux pwm normal mode!\n");
}
}
static int gpio_lowpower_set(enum iomux_func newmode)
{
int ret;
ret = blockmux_set(xmm_iomux_block, xmm_iomux_config, newmode);
if (ret) {
pr_info("SETERROR:blockmux set err\r\n");
return -1;
}
return 0;
}
static int set_iomux_lowpower(struct iomux_block *gpio_block,struct block_config *gpio_block_config)
{
int ret;
BUG_ON(gpio_block_config==NULL);
BUG_ON(gpio_block==NULL);
ret = blockmux_set(gpio_block, gpio_block_config, LOWPOWER);
if (ret<0) {
printk(KERN_ERR "%s: failed to config gpio\n", __func__);
return ret;
}
return 0;
}
int iomux_cmds_tx(struct iomux_desc *cmds, int cnt)
{
struct iomux_desc *cm = NULL;
int i = 0;
cm = cmds;
for (i = 0; i < cnt; i++) {
if (cm == NULL) {
k3fb_loge("cm(%d) is null!\n", i);
continue;
}
BUG_ON(cm->name == NULL);
if (cm->dtype == DTYPE_IOMUX_GET) {
if (cm->name == NULL) {
k3fb_loge("Block name is NULL!\n");
}
*(cm->block) = iomux_get_block(cm->name);
if (*(cm->block) == NULL) {
k3fb_loge("failed to iomux_get_block, name=%s!\n",
(cm->name == NULL) ? "NULL" : cm->name);
continue;
}
*(cm->block_config) = iomux_get_blockconfig(cm->name);
if (*(cm->block_config) == NULL) {
k3fb_loge("failed to iomux_get_blockconfig, name=%s!\n",
(cm->name == NULL) ? "NULL" : cm->name);
continue;
}
} else if (cm->dtype == DTYPE_IOMUX_SET) {
if (blockmux_set(*(cm->block), *(cm->block_config), cm->mode) != 0) {
k3fb_loge("failed to blockmux_set, name=%s!\n",
(cm->name == NULL) ? "NULL" : cm->name);
continue;
}
}
cm++;
}
return cnt;
}
static int __init k3v2_wifi_init(void)
{
int ret = 0;
printk("TI WL18XX: %s \n", __func__);
wifi_host = kzalloc(sizeof(struct wifi_host_s), GFP_KERNEL);
wifi_host->clk = clk_get(NULL, "clk_pmu32kb");
//delete the regulator LDO14 that wifi not used
wifi_host->block = iomux_get_block("block_wifi");
wifi_host->config = iomux_get_blockconfig("block_wifi");
blockmux_set(wifi_host->block, wifi_host->config, LOWPOWER);
/* set power gpio */
ret = gpio_request(K3V2_WIFI_POWER_GPIO, NULL);
if (ret < 0) {
pr_err("%s: gpio_request failed, ret:%d.\n", __func__,
K3V2_WIFI_POWER_GPIO);
goto err_power_gpio_request;
}
gpio_direction_output(K3V2_WIFI_POWER_GPIO, 0);
//z00186406 add to request out band irq, and convert gpio number to irq number begin
ret = gpio_request(K3V2_WIFI_IRQ_GPIO, NULL);
if(ret < 0) {
pr_err( "%s: gpio_request failed, ret:%d.\n", __func__,
K3V2_WIFI_IRQ_GPIO );
goto err_irq_gpio_request;
}
gpio_direction_input(K3V2_WIFI_IRQ_GPIO);
k3v2_wlan_data.irq = gpio_to_irq(K3V2_WIFI_IRQ_GPIO);
//z00186406 add to request out band irq, and convert gpio number to irq number end
wl12xx_set_platform_data(&k3v2_wlan_data);
return 0;
//z00186406 add enable out band irq begin
err_irq_gpio_request:
gpio_free(K3V2_WIFI_IRQ_GPIO);
//z00186406 add enable out band irq end
err_power_gpio_request:
gpio_free(K3V2_WIFI_POWER_GPIO);
return ret;
}
void __init iomux_init_blocks(void)
{
int ret;
struct iomux_block *block_temp = NULL;
struct block_config *config_temp = NULL;
struct block_table *table_temp = NULL;
get_active_block_table();
table_temp = p_active_block_table;
while ((*table_temp).name) {
block_temp = (*table_temp).block;
config_temp = (*table_temp).config_array;
ret = blockmux_set(block_temp, config_temp, LOWPOWER);
if (ret) {
pr_err("IOMUX:iomux initialized failed.\r\n");
break;
}
table_temp++;
}
}
static int adxl34x_config_gpio(struct device *dev, struct adxl34x *acc_data)
{
int ret = 0;
/* get gpio block*/
acc_data->gpio_block = iomux_get_block(GPIO_BOLCK_NAME);
if (IS_ERR(acc_data->gpio_block)) {
dev_err(dev, "%s: failed to get gpio block\n", __func__);
ret = -EINVAL;
return ret;
}
/* get gpio block config*/
acc_data->gpio_block_config = iomux_get_blockconfig(GPIO_BOLCK_NAME);
if (IS_ERR(acc_data->gpio_block_config)) {
dev_err(dev, "%s: failed to get gpio block config\n", __func__);
ret = -EINVAL;
goto err_block_config;
}
/* config gpio work mode*/
ret = blockmux_set(acc_data->gpio_block, acc_data->gpio_block_config, LOWPOWER);
if (ret) {
dev_err(dev, "%s: failed to config gpio\n", __func__);
ret = -EINVAL;
goto err_mux_set;
}
return ret;
err_mux_set:
if (acc_data->gpio_block_config)
acc_data->gpio_block_config = NULL;
err_block_config:
if (acc_data->gpio_block)
acc_data->gpio_block = NULL;
return ret;
}
/**********ADD BY 00186176 begin****************/
static void k3_bq24161_charger_shutdown(struct i2c_client *client)
{
struct k3_bq24161_device_info *di = i2c_get_clientdata(client);
printk("[%s] +\n", __func__);
cancel_delayed_work(&di->bq24161_charger_work);
flush_scheduled_work();
/**********ADD BY 00186176 begin****************/
#ifdef CONFIG_GPIO_BAT
if (blockmux_set(di->piomux_block, di->pblock_config, LOWPOWER))
dev_err(&client->dev, "blockmux_set LOWPOWER failed\n");
#endif
/**********ADD BY 00186176 END****************/
printk("[%s] -\n", __func__);
return;
}
static int adxl34x_enable(struct adxl34x *ac)
{
int err = 0;
mutex_lock(&ac->mutex);
if (ac->disabled) {
err = blockmux_set(ac->gpio_block, ac->gpio_block_config, NORMAL);
if (err) {
dev_err(&ac->bus->dev, "%s, blockmux_set gpio config err %d\n",
__func__, err);
mutex_unlock(&ac->mutex);
return err;
}
AC_WRITE(ac, POWER_CTL, PCTL_MEASURE);
AC_WRITE(ac, INT_ENABLE, ac->int_mask /*| OVERRUN*/);
ac->disabled = 0;
}
mutex_unlock(&ac->mutex);
return err;
}
static int __devexit k3_gps_bcm_remove(struct platform_device *pdev)
{
GPS_BCM_INFO *gps_bcm = platform_get_drvdata(pdev);
int ret = 0;
dev_dbg(&pdev->dev, "k3_gps_bcm_remove +\n");
if (!gps_bcm) {
dev_err(&pdev->dev, "gps_bcm is NULL\n");
return 0;
}
#ifdef CONFIG_MACH_K3V2OEM1
if ((gps_bcm->piomux_block) && (gps_bcm->pblock_config)) {
ret = blockmux_set(gps_bcm->piomux_block, gps_bcm->pblock_config, LOWPOWER);
if (ret)
dev_err(&pdev->dev, "Set gps iomux to LOWPOWER failed, ret=%d\n", ret);
}
clk_disable(gps_bcm->clk);
clk_put(gps_bcm->clk);
#else
gpio_free(gps_bcm->gpioid_power);
#endif
gpio_free(gps_bcm->gpioid_en);
gpio_free(gps_bcm->gpioid_ret);
kfree(gps_bcm);
gps_bcm = NULL;
platform_set_drvdata(pdev, NULL);
dev_dbg(&pdev->dev, "k3_gps_bcm_remove -\n");
return ret;
}
/*NOT called by VIA*/
static void mshci_sd_power_onoff(struct mshci_host *ms_host,int ispowerup)
{
struct himci_host * hi_host = (struct himci_host *)(ms_host->private);
int ret = 0;
if (sd_ldo22_need_control){/* during power-on or power-off,need to restore sd io if necessary */
pmussi_reg_write(SOC_SMART_ENABLE4_ADDR(0),BIT(SOC_SMART_ENABLE4_en_ldo22_int_START));
udelay(30);
pmussi_reg_write(SOC_SMART_LDO7_REG_ADJ_ADDR(0),SDMMC_3V3_IO_LDO7_SSI_VALUE);
sd_ldo22_need_control = 0;
}
if (ispowerup){
udelay(30);
if (hi_host->signal_vcc){
ret = regulator_enable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_enable");
}
}
udelay(30);
if (hi_host->vcc_lvs){
ret = regulator_enable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_enable");
}
}
if (hi_host->vcc_ldo) {
ret = regulator_set_voltage(hi_host->vcc_ldo, SDMMC_SDCARD_285, SDMMC_SDCARD_285);
if (ret != 0) {
himci_error("failed to LDO10 regulator_set_voltage 2.85 \n");
}
}
if (hi_host->vcc_ldo){
ret = regulator_enable(hi_host->vcc_ldo);
if (ret) {
himci_error("failed to regulator_enable");
}
}
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
if (ret) {
himci_error("failed to blockmux_set");
}
}
else{
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, LOWPOWER);
if (ret) {
himci_error("failed to blockmux_set");
}
mshci_sd_lowpower();
if (hi_host->vcc_ldo){
ret = regulator_disable(hi_host->vcc_ldo);
if (ret) {
himci_error("failed to regulator_disable LDO10");
}
}
if (hi_host->vcc_lvs){
ret = regulator_disable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_disable LDO7");
}
}
udelay(30);
if (hi_host->signal_vcc){
ret = regulator_disable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_disable LDO22");
}
}
}
}
static int __devinit k3_bq24161_charger_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
u8 read_reg = 0;
int ret = 0;
enum usb_charger_type plugin_stat = CHARGER_REMOVED;
struct k3_bq24161_device_info *di = NULL;
struct k3_bq24161_platform_data *pdata = NULL;
/*enum plugin_status plugin_stat;*/
if (!g_battery_measure_by_bq27510_device) {
dev_err(&client->dev, "g_battery_measure_by_bq27510_device is NULL!\n");
return -ENOMEM;
}
pdata = client->dev.platform_data;
if (!pdata) {
dev_err(&client->dev, "pdata is NULL!\n");
return -ENOMEM;
}
di = kzalloc(sizeof(*di), GFP_KERNEL);
if (!di) {
dev_err(&client->dev, "di is NULL!\n");
return -ENOMEM;
}
di->dev = &client->dev;
di->client = client;
i2c_set_clientdata(client, di);
ret = k3_bq24161_read_byte(di, &read_reg, REG_PART_REVISION);
if (ret < 0) {
dev_err(&client->dev, "chip not present at address %x\n",
client->addr);
ret = -EINVAL;
goto err_kfree;
}
if (((read_reg & BQ24161_VERSION_MSK) == 0x00)
&& (client->addr == I2C_ADDR_BQ24161))
di->bqchip_version = BQ24161;
if (di->bqchip_version == 0) {
dev_err(&client->dev, "unknown bq chip\n");
dev_err(&client->dev, "Chip address %x", client->addr);
dev_err(&client->dev, "bq chip version reg value %x", read_reg);
ret = -EINVAL;
goto err_kfree;
}
di->max_voltagemV = pdata->max_charger_voltagemV;
di->max_currentmA = pdata->max_charger_currentmA;
di->voltagemV = di->max_voltagemV;
di->currentmA = CURRENT_USB_CHARGE_IN ;
di->term_currentmA = CURRENT_TERM_CHARGE_IN;
di->dppm_voltagemV = VOLT_DPPM_ADJUST;
di->cin_limit = CURRENT_USB_LIMIT_IN;
di->gpio = pdata->gpio;
/**********ADD BY 00186176 begin****************/
/* Set iomux normal */
#ifdef CONFIG_GPIO_BAT
if (!di->piomux_block)
di->piomux_block = iomux_get_block("block_charger");
if (!di->pblock_config)
di->pblock_config = iomux_get_blockconfig("block_charger");
ret = blockmux_set(di->piomux_block, di->pblock_config, NORMAL);
if (ret) {
dev_err(&client->dev, "blockmux_set NORMAL failed, ret=%d\n", ret);
goto err_kfree;
}
#endif
/*set gpio_074 to control CD pin to disable/enable bq24161 IC*/
ret = gpio_request(di->gpio, "gpio_074_cd");
if (ret) {
dev_err(&client->dev, "could not request irq\n");
ret = -ENOMEM;
goto err_io;
}
/* set charger CD pin to low level and enable it to supply power normally*/
gpio_direction_output(di->gpio, 0);
/**********ADD BY 00186176 END****************/
di->enable_low_chg = ENABLE_LOW_CHG;
/*enable low charge,100mA charging*/
k3_bq24161_config_safety_reg(di);
/*disable charge current termination*/
di->enable_iterm = DISABLE_ITERM;
di->factory_flag = 0;
di->enable_ce = ENABLE_CE;
di->hz_mode = 0;
di->cd_active = 0;
#if BQ2416X_USE_WAKE_LOCK
wake_lock_init(&di->charger_wake_lock, WAKE_LOCK_SUSPEND, "charger_wake_lock");
#endif
INIT_DELAYED_WORK(&di->bq24161_charger_work,
k3_bq24161_charger_work);
INIT_WORK(&di->usb_work, k3_bq24161_usb_charger_work);
di->active = 0;
di->params.enable = 1;
di->cfg_params = 1;
/*di->enable_iterm = 1;*/
k3_bq24161_config_control_reg(di);
k3_bq24161_config_voltage_reg(di);
k3_bq24161_config_current_reg(di);
k3_bq24161_config_dppm_voltage_reg(di, di->dppm_voltagemV);
k3_bq24161_config_safety_reg(di);
ret = sysfs_create_group(&client->dev.kobj, &k3_bq24161_attr_group);
if (ret) {
dev_err(&client->dev, "could not create sysfs files\n");
goto err_gpio;
}
/**********ADD BY 00186176 begin****************/
di->nb.notifier_call = k3_bq24161_usb_notifier_call;
ret = hiusb_charger_registe_notifier(&di->nb);
if (ret < 0) {
dev_err(&client->dev, "hiusb_charger_registe_notifier failed\n");
goto err_sysfs;
}
plugin_stat = get_charger_name();
if ((CHARGER_TYPE_USB == plugin_stat) || (CHARGER_TYPE_NON_STANDARD == plugin_stat)) {
di->event = plugin_stat;
k3_bq24161_start_500mA_charger(di);
} else if (CHARGER_TYPE_BC_USB == plugin_stat) {
k3_bq24161_start_BCUSB_charger(di);
} else if (CHARGER_TYPE_STANDARD == plugin_stat) {
k3_bq24161_start_ac_charger(di);
} else {
k3_bq24161_stop_charger(di);
}
return 0;
err_sysfs:
sysfs_remove_group(&client->dev.kobj, &k3_bq24161_attr_group);
err_gpio:
gpio_free(di->gpio);
err_io:
#ifdef CONFIG_GPIO_BAT
if (blockmux_set(di->piomux_block, di->pblock_config, LOWPOWER))
dev_err(&client->dev, "blockmux_set LOWPOWER failed\n");
#endif
/**********ADD BY 00186176 END****************/
err_kfree:
kfree(di);
di = NULL;
return ret;
}
/*
**************************************************************************
* FunctionName: ispv1_ioconfig;
* Description : iomux config;
* Input : power_state: on/off
* Output : NA;
* ReturnValue : NA;
* Other : NA;
**************************************************************************
*/
static int ispv1_ioconfig(camera_power_state power_state, data_interface_t type)
{
int ret = 0;
print_info("%s camera iomux config", __func__);
/* Modified by w00199382 for isp 2.2 , 2012/11/23, begin */
#if 0
if (power_state == POWER_ON) {
ret = blockmux_set(ispv1_io.block_i2c, ispv1_io.block_conf_i2c, NORMAL);
if (ret != 0) {
print_error("%s: failed to set iomux dvp to normal mode.\n", __func__);
}
ret |= blockmux_set(ispv1_io.block_rst, ispv1_io.block_conf_rst, NORMAL);
if (ret != 0) {
print_error("%s: failed to set iomux dvp to normal mode.\n", __func__);
}
ret |= blockmux_set(ispv1_io.block_isp, ispv1_io.block_conf_isp, NORMAL);
if (ret != 0) {
print_error("%s: failed to set iomux isp to GPIO mode.\n", __func__);
}
if (type == DVP) {
ret |= blockmux_set(ispv1_io.block_dvp, ispv1_io.block_conf_dvp, NORMAL);
if (ret != 0) {
print_error("%s: failed to set iomux dvp to normal mode.\n", __func__);
}
}
} else {
ret = blockmux_set(ispv1_io.block_i2c, ispv1_io.block_conf_i2c, LOWPOWER);
if (ret != 0) {
print_error("%s: failed to set iomux dvp to normal mode.\n", __func__);
}
ret |= blockmux_set(ispv1_io.block_rst, ispv1_io.block_conf_rst, LOWPOWER);
if (ret != 0) {
print_error("%s: failed to set iomux dvp to normal mode.\n", __func__);
}
ret |= blockmux_set(ispv1_io.block_isp, ispv1_io.block_conf_isp, LOWPOWER);
if (ret != 0) {
print_error("%s: failed to set iomux isp to GPIO mode.\n", __func__);
}
if (type == DVP) {
ret |= blockmux_set(ispv1_io.block_dvp, ispv1_io.block_conf_dvp, LOWPOWER);
if (ret != 0) {
print_error("%s: failed to set iomux dvp to normal mode.\n", __func__);
}
}
}
#endif
/* Modified by w00199382 for isp 2.2 , 2012/11/23, end */
#if defined(CONFIG_ARCH_HI6620)
if (power_state == POWER_ON) {
ret = pinctrl_select_state(ispv1_io.isp_pinctrl, ispv1_io.pinctrl_def); //work mode
if (ret != 0) {
print_error("%s: failed to set iomux scam/mcam to normal mode.\n", __func__);
}
} else {
ret =pinctrl_select_state(ispv1_io.isp_pinctrl, ispv1_io.pinctrl_idle);
if (ret != 0) {
print_error("%s: failed to set iomux scam/mcam to lowpower mode.\n", __func__);
}
}
#endif
return ret;
}
static int __devinit k3_gps_bcm_probe(struct platform_device *pdev)
{
GPS_BCM_INFO *gps_bcm;
struct resource *res;
int ret = 0;
gps_bcm = kzalloc(sizeof(GPS_BCM_INFO), GFP_KERNEL);
if (!gps_bcm) {
dev_err(&pdev->dev, "Alloc memory failed\n");
return -ENOMEM;
}
platform_set_drvdata(pdev, gps_bcm);
/* Get enable gpio */
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
if (!res) {
dev_err(&pdev->dev, "Get enable gpio resourse failed\n");
ret = -ENXIO;
goto err_free;
}
gps_bcm->gpioid_en = res->start;
ret = gpio_request(gps_bcm->gpioid_en, "gps_enbale");
if (ret < 0) {
dev_err(&pdev->dev, "gpio_request failed, gpio=%lu, ret=%d\n", gps_bcm->gpioid_en, ret);
goto err_free;
}
gpio_export(gps_bcm->gpioid_en, false);
/* Get reset gpio */
res = platform_get_resource(pdev, IORESOURCE_IO, 1);
if (!res) {
dev_err(&pdev->dev, "Get reset gpio resourse failed\n");
ret = -ENXIO;
goto err_free_gpio_en;
}
gps_bcm->gpioid_ret = res->start;
ret = gpio_request(gps_bcm->gpioid_ret, "gps_reset");
if (ret < 0) {
dev_err(&pdev->dev, "gpio_request failed, gpio=%lu, ret=%d\n", gps_bcm->gpioid_ret, ret);
goto err_free_gpio_en;
}
gpio_export(gps_bcm->gpioid_ret, false);
#ifndef CONFIG_MACH_K3V2OEM1
/* Get power gpio (VDDIO 1.8V), Only for FPGA */
res = platform_get_resource(pdev, IORESOURCE_IO, 2);
if (!res) {
dev_err(&pdev->dev, "Get power gpio resourse failed\n");
ret = -ENXIO;
goto err_free_gpio_ret;
}
gps_bcm->gpioid_power = res->start;
ret = gpio_request(gps_bcm->gpioid_power, "gps_power");
if (ret < 0) {
dev_err(&pdev->dev, "gpio_request failed, gpio=%lu, rc=%d\n", gps_bcm->gpioid_power, ret);
gpio_free(gps_bcm->gpioid_en);
goto err_free_gpio_ret;
}
/* Low GPS power, only for FPGA */
gpio_direction_output(gps_bcm->gpioid_power, 0);
/* High GPS power, only for FPGA */
gpio_set_value(gps_bcm->gpioid_power, 1);
dev_dbg(&pdev->dev, "High power\n");
#else
/* Set 32KC clock */
gps_bcm->clk = clk_get(NULL, "clk_pmu32kc");
if (IS_ERR(gps_bcm->clk)) {
dev_err(&pdev->dev, "Get gps clk failed\n");
ret = PTR_ERR(gps_bcm->clk);
goto err_free_gpio_ret;
}
ret = clk_enable(gps_bcm->clk);
if (ret) {
dev_err(&pdev->dev, "Enable clk failed, ret=%d\n", ret);
goto err_free_clk;
}
/* Set iomux NORMAL, If set iomux failed, we still go on */
gps_bcm->piomux_block = iomux_get_block("block_gps_boardcom");
if (!gps_bcm->piomux_block)
dev_err(&pdev->dev, "Get gps iomux_block failed\n");
gps_bcm->pblock_config = iomux_get_blockconfig("block_gps_boardcom");
if (!gps_bcm->pblock_config)
dev_err(&pdev->dev, "Get gps block_config failed\n");
if ((gps_bcm->piomux_block) && (gps_bcm->pblock_config)) {
ret = blockmux_set(gps_bcm->piomux_block, gps_bcm->pblock_config, NORMAL);
if (ret)
dev_err(&pdev->dev, "Set gps iomux to NORMAL failed, ret=%d\n", ret);
}
#endif
/* Low Reset GPIO */
gpio_direction_output(gps_bcm->gpioid_ret, 0);
dev_dbg(&pdev->dev, "Low reset\n");
/* Low Enable GPIO */
gpio_direction_output(gps_bcm->gpioid_en, 0);
dev_dbg(&pdev->dev, "Low enable\n");
/* High Reset GPIO*/
gpio_set_value(gps_bcm->gpioid_ret, 1);
dev_dbg(&pdev->dev, "High reset\n");
return 0;
#ifdef CONFIG_MACH_K3V2OEM1
err_free_clk:
clk_put(gps_bcm->clk);
#endif
err_free_gpio_ret:
gpio_free(gps_bcm->gpioid_ret);
err_free_gpio_en:
gpio_free(gps_bcm->gpioid_en);
err_free:
kfree(gps_bcm);
gps_bcm = NULL;
return ret;
}
void mshci_hi_set_ios(struct mshci_host *ms_host, struct mmc_ios *ios)
{
struct himci_host * hi_host = (struct himci_host *)(ms_host->private);
int ret = -1;
hi_host_trace(HIMCI_TRACE_GEN_API, "++");
himci_assert(ios);
himci_assert(hi_host);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->power_mode = %d ", ios->power_mode);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->clock = %d ", ios->clock);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->bus_width = %d ", ios->bus_width);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->timing = %d ", ios->timing);
/* process power */
if (hi_host->old_power_mode != ios->power_mode) {
switch (ios->power_mode) {
case MMC_POWER_OFF:
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "set io to lowpower");
if (hi_host->vcc) {
regulator_disable(hi_host->vcc);
}
if (hi_host->signal_vcc) {
regulator_disable(hi_host->signal_vcc);
regulator_set_mode(hi_host->signal_vcc, REGULATOR_MODE_IDLE);
}
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, LOWPOWER);
if (ret) {
himci_error("failed to blockmux_set");
}
break;
case MMC_POWER_UP:
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "set io to normal");
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
if (ret) {
himci_error("failed to blockmux_set");
}
if (hi_host->vcc) {
ret = regulator_set_voltage(hi_host->vcc, 2850000, 2850000);
if (ret != 0) {
himci_error("failed to regulator_set_voltage");
}
ret = regulator_enable(hi_host->vcc);
if (ret) {
himci_error("failed to regulator_enable");
}
}
if (hi_host->signal_vcc) {
ret = regulator_set_voltage(hi_host->signal_vcc, 2600000, 2600000);
if (ret != 0) {
himci_error("failed to regulator_set_voltage");
}
regulator_set_mode(hi_host->signal_vcc, REGULATOR_MODE_NORMAL);
ret = regulator_enable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_enable");
}
}
break;
case MMC_POWER_ON:
break;
default:
himci_error("unknown power supply mode");
break;
}
hi_host->old_power_mode = ios->power_mode;
}
/* process timing */
if (hi_host->old_timing != ios->timing) {
hi_host->old_timing = ios->timing;
if ( get_chipid() == DI_CHIP_ID ) {
mshci_hi_update_timing(ms_host, 0);
switch (ios->timing) {
case MMC_TIMING_LEGACY:
if (hi_host->pdev->id == 1) {
/* 2 division, 40M */
writel((0x1<<6) | (0x7<<22),
IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2);
ms_host->max_clk = 40*1000*1000;
ms_host->clock++;
} else if (hi_host->pdev->id == 0) {
/* 2 division, 40M */
writel((0x0<<5) | (0x1<<21),
IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2);
ms_host->max_clk = 40*1000*1000;
ms_host->clock++;
}
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "MMC_TIMING_LEGACY");
break;
case MMC_TIMING_UHS_DDR50:
if (hi_host->pdev->id == 1) {
/* 1 division, 80M */
writel((0x0<<6) | (0x7<<22),
IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2);
ms_host->max_clk = 80*1000*1000;
ms_host->clock++;
} else {
#if 0
/*
* m53980:
* debug purpose.
* change clock via sctrl configuration
*/
printk("clk div a:0x%x\n", readl(IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2));
writel((0x7)|(0xF<<16), IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2);
printk("clk div b:0x%x\n", readl(IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2));
#endif
}
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "MMC_TIMING_UHS_DDR50");
break;
case MMC_TIMING_UHS_SDR50:
if (hi_host->pdev->id == 0) {
writel((0x1<<5) | (0x1<<21),
IO_ADDRESS(REG_BASE_SCTRL) + REG_SCCLKDIV2);
ms_host->max_clk = 80*1000*1000;
ms_host->clock++;
}
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "MMC_TIMING_UHS_SDR50");
break;
default:
break;
}
} else {
ret = clk_set_rate(hi_host->pclk,hi_host->init_tuning_config[0 + (ios->timing + 1) * TUNING_INIT_CONFIG_NUM]);
if (ret) {
himci_error("failed to clk_set_rate");
}
hi_host->tuning_init_sample =
(hi_host->init_tuning_config[3 + (ios->timing + 1) * TUNING_INIT_CONFIG_NUM] +
hi_host->init_tuning_config[4 + (ios->timing + 1) * TUNING_INIT_CONFIG_NUM]) / 2;
mshci_hi_set_timing(hi_host,
hi_host->tuning_init_sample,
hi_host->init_tuning_config[2 + (ios->timing + 1) * TUNING_INIT_CONFIG_NUM],
hi_host->init_tuning_config[1 + (ios->timing + 1) * TUNING_INIT_CONFIG_NUM]);
ms_host->max_clk = hi_host->init_tuning_config[5 + (ios->timing + 1) * TUNING_INIT_CONFIG_NUM];
ms_host->clock++;
}
}
hi_host_trace(HIMCI_TRACE_GEN_API, "--");
}
static int hi_mci_suspend(struct platform_device *dev, pm_message_t pm)
{
struct mshci_host *ms_host = NULL;
struct himci_host *hi_host = NULL;
int ret = 0;
unsigned long flags;
int cbp_flag = 0;
int cbp_ret = 0;
ms_host = platform_get_drvdata(dev);
if (!ms_host) {
printk(KERN_ERR "get drvdata failed !\n");
return -1;
}
hi_host = mshci_priv(ms_host);
if(0 == hi_host->pdev->id)
{
g_ulmmc_suspend_flag = true;
printk("hi_mci_suspend,set g_ulmmc_suspend_flag.");
}
cbp_ret = get_hw_config_int("modem/viacbp82d", &cbp_flag, NULL);
if ((!cbp_ret) || (0 == cbp_flag)) {
pr_info("%s has no cbp support\n", __func__);
}
if ((1 == hi_host->pdev->id)&&(cbp_flag)){
if (ms_host->mmc->ios.power_mode != MMC_POWER_OFF) {
pr_info("%s cbp ext suspend sdio\n", __func__);
if (cbp_in_sdio_tras){
pr_info("%s cbp_in_sdio_tras %d\n", __func__, cbp_in_sdio_tras);
return -EAGAIN;
}
cbp_clock_enabled = 0;
cbp_host_waked = 0;
cbp_notifier_call_chain(0, NULL);
ms_host->mmc->ios.power_mode = MMC_POWER_UP;
ms_host->mmc->ios.clock = 0;
ms_host->mmc->ops->set_ios(ms_host->mmc, &ms_host->mmc->ios);
}
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, LOWPOWER);
if (ret) {
himci_error("failed to blockmux_set");
}
}
if (ms_host->quirks & MSHCI_QUIRK_WLAN_DETECTION) {
/* sdio power off */
if (ms_host->mmc->ios.power_mode != MMC_POWER_OFF) {
ret = mmc_sdio_suspend_ext(ms_host->mmc);
if (ret) {
printk("%s, sdio suspend error\n", __func__);
return ret;
}
ms_host->mmc->ios.power_mode = MMC_POWER_UP;
hi_host->old_timing = 0;
hi_host->old_sig_voltage = 0;
}
}
/*sd and emmc share the same suspend and resume*/
mshci_suspend_host(ms_host, pm);
spin_lock_irqsave(&ms_host->lock, flags);
if(ms_host->clk_ref_counter == CLK_ENABLED){
clk_disable(hi_host->pclk);
ms_host->clk_ref_counter = CLK_DISABLED;
}
spin_unlock_irqrestore(&ms_host->lock, flags);
return 0;
}
static int __devinit hi_mci_probe(struct platform_device *pdev)
{
struct mshci_host *ms_host = NULL;
struct himci_host *hi_host = NULL;
struct hisik3_mmc_platform_data *plat = NULL;
struct resource *memres = NULL;
int ret = 0, irq;
int err;
bool RetVal = 0;
unsigned long flags;
unsigned int sdcard_frequency = 0;
#ifdef CONFIG_MACH_HI6620OEM
if(1 == pdev->id)
{
raw_mmc_turn_on();
}
#endif
himci_trace(HIMCI_TRACE_GEN_API, "++");
himci_assert(pdev);
plat = pdev->dev.platform_data;
himci_trace(HIMCI_TRACE_SIGNIFICANT, "id:%d", pdev->id);
/*通过读取硬件配置项，或者sdcard时钟配置，只需要SD卡流程走，走一遍*/
#ifdef CONFIG_MACH_HI6620OEM
if(1 == pdev->id)
{
RetVal = get_hw_config_int("sd_card/sdcard_frequency", &sdcard_frequency, NULL);
printk("hsad: sd_card/sdcard_frequency = %d, RetVal = %d\n", sdcard_frequency, RetVal);
/*读取失败，配置默认值*/
if (RetVal == false) {
printk(KERN_ERR "get board type failed.\n");
g_sdcard_frequency = 90;
}
/*如果获取配置值异常，则配置默认值*/
if ((sdcard_frequency != 100)&&(sdcard_frequency != 90)) {
printk(KERN_ERR "sdcard_frequency %x is error.\n",sdcard_frequency);
g_sdcard_frequency = 90;
}
g_sdcard_frequency = sdcard_frequency;
}
#endif
/* 获取自己定义的数据 */
if (!plat) {
himci_error("Platform data not available");
return -ENOENT;
}
if(0 == pdev->id)
{
sema_init(&sem_to_rfile_sync_req,0);
}
/*创建硬件信号量IPC_SEM_EMMC*/
if (0 == pdev->id) {
mutex_lock(&emmc_mutex);
emmc_sem_flag = 1;
mutex_unlock(&emmc_mutex);
}
irq = platform_get_irq(pdev, 0);
memres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if ((!irq) || (!memres)) {
himci_error("resource error");
ret = -ENOENT;
goto err_resource_get;
}
himci_trace(HIMCI_TRACE_SIGNIFICANT, "irq:%d,start:0x%x,size:0x%x", irq, \
memres->start, resource_size(memres));
ms_host = mshci_alloc_host(&pdev->dev, sizeof(struct himci_host));
if (IS_ERR(ms_host)) {
himci_error("mshci_alloc_host() failed\n");
ret = PTR_ERR(ms_host);
goto err_resource_get;
}
hi_host = mshci_priv(ms_host);
hi_host->ms_host = ms_host;
hi_host->pdev = pdev;
hi_host->dev = &pdev->dev;
hi_host->plat = plat;
platform_set_drvdata(pdev, ms_host);
/* MMC IP rstdis */
if (plat->rstdis_mmc){
ret = plat->rstdis_mmc();
if ( ret < 0 ){
goto err_resource_get;
}
}
/* set emmc clk */
hi_host->pclk = clk_get(&pdev->dev, plat->clk_mmc_low); /* work clk */
if (IS_ERR(hi_host->pclk)) {
himci_error("clk_get clk_mmc_low fail!");
ret = PTR_ERR(hi_host->pclk);
goto err_io_clk;
}
hi_host->clk_mmc_high= clk_get(&pdev->dev, plat->clk_mmc_high); /* highclk used for tuning */
if (IS_ERR(hi_host->clk_mmc_high)) {
himci_error("clk_get clk_mmc_high fail!");
ret = PTR_ERR(hi_host->clk_mmc_high);
goto err_io_clk;
}
ms_host->pclk = NULL;
ms_host->clk_ref_counter = CLK_DISABLED;
ms_host->clk_mmc_high = NULL;
ms_host->pclk = hi_host->pclk;
ms_host->clk_mmc_high = hi_host->clk_mmc_high;
if (ret) {
himci_error("failed to clk_set_rate");
}
if(ms_host->clk_ref_counter == CLK_DISABLED){
ret = clk_enable(hi_host->pclk);
ms_host->clk_ref_counter = CLK_ENABLED;
if (ret) {
himci_error("clk_enable failed");
ret = -ENOENT;
goto err_clk_ops;
}
}
ms_host->ioaddr = ioremap_nocache(memres->start, resource_size(memres));
if (!ms_host->ioaddr) {
himci_error("ioremap_nocache failed");
ret = -ENXIO;
goto err_req_regs;
}
ms_host->hw_name = "hisi_hi6620_mmc";
ms_host->hw_mmc_id = hi_host->pdev->id;
ms_host->ops = &mshci_hi_ops;
ms_host->quirks = 0;
ms_host->irq = irq;
/* Setup quirks for the controller */
if (plat->quirks) {
ms_host->quirks |= plat->quirks;
}
if (plat->caps & MMC_CAP_CLOCK_GATING) {
/* there is no reason not to use interral clock gating */
ms_host->mmc->caps |= plat->caps;
ms_host->mmc->caps |= MMC_CAP_CLOCK_GATING;
ms_host->clock_gate = 1;
} else {
ms_host->mmc->caps |= plat->caps;
ms_host->clock_gate = 0;
}
ms_host->mmc->caps2 = plat->caps2;
/* sandisk card need clock longer than spec ask */
/* sdcard also disable ip clock gate c00261379*/
if (ms_host->hw_mmc_id == 0 || ms_host->hw_mmc_id == 1)
ms_host->clock_gate = 0;
if (plat->ocr_mask)
ms_host->mmc->ocr_avail |= plat->ocr_mask;
#ifdef CONFIG_MACH_HI6620OEM
if (plat->iomux_name){
hi_host->piomux_block = iomux_get_block(plat->iomux_name);
hi_host->pblock_config = iomux_get_blockconfig(plat->iomux_name);
}
/* todo requlator */
if (plat->reg_name_ldo) {
himci_trace(HIMCI_TRACE_SIGNIFICANT, "devname : %s, regname: %s",
dev_name(hi_host->dev), plat->reg_name_ldo);
hi_host->vcc_ldo = regulator_get(hi_host->dev, plat->reg_name_ldo);
if (!IS_ERR(hi_host->vcc_ldo)) {
/*
* Setup a notifier block to update this if another device
* causes the voltage to change
*/
hi_host->nb.notifier_call = &mshci_hi_disable_voltage;
ret = regulator_register_notifier(hi_host->vcc_ldo, &hi_host->nb);
if (ret) {
dev_err(&pdev->dev,
"regulator notifier request failed\n");
}
} else {
dev_err(&pdev->dev, "regulator_get() failed\n");
hi_host->vcc_ldo = NULL;
}
}
if (plat->reg_name_lvs) {
himci_trace(HIMCI_TRACE_SIGNIFICANT, "devname : %s, regname: %s",
dev_name(hi_host->dev), plat->reg_name_lvs);
hi_host->vcc_lvs = regulator_get(hi_host->dev, plat->reg_name_lvs);
if (!IS_ERR(hi_host->vcc_lvs)) {
/*
* Setup a notifier block to update this if another device
* causes the voltage to change
*/
hi_host->nb.notifier_call = &mshci_hi_disable_voltage;
ret = regulator_register_notifier(hi_host->vcc_lvs, &hi_host->nb);
if (ret) {
dev_err(&pdev->dev,
"regulator notifier request failed\n");
}
} else {
dev_err(&pdev->dev, "regulator_get() failed\n");
hi_host->vcc_lvs = NULL;
}
}
hi_host->ocp_flag = 0;
if (plat->signal_reg_name) {
himci_trace(HIMCI_TRACE_SIGNIFICANT, "devname : %s, signal regname: %s",
dev_name(hi_host->dev), plat->signal_reg_name);
hi_host->signal_vcc = regulator_get(hi_host->dev, plat->signal_reg_name);
if (IS_ERR(hi_host->signal_vcc)) {
dev_err(&pdev->dev, "regulator_get() failed\n");
hi_host->signal_vcc = NULL;
}
}
#endif
if( (1 == pdev->id)&&( (ms_host->quirks & MSHCI_QUIRK_CBP_DETECTION) == 0)) {
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, LOWPOWER);
if (ret) {
himci_error("failed to blockmux_set");
}
mshci_sd_lowpower();
if (hi_host->vcc_lvs){
ret = regulator_enable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_enable LDO7");
}
ret = regulator_disable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_disable LDO7");
}
}
udelay(30);
if (hi_host->signal_vcc){
ret = regulator_enable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_enable LDO22");
}
ret = regulator_disable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_disable LDO22");
}
}
}else {/*for cbp*/
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
if (ret) {
himci_error("failed to blockmux_set");
}
if (hi_host->vcc_lvs){
ret = regulator_enable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_enable LDO7");
}
}
udelay(30);
if (hi_host->signal_vcc){
ret = regulator_enable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_enable LDO22");
}
ret = regulator_disable(hi_host->signal_vcc);
if (ret) {
himci_error("failed to regulator_disable LDO22");
}
}
}
hi_host->old_sig_voltage = plat->default_signal_voltage;
hi_host->old_timing = MMC_TIMING_UHS_DDR50;
hi_host->timing_config = plat->timing_config;
hi_host->allow_switch_signal_voltage = plat->allow_switch_signal_voltage;
hi_host->suspend_timing_config = plat->suspend_timing_config;
if (ms_host->quirks & MSHCI_QUIRK_WLAN_DETECTION) {
ms_host->flags |= MSHCI_DEVICE_DEAD;
ms_host->flags |= MMC_PM_KEEP_POWER;
ms_host->mmc->pm_caps |= MMC_PM_KEEP_POWER;
}
ret = mshci_add_host(ms_host);
if (ret) {
dev_err(&pdev->dev, "mshci_add_host() failed\n");
goto err_add_host;
}
if (ms_host->quirks & MSHCI_QUIRK_WLAN_DETECTION) {
ms_host->flags |= MSHCI_DEVICE_DEAD;
ms_host->flags |= MMC_PM_KEEP_POWER;
ms_host->mmc->pm_caps |= MMC_PM_KEEP_POWER;
if (plat->ext_cd_init)
plat->ext_cd_init(&mshci_hi_notify_change);
plat->set_power = mshci_hi_sdio_set_power;
}
if( (1 == pdev->id)&&( (ms_host->quirks & MSHCI_QUIRK_CBP_DETECTION) != 0)) {
ms_host->flags |= MMC_PM_KEEP_POWER;
ms_host->mmc->pm_caps |= MMC_PM_KEEP_POWER;
}
if (ms_host->quirks & MSHCI_QUIRK_EXTERNAL_CARD_DETECTION) {
err = gpio_request_one(plat->cd_gpio, GPIOF_IN, "ESDHC_CD");
if (err) {
dev_warn(mmc_dev(ms_host->mmc),
"no card-detect pin available!\n");
goto no_card_detect_pin;
}
/*SD_INT_FIX_suspend DTS:2013082704916 modifier: y00241633*/
err = request_irq(gpio_to_irq(plat->cd_gpio), mshci_hi_card_detect_gpio,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND,
mmc_hostname(ms_host->mmc), ms_host);
if (err) {
dev_warn(mmc_dev(ms_host->mmc), "request gpio irq error\n");
goto no_card_detect_irq;
}
if ( plat->sw_gpio ){
/* only sft has this gpio */
err = gpio_request_one(plat->sw_gpio, 0, "ESDHC_POWER_SWITCH");
if (err) {
dev_warn(mmc_dev(ms_host->mmc),
"no card-power-switch pin available!\n");
goto no_card_power_switch_pin;
}
/*控制I/O口电平 1V8 or 3V3*/
gpio_direction_output(plat->sw_gpio, 1);
}
}
return 0;
no_card_power_switch_pin:
plat->sw_gpio = err;
no_card_detect_irq:
gpio_free(plat->cd_gpio);
no_card_detect_pin:
plat->cd_gpio = err;
err_add_host:
iounmap(ms_host->ioaddr);
ms_host->ioaddr = NULL;
err_req_regs:
spin_lock_irqsave(&ms_host->lock, flags);
if(ms_host->clk_ref_counter == CLK_ENABLED){
clk_disable(hi_host->pclk);
ms_host->clk_ref_counter = CLK_DISABLED;
}
spin_unlock_irqrestore(&ms_host->lock, flags);
err_clk_ops:
clk_put(hi_host->clk_mmc_high);
clk_put(hi_host->pclk);
err_io_clk:
mshci_free_host(ms_host);
err_resource_get:
return ret;
}
void mshci_hi_set_ios(struct mshci_host *ms_host, struct mmc_ios *ios)
{
struct himci_host * hi_host = (struct himci_host *)(ms_host->private);
int ret = -1;
int cbp_flag = 0;
hi_host_trace(HIMCI_TRACE_GEN_API, "++");
himci_assert(ios);
himci_assert(hi_host);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->power_mode = %d ", ios->power_mode);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->clock = %d ", ios->clock);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->bus_width = %d ", ios->bus_width);
hi_host_trace(HIMCI_TRACE_GEN_INFO, "ios->timing = %d ", ios->timing);
ret = get_hw_config_int("modem/viacbp82d", &cbp_flag, NULL);
if ((!ret) || (0 == cbp_flag)) {
pr_info("%s has no cbp support\n", __func__);
}
pr_info("%s mode %d\n", __func__, ios->power_mode);
/* process power */
if (hi_host->old_power_mode != ios->power_mode) {
switch (ios->power_mode) {
case MMC_POWER_OFF:
if ((!cbp_flag)&&(1 == ms_host->hw_mmc_id)){
mshci_sd_power_onoff(ms_host, 0);
break;
}
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "set io to lowpower");
if (hi_host->piomux_block && hi_host->pblock_config){
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, LOWPOWER);
if (ret) {
himci_error("failed to blockmux_set");
}
}
if (hi_host->vcc_lvs){
ret = regulator_disable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_enable");
}
}
if (hi_host->vcc_ldo){
ret = regulator_disable(hi_host->vcc_ldo);
if (ret) {
himci_error("failed to regulator_enable");
}
}
break;
case MMC_POWER_UP:
hi_host_trace(HIMCI_TRACE_SIGNIFICANT, "set io to normal");
if ((!cbp_flag)&&(1 == ms_host->hw_mmc_id)){
mshci_sd_power_onoff(ms_host, 1);
break;
}
if (hi_host->vcc_ldo){
ret = regulator_enable(hi_host->vcc_ldo);
if (ret) {
himci_error("failed to regulator_enable");
}
}
if((1 == hi_host->ms_host->hw_mmc_id)&&(cbp_flag)){
/*cbp need set as fixed 1.8v*/
himci_error("sdio regulator_set_voltage 1.8 \n");
if (hi_host->vcc_lvs) {
ret = regulator_set_voltage(hi_host->vcc_lvs, SDMMC_1V8_IO_LDO7_180, SDMMC_1V8_IO_LDO7_180);
if (ret != 0) {
himci_error("failed to LDO7 regulator_set_voltage 1.8 \n");
}
}
}
if (hi_host->vcc_lvs){
ret = regulator_enable(hi_host->vcc_lvs);
if (ret) {
himci_error("failed to regulator_enable");
}
}
if (hi_host->piomux_block && hi_host->pblock_config){
ret = blockmux_set(hi_host->piomux_block, hi_host->pblock_config, NORMAL);
if (ret) {
himci_error("failed to blockmux_set");
}
}
break;
case MMC_POWER_ON:
break;
default:
himci_error("unknown power supply mode");
break;
}
hi_host->old_power_mode = ios->power_mode;
}
hi_host_trace(HIMCI_TRACE_GEN_API, "--");
}
