C++ (Cpp) set_mdnie_value Examples

Example #1

static ssize_t negative_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	unsigned int value;
	int ret;

	ret = strict_strtoul(buf, 0, (unsigned long *)&value);
	dev_info(dev, "%s :: value=%d\n", __func__, value);

	if (ret < 0)
		return ret;
	else {
		if (mdnie->negative == value)
			return count;

		if (value >= NEGATIVE_MAX)
			value = NEGATIVE_OFF;

		value = (value) ? NEGATIVE_ON : NEGATIVE_OFF;

		mutex_lock(&mdnie->lock);
		mdnie->negative = value;
		mutex_unlock(&mdnie->lock);

		set_mdnie_value(mdnie, 0);
	}
	return count;
}

Example #2

static ssize_t scenario_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	unsigned int value;
	int ret;

	ret = strict_strtoul(buf, 0, (unsigned long *)&value);

	dev_info(dev, "%s :: value=%d\n", __func__, value);

	if (!SCENARIO_IS_VALID(value))
		value = UI_MODE;

#if defined(CONFIG_FB_MDNIE_PWM)
	if (value >= SCENARIO_MAX)
		value = UI_MODE;
#endif

	mutex_lock(&mdnie->lock);
	mdnie->scenario = value;
	mutex_unlock(&mdnie->lock);

	set_mdnie_value(mdnie, 0);
#if defined(CONFIG_FB_MDNIE_PWM)
	if ((mdnie->enable) && (mdnie->bd_enable))
		update_brightness(mdnie);
#endif

	return count;
}

Example #3

static ssize_t cabc_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	unsigned int value;
	int ret;

	ret = strict_strtoul(buf, 0, (unsigned long *)&value);

	dev_info(dev, "%s :: value=%d\n", __func__, value);

	if (value >= CABC_MAX)
		value = CABC_OFF;

	value = (value) ? CABC_ON : CABC_OFF;

	mutex_lock(&mdnie->lock);
	mdnie->cabc = value;
	mutex_unlock(&mdnie->lock);

	set_mdnie_value(mdnie, 0);
	if ((mdnie->enable) && (mdnie->bd_enable))
		update_brightness(mdnie);

	return count;
}

Example #4

File: mdnie.c Project: perillamint/tizen-linux-3.0

static ssize_t auto_brightness_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t size)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	int value;
	int rc;

	rc = strict_strtoul(buf, (unsigned int)0, (unsigned long *)&value);
	if (rc < 0)
		return rc;
	else {
		if (mdnie->auto_brightness != value) {
			dev_info(dev, "%s - %d -> %d\n", __func__, mdnie->auto_brightness, value);
			mutex_lock(&mdnie->dev_lock);
			mdnie->auto_brightness = value;
#if defined(CONFIG_FB_S5P_S6C1372)
			mutex_lock(&mdnie->lock);
			mdnie->cabc = (value) ? CABC_ON : CABC_OFF;
			mutex_unlock(&mdnie->lock);
#endif
			if (mdnie->auto_brightness >= 5)
				mdnie->power_lut_idx = LUT_LEVEL_OUTDOOR_2;
			else if (mdnie->auto_brightness == 4)
				mdnie->power_lut_idx = LUT_LEVEL_OUTDOOR_1;
			else
				mdnie->power_lut_idx = LUT_LEVEL_MANUAL_AND_INDOOR;
			mutex_unlock(&mdnie->dev_lock);
			set_mdnie_value(mdnie, 0);
			if (mdnie->bd_enable)
				update_brightness(mdnie);
		}
	}
	return size;
}

Example #5

static ssize_t mode_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	unsigned int value;
	int ret;

	ret = strict_strtoul(buf, 0, (unsigned long *)&value);

	dev_info(dev, "%s :: value=%d\n", __func__, value);

	if (value >= MODE_MAX) {
		value = STANDARD;
		return -EINVAL;
	}

	mutex_lock(&mdnie->lock);
	mdnie->mode = value;
	mutex_unlock(&mdnie->lock);

	set_mdnie_value(mdnie, 0);
#if defined(CONFIG_FB_MDNIE_PWM)
	if ((mdnie->enable) && (mdnie->bd_enable))
		update_brightness(mdnie);
