Brightness Control in iMX6q

cancel
Showing results for 
Search instead for 
Did you mean: 

Brightness Control in iMX6q

145 Views
Contributor I

Hi All 

I am trying to control the LVDS display brightness in imx6q apalis, In user space i am able to see the brightness values change but on display its not changing the brightness control, below is the driver code and  dtsi file for brightness control, Can any one help to resolve this issue little bit urgent task,

Thanks in advance

===================================================================================

/*
* linux/drivers/video/backlight/pwm_bl.c
*
* simple PWM based backlight control, board code has to setup
* 1) pin configuration so PWM waveforms can output
* 2) platform_data being correctly configured
*
* 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/gpio.h>
#include <linux/of_gpio.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/fb.h>
#include <linux/backlight.h>
#include <linux/err.h>
#include <linux/pwm.h>
#include <linux/pwm_backlight.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/delay.h>

/* The S340 KOE TX18D206V panel has a requirement to turn on backlight after
around 1 second to avoid display artifacts. The delay is reduced to
500 ms to reduce the delay in wakeup */
#define TX18D206V_BL_DELAY 200
#define TX18D206V_PWR_SIG_DELAY 1 /* LCD pwr to LDB signal delay */

struct pwm_bl_data {
struct pwm_device *pwm;
struct device *dev;
unsigned int period;
unsigned int lth_brightness;
unsigned int *levels;
bool enabled;
struct regulator *power_supply;
int enable_gpio;
unsigned long enable_gpio_flags;
int lcd_pwr_en_gpio;
unsigned long lcd_pwr_en_gpio_flags;
unsigned long lcd_pwr_en_time;
struct work_struct work;
unsigned int scale;
int (*notify)(struct device *,
int brightness);
void (*notify_after)(struct device *,
int brightness);
int (*check_fb)(struct device *, struct fb_info *);
void (*exit)(struct device *);
};

