diff options
Diffstat (limited to 'drivers/video')
24 files changed, 4964 insertions, 3 deletions
diff --git a/drivers/video/Makefile b/drivers/video/Makefile index ff3c7b2..1261866 100644 --- a/drivers/video/Makefile +++ b/drivers/video/Makefile @@ -182,4 +182,3 @@ obj-$(CONFIG_FB_VIRTUAL) += vfb.o #video output switch sysfs driver obj-$(CONFIG_VIDEO_OUTPUT_CONTROL) += output.o - diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig index 29c581f..d82a55b 100644 --- a/drivers/video/backlight/Kconfig +++ b/drivers/video/backlight/Kconfig @@ -424,6 +424,13 @@ config BACKLIGHT_SMART_DIMMING help Say Y to enable the Smart Dimming Feature. +config BACKLIGHT_LP855X + tristate "Backlight driver for TI LP855X" + depends on BACKLIGHT_CLASS_DEVICE && I2C + help + This supports TI LP8550, LP8551, LP8552, LP8553 and LP8556 + backlight driver. + endif # BACKLIGHT_CLASS_DEVICE endif # BACKLIGHT_LCD_SUPPORT diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile index 9d8d82f..658e9a1 100644 --- a/drivers/video/backlight/Makefile +++ b/drivers/video/backlight/Makefile @@ -30,6 +30,7 @@ obj-$(CONFIG_BACKLIGHT_GENERIC) += generic_bl.o obj-$(CONFIG_BACKLIGHT_HP700) += jornada720_bl.o obj-$(CONFIG_BACKLIGHT_HP680) += hp680_bl.o obj-$(CONFIG_BACKLIGHT_LOCOMO) += locomolcd.o +obj-$(CONFIG_BACKLIGHT_LP855X) += lp855x_bl.o obj-$(CONFIG_BACKLIGHT_OMAP1) += omap1_bl.o obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c new file mode 100644 index 0000000..bbedab5 --- /dev/null +++ b/drivers/video/backlight/lp855x_bl.c @@ -0,0 +1,466 @@ +/* + * TI LP855x Backlight Driver + * + * Copyright (C) 2011 Texas Instruments + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/i2c.h> +#include <linux/backlight.h> +#include <linux/err.h> +#include <linux/delay.h> +#include <linux/gpio.h> +#include <linux/platform_data/lp855x.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif + +/* Registers */ +#define BRIGHTNESS_CTRL 0x00 +#define DEVICE_CTRL 0x01 +#define EEPROM_START 0xA0 +#define EEPROM_END 0xA7 +#define EPROM_START 0xA0 +#define EPROM_END 0xAF + +#if defined(CONFIG_MACH_KONA) +#define EEPROM_CFG3 0xA3 +#define EEPROM_CFG5 0xA5 +#endif + +#define BUF_SIZE 20 +#define DEFAULT_BL_NAME "lcd-backlight" +#define MAX_BRIGHTNESS 255 + +struct lp855x { + const char *chipname; + enum lp855x_chip_id chip_id; + struct i2c_client *client; + struct backlight_device *bl; + struct device *dev; + struct mutex xfer_lock; + struct lp855x_platform_data *pdata; + int enabled; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif +}; + +static int lp855x_read_byte(struct lp855x *lp, u8 reg, u8 *data) +{ + int ret; + + mutex_lock(&lp->xfer_lock); + ret = i2c_smbus_read_byte_data(lp->client, reg); + if (ret < 0) { + mutex_unlock(&lp->xfer_lock); + dev_err(lp->dev, "failed to read 0x%.2x\n", reg); + return ret; + } + mutex_unlock(&lp->xfer_lock); + + *data = (u8)ret; + return 0; +} + +static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data) +{ + int ret; + + mutex_lock(&lp->xfer_lock); + ret = i2c_smbus_write_byte_data(lp->client, reg, data); + mutex_unlock(&lp->xfer_lock); + + return ret; +} + +static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr) +{ + u8 start, end; + + switch (lp->chip_id) { + case LP8550: + case LP8551: + case LP8552: + case LP8553: + start = EEPROM_START; + end = EEPROM_END; + break; + case LP8556: + start = EPROM_START; + end = EPROM_END; + break; + default: + return false; + } + + return (addr >= start && addr <= end); +} + +static int lp855x_init_registers(struct lp855x *lp) +{ + u8 val, addr, mask; + int i, ret; + struct lp855x_platform_data *pd = lp->pdata; + + val = pd->initial_brightness; + ret = lp855x_write_byte(lp, BRIGHTNESS_CTRL, val); + if (ret) + return ret; + + val = pd->device_control; + ret = lp855x_write_byte(lp, DEVICE_CTRL, val); + if (ret) + return ret; + + if (pd->load_new_rom_data && pd->size_program) { + for (i = 0; i < pd->size_program; i++) { + addr = pd->rom_data[i].addr; + val = pd->rom_data[i].val; + mask = pd->rom_data[i].mask; + if (!lp855x_is_valid_rom_area(lp, addr)) + continue; + + if (mask) { + u8 reg_val; + + ret = lp855x_read_byte(lp, addr, ®_val); + if (ret) + return ret; + val = (val & ~mask) | (reg_val & mask); + } + + ret = lp855x_write_byte(lp, addr, val); + if (ret) + return ret; + } + } + + return ret; +} + +static int lp855x_bl_update_status(struct backlight_device *bl) +{ + struct lp855x *lp = bl_get_data(bl); + enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; + int ret; + + if (bl->props.state & BL_CORE_SUSPENDED) + bl->props.brightness = 0; + + if (mode == PWM_BASED) { + struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; + int br = bl->props.brightness; + int max_br = bl->props.max_brightness; + + if (pd->pwm_set_intensity) + pd->pwm_set_intensity(br, max_br); + + } else if (mode == REGISTER_BASED) { + u8 val = bl->props.brightness; + ret = lp855x_write_byte(lp, BRIGHTNESS_CTRL, val); + if (ret) + return ret; + } + + return 0; +} + +static int lp855x_bl_get_brightness(struct backlight_device *bl) +{ + struct lp855x *lp = bl_get_data(bl); + enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; + + if (mode == PWM_BASED) { + struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; + int max_br = bl->props.max_brightness; + + if (pd->pwm_get_intensity) + bl->props.brightness = pd->pwm_get_intensity(max_br); + + } else if (mode == REGISTER_BASED) { + u8 val = 0; + + lp855x_read_byte(lp, BRIGHTNESS_CTRL, &val); + bl->props.brightness = val; + } + + return bl->props.brightness; +} + +static const struct backlight_ops lp855x_bl_ops = { + .options = BL_CORE_SUSPENDRESUME, + .update_status = lp855x_bl_update_status, + .get_brightness = lp855x_bl_get_brightness, +}; + +static int lp855x_backlight_register(struct lp855x *lp) +{ + struct backlight_device *bl; + struct backlight_properties props; + struct lp855x_platform_data *pdata = lp->pdata; + char *name = pdata->name ? : DEFAULT_BL_NAME; + + props.type = BACKLIGHT_PLATFORM; + props.max_brightness = MAX_BRIGHTNESS; + + if (pdata->initial_brightness > props.max_brightness) + pdata->initial_brightness = props.max_brightness; + + props.brightness = pdata->initial_brightness; + + bl = backlight_device_register(name, lp->dev, lp, + &lp855x_bl_ops, &props); + if (IS_ERR(bl)) + return PTR_ERR(bl); + + lp->bl = bl; + + return 0; +} + +static void lp855x_backlight_unregister(struct lp855x *lp) +{ + if (lp->bl) + backlight_device_unregister(lp->bl); +} + +static ssize_t lp855x_get_chip_id(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct lp855x *lp = dev_get_drvdata(dev); + return scnprintf(buf, BUF_SIZE, "%s\n", lp->chipname); +} + +static ssize_t lp855x_get_bl_ctl_mode(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct lp855x *lp = dev_get_drvdata(dev); + enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; + char *strmode = NULL; + + if (mode == PWM_BASED) + strmode = "pwm based"; + else if (mode == REGISTER_BASED) + strmode = "register based"; + + return scnprintf(buf, BUF_SIZE, "%s\n", strmode); +} + +static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL); +static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL); + +static struct attribute *lp855x_attributes[] = { + &dev_attr_chip_id.attr, + &dev_attr_bl_ctl_mode.attr, + NULL, +}; + +static const struct attribute_group lp855x_attr_group = { + .attrs = lp855x_attributes, +}; + +static int lp855x_set_power(struct lp855x *lp, int on) +{ + unsigned long on_udelay = lp->pdata->power_on_udelay; + + pr_info("%s : %d\n", __func__, on); + + if (on) { + int ret = 0; + + gpio_set_value(lp->pdata->gpio_en, GPIO_LEVEL_HIGH); + usleep_range(on_udelay, on_udelay); + + ret = lp855x_init_registers(lp); + if (ret) + return ret; + } else { + gpio_set_value(lp->pdata->gpio_en, GPIO_LEVEL_LOW); + } + + lp->enabled = on; + + return 0; +} + +#if defined(CONFIG_MACH_KONA) +static int lp855x_config(struct lp855x *lp) +{ + u8 val; + int ret; + + /* DEVICE CONTROL: No FAST bit to prevent LP8556 register reset */ + ret = lp855x_write_byte(lp, DEVICE_CTRL, 0x81); + if (ret) + return ret; + + /* CFG3: SCURVE_EN is linear transitions, SLOPE = 200ms, + * FILTER = heavy smoothing, + * PWM_INPUT_HYSTERESIS = 1-bit hysteresis with 12-bit resolution + */ + ret = lp855x_write_byte(lp, EEPROM_CFG3, 0x5E); + if (ret) + return ret; + + /* CFG5: No PWM_DIRECT, PS_MODE from platform data, PWM_FREQ = 9616Hz */ + val = 0x2 << 4 | 0x04; + ret = lp855x_write_byte(lp, EEPROM_CFG5, val); + + if (ret) + return ret; + + return 0; + +} +#endif + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void lp855x_early_suspend(struct early_suspend *h) +{ + struct lp855x *lp = + container_of(h, struct lp855x, early_suspend); + + lp855x_set_power(lp, 0); +} + +static void lp855x_late_resume(struct early_suspend *h) +{ + struct lp855x *lp = + container_of(h, struct lp855x, early_suspend); + + lp855x_set_power(lp, 1); + backlight_update_status(lp->bl); +#if defined(CONFIG_MACH_KONA) + lp855x_config(lp); +#endif + +} +#endif + +static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id) +{ + struct lp855x *lp; + struct lp855x_platform_data *pdata = cl->dev.platform_data; + enum lp855x_brightness_ctrl_mode mode; + int ret; + + if (!pdata) { + dev_err(&cl->dev, "no platform data supplied\n"); + return -EINVAL; + } + + if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) + return -EIO; + + lp = devm_kzalloc(&cl->dev, sizeof(struct lp855x), GFP_KERNEL); + if (!lp) + return -ENOMEM; + + mode = pdata->mode; + lp->client = cl; + lp->dev = &cl->dev; + lp->pdata = pdata; + lp->chipname = id->name; + lp->chip_id = id->driver_data; + i2c_set_clientdata(cl, lp); + + mutex_init(&lp->xfer_lock); + + ret = lp855x_init_registers(lp); + if (ret) { + dev_err(lp->dev, "i2c communication err: %d", ret); + if (mode == REGISTER_BASED) + goto err_dev; + } + + lp->enabled = 1; +#ifdef CONFIG_HAS_EARLYSUSPEND + if (lp->pdata->use_gpio_en) { + lp->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 2; + lp->early_suspend.suspend = lp855x_early_suspend; + lp->early_suspend.resume = lp855x_late_resume; + register_early_suspend(&lp->early_suspend); + } +#endif + + ret = lp855x_backlight_register(lp); + if (ret) { + dev_err(lp->dev, + "failed to register backlight. err: %d\n", ret); + goto err_dev; + } + + ret = sysfs_create_group(&lp->dev->kobj, &lp855x_attr_group); + if (ret) { + dev_err(lp->dev, "failed to register sysfs. err: %d\n", ret); + goto err_sysfs; + } + + backlight_update_status(lp->bl); + +#if defined(CONFIG_MACH_KONA) + lp855x_config(lp); +#endif + + return 0; + +err_sysfs: + lp855x_backlight_unregister(lp); +err_dev: + return ret; +} + +static int __devexit lp855x_remove(struct i2c_client *cl) +{ + struct lp855x *lp = i2c_get_clientdata(cl); + + lp->bl->props.brightness = 0; + backlight_update_status(lp->bl); + sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group); + lp855x_backlight_unregister(lp); + + return 0; +} + +static const struct i2c_device_id lp855x_ids[] = { + {"lp8550", LP8550}, + {"lp8551", LP8551}, + {"lp8552", LP8552}, + {"lp8553", LP8553}, + {"lp8556", LP8556}, + { } +}; +MODULE_DEVICE_TABLE(i2c, lp855x_ids); + +static struct i2c_driver lp855x_driver = { + .driver = { + .name = "lp855x", + }, + .probe = lp855x_probe, + .remove = __devexit_p(lp855x_remove), + .id_table = lp855x_ids, +}; + +static int __init lp855x_init(void) +{ + return i2c_add_driver(&lp855x_driver); +} + +static void __exit lp855x_exit(void) +{ + i2c_del_driver(&lp855x_driver); +} + +module_init(lp855x_init); +module_exit(lp855x_exit); + +MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver"); +MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); +MODULE_LICENSE("GPL"); diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c index b585a38..1ca9b20 100644 --- a/drivers/video/fbmem.c +++ b/drivers/video/fbmem.c @@ -34,6 +34,7 @@ #include <linux/fb.h> #include <asm/fb.h> +#include <linux/cma.h> /* @@ -1380,6 +1381,17 @@ fb_mmap(struct file *file, struct vm_area_struct * vma) /* frame buffer memory */ start = info->fix.smem_start; len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len); + +#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) + if (!cma_is_registered_region(start, len)) { + pr_err("%s: %x@%x is allowed to map\n", + __func__, (unsigned int)start, + (unsigned int)len); + mutex_unlock(&info->mm_lock); + return -EINVAL; + } +#endif + if (off >= len) { /* memory mapped io */ off -= len; diff --git a/drivers/video/samsung/Kconfig b/drivers/video/samsung/Kconfig index 0234465..80f6a0a 100644 --- a/drivers/video/samsung/Kconfig +++ b/drivers/video/samsung/Kconfig @@ -273,6 +273,12 @@ config FB_S5P_S6E63M0 ---help--- This enables support for Samsung S6E63M0 MIPI LCD +config FB_S5P_NT71391 + bool "NT71391 MIPI LCD" + depends on FB_S5P_MIPI_DSIM + ---help--- + This enables support for Novatek NT71391 MIPI LCD + endchoice choice diff --git a/drivers/video/samsung/Makefile b/drivers/video/samsung/Makefile index 75995be..8934e35 100644 --- a/drivers/video/samsung/Makefile +++ b/drivers/video/samsung/Makefile @@ -15,11 +15,16 @@ obj-$(CONFIG_FB_S5P_WA101S) += s3cfb_wa101s.o obj-$(CONFIG_FB_S5P_AMS369FG06) += s3cfb_ams369fg06.o obj-$(CONFIG_FB_S5P_LD9040) += ld9040.o smart_dimming_ld9042.o obj-$(CONFIG_FB_S5P_NT35560) += nt35560.o +ifeq ($(CONFIG_MACH_KONA),y) +obj-$(CONFIG_FB_S5P_MDNIE) += s3cfb_mdnie_kona.o s3cfb_ielcd_kona.o mdnie_kona.o mdnie_tuning_kona.o +else obj-$(CONFIG_FB_S5P_MDNIE) += s3cfb_mdnie.o s3cfb_ielcd.o mdnie.o mdnie_tunning.o +endif obj-$(CONFIG_FB_S5P_LMS501KF03) += s3cfb_lms501kf03.o obj-$(CONFIG_FB_S5P_LMS501XX) += s3cfb_lms501xx.o obj-$(CONFIG_FB_S5P_DUMMY_MIPI_LCD) += s3cfb_dummymipilcd.o obj-$(CONFIG_FB_S5P_S6E8AA0) += s3cfb_s6e8aa0.o smart_dimming.o +obj-$(CONFIG_FB_S5P_NT71391) += s3cfb_nt71391.o obj-$(CONFIG_FB_S5P_EA8061) += s3cfb_ea8061.o smart_dimming_ea8061.o obj-$(CONFIG_FB_S5P_S6EVR02) += s3cfb_s6evr02.o smart_dimming_s6evr02.o s3cfb_ea8061.o smart_dimming_ea8061.o obj-$(CONFIG_FB_S5P_S6E8AB0) += s3cfb_s6e8ab0.o smart_dimming_s6e8ab0.o diff --git a/drivers/video/samsung/mdnie_color_tone_4412.h b/drivers/video/samsung/mdnie_color_tone_4412.h new file mode 100644 index 0000000..7a34444 --- /dev/null +++ b/drivers/video/samsung/mdnie_color_tone_4412.h @@ -0,0 +1,239 @@ +#ifndef __MDNIE_COLOR_TONE_H__ +#define __MDNIE_COLOR_TONE_H__ + +#include "mdnie_kona.h" + +static const unsigned short tune_scr_setting[9][3] = { + {0xff, 0xf9, 0xf9}, + {0xff, 0xf9, 0xfe}, + {0xfc, 0xfa, 0xff}, + {0xff, 0xfc, 0xf8}, + {0xff, 0xff, 0xff}, + {0xfb, 0xfb, 0xff}, + {0xfb, 0xff, 0xf5}, + {0xfa, 0xff, 0xf9}, + {0xf8, 0xff, 0xfc}, +}; + +static unsigned short tune_color_tone_1[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0xaf00, /*SCR RrCr*/ + 0x00e2, 0x00b7, /*SCR RgCg*/ + 0x00e3, 0x00bc, /*SCR RbCb*/ + 0x00e4, 0x00af, /*SCR GrMr*/ + 0x00e5, 0xb700, /*SCR GgMg*/ + 0x00e6, 0x00bc, /*SCR GbMb*/ + 0x00e7, 0x00af, /*SCR BrYr*/ + 0x00e8, 0x00b7, /*SCR BgYg*/ + 0x00e9, 0xbc00, /*SCR BbYb*/ + 0x00ea, 0x00af, /*SCR KrWr*/ + 0x00eb, 0x00b7, /*SCR KgWg*/ + 0x00ec, 0x00bc, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, + +}; + +static unsigned short tune_color_tone_2[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0xa000, /*SCR RrCr*/ + 0x00e2, 0x00a8, /*SCR RgCg*/ + 0x00e3, 0x00b2, /*SCR RbCb*/ + 0x00e4, 0x00a0, /*SCR GrMr*/ + 0x00e5, 0xa800, /*SCR GgMg*/ + 0x00e6, 0x00b2, /*SCR GbMb*/ + 0x00e7, 0x00a0, /*SCR BrYr*/ + 0x00e8, 0x00a8, /*SCR BgYg*/ + 0x00e9, 0xb200, /*SCR BbYb*/ + 0x00ea, 0x00a0, /*SCR KrWr*/ + 0x00eb, 0x00a8, /*SCR KgWg*/ + 0x00ec, 0x00b2, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_tone_3[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x9100, /*SCR RrCr*/ + 0x00e2, 0x0099, /*SCR RgCg*/ + 0x00e3, 0x00a3, /*SCR RbCb*/ + 0x00e4, 0x0091, /*SCR GrMr*/ + 0x00e5, 0x9900, /*SCR GgMg*/ + 0x00e6, 0x00a3, /*SCR GbMb*/ + 0x00e7, 0x0091, /*SCR BrYr*/ + 0x00e8, 0x0099, /*SCR BgYg*/ + 0x00e9, 0xa300, /*SCR BbYb*/ + 0x00ea, 0x0091, /*SCR KrWr*/ + 0x00eb, 0x0099, /*SCR KgWg*/ + 0x00ec, 0x00a3, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +#if defined(CONFIG_FB_MDNIE_PWM) +static unsigned short tune_negative[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWr*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_negative_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWrv*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0075, 0x0000, /*CABC dgain*/ + 0x0076, 0x0000, + 0x0077, 0x0000, + 0x0078, 0x0000, + 0x007f, 0x0002, /*dynamic lcd*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_blind[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWr*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_blind_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWrv*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0075, 0x0000, /*CABC dgain*/ + 0x0076, 0x0000, + 0x0077, 0x0000, + 0x0078, 0x0000, + 0x007f, 0x0002, /*dynamic lcd*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#else +static unsigned short tune_negative[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*SCR*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWr*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_blind[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*SCR*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0x00ff, /*SCR KrWr*/ + 0x00eb, 0x00ff, /*SCR KgWg*/ + 0x00ec, 0x00ff, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#endif + +struct mdnie_tuning_info negative_table[CABC_MAX] = { + {"negative", tune_negative}, +#if defined(CONFIG_FB_MDNIE_PWM) + {"negative_cabc", tune_negative_cabc}, +#endif +}; + +struct mdnie_tuning_info accessibility_table[CABC_MAX][ACCESSIBILITY_MAX] = { + { + {NULL, NULL}, + {"negative", tune_negative}, + {"color_blind", tune_color_blind}, + }, +#if defined(CONFIG_FB_MDNIE_PWM) + { + {NULL, NULL}, + {"negative_cabc", tune_negative_cabc}, + {"color_blind_cabc", tune_color_blind_cabc}, + } +#endif +}; + +struct mdnie_tuning_info color_tone_table[COLOR_TONE_MAX - COLOR_TONE_1] = { + {"color_tone_1", tune_color_tone_1}, + {"color_tone_2", tune_color_tone_2}, + {"color_tone_3", tune_color_tone_3}, +}; + +#endif /* __MDNIE_COLOR_TONE_H__ */ diff --git a/drivers/video/samsung/mdnie_kona.c b/drivers/video/samsung/mdnie_kona.c new file mode 100644 index 0000000..d44aa0e --- /dev/null +++ b/drivers/video/samsung/mdnie_kona.c @@ -0,0 +1,1171 @@ +/* linux/drivers/video/samsung/mdnie.c + * + * Register interface file for Samsung mDNIe driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/mutex.h> +#include <linux/mm.h> +#include <linux/device.h> +#include <linux/backlight.h> +#include <linux/platform_device.h> +#include <linux/mdnie.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif +#include <linux/delay.h> +#include <linux/lcd.h> + +#include "s3cfb.h" +#include "s3cfb_mdnie_kona.h" + +#if defined(CONFIG_FB_S5P_NT71391) +#include "mdnie_table_kona.h" +#endif +#include "mdnie_color_tone_4412.h" + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) +#include "mdnie_table_ebook.h" +#endif + +#if defined(CONFIG_FB_MDNIE_PWM) +#define MIN_BRIGHTNESS 0 +#define DEFAULT_BRIGHTNESS 150 +#if defined(CONFIG_FB_S5P_S6F1202A) +#define CABC_CUTOFF_BACKLIGHT_VALUE 40 /* 2.5% */ +#elif defined(CONFIG_FB_S5P_S6C1372) +#define CABC_CUTOFF_BACKLIGHT_VALUE 34 +#elif defined(CONFIG_FB_S5P_NT71391) +#define CABC_CUTOFF_BACKLIGHT_VALUE 31 +#endif +#define MAX_BRIGHTNESS_LEVEL 255 +#define MID_BRIGHTNESS_LEVEL 150 +#define LOW_BRIGHTNESS_LEVEL 30 +#define DIM_BRIGHTNESS_LEVEL 20 +#endif + +#define MDNIE_SYSFS_PREFIX "/sdcard/mdnie/" +#define PANEL_COLOR_OFFSET_PATH "/sys/class/lcd/panel/color_offset" + +#if defined(CONFIG_TDMB) || defined(CONFIG_TARGET_LOCALE_NTT) +#define SCENARIO_IS_DMB(scenario) ((scenario >= DMB_NORMAL_MODE) && (scenario < DMB_MODE_MAX)) +#else +#define SCENARIO_IS_DMB(scenario) NULL +#endif + +#define SCENARIO_IS_COLOR(scenario) ((scenario >= COLOR_TONE_1) && (scenario < COLOR_TONE_MAX)) +#define SCENARIO_IS_VIDEO(scenario) ((scenario >= VIDEO_MODE) && (scenario <= VIDEO_COLD_MODE)) +#define SCENARIO_IS_VALID(scenario) (SCENARIO_IS_COLOR(scenario) || SCENARIO_IS_DMB(scenario) || scenario < SCENARIO_MAX) + +#define ACCESSIBILITY_IS_VALID(accessibility) (accessibility && (accessibility < ACCESSIBILITY_MAX)) + +#define ADDRESS_IS_SCR_BLACK(address) (address >= MDNIE_REG_BLACK_R && address <= MDNIE_REG_BLACK_B) +#define ADDRESS_IS_SCR_RGB(address) (address >= MDNIE_REG_RED_R && address <= MDNIE_REG_GREEN_B) + +#define SCR_BLACK_MASK(value) (value % MDNIE_REG_BLACK_R) +#define SCR_RGB_MASK(value) (value % MDNIE_REG_RED_R) + +struct class *mdnie_class; +struct mdnie_info *g_mdnie; + +static int mdnie_send_sequence(struct mdnie_info *mdnie, const unsigned short *seq) +{ + int ret = 0, i = 0; + const unsigned short *wbuf = NULL; + + if (IS_ERR_OR_NULL(seq)) { + dev_err(mdnie->dev, "mdnie sequence is null\n"); + return -EPERM; + } + + mutex_lock(&mdnie->dev_lock); + + wbuf = seq; + + mdnie_mask(); + + while (wbuf[i] != END_SEQ) { + ret += mdnie_write(wbuf[i], wbuf[i+1]); + i += 2; + } + + mdnie_unmask(); + + mutex_unlock(&mdnie->dev_lock); + + return ret; +} + +static struct mdnie_tuning_info *mdnie_request_table(struct mdnie_info *mdnie) +{ + struct mdnie_tuning_info *table = NULL; + + mutex_lock(&mdnie->lock); + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + if (mdnie->ebook == EBOOK_ON) { + table = &ebook_table[mdnie->cabc]; + goto exit; + } +#endif + + /* it will be removed next year */ + if (mdnie->negative == NEGATIVE_ON) { + table = &negative_table[mdnie->cabc]; + goto exit; + } + + if (ACCESSIBILITY_IS_VALID(mdnie->accessibility)) { + table = &accessibility_table[mdnie->cabc][mdnie->accessibility]; + goto exit; + } else if (SCENARIO_IS_DMB(mdnie->scenario)) { +#if defined(CONFIG_TDMB) || defined(CONFIG_TARGET_LOCALE_NTT) + table = &tune_dmb[mdnie->mode]; +#endif + goto exit; + } else if (SCENARIO_IS_COLOR(mdnie->scenario)) { + table = &color_tone_table[mdnie->scenario % COLOR_TONE_1]; + goto exit; + } else if (mdnie->scenario == CAMERA_MODE) { + table = &camera_table[mdnie->outdoor]; + goto exit; + } else if (mdnie->scenario < SCENARIO_MAX) { + table = &tuning_table[mdnie->cabc][mdnie->mode][mdnie->scenario]; + goto exit; + } + +exit: + mutex_unlock(&mdnie->lock); + + return table; +} + +static struct mdnie_tuning_info *mdnie_request_etc_table(struct mdnie_info *mdnie) +{ + struct mdnie_tuning_info *table = NULL; + + mutex_lock(&mdnie->lock); + + if (SCENARIO_IS_VIDEO(mdnie->scenario)) + mdnie->tone = mdnie->scenario - VIDEO_MODE; + else if (SCENARIO_IS_DMB(mdnie->scenario)) + mdnie->tone = mdnie->scenario % DMB_NORMAL_MODE; + + table = &etc_table[mdnie->cabc][mdnie->outdoor][mdnie->tone]; + + mutex_unlock(&mdnie->lock); + + return table; +} + +static void mdnie_update_sequence(struct mdnie_info *mdnie, struct mdnie_tuning_info *table) +{ + unsigned short *wbuf = NULL; + int ret; + + if (unlikely(mdnie->tuning)) { + ret = mdnie_request_firmware(mdnie->path, &wbuf, table->name); + if (ret < 0 && IS_ERR_OR_NULL(wbuf)) + goto exit; + mdnie_send_sequence(mdnie, wbuf); + kfree(wbuf); + } else + mdnie_send_sequence(mdnie, table->sequence); + +exit: + return; +} + +static void mdnie_update(struct mdnie_info *mdnie) +{ + struct mdnie_tuning_info *table = NULL; + + if (!mdnie->enable) { + dev_err(mdnie->dev, "mdnie state is off\n"); + return; + } + + table = mdnie_request_table(mdnie); + if (!IS_ERR_OR_NULL(table) && !IS_ERR_OR_NULL(table->sequence)) { + mdnie_update_sequence(mdnie, table); + dev_info(mdnie->dev, "%s\n", table->name); + } + + if (!(SCENARIO_IS_VIDEO(mdnie->scenario) || SCENARIO_IS_DMB(mdnie->scenario))) + goto exit; + + table = mdnie_request_etc_table(mdnie); + if (!IS_ERR_OR_NULL(table) && !IS_ERR_OR_NULL(table->sequence)) { + mdnie_update_sequence(mdnie, table); + dev_info(mdnie->dev, "%s\n", table->name); + } + +exit: + return; +} + +#if defined(CONFIG_FB_MDNIE_PWM) +static int get_backlight_level_from_brightness(struct mdnie_info *mdnie, unsigned int brightness) +{ + unsigned int value; + struct mdnie_backlight_value *pwm = mdnie->backlight; + + /* brightness tuning*/ + if (brightness >= MID_BRIGHTNESS_LEVEL) { + value = (brightness - MID_BRIGHTNESS_LEVEL) * + (pwm->max - pwm->mid) / (MAX_BRIGHTNESS_LEVEL-MID_BRIGHTNESS_LEVEL) + pwm->mid; + } else if (brightness >= LOW_BRIGHTNESS_LEVEL) { + value = (brightness - LOW_BRIGHTNESS_LEVEL) * + (pwm->mid - pwm->low) / (MID_BRIGHTNESS_LEVEL-LOW_BRIGHTNESS_LEVEL) + pwm->low; + } else if (brightness >= DIM_BRIGHTNESS_LEVEL) { + value = (brightness - DIM_BRIGHTNESS_LEVEL) * + (pwm->low - pwm->dim) / (LOW_BRIGHTNESS_LEVEL-DIM_BRIGHTNESS_LEVEL) + pwm->dim; + } else if (brightness > 0) + value = pwm->dim; + else + return 0; + + if (value > 1600) + value = 1600; + + if (value < 16) + value = 1; + else + value = value >> 4; + + return value; +} + +static void mdnie_pwm_control(struct mdnie_info *mdnie, int value) +{ + mutex_lock(&mdnie->dev_lock); + mdnie_write(MDNIE_REG_BANK_SEL, MDNIE_PWM_BANK); + mdnie_write(MDNIE_REG_PWM_CONTROL, 0xC000 | value); + mdnie_write(MDNIE_REG_MASK, 0); + mutex_unlock(&mdnie->dev_lock); +} + +static void mdnie_pwm_control_cabc(struct mdnie_info *mdnie, int value) +{ + int reg; + const unsigned char *p_plut; + u16 min_duty; + unsigned idx; + + mutex_lock(&mdnie->dev_lock); + + idx = SCENARIO_IS_VIDEO(mdnie->scenario) ? LUT_VIDEO : LUT_DEFAULT; + p_plut = power_lut[mdnie->power_lut_idx][idx]; + min_duty = p_plut[7] * value / 100; + + mdnie_write(MDNIE_REG_BANK_SEL, MDNIE_PWM_BANK); + + if (min_duty < 4) + reg = 0xC000 | (max(1, (value * p_plut[3] / 100))); + else { + /*PowerLUT*/ + mdnie_write(MDNIE_REG_POWER_LUT0, (p_plut[0] * value / 100) << 8 | (p_plut[1] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT2, (p_plut[2] * value / 100) << 8 | (p_plut[3] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT4, (p_plut[4] * value / 100) << 8 | (p_plut[5] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT6, (p_plut[6] * value / 100) << 8 | (p_plut[7] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT8, (p_plut[8] * value / 100) << 8); + + reg = 0x5000 | (value << 4); + } + + mdnie_write(MDNIE_REG_PWM_CONTROL, reg); + mdnie_write(MDNIE_REG_MASK, 0); + + mutex_unlock(&mdnie->dev_lock); +} + +void set_mdnie_pwm_value(struct mdnie_info *mdnie, int value) +{ + mdnie_pwm_control(mdnie, value); +} + +static int update_brightness(struct mdnie_info *mdnie) +{ + unsigned int value; + unsigned int brightness = mdnie->bd->props.brightness; + + value = get_backlight_level_from_brightness(mdnie, brightness); + + if (!mdnie->enable) { + dev_err(mdnie->dev, "mdnie states is off\n"); + return 0; + } + + if (brightness <= CABC_CUTOFF_BACKLIGHT_VALUE) { + mdnie_pwm_control(mdnie, value); + } else { + if ((mdnie->cabc) && (mdnie->scenario != CAMERA_MODE) && !(mdnie->tuning)) + mdnie_pwm_control_cabc(mdnie, value); + else + mdnie_pwm_control(mdnie, value); + } + return 0; +} + +static int mdnie_set_brightness(struct backlight_device *bd) +{ + struct mdnie_info *mdnie = bl_get_data(bd); + int ret = 0; + unsigned int brightness = bd->props.brightness; + + if (brightness < MIN_BRIGHTNESS || + brightness > bd->props.max_brightness) { + dev_err(&bd->dev, "lcd brightness should be %d to %d. now %d\n", + MIN_BRIGHTNESS, bd->props.max_brightness, brightness); + brightness = bd->props.max_brightness; + } + + if ((mdnie->enable) && (mdnie->bd_enable)) { + ret = update_brightness(mdnie); + dev_info(&bd->dev, "brightness=%d\n", bd->props.brightness); + if (ret < 0) + return -EINVAL; + } + + return ret; +} + +static int mdnie_get_brightness(struct backlight_device *bd) +{ + return bd->props.brightness; +} + +static const struct backlight_ops mdnie_backlight_ops = { + .get_brightness = mdnie_get_brightness, + .update_status = mdnie_set_brightness, +}; +#endif + +static void update_color_position(struct mdnie_info *mdnie, u16 idx) +{ + u8 cabc, mode, scenario, outdoor, i; + unsigned short *wbuf; + + dev_info(mdnie->dev, "%s: idx=%d\n", __func__, idx); + + mutex_lock(&mdnie->lock); + + for (cabc = 0; cabc < CABC_MAX; cabc++) { + for (mode = 0; mode <= STANDARD; mode++) { + for (scenario = 0; scenario < SCENARIO_MAX; scenario++) { + wbuf = tuning_table[cabc][mode][scenario].sequence; + if (IS_ERR_OR_NULL(wbuf)) + continue; + i = 0; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_BLACK(wbuf[i])) + wbuf[i+1] = tune_scr_setting[idx][SCR_BLACK_MASK(wbuf[i])]; + i += 2; + } + } + } + } + + for (outdoor = 0; outdoor < OUTDOOR_MAX; outdoor++) { + wbuf = camera_table[outdoor].sequence; + if (IS_ERR_OR_NULL(wbuf)) + continue; + i = 0; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_BLACK(wbuf[i])) + wbuf[i+1] = tune_scr_setting[idx][SCR_BLACK_MASK(wbuf[i])]; + i += 2; + } + } + + mutex_unlock(&mdnie->lock); +} + +static int get_panel_color_position(struct mdnie_info *mdnie, int *result) +{ + int ret = 0; + char *fp = NULL; + unsigned int offset[2] = {0,}; + + if (likely(mdnie->color_correction)) + goto skip_color_correction; + + ret = mdnie_open_file(PANEL_COLOR_OFFSET_PATH, &fp); + if (IS_ERR_OR_NULL(fp) || ret <= 0) { + dev_info(mdnie->dev, "%s: open fail: %s, %d\n", __func__, PANEL_COLOR_OFFSET_PATH, ret); + ret = -EINVAL; + goto skip_color_correction; + } + + ret = sscanf(fp, "0x%x, 0x%x", &offset[0], &offset[1]); + if (!(offset[0] + offset[1]) || ret != 2) { + dev_info(mdnie->dev, "%s: 0x%x, 0x%x\n", __func__, offset[0], offset[1]); + ret = -EINVAL; + goto skip_color_correction; + } + + ret = mdnie_calibration(offset[0], offset[1], result); + dev_info(mdnie->dev, "%s: %x, %x, idx=%d\n", __func__, offset[0], offset[1], ret - 1); + +skip_color_correction: + mdnie->color_correction = 1; + if (!IS_ERR_OR_NULL(fp)) + kfree(fp); + + return ret; +} + +static ssize_t mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->mode); +} + +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 = 0; + int result[5] = {0,}; + int ret; + + ret = kstrtoul(buf, 0, (unsigned long *)&value); + if (ret) + return -EINVAL; + + 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); + + if (!mdnie->color_correction) { + ret = get_panel_color_position(mdnie, result); + if (ret > 0) + update_color_position(mdnie, ret - 1); + } + + mdnie_update(mdnie); +#if defined(CONFIG_FB_MDNIE_PWM) + if ((mdnie->enable) && (mdnie->bd_enable)) + update_brightness(mdnie); +#endif + + return count; +} + + +static ssize_t scenario_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->scenario); +} + +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 = kstrtoul(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); + + mdnie_update(mdnie); +#if defined(CONFIG_FB_MDNIE_PWM) + if ((mdnie->enable) && (mdnie->bd_enable)) + update_brightness(mdnie); +#endif + + return count; +} + + +static ssize_t outdoor_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->outdoor); +} + +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 = kstrtoul(buf, 0, (unsigned long *)&value); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (value >= OUTDOOR_MAX) + value = OUTDOOR_OFF; + + value = (value) ? OUTDOOR_ON : OUTDOOR_OFF; + + mutex_lock(&mdnie->lock); + mdnie->outdoor = value; + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + + return count; +} + + +#if defined(CONFIG_FB_MDNIE_PWM) +static ssize_t cabc_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->cabc); +} + +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; + +#if defined(CONFIG_FB_S5P_S6C1372) + if (mdnie->auto_brightness) + return -EINVAL; +#endif + + 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); + + mdnie_update(mdnie); + if ((mdnie->enable) && (mdnie->bd_enable)) + update_brightness(mdnie); + + return count; +} + +static ssize_t auto_brightness_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + int i; + + pos += sprintf(pos, "%d, %d, ", mdnie->auto_brightness, mdnie->power_lut_idx); + for (i = 0; i < 5; i++) + pos += sprintf(pos, "0x%02x, ", power_lut[mdnie->power_lut_idx][0][i]); + pos += sprintf(pos, "\n"); + + return pos - buf; +} + +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); + mdnie_update(mdnie); + if (mdnie->bd_enable) + update_brightness(mdnie); + } + } + return size; +} + +static DEVICE_ATTR(auto_brightness, 0644, auto_brightness_show, auto_brightness_store); +#endif + +static ssize_t tuning_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + struct mdnie_tuning_info *table; + int ret, i; + unsigned short *wbuf; + + pos += sprintf(pos, "++ %s: %s\n", __func__, mdnie->path); + + if (!mdnie->tuning) { + pos += sprintf(pos, "tunning mode is off\n"); + goto exit; + } + + if (strncmp(mdnie->path, MDNIE_SYSFS_PREFIX, sizeof(MDNIE_SYSFS_PREFIX) - 1)) { + pos += sprintf(pos, "file path is invalid, %s\n", mdnie->path); + goto exit; + } + + table = mdnie_request_table(mdnie); + if (!IS_ERR_OR_NULL(table)) { + ret = mdnie_request_firmware(mdnie->path, &wbuf, table->name); + i = 0; + while (wbuf[i] != END_SEQ) { + pos += sprintf(pos, "0x%04x, 0x%04x\n", wbuf[i], wbuf[i+1]); + i += 2; + } + if (!IS_ERR_OR_NULL(wbuf)) + kfree(wbuf); + pos += sprintf(pos, "%s\n", table->name); + } + + if (!(SCENARIO_IS_VIDEO(mdnie->scenario) || SCENARIO_IS_DMB(mdnie->scenario))) + goto exit; + + table = mdnie_request_etc_table(mdnie); + if (!IS_ERR_OR_NULL(table)) { + ret = mdnie_request_firmware(mdnie->path, &wbuf, table->name); + i = 0; + while (wbuf[i] != END_SEQ) { + pos += sprintf(pos, "0x%04x, 0x%04x\n", wbuf[i], wbuf[i+1]); + i += 2; + } + if (!IS_ERR_OR_NULL(wbuf)) + kfree(wbuf); + pos += sprintf(pos, "%s\n", table->name); + } + +exit: + pos += sprintf(pos, "-- %s\n", __func__); + + return pos - buf; +} + +static ssize_t tuning_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + int ret; + + if (sysfs_streq(buf, "0") || sysfs_streq(buf, "1")) { + ret = kstrtoul(buf, 0, (unsigned long *)&mdnie->tuning); + if (!mdnie->tuning) + memset(mdnie->path, 0, sizeof(mdnie->path)); + dev_info(dev, "%s :: %s\n", __func__, mdnie->tuning ? "enable" : "disable"); + } else { + if (!mdnie->tuning) + return count; + + if (count > (sizeof(mdnie->path) - sizeof(MDNIE_SYSFS_PREFIX))) { + dev_err(dev, "file name %s is too long\n", mdnie->path); + return -ENOMEM; + } + + memset(mdnie->path, 0, sizeof(mdnie->path)); + snprintf(mdnie->path, sizeof(MDNIE_SYSFS_PREFIX) + count-1, "%s%s", MDNIE_SYSFS_PREFIX, buf); + dev_info(dev, "%s :: %s\n", __func__, mdnie->path); + + mdnie_update(mdnie); + } + + return count; +} + +static ssize_t negative_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->negative); +} + +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 = kstrtoul(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); + + mdnie_update(mdnie); + } + return count; +} + +static ssize_t accessibility_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + unsigned short *wbuf; + int i = 0; + + pos += sprintf(pos, "%d, ", mdnie->accessibility); + if (mdnie->accessibility == COLOR_BLIND) { + if (!IS_ERR_OR_NULL(accessibility_table[mdnie->cabc][COLOR_BLIND].sequence)) { + wbuf = accessibility_table[mdnie->cabc][COLOR_BLIND].sequence; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_RGB(wbuf[i])) + pos += sprintf(pos, "0x%04x, ", wbuf[i+1]); + i += 2; + } + } + } + pos += sprintf(pos, "\n"); + + return pos - buf; +} + +static ssize_t accessibility_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, s[9], cabc, i, len = 0; + int ret; + unsigned short *wbuf; + char str[100] = {0,}; + + ret = sscanf(buf, "%d %x %x %x %x %x %x %x %x %x", + &value, &s[0], &s[1], &s[2], &s[3], + &s[4], &s[5], &s[6], &s[7], &s[8]); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (ret < 0) + return ret; + else { + if (value >= ACCESSIBILITY_MAX) + value = ACCESSIBILITY_OFF; + + mutex_lock(&mdnie->lock); + mdnie->accessibility = value; + if (value == COLOR_BLIND) { + if (ret != 10) { + mutex_unlock(&mdnie->lock); + return -EINVAL; + } + + for (cabc = 0; cabc < CABC_MAX; cabc++) { + wbuf = accessibility_table[cabc][COLOR_BLIND].sequence; + if (IS_ERR_OR_NULL(wbuf)) + continue; + i = 0; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_RGB(wbuf[i])) + wbuf[i+1] = s[SCR_RGB_MASK(wbuf[i])]; + i += 2; + } + } + + i = 0; + len = sprintf(str + len, "%s :: ", __func__); + while (len < sizeof(str) && i < ARRAY_SIZE(s)) { + len += sprintf(str + len, "0x%04x, ", s[i]); + i++; + } + dev_info(dev, "%s\n", str); + } + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + } + return count; +} + +static ssize_t color_correct_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + int i; + int result[5] = {0,}; + + if (!mdnie->color_correction) + return -EINVAL; + + for (i = 1; i < ARRAY_SIZE(result); i++) + pos += sprintf(pos, "F%d= %d, ", i, result[i]); + pos += sprintf(pos, "idx=%d\n", get_panel_color_position(mdnie, result)); + + return pos - buf; +} + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) +static ssize_t ebook_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->ebook); +} + +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\n", __func__, value); + + 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); + + mdnie_update(mdnie); + } + return count; +} +#endif + +static struct device_attribute mdnie_attributes[] = { + __ATTR(mode, 0664, mode_show, mode_store), + __ATTR(scenario, 0664, scenario_show, scenario_store), + __ATTR(outdoor, 0664, outdoor_show, outdoor_store), +#if defined(CONFIG_FB_MDNIE_PWM) + __ATTR(cabc, 0664, cabc_show, cabc_store), +#endif + __ATTR(tuning, 0664, tuning_show, tuning_store), + __ATTR(negative, 0664, negative_show, negative_store), + __ATTR(accessibility, 0664, accessibility_show, accessibility_store), + __ATTR(color_correct, 0444, color_correct_show, NULL), +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + __ATTR(ebook, 0664, ebook_show, ebook_store), +#endif + __ATTR_NULL, +}; + +#ifdef CONFIG_PM +#if defined(CONFIG_HAS_EARLYSUSPEND) +#if defined(CONFIG_FB_MDNIE_PWM) +static void mdnie_early_suspend(struct early_suspend *h) +{ + struct mdnie_info *mdnie = container_of(h, struct mdnie_info, early_suspend); + struct lcd_platform_data *pd = mdnie->lcd_pd; + + dev_info(mdnie->dev, "+%s\n", __func__); + + mdnie->bd_enable = FALSE; + + if (mdnie->enable) + mdnie_pwm_control(mdnie, 0); + + if (pd && pd->power_on) + pd->power_on(NULL, 0); + + dev_info(mdnie->dev, "-%s\n", __func__); + + return; +} +#endif + +static 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 && pd->power_on) + 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 + + mdnie_update(mdnie); + + dev_info(mdnie->dev, "-%s\n", __func__); + + return; +} +#endif +#endif + +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) + if (!pdata) { + pr_err("no platform data specified\n"); + ret = -EINVAL; + goto error2; + } + + 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; + + ret = device_create_file(&mdnie->bd->dev, &dev_attr_auto_brightness); + if (ret < 0) + dev_err(&mdnie->bd->dev, "failed to add sysfs entries, %d\n", __LINE__); +#endif + + mdnie->scenario = UI_MODE; + mdnie->mode = STANDARD; + mdnie->tone = TONE_NORMAL; + mdnie->outdoor = OUTDOOR_OFF; + mdnie->enable = TRUE; + mdnie->tuning = FALSE; + mdnie->negative = NEGATIVE_OFF; + mdnie->accessibility = ACCESSIBILITY_OFF; + mdnie->cabc = CABC_OFF; + +#if defined(CONFIG_FB_MDNIE_PWM) +#if defined(CONFIG_FB_S5P_S6F1202A) + mdnie->cabc = CABC_ON; +#endif + mdnie->power_lut_idx = LUT_LEVEL_MANUAL_AND_INDOOR; + mdnie->auto_brightness = 0; +#endif + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + mdnie->ebook = EBOOK_OFF; +#endif + + mutex_init(&mdnie->lock); + mutex_init(&mdnie->dev_lock); + + platform_set_drvdata(pdev, mdnie); + dev_set_drvdata(mdnie->dev, mdnie); + +#ifdef CONFIG_HAS_EARLYSUSPEND +#if defined(CONFIG_FB_MDNIE_PWM) + mdnie->early_suspend.suspend = mdnie_early_suspend; +#endif + mdnie->early_suspend.resume = mdnie_late_resume; + mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; + register_early_suspend(&mdnie->early_suspend); +#endif + + +#if defined(CONFIG_FB_MDNIE_PWM) + dev_info(mdnie->dev, "lcdtype = %d\n", pdata->display_type); + if (pdata->display_type > ARRAY_SIZE(backlight_table)) + pdata->display_type = 0; + mdnie->backlight = &backlight_table[pdata->display_type]; +#endif + +#if defined(CONFIG_FB_S5P_S6F1202A) + if (pdata->display_type == 0) { + memcpy(tuning_table, tuning_table_hydis, sizeof(tuning_table)); + memcpy(etc_table, etc_table_hydis, sizeof(etc_table)); + memcpy(camera_table, camera_table_hydis, sizeof(camera_table)); + } else if (pdata->display_type == 1) { + memcpy(tuning_table, tuning_table_sec, sizeof(tuning_table)); + memcpy(etc_table, etc_table_sec, sizeof(etc_table)); + memcpy(camera_table, camera_table_sec, sizeof(camera_table)); + } else if (pdata->display_type == 2) { + memcpy(tuning_table, tuning_table_boe, sizeof(tuning_table)); + memcpy(etc_table, etc_table_boe, sizeof(etc_table)); + memcpy(camera_table, camera_table_boe, sizeof(camera_table)); + } +#endif + + g_mdnie = mdnie; + + mdnie_update(mdnie); + + dev_info(mdnie->dev, "registered successfully\n"); + + return 0; + +error2: + kfree(mdnie); +error1: + class_destroy(mdnie_class); +error0: + return ret; +} + +static int mdnie_remove(struct platform_device *pdev) +{ + struct mdnie_info *mdnie = dev_get_drvdata(&pdev->dev); + +#if defined(CONFIG_FB_MDNIE_PWM) + backlight_device_unregister(mdnie->bd); +#endif + class_destroy(mdnie_class); + kfree(mdnie); + + return 0; +} + +static void mdnie_shutdown(struct platform_device *pdev) +{ +#if defined(CONFIG_FB_MDNIE_PWM) + struct mdnie_info *mdnie = dev_get_drvdata(&pdev->dev); + struct lcd_platform_data *pd = NULL; + pd = mdnie->lcd_pd; + + dev_info(mdnie->dev, "+%s\n", __func__); + + mdnie->bd_enable = FALSE; + + if (mdnie->enable) + mdnie_pwm_control(mdnie, 0); + + if (pd && pd->power_on) + pd->power_on(NULL, 0); + + dev_info(mdnie->dev, "-%s\n", __func__); +#endif +} + + +static struct platform_driver mdnie_driver = { + .driver = { + .name = "mdnie", + .owner = THIS_MODULE, + }, + .probe = mdnie_probe, + .remove = mdnie_remove, +#ifndef CONFIG_HAS_EARLYSUSPEND + .suspend = mdnie_suspend, + .resume = mdnie_resume, +#endif + .shutdown = mdnie_shutdown, +}; + +static int __init mdnie_init(void) +{ + return platform_driver_register(&mdnie_driver); +} +module_init(mdnie_init); + +static void __exit mdnie_exit(void) +{ + platform_driver_unregister(&mdnie_driver); +} +module_exit(mdnie_exit); + +MODULE_DESCRIPTION("mDNIe Driver"); +MODULE_LICENSE("GPL"); + diff --git a/drivers/video/samsung/mdnie_kona.h b/drivers/video/samsung/mdnie_kona.h new file mode 100644 index 0000000..b5c95ab --- /dev/null +++ b/drivers/video/samsung/mdnie_kona.h @@ -0,0 +1,148 @@ +#ifndef __MDNIE_H__ +#define __MDNIE_H__ + +#define END_SEQ 0xffff + +enum MODE { + DYNAMIC, + STANDARD, +#if !defined(CONFIG_FB_MDNIE_PWM) + NATURAL, +#endif + MOVIE, + MODE_MAX, +}; + +enum SCENARIO { + CYANOGENMOD_MODE, + UI_MODE, + VIDEO_MODE, + VIDEO_WARM_MODE, + VIDEO_COLD_MODE, + CAMERA_MODE, + NAVI_MODE, + GALLERY_MODE, + VT_MODE, + SCENARIO_MAX, + COLOR_TONE_1 = 40, + COLOR_TONE_2, + COLOR_TONE_3, + COLOR_TONE_MAX, +}; + +enum SCENARIO_DMB { + DMB_NORMAL_MODE = 20, + DMB_WARM_MODE, + DMB_COLD_MODE, + DMB_MODE_MAX, +}; + +enum OUTDOOR { + OUTDOOR_OFF, + OUTDOOR_ON, + OUTDOOR_MAX, +}; + +enum TONE { + TONE_NORMAL, + TONE_WARM, + TONE_COLD, + TONE_MAX, +}; + +enum CABC { + CABC_OFF, +#if defined(CONFIG_FB_MDNIE_PWM) + CABC_ON, +#endif + CABC_MAX, +}; + +enum POWER_LUT { + LUT_DEFAULT, + LUT_VIDEO, + LUT_MAX, +}; + +enum POWER_LUT_LEVEL { + LUT_LEVEL_MANUAL_AND_INDOOR, + LUT_LEVEL_OUTDOOR_1, + LUT_LEVEL_OUTDOOR_2, + LUT_LEVEL_MAX, +}; + +enum NEGATIVE { + NEGATIVE_OFF, + NEGATIVE_ON, + NEGATIVE_MAX, +}; + +enum ACCESSIBILITY { + ACCESSIBILITY_OFF, + NEGATIVE, + COLOR_BLIND, + ACCESSIBILITY_MAX, +}; + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) +enum EBOOK { + EBOOK_OFF, + EBOOK_ON, + EBOOK_MAX, +}; +#endif + +struct mdnie_tuning_info { + char *name; + unsigned short * const sequence; +}; + +struct mdnie_backlight_value { + const unsigned int max; + const unsigned int mid; + const unsigned char low; + const unsigned char dim; +}; + +struct mdnie_info { + struct device *dev; +#if defined(CONFIG_FB_MDNIE_PWM) + struct lcd_platform_data *lcd_pd; + struct backlight_device *bd; + unsigned int bd_enable; + unsigned int auto_brightness; + unsigned int power_lut_idx; + struct mdnie_backlight_value *backlight; +#endif + struct mutex lock; + struct mutex dev_lock; + + unsigned int enable; + enum SCENARIO scenario; + enum MODE mode; + enum TONE tone; + enum OUTDOOR outdoor; + enum CABC cabc; + unsigned int tuning; + unsigned int negative; + unsigned int accessibility; + unsigned int color_correction; + char path[50]; +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + unsigned int ebook; +#endif +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif +}; + +extern struct mdnie_info *g_mdnie; + +#if defined(CONFIG_FB_MDNIE_PWM) +extern void set_mdnie_pwm_value(struct mdnie_info *mdnie, int value); +#endif +extern int mdnie_calibration(unsigned short x, unsigned short y, int *r); +extern int mdnie_request_firmware(const char *path, u16 **buf, char *name); +extern int mdnie_open_file(const char *path, char **fp); + +#endif /* __MDNIE_H__ */ diff --git a/drivers/video/samsung/mdnie_table_4412_kona.h b/drivers/video/samsung/mdnie_table_4412_kona.h new file mode 100644 index 0000000..40e7c07 --- /dev/null +++ b/drivers/video/samsung/mdnie_table_4412_kona.h @@ -0,0 +1,319 @@ +#ifndef __MDNIE_TABLE_H__ +#define __MDNIE_TABLE_H__ + +#include "mdnie_kona.h" + + +static unsigned short tune_dynamic_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_camera[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ +}; + +static unsigned short tune_camera_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ +}; + +static unsigned short tune_cold[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_normal_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +#if defined(CONFIG_FB_MDNIE_PWM) +struct mdnie_tuning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { + { + { + {"normal", NULL}, + {"warm", tune_warm}, + {"cold", tune_cold}, + }, + { + {"normal_outdoor", tune_normal_outdoor}, + {"warm_outdoor", tune_warm_outdoor}, + {"cold_outdoor", tune_cold_outdoor}, + }, + }, + { + { + {"normal_cabc", NULL}, + {"warm_cabc", tune_warm}, + {"cold_cabc", tune_cold}, + }, + { + {"normal_outdoor_cabc", tune_normal_outdoor}, + {"warm_outdoor_cabc", tune_warm_outdoor}, + {"cold_outdoor_cabc", tune_cold_outdoor}, + }, + }, +}; + +struct mdnie_tuning_info tuning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { + { + { + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"camera", NULL}, + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_gallery", tune_dynamic_gallery}, + {"dynamic_vt", tune_dynamic_vt}, + }, { + {"standard_ui", tune_standard_ui}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"camera", NULL}, + {"standard_ui", tune_standard_ui}, + {"standard_gallery", tune_standard_gallery}, + {"standard_vt", tune_standard_vt}, + }, { + {"movie_ui", tune_movie_ui}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"camera", NULL}, + {"movie_ui", tune_movie_ui}, + {"movie_gallery", tune_movie_gallery}, + {"movie_vt", tune_movie_vt}, + }, + }, { + { + {"dynamic_ui_cabc", tune_dynamic_ui}, + {"dynamic_video_cabc", tune_dynamic_video}, + {"dynamic_video_cabc", tune_dynamic_video}, + {"dynamic_video_cabc", tune_dynamic_video}, + {"camera", NULL}, + {"dynamic_ui_cabc", tune_dynamic_ui}, + {"dynamic_gallery_cabc", tune_dynamic_gallery}, + {"dynamic_vt_cabc", tune_dynamic_vt}, + }, { + {"standard_ui_cabc", tune_standard_ui}, + {"standard_video_cabc", tune_standard_video}, + {"standard_video_cabc", tune_standard_video}, + {"standard_video_cabc", tune_standard_video}, + {"camera", NULL}, + {"standard_ui_cabc", tune_standard_ui}, + {"standard_gallery_cabc", tune_standard_gallery}, + {"standard_vt_cabc", tune_standard_vt}, + }, { + {"movie_ui_cabc", tune_movie_ui}, + {"movie_video_cabc", tune_movie_video}, + {"movie_video_cabc", tune_movie_video}, + {"movie_video_cabc", tune_movie_video}, + {"camera", NULL}, + {"movie_ui_cabc", tune_movie_ui}, + {"movie_gallery_cabc", tune_movie_gallery}, + {"movie_vt_cabc", tune_movie_vt}, + }, + }, +}; +#else +struct mdnie_tuning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { + { + { + {"normal", NULL}, + {"warm", tune_warm}, + {"cold", tune_cold}, + }, + { + {"normal_outdoor", tune_normal_outdoor}, + {"warm_outdoor", tune_warm_outdoor}, + {"cold_outdoor", tune_cold_outdoor}, + }, + } +}; + +struct mdnie_tuning_info tuning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { + { + { + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"camera", NULL/*tune_camera*/}, + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_gallery", tune_dynamic_gallery}, + {"dynamic_vt", tune_dynamic_vt}, + }, { + {"standard_ui", tune_standard_ui}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"camera", NULL/*tune_camera*/}, + {"standard_ui", tune_standard_ui}, + {"standard_gallery", tune_standard_gallery}, + {"standard_vt", tune_standard_vt}, + }, { + {"natural_ui", tune_natural_ui}, + {"natural_video", tune_natural_video}, + {"natural_video", tune_natural_video}, + {"natural_video", tune_natural_video}, + {"camera", NULL/*tune_camera*/}, + {"natural_ui", tune_natural_ui}, + {"natural_gallery", tune_natural_gallery}, + {"natural_vt", tune_natural_vt}, + }, { + {"movie_ui", tune_movie_ui}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"camera", NULL/*tune_camera*/}, + {"movie_ui", tune_movie_ui}, + {"movie_gallery", tune_movie_gallery}, + {"movie_vt", tune_movie_vt}, + }, + } +}; +#endif + +struct mdnie_tuning_info camera_table[OUTDOOR_MAX] = { + {"camera", tune_camera}, + {"camera_outdoor", tune_camera_outdoor}, +}; + +#endif /* __MDNIE_TABLE_H__ */ diff --git a/drivers/video/samsung/mdnie_table_ebook.h b/drivers/video/samsung/mdnie_table_ebook.h new file mode 100644 index 0000000..2f75fa4 --- /dev/null +++ b/drivers/video/samsung/mdnie_table_ebook.h @@ -0,0 +1,153 @@ +#ifndef __MDNIE_TABLE_EBOOK_H__ +#define __MDNIE_TABLE_EBOOK_H__ + +#include "mdnie_kona.h" + +#if defined(CONFIG_FB_MDNIE_PWM) +static unsigned short tune_ebook[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a0, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00ff, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ef, /*SCR KgWg*/ + 0x00ec,0x00e4, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x1090, /*CC lut r 16 144*/ + 0x0022,0x20a0, /*CC lut r 32 160*/ + 0x0023,0x30b0, /*CC lut r 48 176*/ + 0x0024,0x40c0, /*CC lut r 64 192*/ + 0x0025,0x50d0, /*CC lut r 80 208*/ + 0x0026,0x60e0, /*CC lut r 96 224*/ + 0x0027,0x70f0, /*CC lut r 112 240*/ + 0x0028,0x80ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_ebook_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02a0, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00ff, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ef, /*SCR KgWg*/ + 0x00ec,0x00e4, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x1090, /*CC lut r 16 144*/ + 0x0022,0x20a0, /*CC lut r 32 160*/ + 0x0023,0x30b0, /*CC lut r 48 176*/ + 0x0024,0x40c0, /*CC lut r 64 192*/ + 0x0025,0x50d0, /*CC lut r 80 208*/ + 0x0026,0x60e0, /*CC lut r 96 224*/ + 0x0027,0x70f0, /*CC lut r 112 240*/ + 0x0028,0x80ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#else +static unsigned short tune_ebook[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a0, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00ff, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ef, /*SCR KgWg*/ + 0x00ec,0x00e4, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x1090, /*CC lut r 16 144*/ + 0x0022,0x20a0, /*CC lut r 32 160*/ + 0x0023,0x30b0, /*CC lut r 48 176*/ + 0x0024,0x40c0, /*CC lut r 64 192*/ + 0x0025,0x50d0, /*CC lut r 80 208*/ + 0x0026,0x60e0, /*CC lut r 96 224*/ + 0x0027,0x70f0, /*CC lut r 112 240*/ + 0x0028,0x80ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#endif + +struct mdnie_tuning_info ebook_table[CABC_MAX] = { +#if defined(CONFIG_FB_MDNIE_PWM) + {"EBOOK", tune_ebook}, + {"EBOOK_CABC", tune_ebook_cabc}, +#else + {"EBOOK", tune_ebook}, +#endif +}; +#endif /* __MDNIE_TABLE_EBOOK_H__ */ diff --git a/drivers/video/samsung/mdnie_table_kona.h b/drivers/video/samsung/mdnie_table_kona.h new file mode 100644 index 0000000..8b3b283 --- /dev/null +++ b/drivers/video/samsung/mdnie_table_kona.h @@ -0,0 +1,1304 @@ +#ifndef __MDNIE_TABLE_H__ +#define __MDNIE_TABLE_H__ + +#include "mdnie_kona.h" + + +static struct mdnie_backlight_value backlight_table[4] = { + { + .max = 977, /*3G/WIFI BOE LCD SYS REV <= 0x03*/ + .mid = 531, /*LTE BOE LCD SYS REV <= 0x02*/ + .low = 16, + .dim = 16, + }, { + .max = 1280, /*3G/WIFI BOE LCD SYS REV >= 0x04*/ + .mid = 700, /*LTE BOE LCD SYS REV >= 0x03*/ + .low = 16, + .dim = 16, + }, { + .max = 1056, /*3G/WIFI SDC LCD SYS REV <= 0x03*/ + .mid = 574, /*LTE SDC LCD SYS REV <= 0x02*/ + .low = 16, + .dim = 16, + }, { + .max = 1435, /* 3G/WIFI SDC LCD SYS REV >= 0x04*/ + .mid = 780, /* LTE SDC LCD SYS REV >= 0x03*/ + .low = 17, + .dim = 17, + } +}; + +static const unsigned char power_lut[LUT_LEVEL_MAX][LUT_MAX][9] = { + /* Indoor power look up table */ + { + {0x42, 0x3d, 0x3E, 0x48, 0x42, 0x3F, 0x3A, 0x37, 0x3F}, + {0x38, 0x3d, 0x34, 0x48, 0x38, 0x35, 0x30, 0x2d, 0x35}, + }, + /* Outdoor power look up table for outdoor 1 (1k~15k) */ + { + {0x42, 0x47, 0x3E, 0x52, 0x42, 0x3F, 0x3A, 0x37, 0x3F}, + {0x38, 0x3d, 0x34, 0x48, 0x38, 0x35, 0x30, 0x2d, 0x35}, + }, + /* Outdoor power look up table (15k ~) */ + { + {100, 100, 100, 100, 100, 100, 100, 100, 100}, + {100, 100, 100, 100, 100, 100, 100, 100, 100}, + }, +}; + +static unsigned short tune_camera[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x002c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_camera_outdoor[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x042c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x00d0,0x01a0, /*UC y*/ + 0x00d1,0x01ff, /*UC cs*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_ui[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_video[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0080, /*DE pf*/ + 0x0094,0x0080, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0080, /*DE nf*/ + 0x0097,0x0080, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_gallery[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0050, /*DE pf*/ + 0x0094,0x0050, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0050, /*DE nf*/ + 0x0097,0x0050, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_vt[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00e0, /*DE pe*/ + 0x0093,0x00e0, /*DE pf*/ + 0x0094,0x00e0, /*DE pb*/ + 0x0095,0x00e0, /*DE ne*/ + 0x0096,0x00e0, /*DE nf*/ + 0x0097,0x00e0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_ui[] = { + /*start KONA standard ui cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_video[] = { + /*start KONA standard video cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0060, /*DE pf*/ + 0x0094,0x0060, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0060, /*DE nf*/ + 0x0097,0x0060, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_gallery[] = { + /*start KONA standard gallery cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_vt[] = { + /*start KONA standard vtcall cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00c0, /*DE pe*/ + 0x0093,0x00c0, /*DE pf*/ + 0x0094,0x00c0, /*DE pb*/ + 0x0095,0x00c0, /*DE ne*/ + 0x0096,0x00c0, /*DE nf*/ + 0x0097,0x00c0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_ui[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_video[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0000, /*DE pf*/ + 0x0094,0x0000, /*DE pb*/ + 0x0095,0x0000, /*DE ne*/ + 0x0096,0x0000, /*DE nf*/ + 0x0097,0x0000, /*DE nb*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1004, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_gallery[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_vt[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x002e, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x0040, /*DE pe*/ + 0x0093,0x0040, /*DE pf*/ + 0x0094,0x0040, /*DE pb*/ + 0x0095,0x0040, /*DE ne*/ + 0x0096,0x0040, /*DE nf*/ + 0x0097,0x0040, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1204, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_ui_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_video_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0080, /*DE pf*/ + 0x0094,0x0080, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0080, /*DE nf*/ + 0x0097,0x0080, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_gallery_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0050, /*DE pf*/ + 0x0094,0x0050, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0050, /*DE nf*/ + 0x0097,0x0050, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_vt_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00e0, /*DE pe*/ + 0x0093,0x00e0, /*DE pf*/ + 0x0094,0x00e0, /*DE pb*/ + 0x0095,0x00e0, /*DE ne*/ + 0x0096,0x00e0, /*DE nf*/ + 0x0097,0x00e0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_ui_cabc[] = { + /*start KONA standard ui cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_video_cabc[] = { + /*start KONA standard video cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0060, /*DE pf*/ + 0x0094,0x0060, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0060, /*DE nf*/ + 0x0097,0x0060, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_gallery_cabc[] = { + /*start KONA standard gallery cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_vt_cabc[] = { + /*start KONA standard vtcall cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00c0, /*DE pe*/ + 0x0093,0x00c0, /*DE pf*/ + 0x0094,0x00c0, /*DE pb*/ + 0x0095,0x00c0, /*DE ne*/ + 0x0096,0x00c0, /*DE nf*/ + 0x0097,0x00c0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_ui_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_video_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0000, /*DE pf*/ + 0x0094,0x0000, /*DE pb*/ + 0x0095,0x0000, /*DE ne*/ + 0x0096,0x0000, /*DE nf*/ + 0x0097,0x0000, /*DE nb*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1004, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_gallery_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_vt_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x022e, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x0040, /*DE pe*/ + 0x0093,0x0040, /*DE pf*/ + 0x0094,0x0040, /*DE pb*/ + 0x0095,0x0040, /*DE ne*/ + 0x0096,0x0040, /*DE nf*/ + 0x0097,0x0040, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1204, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x00ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x00ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_normal_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x04ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x04ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00d0, 0x01c0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x04ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x02ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x02ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_normal_outdoor_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x06ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_outdoor_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x06ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00d0, 0x01c0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_outdoor_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x06ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +struct mdnie_tuning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { + { + { + {"normal", NULL}, + {"warm", tune_warm}, + {"cold", tune_cold}, + }, + { + {"normal_outdoor", tune_normal_outdoor}, + {"warm_outdoor", tune_warm_outdoor}, + {"cold_outdoor", tune_cold_outdoor}, + }, + }, + { + { + {"normal_cabc", NULL}, + {"warm_cabc", tune_warm_cabc}, + {"cold_cabc", tune_cold_cabc}, + }, + { + {"normal_outdoor_cabc", tune_normal_outdoor_cabc}, + {"warm_outdoor_cabc", tune_warm_outdoor_cabc}, + {"cold_outdoor_cabc", tune_cold_outdoor_cabc}, + }, + }, +}; + +struct mdnie_tuning_info tuning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { + { + { + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"camera", NULL}, + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_gallery", tune_dynamic_gallery}, + {"dynamic_vt", tune_dynamic_vt}, + }, { + {"standard_ui", tune_standard_ui}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"camera", NULL}, + {"standard_ui", tune_standard_ui}, + {"standard_gallery", tune_standard_gallery}, + {"standard_vt", tune_standard_vt}, + }, { + {"movie_ui", tune_movie_ui}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"camera", NULL}, + {"movie_ui", tune_movie_ui}, + {"movie_gallery", tune_movie_gallery}, + {"movie_vt", tune_movie_vt}, + }, + }, { + { + {"dynamic_ui_cabc", tune_dynamic_ui_cabc}, + {"dynamic_video_cabc", tune_dynamic_video_cabc}, + {"dynamic_video_cabc", tune_dynamic_video_cabc}, + {"dynamic_video_cabc", tune_dynamic_video_cabc}, + {"camera", NULL}, + {"dynamic_ui_cabc", tune_dynamic_ui_cabc}, + {"dynamic_gallery_cabc", tune_dynamic_gallery_cabc}, + {"dynamic_vt_cabc", tune_dynamic_vt_cabc}, + }, { + {"standard_ui_cabc", tune_standard_ui_cabc}, + {"standard_video_cabc", tune_standard_video_cabc}, + {"standard_video_cabc", tune_standard_video_cabc}, + {"standard_video_cabc", tune_standard_video_cabc}, + {"camera", NULL}, + {"standard_ui_cabc", tune_standard_ui_cabc}, + {"standard_gallery_cabc", tune_standard_gallery_cabc}, + {"standard_vt_cabc", tune_standard_vt_cabc}, + }, { + {"movie_ui_cabc", tune_movie_ui_cabc}, + {"movie_video_cabc", tune_movie_video_cabc}, + {"movie_video_cabc", tune_movie_video_cabc}, + {"movie_video_cabc", tune_movie_video_cabc}, + {"camera", NULL}, + {"movie_ui_cabc", tune_movie_ui_cabc}, + {"movie_gallery_cabc", tune_movie_gallery_cabc}, + {"movie_vt_cabc", tune_movie_vt_cabc}, + }, + }, +}; + +struct mdnie_tuning_info camera_table[OUTDOOR_MAX] = { + {"camera", tune_camera}, + {"camera_outdoor", tune_camera_outdoor}, +}; + +#endif /* __MDNIE_TABLE_H__ */ diff --git a/drivers/video/samsung/mdnie_table_t0.h b/drivers/video/samsung/mdnie_table_t0.h index 94062c8..f653e4e 100644 --- a/drivers/video/samsung/mdnie_table_t0.h +++ b/drivers/video/samsung/mdnie_table_t0.h @@ -3,6 +3,18 @@ #include "mdnie.h" +static const unsigned short tune_cyanogenmod[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0008, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090, 0x0080, /*DE egth*/ + 0x00b0, 0x1010, /*CS hg ry*/ + 0x00b1, 0x1010, /*CS hg gc*/ + 0x00b2, 0x1010, /*CS hg bm*/ + 0x00b3, 0x1204, /*CS weight grayTH*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; static const unsigned short tune_dynamic_gallery[] = { 0x0000, 0x0000, /*BANK 0*/ @@ -638,6 +650,7 @@ struct mdnie_tunning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { struct mdnie_tunning_info tunning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { { { + {"CYANOGENMOD", tune_cyanogenmod}, {"DYNAMIC_UI", tune_dynamic_ui}, {"DYNAMIC_VIDEO", tune_dynamic_video}, {"DYNAMIC_VIDEO", tune_dynamic_video}, @@ -647,6 +660,7 @@ struct mdnie_tunning_info tunning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { {"DYNAMIC_GALLERY", tune_dynamic_gallery}, {"DYNAMIC_VT", tune_dynamic_vt}, }, { + {"CYANOGENMOD", tune_cyanogenmod}, {"STANDARD_UI", tune_standard_ui}, {"STANDARD_VIDEO", tune_standard_video}, {"STANDARD_VIDEO", tune_standard_video}, @@ -656,6 +670,7 @@ struct mdnie_tunning_info tunning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { {"STANDARD_GALLERY", tune_standard_gallery}, {"STANDARD_VT", tune_standard_vt}, }, { + {"CYANOGENMOD", tune_cyanogenmod}, {"NATURAL_UI", tune_natural_ui}, {"NATURAL_VIDEO", tune_natural_video}, {"NATURAL_VIDEO_WARM", tune_natural_video}, @@ -665,6 +680,7 @@ struct mdnie_tunning_info tunning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { {"NATURAL_GALLERY", tune_natural_gallery}, {"NATURAL_VT", tune_natural_vt}, }, { + {"CYANOGENMOD", tune_cyanogenmod}, {"MOVIE_UI", tune_movie_ui}, {"MOVIE_VIDEO", tune_movie_video}, {"MOVIE_VIDEO", tune_movie_video}, diff --git a/drivers/video/samsung/mdnie_tuning_kona.c b/drivers/video/samsung/mdnie_tuning_kona.c new file mode 100644 index 0000000..e198a85 --- /dev/null +++ b/drivers/video/samsung/mdnie_tuning_kona.c @@ -0,0 +1,294 @@ +/* linux/drivers/video/samsung/mdnie_tuning.c + * + * Register interface file for Samsung mDNIe driver + * + * Copyright (c) 2011 Samsung Electronics + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/errno.h> +#include <linux/fs.h> +#include <linux/ctype.h> +#include <linux/uaccess.h> +#include <linux/magic.h> + +#include "s3cfb.h" +#include "mdnie_kona.h" + +#define KFREE(ptr) do { if (ptr) kfree(ptr); (ptr) = NULL; } while (0) +#define CONSTANT_F1 ((23<<10)/21) +#define CONSTANT_F2 ((19<<10)/18) +#define CONSTANT_F3 (5<<10) +#define CONSTANT_F4 ((21<<10)/8) + +int mdnie_calibration(unsigned short x, unsigned short y, int *result) +{ + u8 ret = 0; + + result[1] = ((y << 10) - (CONSTANT_F1 * x) + (12 << 10)) >> 10; + result[2] = ((y << 10) - (CONSTANT_F2 * x) + (44 << 10)) >> 10; + result[3] = ((y << 10) + (CONSTANT_F3 * x) - (18365 << 10)) >> 10; + result[4] = ((y << 10) + (CONSTANT_F4 * x) - (10814 << 10)) >> 10; + + pr_info("%d, %d, %d, %d\n", result[1], result[2], result[3], result[4]); + + if (result[1] > 0) { + if (result[3] > 0) + ret = 3; + else + ret = (result[4] < 0) ? 1 : 2; + } else { + if (result[2] < 0) { + if (result[3] > 0) + ret = 9; + else + ret = (result[4] < 0) ? 7 : 8; + } else { + if (result[3] > 0) + ret = 6; + else + ret = (result[4] < 0) ? 4 : 5; + } + } + + ret = (ret > 0) ? ret : 1; + ret = (ret > 9) ? 1 : ret; + + return ret; +} + +static int parse_text(char *src, int len, u16 *buf, char *name) +{ + int i, count, ret; + int index = 0; + char *str_line[100]; + char *sstart; + char *c; + unsigned int data1, data2; + + c = src; + count = 0; + sstart = c; + + for (i = 0; i < len; i++, c++) { + char a = *c; + if (a == '\r' || a == '\n') { + if (c > sstart) { + str_line[count] = sstart; + count++; + } + *c = '\0'; + sstart = c+1; + } + } + + if (c > sstart) { + str_line[count] = sstart; + count++; + } + + /* printk(KERN_INFO "----------------------------- Total number of lines:%d\n", count); */ + + for (i = 0; i < count; i++) { + /* printk(KERN_INFO "line:%d, [start]%s[end]\n", i, str_line[i]); */ + ret = sscanf(str_line[i], "0x%x, 0x%x\n", &data1, &data2); + /* printk(KERN_INFO "Result => [0x%2x 0x%4x] %s\n", data1, data2, (ret == 2) ? "Ok" : "Not available"); */ + if (ret == 2) { + buf[index++] = (unsigned short)data1; + buf[index++] = (unsigned short)data2; + } + } + + buf[index] = END_SEQ; + + return index; +} + +int mdnie_txtbuf_to_parsing(char *path, u16 size, u16 *buf, char *name) +{ + struct file *filp; + char *dp; + long l; + loff_t pos; + int ret, num; + mm_segment_t fs; + + fs = get_fs(); + set_fs(get_ds()); + + if (!path) { + pr_err("%s: invalid filepath\n", __func__); + goto parse_err; + } + + filp = filp_open(path, O_RDONLY, 0); + + if (IS_ERR(filp)) { + pr_err("file open error: %s\n", path); + goto parse_err; + } + + l = filp->f_path.dentry->d_inode->i_size; + dp = kmalloc(l, GFP_KERNEL); + if (dp == NULL) { + pr_err("Out of Memory!\n"); + filp_close(filp, current->files); + goto parse_err; + } + pos = 0; + memset(dp, 0, l); + ret = vfs_read(filp, (char __user *)dp, l, &pos); + + if (ret != l) { + pr_info("read size = %d, l = %ld, size=%d\n", ret, l, size); + l = (l > ret) ? ret : l; + if (size < l) { + KFREE(dp); + filp_close(filp, current->files); + goto parse_err; + } + } + + filp_close(filp, current->files); + set_fs(fs); + + num = parse_text(dp, l, buf, name); + + if (!num) { + pr_err("Nothing to parse!\n"); + KFREE(dp); + goto parse_err; + } + + KFREE(dp); + + return num; + +parse_err: + return -EPERM; +} + +int mdnie_open_file(const char *path, char **fp) +{ + struct file *filp; + char *dp; + long length; + int ret; + struct super_block *sb; + loff_t pos = 0; + + if (!path) { + pr_err("%s: path is invalid\n", __func__); + return -EPERM; + } + + filp = filp_open(path, O_RDONLY, 0); + if (IS_ERR(filp)) { + pr_err("%s: file open err: %s\n", __func__, path); + return -EPERM; + } + + length = i_size_read(filp->f_path.dentry->d_inode); + if (length <= 0) { + pr_err("%s: file size %ld error\n", __func__, length); + return -EPERM; + } + + dp = kzalloc(length, GFP_KERNEL); + if (dp == NULL) { + pr_err("%s: Out of Memory\n", __func__); + filp_close(filp, current->files); + return -EPERM; + } + + ret = kernel_read(filp, pos, dp, length); + if (ret != length) { + /* check node is sysfs, bus this way is not safe */ + sb = filp->f_path.dentry->d_inode->i_sb; + if ((sb->s_magic != SYSFS_MAGIC) && (length != sb->s_blocksize)) { + pr_err("%s: read size= %d, length= %ld\n", __func__, ret, length); + KFREE(dp); + filp_close(filp, current->files); + return -EPERM; + } + } + + filp_close(filp, current->files); + + *fp = dp; + + return ret; +} + +int mdnie_check_firmware(const char *path, char *name) +{ + char *ptr = NULL; + int ret = 0, size; + + size = mdnie_open_file(path, &ptr); + if (IS_ERR_OR_NULL(ptr) || size <= 0) { + pr_err("%s: file open fail %s\n", __func__, path); + KFREE(ptr); + return 0; + } + + ret = (strstr(ptr, name) != NULL) ? 1 : 0; + + KFREE(ptr); + + return ret; +} + +int mdnie_request_firmware(const char *path, u16 **buf, char *name) +{ + char *token, *ptr = NULL; + unsigned short *dp; + int ret = 0, size, i = 0; + unsigned int data1, data2; + + size = mdnie_open_file(path, &ptr); + if (IS_ERR_OR_NULL(ptr) || size <= 0) { + pr_err("%s: file open fail %s\n", __func__, path); + KFREE(ptr); + return ret; + } + + dp = kzalloc(size, GFP_KERNEL); + if (dp == NULL) { + pr_err("%s: Out of Memory\n", __func__); + KFREE(ptr); + return -ENOMEM; + } + + if (name) { + if (strstr(ptr, name) != NULL) { + pr_info("found %s in %s\n", name, path); + ptr = strstr(ptr, name); + } + } + + while ((token = strsep(&ptr, "\r\n")) != NULL) { + if ((name) && (!strncmp(token, "};", 2))) { + pr_info("found %s end in local, stop searching\n", name); + break; + } + ret = sscanf(token, "%x, %x", &data1, &data2); + if (ret == 2) { + dp[i] = (u16)data1; + dp[i+1] = (u16)data2; + i += 2; + } + } + + dp[i] = END_SEQ; + + *buf = dp; + + KFREE(ptr); + + return i; +} + diff --git a/drivers/video/samsung/s3cfb_ielcd_kona.c b/drivers/video/samsung/s3cfb_ielcd_kona.c new file mode 100644 index 0000000..7eadd5f --- /dev/null +++ b/drivers/video/samsung/s3cfb_ielcd_kona.c @@ -0,0 +1,136 @@ +/* linux/drivers/video/samsung/s3cfb_mdnie.c + * + * Register interface file for Samsung IELCD driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/clk.h> +#include <linux/mutex.h> +#include <linux/poll.h> +#include <linux/wait.h> +#include <linux/fs.h> +#include <linux/irq.h> +#include <linux/mm.h> +#include <linux/fb.h> +#include <linux/ctype.h> +#include <linux/miscdevice.h> +#include <linux/dma-mapping.h> +#include <linux/delay.h> +#include <linux/device.h> + +#include <linux/io.h> +#include <mach/map.h> +#include <plat/clock.h> +#include <plat/regs-fb-s5p.h> + +#include "s3cfb.h" +#include "s3cfb_mdnie_kona.h" +#include "s3cfb_ielcd_kona.h" + +static struct resource *s3c_ielcd_mem; +static void __iomem *s3c_ielcd_base; + +#define s3c_ielcd_readl(addr) __raw_readl(s3c_ielcd_base + addr) +#define s3c_ielcd_writel(addr, val) writel(val, s3c_ielcd_base + addr) + +static struct s3cfb_global ielcd_fb; +static struct s3cfb_global *ielcd_fbdev; + +int ielcd_hw_init(void) +{ + s3c_ielcd_mem = request_mem_region(S3C_IELCD_PHY_BASE, S3C_IELCD_MAP_SIZE, "ielcd"); + if (IS_ERR_OR_NULL(s3c_ielcd_mem)) { + pr_err("%s: fail to request_mem_region\n", __func__); + return -ENOENT; + } + + s3c_ielcd_base = ioremap(S3C_IELCD_PHY_BASE, S3C_IELCD_MAP_SIZE); + if (IS_ERR_OR_NULL(s3c_ielcd_base)) { + pr_err("%s: fail to ioremap\n", __func__); + return -ENOENT; + } + + ielcd_fbdev = &ielcd_fb; + + return 0; +} + +int ielcd_display_on(void) +{ + unsigned int cfg; + + cfg = s3c_ielcd_readl(S3C_VIDCON0); + cfg |= (S3C_VIDCON0_ENVID_ENABLE | S3C_VIDCON0_ENVID_F_ENABLE); + s3c_ielcd_writel(S3C_VIDCON0, cfg); + + return 0; +} + +int ielcd_display_off(void) +{ + unsigned int cfg, ielcd_count = 0; + + cfg = s3c_ielcd_readl(S3C_VIDCON0); + cfg |= S3C_VIDCON0_ENVID_ENABLE; + cfg &= ~(S3C_VIDCON0_ENVID_F_ENABLE); + + s3c_ielcd_writel(S3C_VIDCON0, cfg); + + do { + if (++ielcd_count > 2000000) { + printk(KERN_ERR "ielcd off fail\n"); + return 1; + } + + if (!(s3c_ielcd_readl(S3C_VIDCON1) & 0xffff0000)) + return 0; + } while (1); +} + +void ielcd_init_global(struct s3cfb_global *ctrl) +{ + unsigned int cfg; + + *ielcd_fbdev = *ctrl; + ctrl->ielcd_regs = ielcd_fbdev->regs = s3c_ielcd_base; + + s3c_ielcd_writel(S3C_IELCD_GPOUTCON0, S3C_IELCD_MAGIC_KEY); + + s3cfb_set_polarity_only(ielcd_fbdev); + s3cfb_set_timing(ielcd_fbdev); + s3cfb_set_lcd_size(ielcd_fbdev); + + /* vclock divider setting , same as FIMD */ + cfg = readl(ctrl->regs + S3C_VIDCON0); + cfg &= ~(S3C_VIDCON0_VIDOUT_MASK | S3C_VIDCON0_VCLKEN_MASK); + cfg |= S3C_VIDCON0_VIDOUT_RGB; + cfg |= S3C_VIDCON0_VCLKEN_NORMAL; + s3c_ielcd_writel(S3C_VIDCON0, cfg); + + /* window0 position setting , fixed */ + s3c_ielcd_writel(S3C_VIDOSD0A, 0); + + /* window0 position setting */ + cfg = S3C_VIDOSD_RIGHT_X(ctrl->lcd->width - 1); + cfg |= S3C_VIDOSD_BOTTOM_Y(ctrl->lcd->height - 1); + s3c_ielcd_writel(S3C_VIDOSD0B, cfg); + + /* window0 osd size setting */ + s3c_ielcd_writel(S3C_VIDOSD0C, ctrl->lcd->width * ctrl->lcd->height); + + /* window0 setting , fixed */ + cfg = S3C_WINCON_DATAPATH_LOCAL | S3C_WINCON_BPPMODE_32BPP | S3C_WINCON_INRGB_RGB; + s3c_ielcd_writel(S3C_WINCON0, cfg); + + s3cfb_window_on(ielcd_fbdev, 0); +} + diff --git a/drivers/video/samsung/s3cfb_ielcd_kona.h b/drivers/video/samsung/s3cfb_ielcd_kona.h new file mode 100644 index 0000000..4c89643 --- /dev/null +++ b/drivers/video/samsung/s3cfb_ielcd_kona.h @@ -0,0 +1,28 @@ +/* linux/drivers/video/samsung/s3cfb_ielcd.h + * + * Header file for Samsung (IELCD) driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#ifndef __S3CFB_IELCD_H__ +#define __S3CFB_IELCD_H__ + +#define S3C_IELCD_MAGIC_KEY 0x2ff47 + +#define S3C_IELCD_PHY_BASE 0x11C40000 +#define S3C_IELCD_MAP_SIZE 0x00008000 + +#define S3C_IELCD_GPOUTCON0 0x0278 + +int ielcd_hw_init(void); +int ielcd_display_on(void); +int ielcd_display_off(void); +void ielcd_init_global(struct s3cfb_global *ctrl); + +#endif diff --git a/drivers/video/samsung/s3cfb_main.c b/drivers/video/samsung/s3cfb_main.c index fadea40..191c68e 100644 --- a/drivers/video/samsung/s3cfb_main.c +++ b/drivers/video/samsung/s3cfb_main.c @@ -41,9 +41,14 @@ #endif #ifdef CONFIG_FB_S5P_MDNIE +#ifdef CONFIG_MACH_KONA +#include "s3cfb_mdnie_kona.h" +#include "mdnie_kona.h" +#else #include "s3cfb_mdnie.h" #include "mdnie.h" #endif +#endif #ifdef CONFIG_HAS_WAKELOCK #include <linux/wakelock.h> #include <linux/earlysuspend.h> @@ -604,8 +609,12 @@ static int s3cfb_probe(struct platform_device *pdev) #ifdef CONFIG_FB_S5P_MDNIE /* only FIMD0 is supported */ if (i == 0) +#ifdef CONFIG_MACH_KONA + mdnie_setup(); +#else s3c_mdnie_setup(); #endif +#endif /* hw setting */ s3cfb_init_global(fbdev[i]); @@ -636,8 +645,12 @@ static int s3cfb_probe(struct platform_device *pdev) pdata->set_display_path(); s3cfb_set_dualrgb(fbdev[i], S3C_DUALRGB_MDNIE); +#ifdef CONFIG_MACH_KONA + mdnie_display_on(fbdev[i]); +#else s3c_mdnie_init_global(fbdev[i]); s3c_mdnie_display_on(fbdev[i]); +#endif } #endif s3cfb_enable_window(fbdev[0], pdata->default_win); @@ -916,8 +929,12 @@ void s3cfb_early_suspend(struct early_suspend *h) ret = s3cfb_display_off(fbdev[i]); #ifdef CONFIG_FB_S5P_MDNIE +#ifdef CONFIG_MACH_KONA + ret += mdnie_display_off(); +#else ret += s3c_mdnie_display_off(); #endif +#endif if (ret > 0) s3cfb_lcd0_pmu_off(); @@ -1023,10 +1040,14 @@ void s3cfb_late_resume(struct early_suspend *h) #if defined(CONFIG_FB_S5P_S6C1372) || defined(CONFIG_FB_S5P_S6F1202A) s5c1372_ldi_enable(); #endif +#ifdef CONFIG_MACH_KONA + mdnie_display_on(fbdev[i]); +#else s3c_mdnie_init_global(fbdev[i]); set_mdnie_value(g_mdnie, 1); s3c_mdnie_display_on(fbdev[i]); #endif +#endif s3cfb_display_on(fbdev[i]); /* Set alpha value width to 8-bit */ diff --git a/drivers/video/samsung/s3cfb_mdnie_kona.c b/drivers/video/samsung/s3cfb_mdnie_kona.c new file mode 100644 index 0000000..1fc7fcd --- /dev/null +++ b/drivers/video/samsung/s3cfb_mdnie_kona.c @@ -0,0 +1,120 @@ +/* linux/drivers/video/samsung/s3cfb_mdnie.c + * + * Register interface file for Samsung mDNIe driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + + +#include "s3cfb.h" +#include "s3cfb_ielcd_kona.h" +#include "s3cfb_mdnie_kona.h" +#include "mdnie_kona.h" + + +#define s3c_mdnie_read(addr) __raw_readl(s3c_mdnie_base + addr*4) +#define s3c_mdnie_write(addr, val) __raw_writel(val, s3c_mdnie_base + addr*4) + + +static struct resource *s3c_mdnie_mem; +static void __iomem *s3c_mdnie_base; + + +int mdnie_write(unsigned int addr, unsigned int val) +{ + return s3c_mdnie_write(addr, val); +} + +int mdnie_mask(void) +{ + return s3c_mdnie_write(MDNIE_REG_MASK, 0x9FFF); +} + +int mdnie_unmask(void) +{ + return s3c_mdnie_write(MDNIE_REG_MASK, 0); +} + +int mdnie_set_size(unsigned int hsize, unsigned int vsize) +{ + unsigned int reg; + + /* Bank0 Select : DO NOT REMOVE THIS LINE */ + s3c_mdnie_write(MDNIE_REG_BANK_SEL, 0); + +#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) + /* Input Data Unmask */ + reg = s3c_mdnie_read(S3C_MDNIE_rR1); + reg &= ~S3C_MDNIE_INPUT_DATA_ENABLE; + s3c_mdnie_write(S3C_MDNIE_rR1, reg); +#endif + + /* LCD width */ + reg = s3c_mdnie_read(MDNIE_REG_WIDTH); + reg &= ~S3C_MDNIE_SIZE_MASK; + reg |= S3C_MDNIE_HSIZE(hsize); + s3c_mdnie_write(MDNIE_REG_WIDTH, reg); + + /* LCD height */ + reg = s3c_mdnie_read(MDNIE_REG_HEIGHT); + reg &= ~S3C_MDNIE_SIZE_MASK; + reg |= S3C_MDNIE_VSIZE(vsize); + s3c_mdnie_write(MDNIE_REG_HEIGHT, reg); + + mdnie_unmask(); + + return 0; +} + +int mdnie_display_on(struct s3cfb_global *ctrl) +{ + mdnie_set_size(ctrl->lcd->width, ctrl->lcd->height); + + ielcd_init_global(ctrl); + + ielcd_display_on(); + + if (!IS_ERR_OR_NULL(g_mdnie)) + g_mdnie->enable = TRUE; + + return 0; +} + +int mdnie_display_off(void) +{ + if (!IS_ERR_OR_NULL(g_mdnie)) + g_mdnie->enable = FALSE; + + return ielcd_display_off(); +} + +static int mdnie_hw_init(void) +{ + s3c_mdnie_mem = request_mem_region(S3C_MDNIE_PHY_BASE, S3C_MDNIE_MAP_SIZE, "mdnie"); + if (IS_ERR_OR_NULL(s3c_mdnie_mem)) { + pr_err("%s: fail to request_mem_region\n", __func__); + return -ENOENT; + } + + s3c_mdnie_base = ioremap(S3C_MDNIE_PHY_BASE, S3C_MDNIE_MAP_SIZE); + if (IS_ERR_OR_NULL(s3c_mdnie_base)) { + pr_err("%s: fail to ioremap\n", __func__); + return -ENOENT; + } + + return 0; +} + +void mdnie_setup(void) +{ + mdnie_hw_init(); + ielcd_hw_init(); +} + +MODULE_DESCRIPTION("EXYNOS mDNIe Device Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/video/samsung/s3cfb_mdnie_kona.h b/drivers/video/samsung/s3cfb_mdnie_kona.h new file mode 100644 index 0000000..4a91691 --- /dev/null +++ b/drivers/video/samsung/s3cfb_mdnie_kona.h @@ -0,0 +1,88 @@ + +/* linux/drivers/video/samsung/s3cfb_mdnie.h + * + * Header file for Samsung (MDNIE) driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#ifndef __S3CFB_MDNIE_H__ +#define __S3CFB_MDNIE_H__ + +#define S3C_MDNIE_PHY_BASE 0x11CA0000 +#define S3C_MDNIE_MAP_SIZE 0x00001000 + +/* Register Address */ +#if defined(CONFIG_CPU_EXYNOS4210) +#define MDNIE_REG_BANK_SEL 0x0000 +#define MDNIE_REG_WIDTH 0x0022 +#define MDNIE_REG_HEIGHT 0x0023 +#define MDNIE_REG_MASK 0x0028 + +#define MDNIE_REG_PWM_CONTROL 0x00B4 +#define MDNIE_REG_POWER_LUT0 0x0076 +#define MDNIE_REG_POWER_LUT2 0x0077 +#define MDNIE_REG_POWER_LUT4 0x0078 +#define MDNIE_REG_POWER_LUT6 0x0079 +#define MDNIE_REG_POWER_LUT8 0x007A + +#elif defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) +#define MDNIE_REG_BANK_SEL 0x0000 +#define MDNIE_REG_WIDTH 0x0003 +#define MDNIE_REG_HEIGHT 0x0004 +#define MDNIE_REG_MASK 0x00FF + +#define S3C_MDNIE_rR1 0x0001 + +#define MDNIE_REG_PWM_CONTROL 0x00B6 +#define MDNIE_REG_POWER_LUT0 0x0079 +#define MDNIE_REG_POWER_LUT2 0x007A +#define MDNIE_REG_POWER_LUT4 0x007B +#define MDNIE_REG_POWER_LUT6 0x007C +#define MDNIE_REG_POWER_LUT8 0x007D +#endif + +#define MDNIE_REG_RED_R 0x00E1 /*SCR RrCr*/ +#define MDNIE_REG_RED_G 0x00E2 /*SCR RgCg*/ +#define MDNIE_REG_RED_B 0x00E3 /*SCR RbCb*/ +#define MDNIE_REG_BLUE_R 0x00E4 /*SCR GrMr*/ +#define MDNIE_REG_BLUE_G 0x00E5 /*SCR GgMg*/ +#define MDNIE_REG_BLUE_B 0x00E6 /*SCR GbMb*/ +#define MDNIE_REG_GREEN_R 0x00E7 /*SCR BrYr*/ +#define MDNIE_REG_GREEN_G 0x00E8 /*SCR BgYg*/ +#define MDNIE_REG_GREEN_B 0x00E9 /*SCR BbYb*/ +#define MDNIE_REG_BLACK_R 0x00EA /*SCR KrWr*/ +#define MDNIE_REG_BLACK_G 0x00EB /*SCR KgWg*/ +#define MDNIE_REG_BLACK_B 0x00EC /*SCR KbWb*/ + +/* Register Value */ +#if defined(CONFIG_CPU_EXYNOS4210) +#define MDNIE_PWM_BANK 0x0000 +#elif defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) +#define MDNIE_PWM_BANK 0x0001 /* CMC624's PWM CTL is in BANK1 */ +#endif + +#define S3C_MDNIE_INPUT_DATA_ENABLE (1 << 10) + +#define S3C_MDNIE_SIZE_MASK 0x7FF +#define S3C_MDNIE_HSIZE(n) (n & S3C_MDNIE_SIZE_MASK) +#define S3C_MDNIE_VSIZE(n) (n & S3C_MDNIE_SIZE_MASK) + + +#define TRUE 1 +#define FALSE 0 + +void mdnie_setup(void); +int mdnie_display_on(struct s3cfb_global *ctrl); +int mdnie_display_off(void); + +int mdnie_write(unsigned int addr, unsigned int val); +int mdnie_mask(void); +int mdnie_unmask(void); + +#endif diff --git a/drivers/video/samsung/s3cfb_nt71391.c b/drivers/video/samsung/s3cfb_nt71391.c new file mode 100644 index 0000000..921544a --- /dev/null +++ b/drivers/video/samsung/s3cfb_nt71391.c @@ -0,0 +1,415 @@ +/* linux/drivers/video/samsung/s3cfb_nt71391.c + * + * Copyright (c) 2012 Samsung Electronics Co., Ltd. + * http://www.samsung.com/ + * + * NT71391 : 8" WXGA Landscape LCD module driver + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/delay.h> +#include <linux/errno.h> +#include <linux/gpio.h> +#include <linux/kernel.h> +#include <linux/lcd.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/wait.h> +#include <plat/regs-dsim.h> +#include <mach/dsim.h> +#include <mach/mipi_ddi.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif + +#include "s3cfb.h" +#include "s5p-dsim.h" + +#define NT71391_CHANGE_MINI_LVDS_FREQ_MIPI 1 + +#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL) + +struct lcd_info { + struct device *dev; + unsigned int ldi_enable; + unsigned int power; + unsigned int connected; + struct mutex lock; + struct lcd_device *ld; + struct lcd_platform_data *lcd_pd; + struct dsim_global *dsim; +}; + +#ifdef NT71391_CHANGE_MINI_LVDS_FREQ_MIPI + +#define NT71391_TCON_REG_ADD 0xAC +#define NT71391_TCON_REG_CHECKSUM 0xFF +#define NT71931_N_16 0x18 +#define NT71931_N_17 0x19 +#define NT71931_N_18 0x1A +#define NT71931_N_19 0x1B +#define NT71931_N_20 0x1C +#define NT71931_N_21 0x1D +#define NT71931_N_22 0x1E +#define NT71931_N_23 0x1F +#define NT71931_N_24 0x10 +#define NT71931_N_25 0x11 + + +enum NT71391_COMMAND_TYPE { + NT71391_LOCK_CMD2 = 0x03, + NT71391_READ = 0x14, + NT71391_WRITE = 0x23, +}; + + +static const unsigned char NT71391_UNLOCK_PAGE0[] = { + 0xF3,0xA0 +}; + +static const unsigned char NT71391_UNLOCK_PAGE1[] = { + 0xF3,0xA1 +}; + +static const unsigned char NT71391_FREQ_SETTING[] = { + NT71391_TCON_REG_ADD,NT71931_N_16 +}; + +static const unsigned char TESTA[] = { + 0x2B,0xC0 +}; + +static int _nt71391_write(struct lcd_info *lcd, const unsigned char *seq, enum NT71391_COMMAND_TYPE cmd_type) +{ + const unsigned char *wbuf; + int ret = 0; + + if (!lcd->connected) + return 0; + + mutex_lock(&lcd->lock); + + wbuf = seq; + + switch (cmd_type) { + case NT71391_LOCK_CMD2: + ret = lcd->dsim->ops->cmd_write(lcd->dsim, NT71391_LOCK_CMD2,0x0,0x0); + break; + case NT71391_READ: + ret = lcd->dsim->ops->cmd_write(lcd->dsim, NT71391_READ,wbuf[0],0x0); + break; + case NT71391_WRITE: + ret = lcd->dsim->ops->cmd_write(lcd->dsim, NT71391_WRITE, wbuf[0], wbuf[1]); + break; + default: + dev_dbg(&lcd->ld->dev, "%s :: Invalid cmd type \n", __func__); + break; + } + + mutex_unlock(&lcd->lock); + + return ret; +} + +static int nt71391_write(struct lcd_info *lcd, const unsigned char *seq, enum NT71391_COMMAND_TYPE cmd_type) +{ + int ret = 0; + int retry_cnt = 1; + +retry: + ret = _nt71391_write(lcd, seq, cmd_type); + if (!ret) { + if (retry_cnt) { + dev_dbg(&lcd->ld->dev, "%s :: retry: %d\n", __func__, retry_cnt); + retry_cnt--; + goto retry; + } else + dev_dbg(&lcd->ld->dev, "%s :: 0x%02x\n", __func__, seq[0]); + } + + return ret; +} + +static int _nt71391_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf) +{ + int ret = 0; + + if (!lcd->connected) + return ret; + + mutex_lock(&lcd->lock); + + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_dcs_read(lcd->dsim, addr, count, buf); + + mutex_unlock(&lcd->lock); + + return ret; +} + +static int nt71391_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf, u8 retry_cnt) +{ + int ret = 0; + +read_retry: + ret = _nt71391_read(lcd, addr, count, buf); + if (!ret) { + if (retry_cnt) { + printk(KERN_WARNING "[WARN:LCD] %s : retry cnt : %d\n", __func__, retry_cnt); + retry_cnt--; + goto read_retry; + } else + printk(KERN_ERR "[ERROR:LCD] %s : 0x%02x read failed\n", __func__, addr); + } + + return ret; +} +#endif +static ssize_t lcdtype_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + char temp[15]; + sprintf(temp, "BOE_BP080WX7\n"); + strcat(buf, temp); + return strlen(buf); +} + +static DEVICE_ATTR(lcd_type, 0664, + lcdtype_show, NULL); + +static ssize_t window_type_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + char temp[15]; + + sprintf(temp, "%x %x %x\n", 0x0, 0x0, 0x0); + + strcat(buf, temp); + return strlen(buf); +} + +static DEVICE_ATTR(window_type, 0444, + window_type_show, NULL); + +static int nt71391_power_on(struct lcd_info *lcd) +{ + +#ifdef NT71391_CHANGE_MINI_LVDS_FREQ_MIPI + int ret = 0; + struct lcd_platform_data *pd = NULL; + pd = lcd->lcd_pd; + + dev_info(&lcd->ld->dev, "%s\n", __func__); + + msleep(120); /* power on 50ms, i2c 70ms */ + nt71391_write(lcd, NT71391_UNLOCK_PAGE0, NT71391_WRITE); + nt71391_write(lcd, NT71391_FREQ_SETTING, NT71391_WRITE); + nt71391_write(lcd, NULL, NT71391_LOCK_CMD2); + + + lcd->dsim->ops->cmd_write(lcd->dsim, TURN_ON, 0, 0); +#else + int ret = 0; + struct lcd_platform_data *pd = NULL; + pd = lcd->lcd_pd; + + dev_info(&lcd->ld->dev, "%s\n", __func__); + + msleep(120); /* power on 50ms, i2c 70ms */ + + lcd->dsim->ops->cmd_write(lcd->dsim, TURN_ON, 0, 0); +#endif + + lcd->ldi_enable = 1; + + return ret; +} + +static int nt71391_power_off(struct lcd_info *lcd) +{ + int ret = 0; + + dev_info(&lcd->ld->dev, "%s\n", __func__); + + lcd->ldi_enable = 0; + + msleep(135); + + return ret; +} + +static int nt71391_power(struct lcd_info *lcd, int power) +{ + int ret = 0; + + if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power)) + ret = nt71391_power_on(lcd); + else if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power)) + ret = nt71391_power_off(lcd); + + if (!ret) + lcd->power = power; + + return ret; +} + +static int nt71391_set_power(struct lcd_device *ld, int power) +{ + struct lcd_info *lcd = lcd_get_data(ld); + + if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN && + power != FB_BLANK_NORMAL) { + dev_err(&lcd->ld->dev, "power value should be 0, 1 or 4.\n"); + return -EINVAL; + } + + return nt71391_power(lcd, power); +} + +static int nt71391_get_power(struct lcd_device *ld) +{ + struct lcd_info *lcd = lcd_get_data(ld); + + return lcd->power; +} + +static struct lcd_ops nt71391_lcd_ops = { + .set_power = nt71391_set_power, + .get_power = nt71391_get_power, +}; + +#ifdef CONFIG_HAS_EARLYSUSPEND +extern void (*lcd_early_suspend)(void); +extern void (*lcd_late_resume)(void); + +struct lcd_info *g_lcd; + +void nt71391_early_suspend(void) +{ + struct lcd_info *lcd = g_lcd; + int err = 0; + + set_dsim_lcd_enabled(0); + + dev_info(&lcd->ld->dev, "+%s\n", __func__); + + nt71391_power(lcd, FB_BLANK_POWERDOWN); + + dev_info(&lcd->ld->dev, "-%s\n", __func__); + + return ; +} + +void nt71391_late_resume(void) +{ + struct lcd_info *lcd = g_lcd; + + dev_info(&lcd->ld->dev, "+%s\n", __func__); + + nt71391_power(lcd, FB_BLANK_UNBLANK); + + dev_info(&lcd->ld->dev, "-%s\n", __func__); + + set_dsim_lcd_enabled(1); + + return ; +} +#endif + + +static int __init nt71391_probe(struct device *dev) +{ + struct lcd_info *lcd; + int ret = 0; + + lcd = kzalloc(sizeof(struct lcd_info), GFP_KERNEL); + if (!lcd) { + pr_err("failed to allocate for lcd\n"); + ret = -ENOMEM; + goto err_alloc; + } + + g_lcd = lcd; + + lcd->ld = lcd_device_register("panel", dev, lcd, &nt71391_lcd_ops); + if (IS_ERR(lcd->ld)) { + pr_err("failed to register lcd device\n"); + ret = PTR_ERR(lcd->ld); + goto out_free_lcd; + } + + lcd->dev = dev; + lcd->connected = 1; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); + lcd->power = FB_BLANK_UNBLANK; + + mutex_init(&lcd->lock); + + dev_set_drvdata(dev, lcd); + + dev_info(dev, "lcd panel driver has been probed.\n"); + +#ifdef CONFIG_HAS_EARLYSUSPEND + lcd_early_suspend = nt71391_early_suspend; + lcd_late_resume = nt71391_late_resume; +#endif + + ret = device_create_file(&lcd->ld->dev, &dev_attr_lcd_type); + if (ret < 0) + dev_err(&lcd->ld->dev, "failed to add sysfs entries\n"); + + ret = device_create_file(&lcd->ld->dev, &dev_attr_window_type); + if (ret < 0) + dev_err(&lcd->ld->dev, "failed to add window_type entries\n"); + + return 0; + +out_free_lcd: + kfree(lcd); +err_alloc: + return ret; +} + +static int __devexit nt71391_remove(struct device *dev) +{ + struct lcd_info *lcd = dev_get_drvdata(dev); + + nt71391_power(lcd, FB_BLANK_POWERDOWN); + lcd_device_unregister(lcd->ld); + kfree(lcd); + + return 0; +} + +static void nt71391_shutdown(struct device *dev) +{ + struct lcd_info *lcd = dev_get_drvdata(dev); + + nt71391_power(lcd, FB_BLANK_POWERDOWN); +} + +static struct mipi_lcd_driver nt71391_mipi_driver = { + .name = "nt71391", + .probe = nt71391_probe, + .remove = __devexit_p(nt71391_remove), + .shutdown = nt71391_shutdown, +}; + +static int __init nt71391_init(void) +{ + return s5p_dsim_register_lcd_driver(&nt71391_mipi_driver); +} + +static void __exit nt71391_exit(void) +{ + return; +} + +module_init(nt71391_init); +module_exit(nt71391_exit); + +MODULE_AUTHOR("SAMSUNG"); +MODULE_DESCRIPTION("NT71391 LCD driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/video/samsung/s3cfb_ops.c b/drivers/video/samsung/s3cfb_ops.c index 8d5739d..0bcd529 100644 --- a/drivers/video/samsung/s3cfb_ops.c +++ b/drivers/video/samsung/s3cfb_ops.c @@ -53,6 +53,10 @@ #include <plat/s5p-sysmmu.h> #endif +#if defined(CONFIG_MACH_KONA) || defined(CONFIG_MACH_TAB3) || defined(CONFIG_MACH_T0) +extern unsigned int lpcharge; +#endif + struct s3c_platform_fb *to_fb_plat(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); @@ -1078,6 +1082,15 @@ int s3cfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fb) } #endif +#if defined(CONFIG_MACH_KONA) || defined(CONFIG_MACH_TAB3) || defined(CONFIG_MACH_T0) + if (lpcharge) { + /* support LPM (off charging mode) display based on FBIOPAN_DISPLAY */ + s3cfb_check_var(var, fb); + s3cfb_set_par(fb); + s3cfb_enable_window(fbdev, win->id); + } +#endif + if (var->yoffset + var->yres > var->yres_virtual) { dev_err(fbdev->dev, "invalid yoffset value\n"); if (win->id == pdata->default_win) diff --git a/drivers/video/samsung_extdisp/s3cfb_extdsp.h b/drivers/video/samsung_extdisp/s3cfb_extdsp.h index 99f134c..11f4f37 100644 --- a/drivers/video/samsung_extdisp/s3cfb_extdsp.h +++ b/drivers/video/samsung_extdisp/s3cfb_extdsp.h @@ -151,7 +151,7 @@ struct s3cfb_extdsp_user_window { #define S3CFB_EXTDSP_GET_FREE_BUFFER _IOW('F', 329, unsigned int) extern struct fb_ops s3cfb_extdsp_ops; -extern inline struct s3cfb_extdsp_global *get_extdsp_global(int id); +extern struct s3cfb_extdsp_global *get_extdsp_global(int id); /* S3CFB_EXTDSP */ extern int s3cfb_extdsp_enable_window(struct s3cfb_extdsp_global *fbdev, int id); diff --git a/drivers/video/samsung_extdisp/s3cfb_extdsp_main.c b/drivers/video/samsung_extdisp/s3cfb_extdsp_main.c index 4f9f2b2..dacd94d 100644 --- a/drivers/video/samsung_extdisp/s3cfb_extdsp_main.c +++ b/drivers/video/samsung_extdisp/s3cfb_extdsp_main.c @@ -43,7 +43,7 @@ struct s3cfb_extdsp_extdsp_desc *fbextdsp; -inline struct s3cfb_extdsp_global *get_extdsp_global(int id) +struct s3cfb_extdsp_global *get_extdsp_global(int id) { struct s3cfb_extdsp_global *fbdev; |