#endif

	return count;
}

Example #6

void mdnie_late_resume(struct early_suspend *h)
{
    struct mdnie_info *mdnie = container_of(h, struct mdnie_info, early_suspend);
#if defined(CONFIG_FB_MDNIE_PWM)
    struct lcd_platform_data *pd = mdnie->lcd_pd;
#endif

    dev_info(mdnie->dev, "+%s\n", __func__);

#if defined(CONFIG_FB_MDNIE_PWM)
    if (mdnie->enable)
        mdnie_pwm_control(mdnie, 0);

    if (!pd)
        dev_info(&mdnie->bd->dev, "platform data is NULL.\n");

    if (!pd->power_on)
        dev_info(&mdnie->bd->dev, "power_on is NULL.\n");
    else
        pd->power_on(NULL, 1);

    if (mdnie->enable) {
        dev_info(&mdnie->bd->dev, "brightness=%d\n", mdnie->bd->props.brightness);
        update_brightness(mdnie);
    }

    mdnie->bd_enable = TRUE;
#endif

    set_mdnie_value(mdnie, 1);

    dev_info(mdnie->dev, "-%s\n", __func__);

    return;
}

Example #7

static ssize_t ebook_store(struct device *dev,
                           struct device_attribute *attr, const char *buf, size_t count)
{
    struct mdnie_info *mdnie = dev_get_drvdata(dev);
    unsigned int value;
    int ret;

    ret = strict_strtoul(buf, 0, (unsigned long *)&value);
    dev_info(dev, "%s :: value=%d, by %s\n", __func__, value, current->comm);

    if (ret < 0)
        return ret;
    else {
        if (mdnie->ebook == value)
            return count;

        if (value >= EBOOK_MAX)
            value = EBOOK_OFF;

        value = (value) ? EBOOK_ON : EBOOK_OFF;

        mutex_lock(&mdnie->lock);
        mdnie->ebook = value;
        mutex_unlock(&mdnie->lock);

        set_mdnie_value(mdnie, 0);
    }
    return count;
}

Example #8

static ssize_t user_mode_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t size)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	int value = 0;

	sscanf(buf, "%d", &value);

	mdnie->user_mode = value;
	set_mdnie_value(mdnie);

	return size;
}

Example #9

static ssize_t negative_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
{
 	struct mdnie_info *mdnie = dev_get_drvdata(dev);
 	unsigned int value;
 	int ret, i;
 	struct timespec ts;
 	struct rtc_time tm;
 
 	ret = strict_strtoul(buf, 0, (unsigned long *)&value);
 	dev_info(dev, "%s :: value=%d, by %s\n", __func__, value, current->comm);
 
      printk("%s ret = %d\n", __func__, ret);
 
 	if (ret < 0)
 		return ret;
 	else {
 		if (mdnie->negative == value)
 			return count;
 
 		if (value >= NEGATIVE_MAX)
 			value = NEGATIVE_OFF;
 
 		value = (value) ? NEGATIVE_ON : NEGATIVE_OFF;
 
 		mutex_lock(&mdnie->lock);
 		mdnie->negative = value;
 		if (value) {
 			getnstimeofday(&ts);
 			rtc_time_to_tm(ts.tv_sec, &tm);
 			negative[negative_idx].enable = value;
 			negative[negative_idx].pid = current->pid;
 			strcpy(negative[negative_idx].comm, current->comm);
 			sprintf(negative[negative_idx].time, "%d-%02d-%02d %02d:%02d:%02d",
 				tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
 			negative_idx++;
 			negative_idx %= 5;
 		}else{

                   for(i=0; i < 5; i++)
                   {
                        negative[i].enable = NEGATIVE_OFF;
                   }
 		}
 		mutex_unlock(&mdnie->lock);
 
 		set_mdnie_value(mdnie, 0);
 	}
 	return count;
}

Example #10

static ssize_t user_cr_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t size)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	int value;

	sscanf(buf, "%d", &value);

	if (value >= 0 || value <= 255)
		mdnie->user_cr = (u16)value;
	else {
		printk(KERN_ERR "[mDNIe] invalid user mcm cr value. 0 <= value <= 255\n");
		mdnie->user_cr = 128;
	}

	set_mdnie_value(mdnie);

	return size;
}

