void act8846_device_suspend(void)
{		
	struct regulator *dcdc;
	#ifdef CONFIG_ACT8846_SUPPORT_RESET
	sram_gpio_set_value(pmic_vsel, GPIO_LOW);  
	
	dcdc =dvfs_get_regulator( "vdd_cpu");
	vdd_cpu_vol = regulator_get_voltage(dcdc);
	regulator_set_voltage(dcdc, 900000, 900000);
	udelay(100);

	dcdc =dvfs_get_regulator( "vdd_core");
	vdd_core_vol = regulator_get_voltage(dcdc);
	regulator_set_voltage(dcdc, 900000, 900000);
	udelay(100);

	dcdc =regulator_get(NULL, "act_dcdc4");
	regulator_set_voltage(dcdc, 2800000, 2800000);
	regulator_put(dcdc);
	udelay(100);

	#endif
}
void act8846_device_resume(void)
{
	struct regulator *dcdc;
	#ifdef CONFIG_ACT8846_SUPPORT_RESET

	dcdc =dvfs_get_regulator( "vdd_cpu");
	regulator_set_voltage(dcdc, vdd_cpu_vol, vdd_cpu_vol);
	udelay(100);

	dcdc =dvfs_get_regulator( "vdd_core");
	regulator_set_voltage(dcdc, vdd_core_vol, vdd_core_vol);
	udelay(100);

	dcdc =regulator_get(NULL, "act_dcdc4");
	regulator_set_voltage(dcdc, 3000000, 3000000);
	regulator_put(dcdc);
	udelay(100);
	
	sram_gpio_set_value(pmic_vsel, GPIO_HIGH);  
	
	#endif
	
}
Beispiel #3
0
ssize_t clk_volt_store(struct kobject *kobj, struct kobj_attribute *attr,
		const char *buf, size_t n)
{
	char cmd[20], regulator_name[20];
	unsigned int volt;
	int ret = 0;
	int need_put_regulator=0;
	struct regulator *regulator;

	printk("%s: %s\n", __func__, buf);
	sscanf(buf, "%s %s %u", cmd, regulator_name, &volt);

	regulator = dvfs_get_regulator(regulator_name);
	if (IS_ERR_OR_NULL(regulator)) {
		regulator = regulator_get(NULL, regulator_name);
		if (IS_ERR(regulator)){
			PM_ERR("%s get dvfs_regulator %s error\n", __func__, regulator_name);
			return n;
		}
		need_put_regulator = 1;
	}	

	if (0 == strncmp(cmd, "set", strlen("set"))){
		if (volt & SET_SUSPEND_VOLT_FLAG){
			volt &= ~SET_SUSPEND_VOLT_FLAG;
			//ret = regulator_set_suspend_voltage(regulator, volt); 
			if (!ret)
				printk("set %s suspend volt to %uuV ok\n", regulator_name, volt);
			else
				printk("regulator_set_suspend_voltage err:%d\n", ret);
		}else{
			ret = regulator_set_voltage(regulator, volt, volt); 
			if (!ret)
				printk("set %s volt to %uuV ok\n", regulator_name, regulator_get_voltage(regulator));
			else
				printk("regulator_set_voltage err:%d\n", ret);
		}
		
	}
	if (0 == strncmp(cmd, "get", strlen("get"))){
		printk("%s:%duV\n", regulator_name, regulator_get_voltage(regulator));
	}

	if (need_put_regulator)
		regulator_put(regulator);

//	if (0 == strncmp(cmd, "enable", strlen("enable"))) {
	return n;
}
Beispiel #4
0
ssize_t clk_auto_volt_store(struct kobject *kobj, struct kobj_attribute *attr,
                            const char *buf, size_t n)
{
    char cmd[10];
    char volt_flag[10];
    char regulator_name[20];

    sscanf(buf, "%s %s %s %u %u %u %u", cmd, volt_flag, regulator_name, &begin_volt, &stop_volt, &volt_step, &timer_tick);

    if (0 == strncmp(cmd, "start", strlen("start"))) {
        if (0 == strncmp(volt_flag, "up", strlen("up"))) {
            if (begin_volt >= stop_volt) {
                PM_ERR("wrong! begin_volt >= stop_volt!\n");
                return -EINVAL;
            }
            volt_direction = VOLT_UP;

        } else if (0 == strncmp(volt_flag, "down", strlen("down"))) {
            if (begin_volt <= stop_volt) {
                PM_ERR("wrong! begin_volt <= stop_volt!\n");
                return -EINVAL;
            }
            volt_direction = VOLT_DOWN;

        } else {
            PM_ERR("argument %s is invalid!\n",volt_flag);
            return -EINVAL;
        }

        regulator = dvfs_get_regulator(regulator_name);
        if (IS_ERR_OR_NULL(regulator)) {
            PM_ERR("%s get dvfs_regulator %s error\n", __func__, regulator_name);
            return -ENOMEM;
        }

        if (wq_is_run == 1) {
            cancel_delayed_work(&scal_volt_work);
            flush_workqueue(scal_volt_wq);
            //destroy_workqueue(scal_volt_wq);
            wq_is_run = 0;
        }

        PM_DBG("begin!\n");

        volt = begin_volt;

        scal_volt_wq = create_workqueue("scal volt wq");
        INIT_DELAYED_WORK(&scal_volt_work, scal_volt_func);
        queue_delayed_work(scal_volt_wq, &scal_volt_work, msecs_to_jiffies(timer_tick*1000));

        wq_is_run = 1;

    } else if (0 == strncmp(cmd, "stop", strlen("stop"))) {
        if (wq_is_run == 1) {
            cancel_delayed_work(&scal_volt_work);
            flush_workqueue(scal_volt_wq);
            //destroy_workqueue(scal_volt_wq);
            wq_is_run = 0;
        }

    } else {
        PM_ERR("argument %s is invalid!\n", cmd);
        return -EINVAL;
    }

    return  n;
}