static void pwm_backlight_on_work(struct work_struct *work)
{
struct pwm_bl_data *pb = container_of(work, struct pwm_bl_data, work);
unsigned long remaining_time = 0, timeout = 0;
int err;

if (pb->enabled)
return;

timeout = msecs_to_jiffies(TX18D206V_BL_DELAY);
if (time_before(pb->lcd_pwr_en_time, timeout)) {
remaining_time = pb->lcd_pwr_en_time + timeout - jiffies;
if (remaining_time > timeout) { /* Handling overflow cases */
remaining_time = timeout;
pb->lcd_pwr_en_time = jiffies;
}
msleep(jiffies_to_msecs(remaining_time));
}

err = regulator_enable(pb->power_supply);
if (err < 0)
dev_err(pb->dev, "failed to enable power supply\n");

if (gpio_is_valid(pb->enable_gpio)) {
if (pb->enable_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
gpio_set_value(pb->enable_gpio, 0);
else
gpio_set_value(pb->enable_gpio, 1);
}

pwm_enable(pb->pwm);
pb->enabled = true;
}

static void pwm_backlight_power_off(struct pwm_bl_data *pb)
{
if (!pb->enabled)
return;

pwm_config(pb->pwm, 0, pb->period);
pwm_disable(pb->pwm);

if (gpio_is_valid(pb->enable_gpio)) {
if (pb->enable_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
gpio_set_value(pb->enable_gpio, 1);
else
gpio_set_value(pb->enable_gpio, 0);
}

regulator_disable(pb->power_supply);
pb->enabled = false;
}

static int compute_duty_cycle(struct pwm_bl_data *pb, int brightness)
{
unsigned int lth = pb->lth_brightness;
int duty_cycle;
printk("INSIDE DUTY CYCLE \n\n\n");
printk("lth :%d \n\n\n\n",lth);
printk("period : %d \n\n\n\n",pb->period);
if (pb->levels)
{
duty_cycle = pb->levels[brightness];
printk("DC1 : %d \n\n\n",duty_cycle);
}
else
{
duty_cycle = brightness;
printk("DC2 : %d\n\n\n",duty_cycle);
printk("DC Return : %d\n\n\n",(duty_cycle * (pb->period - lth) / pb->scale) + lth );
}
return (duty_cycle * (pb->period - lth) / pb->scale) + lth;
}

static int pwm_backlight_update_status(struct backlight_device *bl)
{
struct pwm_bl_data *pb = bl_get_data(bl);
int brightness = bl->props.brightness;
int duty_cycle;

printk("BL UPDATE STATUS : %d \n\n\n",brightness);

#ifndef CONFIG_MACH_APALIS_IMX6_THER_S340
if (bl->props.power != FB_BLANK_UNBLANK ||
bl->props.fb_blank != FB_BLANK_UNBLANK ||
bl->props.state & BL_CORE_FBBLANK)
brightness = 0;
#endif

if (pb->notify)
brightness = pb->notify(pb->dev, brightness);

if (brightness > 0) {
printk("INSIDE UPDATE STATUS FUN:\n\n\n");
duty_cycle = compute_duty_cycle(pb, brightness);
printk("Duty Cycle after compute : %d \n\n\n",duty_cycle);
pwm_config(pb->pwm, duty_cycle, pb->period);
//schedule_work(&pb->work); 
pwm_backlight_on_work(&pb->work); //myself added

} else {
/* Cancel the scheduled work to avoid race conditions */
cancel_work_sync(&pb->work);
pwm_backlight_power_off(pb);
}

if (pb->notify_after)
pb->notify_after(pb->dev, brightness);

return 0;
}

static int pwm_backlight_get_brightness(struct backlight_device *bl)
{
return bl->props.brightness;
}

static int pwm_backlight_check_fb(struct backlight_device *bl,
struct fb_info *info)
{
struct pwm_bl_data *pb = bl_get_data(bl);

return !pb->check_fb || pb->check_fb(pb->dev, info);
}

static const struct backlight_ops pwm_backlight_ops = {
.update_status = pwm_backlight_update_status,
.get_brightness = pwm_backlight_get_brightness,
.check_fb = pwm_backlight_check_fb,
};

#ifdef CONFIG_OF
static int pwm_backlight_parse_dt(struct device *dev,
struct platform_pwm_backlight_data *data)
{
struct device_node *node = dev->of_node;
enum of_gpio_flags flags;
struct property *prop;
int length;
u32 value;
int ret;

if (!node)
return -ENODEV;

memset(data, 0, sizeof(*data));

/* determine the number of brightness levels */
prop = of_find_property(node, "brightness-levels", &length);
if (!prop)
return -EINVAL;

data->max_brightness = length / sizeof(u32);

/* read brightness levels from DT property */
if (data->max_brightness > 0) {
size_t size = sizeof(*data->levels) * data->max_brightness;

data->levels = devm_kzalloc(dev, size, GFP_KERNEL);
if (!data->levels)
return -ENOMEM;

ret = of_property_read_u32_array(node, "brightness-levels",
data->levels,
data->max_brightness);
if (ret < 0)
return ret;

ret = of_property_read_u32(node, "default-brightness-level",
&value);
if (ret < 0)
return ret;

data->dft_brightness = value;
data->max_brightness--;
}

data->enable_gpio = of_get_named_gpio_flags(node, "enable-gpios", 0,
&flags);
if (data->enable_gpio == -EPROBE_DEFER)
return -EPROBE_DEFER;

if (gpio_is_valid(data->enable_gpio) && (flags & OF_GPIO_ACTIVE_LOW))
data->enable_gpio_flags |= PWM_BACKLIGHT_GPIO_ACTIVE_LOW;

data->lcd_pwr_en_gpio = of_get_named_gpio_flags(node, "lcd-pwr-en-gpio", 0,
&flags);
if (data->lcd_pwr_en_gpio == -EPROBE_DEFER)
return -EPROBE_DEFER;

if (gpio_is_valid(data->lcd_pwr_en_gpio) && (flags & OF_GPIO_ACTIVE_LOW))
data->lcd_pwr_en_gpio_flags |= PWM_BACKLIGHT_GPIO_ACTIVE_LOW;

return 0;
}

static struct of_device_id pwm_backlight_of_match[] = {
{ .compatible = "pwm-backlight" },
{ }
};

MODULE_DEVICE_TABLE(of, pwm_backlight_of_match);
#else
static int pwm_backlight_parse_dt(struct device *dev,
struct platform_pwm_backlight_data *data)
{
return -ENODEV;
}
#endif

static int pwm_backlight_probe(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = dev_get_platdata(&pdev->dev);
struct platform_pwm_backlight_data defdata;
struct backlight_properties props;
struct backlight_device *bl;
struct pwm_bl_data *pb;
int ret;

printk("PWM BACKLIGHT PROBED \n\n\n\n\n\n");

if (!data) {
ret = pwm_backlight_parse_dt(&pdev->dev, &defdata);
if (ret < 0) {
dev_err(&pdev->dev, "failed to find platform data\n");
return ret;
}

data = &defdata;
}

if (data->init) {
ret = data->init(&pdev->dev);
if (ret < 0)
return ret;
}

pb = devm_kzalloc(&pdev->dev, sizeof(*pb), GFP_KERNEL);
if (!pb) {
ret = -ENOMEM;
goto err_alloc;
}

if (data->levels) {
unsigned int i;

for (i = 0; i <= data->max_brightness; i++)
if (data->levels[i] > pb->scale)
pb->scale = data->levels[i];

pb->levels = data->levels;
} else
pb->scale = data->max_brightness;

pb->enable_gpio = data->enable_gpio;
pb->enable_gpio_flags = data->enable_gpio_flags;
pb->lcd_pwr_en_gpio = data->lcd_pwr_en_gpio;
pb->lcd_pwr_en_gpio_flags = data->lcd_pwr_en_gpio_flags;
pb->notify = data->notify;
pb->notify_after = data->notify_after;
pb->check_fb = data->check_fb;
pb->exit = data->exit;
pb->dev = &pdev->dev;
pb->enabled = false;

INIT_WORK(&pb->work, pwm_backlight_on_work);
if (gpio_is_valid(pb->enable_gpio)) {
unsigned long flags;

if (pb->enable_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
flags = GPIOF_OUT_INIT_HIGH;
else
flags = GPIOF_OUT_INIT_LOW;

ret = gpio_request_one(pb->enable_gpio, flags, "enable");
if (ret < 0) {
dev_err(&pdev->dev, "failed to request GPIO#%d: %d\n",
pb->enable_gpio, ret);
goto err_alloc;
}
}
if (gpio_is_valid(pb->lcd_pwr_en_gpio)) {
unsigned long flags;

if (pb->lcd_pwr_en_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
flags = GPIOF_OUT_INIT_HIGH;
else
flags = GPIOF_OUT_INIT_LOW;

ret = gpio_request_one(pb->lcd_pwr_en_gpio, flags, "enable");
if (ret < 0) {
dev_err(&pdev->dev, "failed to request GPIO#%d: %d\n",
pb->lcd_pwr_en_gpio, ret);
goto err_gpio;
}
/* Turn ON the LCD power explicitly */
if (pb->lcd_pwr_en_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
gpio_set_value(pb->lcd_pwr_en_gpio, 0);
else
gpio_set_value(pb->lcd_pwr_en_gpio, 1);
pb->lcd_pwr_en_time = jiffies;

/* delaying by few ms to maintain panel timings */
mdelay(TX18D206V_PWR_SIG_DELAY);
}

pb->power_supply = devm_regulator_get(&pdev->dev, "power");
if (IS_ERR(pb->power_supply)) {
ret = PTR_ERR(pb->power_supply);
goto err_gpio;
}

pb->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");

pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
if (IS_ERR(pb->pwm)) {
dev_err(&pdev->dev, "unable to request legacy PWM\n");
ret = PTR_ERR(pb->pwm);
goto err_gpio;
}
}

dev_dbg(&pdev->dev, "got pwm for backlight\n");

/*
* The DT case will set the pwm_period_ns field to 0 and store the
* period, parsed from the DT, in the PWM device. For the non-DT case,
* set the period from platform data.
*/
if (data->pwm_period_ns > 0)
pwm_set_period(pb->pwm, data->pwm_period_ns);

pb->period = pwm_get_period(pb->pwm);
pb->lth_brightness = data->lth_brightness * (pb->period / pb->scale);

memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_RAW;
props.max_brightness = data->max_brightness;
bl = backlight_device_register(dev_name(&pdev->dev), &pdev->dev, pb,
&pwm_backlight_ops, &props);
if (IS_ERR(bl)) {
dev_err(&pdev->dev, "failed to register backlight\n");
ret = PTR_ERR(bl);
goto err_gpio;
}

if (data->dft_brightness > data->max_brightness) {
dev_warn(&pdev->dev,
"invalid default brightness level: %u, using %u\n",
data->dft_brightness, data->max_brightness);
data->dft_brightness = data->max_brightness;
}

bl->props.brightness = data->dft_brightness;
backlight_update_status(bl);

platform_set_drvdata(pdev, bl);
return 0;

err_gpio:
if (gpio_is_valid(pb->enable_gpio))
gpio_free(pb->enable_gpio);
if (gpio_is_valid(pb->lcd_pwr_en_gpio))
gpio_free(pb->lcd_pwr_en_gpio);
err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}

static int pwm_backlight_remove(struct platform_device *pdev)
{
struct backlight_device *bl = platform_get_drvdata(pdev);
struct pwm_bl_data *pb = bl_get_data(bl);

backlight_device_unregister(bl);
pwm_backlight_power_off(pb);

if (pb->exit)
pb->exit(&pdev->dev);

return 0;
}

#ifdef CONFIG_PM_SLEEP
static int pwm_backlight_suspend(struct device *dev)
{
struct backlight_device *bl = dev_get_drvdata(dev);
struct pwm_bl_data *pb = bl_get_data(bl);

if (pb->notify)
pb->notify(pb->dev, 0);

pwm_backlight_power_off(pb);
/* Cancel the scheduled work to avoid race conditions */
cancel_work_sync(&pb->work);

if (gpio_is_valid(pb->lcd_pwr_en_gpio)) {
if (pb->lcd_pwr_en_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
gpio_set_value(pb->lcd_pwr_en_gpio, 1);
else
gpio_set_value(pb->lcd_pwr_en_gpio, 0);
}

if (pb->notify_after)
pb->notify_after(pb->dev, 0);

return 0;
}

static int pwm_backlight_resume(struct device *dev)
{
struct backlight_device *bl = dev_get_drvdata(dev);
struct pwm_bl_data *pb = bl_get_data(bl);

if (gpio_is_valid(pb->lcd_pwr_en_gpio)) {
if (pb->lcd_pwr_en_gpio_flags & PWM_BACKLIGHT_GPIO_ACTIVE_LOW)
gpio_set_value(pb->lcd_pwr_en_gpio, 0);
else
gpio_set_value(pb->lcd_pwr_en_gpio, 1);
pb->lcd_pwr_en_time = jiffies;

/* delaying by few ms to maintain panel timings */
mdelay(TX18D206V_PWR_SIG_DELAY);
}

backlight_update_status(bl);

return 0;
}
#endif

static const struct dev_pm_ops pwm_backlight_pm_ops = {
#ifdef CONFIG_PM_SLEEP
.suspend = pwm_backlight_suspend,
.resume = pwm_backlight_resume,
.poweroff = pwm_backlight_suspend,
.restore = pwm_backlight_resume,
#endif
};

static struct platform_driver pwm_backlight_driver = {
.driver = {
.name = "pwm-backlight",
.owner = THIS_MODULE,
.pm = &pwm_backlight_pm_ops,
.of_match_table = of_match_ptr(pwm_backlight_of_match),
},
.probe = pwm_backlight_probe,
.remove = pwm_backlight_remove,
};

module_platform_driver(pwm_backlight_driver);

MODULE_DESCRIPTION("PWM based Backlight Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:pwm-backlight");

======================================================================

OUTPUT:

$ /sys/devices/soc0/backlight/backlight/backlight # echo 0 > brightness

BL UPDATE STATUS : 0

$/sys/devices/soc0/backlight/backlight/backlight # echo 7 > brightness

BL UPDATE STATUS : 7


INSIDE UPDATE STATUS FUN:


INSIDE DUTY CYCLE


lth :0

period : 0

DC1 : 174


Duty Cycle after compute : 0

===================================================================

in .dtsi file configuration:

&backlight {
brightness-levels = <255 228 224 218 210 200 188 174 158 140 120 98 74 48 0>;
default-brightness-level = <10>;
enable-gpios = <&gpio1 6 0>;
lcd-pwr-en-gpio = <&gpio1 9 0>;
status = "okay";
};

and

 

backlight: backlight {
compatible = "pwm-backlight";
pwms = <&pwm4 0 500000>;
//status = "disabled";
status = "okay"; 
};

Best Regards 

SGN

0 Kudos
3 Replies

53 Views
NXP TechSupport
NXP TechSupport

Hi Nandish

for apalis board one can look at toradex resources:

Backlight (Linux) 

Best regards
igor
-----------------------------------------------------------------------------------------------------------------------
Note: If this post answers your question, please click the Correct Answer button. Thank you!
-----------------------------------------------------------------------------------------------------------------------

0 Kudos

53 Views
Contributor I

Hi  Igor,

Thanks for your quick reply, i saw that even in Toradex also but no luck,

any changes in need in driver, because i am getting the pwm as 0,

and i made small changes in code 

====================================================================

static int compute_duty_cycle(struct pwm_bl_data *pb, int brightness)
{
unsigned int lth = pb->lth_brightness;
int duty_cycle;
printk("INSIDE DUTY CYCLE \n\n\n");
printk("lth Brightness :%d \n\n\n\n",lth);
printk("period : %d \n\n\n\n",pb->period);
if (pb->levels)
{
duty_cycle = pb->levels[brightness];
printk("DC1 : %d \n\n\n",duty_cycle);
}
else
{
duty_cycle = brightness;
printk("DC2 : %d\n\n\n",duty_cycle);
printk("DC Return : %d\n\n\n",(duty_cycle * (pb->period - lth) / pb->scale) + lth );
}
//return (duty_cycle * (pb->period - lth) / pb->scale) + lth;
return (duty_cycle);
}

=============================================================

$ /sys/devices/soc0/backlight/backlight/backlight # echo 0 > brightness

BL UPDATE STATUS : 0

 

$/sys/devices/soc0/backlight/backlight/backlight # echo 8 > brightness

BL UPDATE STATUS : 8


INSIDE BL UPDATE STATUS FUN Brightness : 8


INSIDE DUTY CYCLE


lth Brightness : 0

period : 0

DC1 : 158


Duty Cycle after compute : 158


pb->pwm is : -665628032


pb->period is : 0

best regards

SGN

0 Kudos

53 Views
NXP TechSupport
NXP TechSupport

for pwm4 usage toradex has special comments:

Apalis iMX 6 PWM4 & Backlight PWM Sharing - Toradex Community 

Best regards
igor

0 Kudos