Example #11

static ssize_t outdoor_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct mdnie_info *mdnie = dev_get_drvdata(dev);
	unsigned int value;
	int ret;

	ret = strict_strtoul(buf, 0, (unsigned long *)&value);

	dev_info(dev, "%s :: value=%d\n", __func__, value);

	if (value > OUTDOOR_MAX)
		value = OUTDOOR_OFF;

	mdnie->outdoor = (value) ? OUTDOOR_ON : OUTDOOR_OFF;

	set_mdnie_value(mdnie);

	return count;
}

Example #12

File: mdnie.c Project: ffolkes/android_kernel_samsung_smdk4412

void mdnie_late_resume(struct early_suspend *h)
{
	u32 i;
	struct mdnie_info *mdnie = container_of(h, struct mdnie_info, early_suspend);
	struct lcd_platform_data *pd = NULL;

	dev_info(mdnie->dev, "+%s\n", __func__);

#if defined(CONFIG_FB_MDNIE_PWM)
	pd = mdnie->lcd_pd;

	if (mdnie->enable)
		mdnie_pwm_control(mdnie, 0);

	if (!pd)
		dev_info(&mdnie->bd->dev, "platform data is NULL.\n");

	if (!pd->power_on)
		dev_info(&mdnie->bd->dev, "power_on is NULL.\n");
	else
		pd->power_on(NULL, 1);

	if (mdnie->enable) {
		dev_info(&mdnie->bd->dev, "brightness=%d\n", mdnie->bd->props.brightness);
		update_brightness(mdnie);
	}

	mdnie->bd_enable = TRUE;
#endif

	set_mdnie_value(mdnie, 1);

	dev_info(mdnie->dev, "-%s\n", __func__);
	for (i = 0; i < 5; i++) {
		if (negative[i].enable)
			dev_info(mdnie->dev, "pid=%d, %s, %s\n", negative[i].pid, negative[i].comm, negative[i].time);
	}

	return ;
}

Example #13

void mDNIe_Init_Set_Mode(void)
{
	if (!IS_ERR_OR_NULL(g_mdnie))
		set_mdnie_value(g_mdnie);
}

Example #14

static int mdnie_probe(struct platform_device *pdev)
{
	struct platform_mdnie_data *pdata = pdev->dev.platform_data;
	struct mdnie_info *mdnie;
	int ret = 0;

	mdnie_class = class_create(THIS_MODULE, dev_name(&pdev->dev));
	if (IS_ERR_OR_NULL(mdnie_class)) {
		pr_err("failed to create mdnie class\n");
		ret = -EINVAL;
		goto error0;
	}

	mdnie_class->dev_attrs = mdnie_attributes;

	mdnie = kzalloc(sizeof(struct mdnie_info), GFP_KERNEL);
	if (IS_ERR_OR_NULL(mdnie)) {
		pr_err("failed to allocate mdnie\n");
		ret = -EINVAL;
		goto error1;
	}

	mdnie->dev = device_create(mdnie_class, &pdev->dev, 0, &mdnie, "mdnie");
	if (IS_ERR_OR_NULL(mdnie->dev)) {
		pr_err("failed to create mdnie device\n");
		ret = -EINVAL;
		goto error2;
	}

#if defined(CONFIG_FB_MDNIE_PWM)
	mdnie->bd = backlight_device_register("backlight", mdnie->dev,
		mdnie, &mdnie_backlight_ops, NULL);
	mdnie->bd->props.max_brightness = MAX_BRIGHTNESS_LEVEL;
	mdnie->bd->props.brightness = DEFAULT_BRIGHTNESS;
	mdnie->bd_enable = TRUE;
	mdnie->lcd_pd = pdata->lcd_pd;
#endif

	mdnie->scenario = UI_MODE;
	mdnie->mode = STANDARD;
	mdnie->tone = TONE_NORMAL;
	mdnie->outdoor = FALSE;
	mdnie->cabc = FALSE;
	mdnie->enable = TRUE;
	mdnie->tunning = FALSE;

	mutex_init(&mdnie->lock);

	platform_set_drvdata(pdev, mdnie);
	dev_set_drvdata(mdnie->dev, mdnie);

#ifdef CONFIG_HAS_WAKELOCK
#ifdef CONFIG_HAS_EARLYSUSPEND
	mdnie->early_suspend.suspend = mdnie_early_suspend;
	mdnie->early_suspend.resume = mdnie_late_resume;
	mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
	register_early_suspend(&mdnie->early_suspend);
#endif
#endif

#if defined(CONFIG_FB_S3C_S6F1202A)
	if (pdata->display_type == 0) {
		memcpy(tunning_table, tunning_table_hydis, sizeof(tunning_table));
		memcpy(etc_table, etc_table_hydis, sizeof(etc_table));
		tune_camera_outdoor = tune_camera_outdoor_hydis;
	} else if (pdata->display_type == 1) {
		memcpy(tunning_table, tunning_table_sec, sizeof(tunning_table));
		memcpy(etc_table, etc_table_sec, sizeof(etc_table));
		tune_camera_outdoor = tune_camera_outdoor_sec;
	} else if (pdata->display_type == 2) {
		memcpy(tunning_table, tunning_table_boe, sizeof(tunning_table));
		memcpy(etc_table, etc_table_boe, sizeof(etc_table));
		tune_camera_outdoor = tune_camera_outdoor_boe;
	}
#endif

	g_mdnie = mdnie;

	set_mdnie_value(mdnie);

	dev_info(mdnie->dev, "registered successfully\n");

	return 0;

error2:
	kfree(mdnie);
error1:
	class_destroy(mdnie_class);
error0:
	return ret;
}

