RK3568平台 PWM Backlight控制背光亮度_rk3568 pwm初始化

	ret = -ENOMEM;
	goto err_alloc;
}

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;
pb->post_pwm_on_delay = data->post_pwm_on_delay;
pb->pwm_off_delay = data->pwm_off_delay;
pb->min_duty = 102;
pb->max_duty = 255;

    //IST ADD START by xc 230318
#if 0
printk("boot_mode = %s\n", boot_mode);
if(strcmp(boot_mode, "1") == 0) {
	pb->enable_gpio = NULL;
	printk("normal boot\n");
}else {
	pb->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
						  GPIOD_OUT_HIGH);
	if (IS_ERR(pb->enable_gpio)) {
		ret = PTR_ERR(pb->enable_gpio);
		goto err_alloc;
	}
	printk("recovery boot\n");
}
#endif
//IST ADD END
pb->power_supply = devm_regulator_get(&pdev->dev, "power");
if (IS_ERR(pb->power_supply)) {
	ret = PTR_ERR(pb->power_supply);
	goto err_alloc;
}

pb->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pb->pwm) && PTR_ERR(pb->pwm) != -EPROBE_DEFER && !node) {
	dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
	pb->legacy = true;
	pb->pwm = pwm_request(data->pwm_id, "pwm-backlight");
}

if (IS_ERR(pb->pwm)) {
	ret = PTR_ERR(pb->pwm);
	if (ret != -EPROBE_DEFER)
		dev_err(&pdev->dev, "unable to request PWM\n");
	goto err_alloc;
}

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

dev_info(&pdev->dev, "get backlight pb->pwm->args.polarity: %d, ", pb->pwm->args.polarity);

memset(bl_polarity_data, 0, FREQ_DATA_SIZE + 1);
ret = rk_vendor_read(BACKLIGHT_POLARITY_ID, bl_polarity_data, FREQ_DATA_SIZE);
if (ret < 0)  {
	dev_err(&pdev->dev, "read backlight freq from vendor storage fail: %d\n", ret);
	//return -EINVAL;
} else {
    kstrtoint(bl_polarity_data, 0, &pwm_polarity);
	dev_info(&pdev->dev, "set backlight pwm_polarity: %d ", pwm_polarity);
	if(pwm_polarity == 0){
		pb->pwm->args.polarity = PWM_POLARITY_NORMAL;
	}else{
		pb->pwm->args.polarity = PWM_POLARITY_INVERSED;
	}
    dev_info(&pdev->dev, "set backlight polarity: %d ", pb->pwm->args.polarity);
}

ret = rk_vendor_read(BACKLIGHT_MIN_DUTY_ID, bl_polarity_data, FREQ_DATA_SIZE);
if (ret < 0)  {
    dev_err(&pdev->dev, "read backlight min duty from vendor storage fail: %d\n", ret);
        //return -EINVAL;
} else {
    kstrtoint(bl_polarity_data, 0, &min_duty);
           pb->min_duty = (min_duty*255)/100;
    dev_info(&pdev->dev, "set backlight min_duty: %d ", pb->min_duty);
}

ret = rk_vendor_read(BACKLIGHT_MAX_DUTY_ID, bl_polarity_data, FREQ_DATA_SIZE);
if (ret < 0)  {
        dev_err(&pdev->dev, "read backlight max duty from vendor storage fail: %d\n", ret);
        //return -EINVAL;
} else {
    kstrtoint(bl_polarity_data, 0, &max_duty);
           pb->max_duty = (max_duty*255)/100;
    dev_info(&pdev->dev, "set backlight max_duty: %d ", pb->max_duty);
}

/* Sync up PWM state. */
pwm_init_state(pb->pwm, &state);

/*
 * 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 it has not already been set
 * via the PWM lookup table.
 */
if (!state.period && (data->pwm_period_ns > 0))
	state.period = data->pwm_period_ns;

memset(bl_freq_data, 0, FREQ_DATA_SIZE + 1);
ret = rk_vendor_read(BACKLIGHT_PWM_FREQ_ID, bl_freq_data, FREQ_DATA_SIZE);
if (ret < 0)  {
	dev_err(&pdev->dev, "read backlight freq from vendor storage fail: %d\n", ret);
	//return -EINVAL;
} else {
    kstrtoint(bl_freq_data, 0, &pwm_freq);
    state.period = 1000000000 / pwm_freq;

	pb->pwm->args.period = state.period;
    dev_info(&pdev->dev, "set backlight freq: %d, period: %d", pwm_freq, state.period);
}
dev_info(&pdev->dev, "get backlight polarity: %d, ", state.polarity);

ret = pwm_apply_state(pb->pwm, &state);
if (ret) {
	dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
		ret);
	goto err_alloc;
}

memset(&props, 0, sizeof(struct backlight_properties));

