Initial file dump from open source releaseHEADmaster

1 files changed, 516 insertions, 0 deletions

diff --git a/drivers/video/backlight/rt4502_bl.c b/drivers/video/backlight/rt4502_bl.c
new file mode 100644
index 00000000..d6c212ef
--- /dev/null
+++ b/drivers/video/backlight/rt4502_bl.c
@@ -0,0 +1,516 @@
+
+/*******************************************************************************
+* Copyright 2013 Samsung Electronics Corporation.  All rights reserved.
+*
+* 	@file	drivers/video/backlight/rt4502_bl.c
+*
+* Unless you and Broadcom execute a separate written software license agreement
+* governing use of this software, this software is licensed to you under the
+* terms of the GNU General Public License version 2, available at
+* http://www.gnu.org/copyleft/gpl.html (the "GPL").
+*
+* Notwithstanding the above, under no circumstances may you combine this
+* software in any way with any other Broadcom software provided under a license
+* other than the GPL, without Broadcom's express prior written consent.
+*******************************************************************************/
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/earlysuspend.h>
+#endif
+#include <linux/platform_device.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/rt4502_bl.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+#include <linux/rtc.h>
+
+#include <linux/of.h>
+
+#include <soc/sprd/board.h>
+
+int current_intensity;
+#ifdef SPI0_BACKLIGHT_PWM_GPIO
+static int backlight_pin = SPI0_BACKLIGHT_PWM_GPIO;
+#else
+static int backlight_pin = 190;
+#endif
+
+static DEFINE_SPINLOCK(bl_ctrl_lock);
+
+#define START_BRIGHTNESS 10 /*This value should be same as bootloader*/
+
+int real_level = START_BRIGHTNESS;
+EXPORT_SYMBOL(real_level);
+#ifdef CONFIG_HAS_EARLYSUSPEND
+
+#endif
+static int backlight_mode=1;
+#define MAX_BRIGHTNESS_IN_BLU	33
+#define DIMMING_VALUE		31
+#define MAX_BRIGHTNESS_VALUE	255
+#define MIN_BRIGHTNESS_VALUE	20
+#define BACKLIGHT_DEBUG 1
+#define BACKLIGHT_SUSPEND 0
+#define BACKLIGHT_RESUME 1
+#if BACKLIGHT_DEBUG
+#define BLDBG(fmt, args...) printk(fmt, ## args)
+#else
+#define BLDBG(fmt, args...)
+#endif
+struct rt4502_bl_data {
+	struct platform_device *pdev;
+	unsigned int ctrl_pin;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	struct early_suspend early_suspend_desc;
+#endif
+};
+struct brt_value{
+	int level;				// Platform setting values
+	int tune_level;			// Chip Setting values
+};
+#if defined (CONFIG_MACH_RHEA_SS_LUCAS)
+struct brt_value brt_table_ktd[] = {
+   { MIN_BRIGHTNESS_VALUE,  31 }, // Min pulse 32
+   { 32,  31 },
+   { 46,  30 },
+   { 60,  29 },  
+   { 73,  28 }, 
+   { 86,  27 }, 
+   { 98,  26 }, 
+   { 105,  25 }, 
+   { 110,  24 }, 
+   { 115,  23 }, 
+   { 120,  22 }, 
+   { 125,  21 }, 
+  	{ 130,  20 }, 
+   { 140,  19 },//default value  
+   { 155,  18 },   
+   { 165,  17 },
+   { 176,  16 }, 
+   { 191,  15 }, 
+   { 207,  14 },
+   { 214,  13 },
+   { 221,  12 },
+   { 228,  10 },
+   { 235,  8 },
+   { 242,  7 },
+   { 249,  5 },
+   { MAX_BRIGHTNESS_VALUE,  5 }, // Max pulse 1
+};
+#elif defined (CONFIG_MACH_CORSICA_VE) || defined (CONFIG_MACH_VIVALTO)
+struct brt_value brt_table_ktd[] = {
+	{MIN_BRIGHTNESS_VALUE, 31},	/*Min pulse 32 */
+	{30, 31},
+	{41, 30},
+	{52, 29},
+	{63, 28},
+	{74, 27},
+	{85, 26},
+	{96, 25},
+	{107, 24},
+	{118, 23},
+	{127, 22},
+	{135, 21},
+	{143, 20},		/*default value */
+	{155, 18},
+	{168, 17},
+	{177, 16},
+	{186, 15},
+	{194, 14},
+	{202, 13},
+	{210, 12},
+	{218, 11},
+	{226, 10},
+	{234, 9},
+	{241, 7},
+	{248, 6},
+	{MAX_BRIGHTNESS_VALUE, 5},	/*Max pulse 1 */
+};
+#elif defined(CONFIG_MACH_KANAS_W) || defined(CONFIG_MACH_KANAS_TD) || defined(CONFIG_PIKEAYOUNG2DTV)
+struct brt_value brt_table_ktd[] = {
+	{ MIN_BRIGHTNESS_VALUE,  31 }, // Min pulse 32
+	{ 28,  31 },
+	{ 36,  30 },
+	{ 44,  29 },
+	{ 52,  28 },
+	{ 60,  27 },
+	{ 68,  26 },
+	{ 76,  25 },
+	{ 84,  24 },
+	{ 92,  23 },
+	{ 100,  22 },
+	{ 108,  21 },
+	{ 116,  20 },
+	{ 124,  19 },
+	{ 132,  18 },
+	{ 140,  17 },
+	{ 148,  16 },  //default value
+	{ 156,  15 },
+	{ 164,  14 },
+	{ 172,  13 },
+	{ 180,  12 },
+	{ 188,  11 },
+	{ 196,  10 },
+	{ 204,  9 },
+	{ 212,  8 },
+	{ 220,  7 },
+	{ 228,  6 },
+	{ 236,  5 },
+	{ 244,  4 },
+	{ 252,  3 },
+	{ MAX_BRIGHTNESS_VALUE, 2 },
+};
+#else
+struct brt_value brt_table_ktd[] = {
+{ MIN_BRIGHTNESS_VALUE,  31 }, // Min pulse 32 
+   { 30,  31 },   
+   { 41,  30 },   
+   { 52,  29 },     
+   { 63,  28 },    
+   { 74,  27 },    
+   { 85,  26 },    
+   { 96,  25 },    
+   { 107,  24 },    
+   { 118,  23 }, 
+   { 127,  22 },    
+   { 135,  21 },    
+   { 143,  20 }, // defualt value
+   { 155,  18 }, 
+   { 168,  17 },    
+   { 177,  16 },     
+   { 186,  15 },       
+   { 194,  14 },   
+   { 202,  13 },   
+   { 210,  12 },   
+   { 218,  11 },    
+   { 226,  10 },  
+   { 234,  9 },   
+   { 241,  5 },    
+   { 248,  4 },      
+   { MAX_BRIGHTNESS_VALUE, 3 }, 
+ };
+
+#endif
+#define MAX_BRT_STAGE_KTD (int)(sizeof(brt_table_ktd)/sizeof(struct brt_value))
+
+struct mutex rt4502_mutex;
+DEFINE_MUTEX(rt4502_mutex);
+
+static void lcd_backlight_control(int num)
+{
+    int limit;
+    
+    limit = num;
+    BLDBG("[BACKLIGHT] lcd_backlight_control ==> pulse  : %d\n", num);
+   spin_lock(&bl_ctrl_lock);
+    for(;limit>0;limit--)
+    {
+       udelay(2);
+       gpio_set_value(backlight_pin,0);
+       udelay(2); 
+       gpio_set_value(backlight_pin,1);
+    }
+   spin_unlock(&bl_ctrl_lock);
+}
+/* input: intensity in percentage 0% - 100% */
+static int rt4502_backlight_update_status(struct backlight_device *bd)
+{
+	int user_intensity = bd->props.brightness;
+    int tune_level = 0;
+	int pulse;
+    int i;
+    BLDBG("[BACKLIGHT] rt4502_backlight_update_status ==> user_intensity  : %d\n", user_intensity);
+
+	if (bd->props.power != FB_BLANK_UNBLANK)
+		user_intensity = 0;
+
+	if (bd->props.fb_blank != FB_BLANK_UNBLANK)
+		user_intensity = 0;
+
+	if (bd->props.state & BL_CORE_SUSPENDED)
+		user_intensity = 0;
+
+	mutex_lock(&rt4502_mutex);
+	if(backlight_mode==BACKLIGHT_RESUME){
+		if(user_intensity > 0) {
+			if(user_intensity < MIN_BRIGHTNESS_VALUE) {
+				tune_level = DIMMING_VALUE; //DIMMING
+			} else if (user_intensity == MAX_BRIGHTNESS_VALUE) {
+				tune_level = brt_table_ktd[MAX_BRT_STAGE_KTD-1].tune_level;
+			} else {
+				for(i = 0; i < MAX_BRT_STAGE_KTD; i++) {
+					if(user_intensity <= brt_table_ktd[i].level ) {
+						tune_level = brt_table_ktd[i].tune_level;
+						break;
+					}
+				}
+			}
+		}
+		BLDBG("[BACKLIGHT] rt4502_backlight_update_status ==> real_level: %d, tune_level : %d\n", real_level, tune_level);
+		if (real_level==tune_level)
+		{
+			mutex_unlock(&rt4502_mutex);   
+			return 0;
+		}
+		else
+		{
+			if(tune_level<=0)
+			{
+				gpio_set_value(backlight_pin,0);
+				mdelay(3);
+			}
+			else
+			{
+				if( real_level<=tune_level)
+				{
+					pulse = tune_level - real_level;
+				}
+				else
+				{
+					pulse = 32 - (real_level - tune_level);
+				}
+				//pulse = MAX_BRIGHTNESS_IN_BLU -tune_level;
+				if (pulse==0)
+				{
+					mutex_unlock(&rt4502_mutex);
+					return 0;
+				}
+				lcd_backlight_control(pulse);
+			}
+			real_level = tune_level;
+		}
+	}
+	mutex_unlock(&rt4502_mutex);
+
+       return 0;
+}
+static int rt4502_backlight_get_brightness(struct backlight_device *bl)
+{
+     BLDBG("[BACKLIGHT] rt4502_backlight_get_brightness\n");
+
+	return current_intensity;
+}
+static struct backlight_ops rt4502_backlight_ops = {
+	.update_status	= rt4502_backlight_update_status,
+	.get_brightness	= rt4502_backlight_get_brightness,
+};
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void rt4502_backlight_earlysuspend(struct early_suspend *desc)
+{
+    struct timespec ts;
+    struct rtc_time tm;
+ 
+    backlight_mode=BACKLIGHT_SUSPEND; 
+     mutex_lock(&rt4502_mutex);	
+       gpio_set_value(backlight_pin,0);
+       mdelay(3); 	
+	real_level=0;
+    mutex_unlock(&rt4502_mutex);	
+	getnstimeofday(&ts);
+	rtc_time_to_tm(ts.tv_sec, &tm);
+        printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlysuspend\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+}
+static void rt4502_backlight_earlyresume(struct early_suspend *desc)
+{
+	struct rt4502_bl_data *rt4502 = container_of(desc, struct rt4502_bl_data,
+				early_suspend_desc);
+	struct backlight_device *bl = platform_get_drvdata(rt4502->pdev);
+	struct timespec ts;
+	struct rtc_time tm;
+
+#if 1//defined(CONFIG_MACH_HAWAII_SS_ROYVEDTV_REV00) 
+	gpio_set_value(backlight_pin, 1);
+	BLDBG("[BACKLIGHT] rt4502_backlight_earlyresume->Control Pin Enable\n");
+	udelay(100);
+#endif
+
+	getnstimeofday(&ts);
+	rtc_time_to_tm(ts.tv_sec, &tm);
+       backlight_mode=BACKLIGHT_RESUME;
+       printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlyresume\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
+       backlight_update_status(bl);
+}
+#else
+#ifdef CONFIG_PM
+static int rt4502_backlight_suspend(struct platform_device *pdev,
+					pm_message_t state)
+{
+	struct backlight_device *bl = platform_get_drvdata(pdev);
+	struct rt4502_bl_data *rt4502 = dev_get_drvdata(&bl->dev);
+    
+        BLDBG("[BACKLIGHT] rt4502_backlight_suspend\n");
+        
+	return 0;
+}
+static int rt4502_backlight_resume(struct platform_device *pdev)
+{
+	struct backlight_device *bl = platform_get_drvdata(pdev);
+        BLDBG("[BACKLIGHT] rt4502_backlight_resume\n");
+        
+	  backlight_update_status(bl);
+        
+	return 0;
+}
+#else
+#define rt4502_backlight_suspend  NULL
+#define rt4502_backlight_resume   NULL
+#endif
+#endif
+
+
+#ifdef CONFIG_OF
+static int rt4502_backlight_parse_dt(struct device *dev,
+                  struct platform_rt4502_backlight_data *data)
+{
+	struct device_node *node = dev->of_node;
+	struct property *prop;
+	int length;
+	u32 value;
+	int ret;
+
+	if (!node)
+		return -ENODEV;
+
+	memset(data, 0, sizeof(*data));
+
+	ret = of_property_read_u32(node, "max_brightness", &value);
+	if (ret < 0)
+		return ret;
+	data->max_brightness = value;
+
+	ret = of_property_read_u32(node, "dft_brightness", &value);
+	if (ret < 0)
+		return ret;
+	data->dft_brightness = value;
+
+	ret = of_property_read_u32(node, "ctrl_pin", &value);
+	if (ret < 0)
+		return ret;
+	data->ctrl_pin = value;
+
+	return 0;
+}
+
+#else
+static int rt4502_backlight_parse_dt(struct device *dev,
+                  struct platform_rt4502_backlight_data *data)
+{
+	return -ENODEV;
+}
+#endif
+static int rt4502_backlight_probe(struct platform_device *pdev)
+{
+	struct platform_rt4502_backlight_data *data = pdev->dev.platform_data;
+	struct platform_rt4502_backlight_data defdata;
+	struct backlight_device *bl;
+	struct rt4502_bl_data *rt4502;
+    	struct backlight_properties props;
+	int ret;
+        BLDBG("[BACKLIGHT] rt4502_backlight_probe\n");
+    if (!data)
+	{
+		ret = rt4502_backlight_parse_dt(&pdev->dev, &defdata);
+		if (ret < 0) {
+			dev_err(&pdev->dev, "failed to find platform data\n");
+			return ret;
+		}
+		data = &defdata;
+	}
+	rt4502 = kzalloc(sizeof(*rt4502), GFP_KERNEL);
+	if (!rt4502) {
+		dev_err(&pdev->dev, "no memory for state\n");
+		ret = -ENOMEM;
+		goto err_alloc;
+	}
+	rt4502->ctrl_pin = data->ctrl_pin;
+      backlight_pin = data->ctrl_pin;
+      
+	memset(&props, 0, sizeof(struct backlight_properties));
+	props.max_brightness = data->max_brightness;
+	props.type = BACKLIGHT_PLATFORM;
+	bl = backlight_device_register(pdev->name, &pdev->dev,
+			rt4502, &rt4502_backlight_ops, &props);
+	if (IS_ERR(bl)) {
+		dev_err(&pdev->dev, "failed to register backlight\n");
+		ret = PTR_ERR(bl);
+		goto err_bl;
+	}
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	rt4502->pdev = pdev;
+	rt4502->early_suspend_desc.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
+	rt4502->early_suspend_desc.suspend = rt4502_backlight_earlysuspend;
+	rt4502->early_suspend_desc.resume = rt4502_backlight_earlyresume;
+	register_early_suspend(&rt4502->early_suspend_desc);
+#endif
+	bl->props.max_brightness = data->max_brightness;
+	bl->props.brightness = data->dft_brightness;
+	platform_set_drvdata(pdev, bl);
+
+	rt4502_backlight_update_status(bl);
+
+	return 0;
+err_bl:
+	kfree(rt4502);
+err_alloc:
+	return ret;
+}
+static int rt4502_backlight_remove(struct platform_device *pdev)
+{
+	struct backlight_device *bl = platform_get_drvdata(pdev);
+	struct rt4502_bl_data *rt4502 = dev_get_drvdata(&bl->dev);
+	backlight_device_unregister(bl);
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	unregister_early_suspend(&rt4502->early_suspend_desc);
+#endif
+	kfree(rt4502);
+	return 0;
+}
+
+static int rt4502_backlight_shutdown(struct platform_device *pdev)
+{
+	printk("[BACKLIGHT] rt4502_backlight_shutdown\n");
+       gpio_set_value(backlight_pin,0);
+       mdelay(3); 	
+	return 0;
+}
+
+static const struct of_device_id backlight_of_match[] = {
+	{ .compatible = "sprd,sprd_backlight", },
+	{ }
+};
+
+static struct platform_driver rt4502_backlight_driver = {
+	.driver		= {
+		.name	= "sprd_backlight",
+		.owner	= THIS_MODULE,
+		.of_match_table = backlight_of_match,
+	},
+	.probe		= rt4502_backlight_probe,
+	.remove		= rt4502_backlight_remove,
+	.shutdown      = rt4502_backlight_shutdown,
+#ifndef CONFIG_HAS_EARLYSUSPEND
+	.suspend        = rt4502_backlight_suspend,
+	.resume         = rt4502_backlight_resume,
+#endif
+};
+static int __init rt4502_backlight_init(void)
+{
+	return platform_driver_register(&rt4502_backlight_driver);
+}
+module_init(rt4502_backlight_init);
+static void __exit rt4502_backlight_exit(void)
+{
+	platform_driver_unregister(&rt4502_backlight_driver);
+}
+module_exit(rt4502_backlight_exit);
+MODULE_DESCRIPTION("rt4502 based Backlight Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:rt4502-backlight");
+