Example #15

static int mdnie_probe(struct platform_device *pdev)
{
#if defined(CONFIG_FB_MDNIE_PWM)
	struct platform_mdnie_data *pdata = pdev->dev.platform_data;
#endif
	struct mdnie_info *mdnie;
	int ret = 0;

	mdnie_class = class_create(THIS_MODULE, dev_name(&pdev->dev));
	if (IS_ERR_OR_NULL(mdnie_class)) {
		pr_err("failed to create mdnie class\n");
		ret = -EINVAL;
		goto error0;
	}

	mdnie_class->dev_attrs = mdnie_attributes;

	mdnie = kzalloc(sizeof(struct mdnie_info), GFP_KERNEL);
	if (!mdnie) {
		pr_err("failed to allocate mdnie\n");
		ret = -ENOMEM;
		goto error1;
	}

	mdnie->dev = device_create(mdnie_class, &pdev->dev, 0, &mdnie, "mdnie");
	if (IS_ERR_OR_NULL(mdnie->dev)) {
		pr_err("failed to create mdnie device\n");
		ret = -EINVAL;
		goto error2;
	}

#if defined(CONFIG_FB_MDNIE_PWM)
	mdnie->bd = backlight_device_register("panel", mdnie->dev,
		mdnie, &mdnie_backlight_ops, NULL);
	mdnie->bd->props.max_brightness = MAX_BRIGHTNESS_LEVEL;
	mdnie->bd->props.brightness = DEFAULT_BRIGHTNESS;
	mdnie->bd_enable = TRUE;
	mdnie->lcd_pd = pdata->lcd_pd;
#endif

	mdnie->scenario = UI_MODE;
	mdnie->mode = STANDARD;
	mdnie->tone = TONE_NORMAL;
	mdnie->outdoor = OUTDOOR_OFF;
#if defined(CONFIG_FB_MDNIE_PWM)
	mdnie->cabc = CABC_ON;
#else
	mdnie->cabc = CABC_OFF;
#endif
	mdnie->enable = TRUE;
	mdnie->tunning = FALSE;
	mdnie->negative = NEGATIVE_OFF;

	mutex_init(&mdnie->lock);
	mutex_init(&mdnie->dev_lock);

	platform_set_drvdata(pdev, mdnie);
	dev_set_drvdata(mdnie->dev, mdnie);

#ifdef CONFIG_HAS_WAKELOCK
#ifdef CONFIG_HAS_EARLYSUSPEND
#if defined(CONFIG_FB_MDNIE_PWM)
	mdnie->early_suspend.suspend = mdnie_early_suspend;
	mdnie->early_suspend.resume = mdnie_late_resume;
	mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
	register_early_suspend(&mdnie->early_suspend);
#endif
#endif
#endif

#if defined(CONFIG_FB_S5P_S6C1372)
	check_lcd_type();
	dev_info(mdnie->dev, "lcdtype = %d\n", pdata->display_type);
	if (pdata->display_type == 1) {
		b_value.max = 1441;
		b_value.mid = 784;
		b_value.low = 16;
		b_value.dim = 16;
	} else {
		b_value.max = 1137;	/* 71% */
		b_value.mid = 482;	/* 38% */
		b_value.low = 16;	/* 1% */
		b_value.dim = 16;	/* 1% */
	}
#endif

#if defined(CONFIG_FB_S5P_S6F1202A)
	if (pdata->display_type == 0) {
		memcpy(tunning_table, tunning_table_hy, sizeof(tunning_table));
		memcpy(etc_table, etc_table_hy, sizeof(etc_table));
		tune_camera = tune_camera_hy;
		tune_camera_outdoor = tune_camera_outdoor_hy;
	} else if (pdata->display_type == 1) {
		memcpy(tunning_table, tunning_table_sec, sizeof(tunning_table));
		memcpy(etc_table, etc_table_sec, sizeof(etc_table));
		tune_camera = tune_camera_sec;
		tune_camera_outdoor = tune_camera_outdoor_sec;
	} else if (pdata->display_type == 2) {
		memcpy(tunning_table, tunning_table_bo, sizeof(tunning_table));
		memcpy(etc_table, etc_table_bo, sizeof(etc_table));
		tune_camera = tune_camera_bo;
		tune_camera_outdoor = tune_camera_outdoor_bo;
	}
#endif

	g_mdnie = mdnie;

	set_mdnie_value(mdnie, 0);

	dev_info(mdnie->dev, "registered successfully\n");

	return 0;

error2:
	kfree(mdnie);
error1:
	class_destroy(mdnie_class);
error0:
	return ret;
}