if (data->levels) {
	pb->levels = data->levels;

	/*
	 * For the DT case, only when brightness levels is defined
	 * data->levels is filled. For the non-DT case, data->levels
	 * can come from platform data, however is not usual.
	 */
	for (i = 0; i <= data->max_brightness; i++)
		if (data->levels[i] > pb->scale)
			pb->scale = data->levels[i];

	if (pwm_backlight_is_linear(data))
		props.scale = BACKLIGHT_SCALE_LINEAR;
	else
		props.scale = BACKLIGHT_SCALE_NON_LINEAR;
} else if (!data->max_brightness) {
	/*
	 * If no brightness levels are provided and max_brightness is
	 * not set, use the default brightness table. For the DT case,
	 * max_brightness is set to 0 when brightness levels is not
	 * specified. For the non-DT case, max_brightness is usually
	 * set to some value.
	 */

	/* Get the PWM period (in nanoseconds) */
	pwm_get_state(pb->pwm, &state);

	ret = pwm_backlight_brightness_default(&pdev->dev, data,
					       state.period);
	if (ret < 0) {
		dev_err(&pdev->dev,
			"failed to setup default brightness table\n");
		goto err_alloc;
	}

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

		pb->levels = data->levels;
	}

	props.scale = BACKLIGHT_SCALE_NON_LINEAR;
} else {
	/*
	 * That only happens for the non-DT case, where platform data
	 * sets the max_brightness value.
	 */
	pb->scale = data->max_brightness;
}

pwm_adjust_config(pb->pwm);

pb->lth_brightness = data->lth_brightness * (div_u64(state.period,
			pb->scale));

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);
	if (pb->legacy)
		pwm_free(pb->pwm);
	goto err_alloc;
}

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;
bl->props.power = pwm_backlight_initial_power_state(pb);
backlight_update_status(bl);

platform_set_drvdata(pdev, bl);
return 0;

err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}

**pwm\_backlight\_parse\_dt解析DTS：**

static int pwm_backlight_parse_dt(struct device *dev,
struct platform_pwm_backlight_data *data)
{
struct device_node *node = dev->of_node;
unsigned int num_levels = 0;
unsigned int levels_count;
unsigned int num_steps = 0;
struct property *prop;
unsigned int *table;
int length;
u32 value;
int ret;

if (!node)
	return -ENODEV;

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

/*
 * These values are optional and set as 0 by default, the out values
 * are modified only if a valid u32 value can be decoded.
 */
of_property_read_u32(node, "post-pwm-on-delay-ms",
		     &data->post_pwm_on_delay);
of_property_read_u32(node, "pwm-off-delay-ms", &data->pwm_off_delay);

/*
 * Determine the number of brightness levels, if this property is not
 * set a default table of brightness levels will be used.
 */
prop = of_find_property(node, "brightness-levels", &length);
if (!prop)
	return 0;

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;
	unsigned int i, j, n = 0;

	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;

	/*
	 * This property is optional, if is set enables linear
	 * interpolation between each of the values of brightness levels
	 * and creates a new pre-computed table.
	 */
	of_property_read_u32(node, "num-interpolated-steps",
			     &num_steps);

	/*
	 * Make sure that there is at least two entries in the
	 * brightness-levels table, otherwise we can't interpolate
	 * between two points.
	 */
	if (num_steps) {
		if (data->max_brightness < 2) {
			dev_err(dev, "can't interpolate\n");
			return -EINVAL;
		}

		/*
		 * Recalculate the number of brightness levels, now
		 * taking in consideration the number of interpolated
		 * steps between two levels.
		 */
		for (i = 0; i < data->max_brightness - 1; i++) {
			if ((data->levels[i + 1] - data->levels[i]) /
			   num_steps)
				num_levels += num_steps;
			else
				num_levels++;
		}
		num_levels++;
		dev_dbg(dev, "new number of brightness levels: %d\n",
			num_levels);

		/*
		 * Create a new table of brightness levels with all the
		 * interpolated steps.
		 */
		size = sizeof(*table) * num_levels;
		table = devm_kzalloc(dev, size, GFP_KERNEL);
		if (!table)
			return -ENOMEM;

		/* Fill the interpolated table. */
		levels_count = 0;
		for (i = 0; i < data->max_brightness - 1; i++) {
			value = data->levels[i];
			n = (data->levels[i + 1] - value) / num_steps;
			if (n > 0) {
				for (j = 0; j < num_steps; j++) {
					table[levels_count] = value;
					value += n;
					levels_count++;
				}
			} else {
				table[levels_count] = data->levels[i];
				levels_count++;
			}
		}
		table[levels_count] = data->levels[i];

		/*
		 * As we use interpolation lets remove current
		 * brightness levels table and replace for the
		 * new interpolated table.
		 */
		devm_kfree(dev, data->levels);
		data->levels = table;

		/*
		 * Reassign max_brightness value to the new total number
		 * of brightness levels.
		 */
		data->max_brightness = num_levels;
	}

	data->max_brightness--;
}

return 0;

}

重点看：pwm\_backlight\_update\_status和compute\_duty\_cycle


当向backlight写入合适的亮度后就会调用到pwm\_backlight\_update\_status，其中的backlight写入的值，写入的backlight会传入compute\_duty\_cycle计算出占空比。


**pwm\_backlight\_update\_status：**

static int pwm_backlight_update_status(struct backlight_device *bl)
{
struct pwm_bl_data *pb = bl_get_data(bl);
int brightness = backlight_get_brightness(bl);
struct pwm_state state;

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

if (brightness > 0) {
	pwm_get_state(pb->pwm, &state);
	state.duty_cycle = compute_duty_cycle(pb, brightness);
	pwm_apply_state(pb->pwm, &state);

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新！！

图片转存中…(img-BJ22eKLC-1715595557020)]

[外链图片转存中…(img-yzWtFVSq-1715595557020)]

[外链图片转存中…(img-0pAqDe7K-1715595557021)]

[外链图片转存中…(img-dwPnY5Pb-1715595557021)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新！！