Example #16

void mdnie_late_resume(struct early_suspend *h)
{
 	u32 i, conversion;
 	struct mdnie_info *mdnie = container_of(h, struct mdnie_info, early_suspend);
#if defined(CONFIG_FB_MDNIE_PWM)
 	struct lcd_platform_data *pd = NULL;
 
 	dev_info(mdnie->dev, "+%s\n", __func__);
 	pd = mdnie->lcd_pd;
 
 	if (mdnie->enable)
 		mdnie_pwm_control(mdnie, 0);
 
 	if (!pd)
 		dev_info(&mdnie->bd->dev, "platform data is NULL.\n");
 
 	if (!pd->power_on)
 		dev_info(&mdnie->bd->dev, "power_on is NULL.\n");
 	else
 		pd->power_on(NULL, 1);
 
 	if (mdnie->enable) {
 		dev_info(&mdnie->bd->dev, "brightness=%d\n", mdnie->bd->props.brightness);
 		update_brightness(mdnie);
 	}
 
 	mdnie->bd_enable = TRUE;
 	dev_info(mdnie->dev, "-%s\n", __func__);
#endif

      printk("[mdnie] %s \n", __func__);

      mdnie_status = MDNIE_RESUME;

 	for (i = 0; i < 5; i++) {
 		if (negative[i].enable){
 			dev_info(mdnie->dev, "pid=%d, %s, %s\n", negative[i].pid, negative[i].comm, negative[i].time);
                   mdnie->negative = NEGATIVE_ON;
 	}
 	}


      //if(NEGATIVE_ON == mdnie->negative)
         mdelay(110);

      set_cabc_value(mdnie, 0);
      set_mdnie_value(mdnie, 0);

      //if(NEGATIVE_ON == mdnie->negative)
        mdelay(30);
 
#if LCD_LOW_TEMP_CONVERSION
        if(lcd_panel_id == LCD_PANEL_DTC){
           if( -50 < get_temp_from_ps_battery()){
         conversion = 0x02;
            }else{
         conversion = 0x01;
            }
        }else{
            if( -50 < get_temp_from_ps_battery()){
                conversion = 0x02;
            }else{
                conversion = 0x01;
            }
         }
      vc_display_bus_write(0,0xB4,&conversion,1);
#endif

 	return ;
}