RK3568平台（PWM篇）PWM Backlight控制背光亮度

一.PWM基本概念

以单片机为例，我们知道，单片机的IO口输出的是数字信号，IO口只能输出高电平和低电平。

假设高电平为5V 低电平则为0V 那么我们要输出不同的模拟电压，就要用到PWM，通过改变IO口输出的方波的占空比从而获得使用数字信号模拟成的模拟电压信号。

我们知道，电压是以一种连接1或断开0的重复脉冲序列被夹到模拟负载上去的（例如LED灯，直流电机等），连接即是直流供电输出，断开即是直流供电断开。通过对连接和断开时间的控制，理论上来讲，可以输出任意不大于最大电压值（即0~5V之间任意大小）的模拟电压。

比方说 占空比为50% 那就是高电平时间一半，低电平时间一半，在一定的频率下，就可以得到模拟的2.5V输出电压 那么75%的占空比 得到的电压就是3.75V。

二.硬件原理图

三.DTS分析

backlight: backlight {
		status = "disabled";
		compatible = "pwm-backlight";
		pwms = <&pwm0 0 25000 0>;
		brightness-levels = <
			  0   1   2   3   4   5   6   7
			  8   9  10  11  12  13  14  15
			 16  17  18  19  20  21  22  23
			 24  25  26  27  28  29  30  31
			 32  33  34  35  36  37  38  39
			 40  41  42  43  44  45  46  47
			 48  49  50  51  52  53  54  55
			 56  57  58  59  60  61  62  63
			 64  65  66  67  68  69  70  71
			 72  73  74  75  76  77  78  79
			 80  81  82  83  84  85  86  87
			 88  89  90  91  92  93  94  95
			 96  97  98  99 100 101 102 103
			104 105 106 107 108 109 110 111
			112 113 114 115 116 117 118 119
			120 121 122 123 124 125 126 127
			128 129 130 131 132 133 134 135
			136 137 138 139 140 141 142 143
			144 145 146 147 148 149 150 151
			152 153 154 155 156 157 158 159
			160 161 162 163 164 165 166 167
			168 169 170 171 172 173 174 175
			176 177 178 179 180 181 182 183
			184 185 186 187 188 189 190 191
			192 193 194 195 196 197 198 199
			200 201 202 203 204 205 206 207
			208 209 210 211 212 213 214 215
			216 217 218 219 220 221 222 223
			224 225 226 227 228 229 230 231
			232 233 234 235 236 237 238 239
			240 241 242 243 244 245 246 247
			248 249 250 251 252 253 254 255>;
		default-brightness-level = <200>;
	};

pwms = <&pwm0 0 25000 0>;
第二个参数“0”表示 index 为 0，因为 pwm0 下面只有 1 个 pwm，所以我们的平台下
面都是填 0；第三个参数“25000”表示周期为 25000ns，所以频率就是 40k，其他频
率配置类似；最后一个参数“0”表示极性，分为正极性和负极性，0 表示正极性。

brightness-levels数组
brightness-levels 数组，我们一般以值 255 为一个 scale，所以一般定义
brightness-levels 为一 256 个元素的数组；当 pwm 设置为正极性时，从 0到255 表示
背光为正极，占空比从 0%100%变化，2550 位负极性，占空比从 100%0%变化；
当 pwm 设置为负极性时，则相反。必须要保证256个元素。

default-brightness-level
表示默认的背光，它存在于开机时候背光初始化到安卓用户
设置下来新的背光这段时间，default-brightness-level = <200>表示为第 200 个元素
的背光亮度。

enable-gpios
表示背光使能脚，这个根据电路原理图配置即可；有的硬件没有这个背光
使能脚，那么将这个配置删除，背光驱动通过配置 brightness-levels 数组的第 0 个元素
将显示调黑。

四.pwm背光子系统

驱动和设备树配对：

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

module_platform_driver(pwm_backlight_driver);

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

probe函数：

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 device_node *node = pdev->dev.of_node;
	struct pwm_bl_data *pb;
	struct pwm_state state;
	unsigned int i;
    int pwm_freq,pwm_polarity,min_duty,max_duty;
    u8 bl_freq_data[FREQ_DATA_SIZE + 1];
	u8 bl_polarity_data[FREQ_DATA_SIZE + 1];
	int ret;

	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;
	}

	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);
		pwm_backlight_power_on(pb);
	} else {
		pwm_backlight_power_off(pb);
	}

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

	return 0;
}

compute_duty_cycle：

static int compute_duty_cycle(struct pwm_bl_data *pb, int brightness)
{
	unsigned int lth = pb->lth_brightness;
	struct pwm_state state;
	u64 duty_cycle;

	pwm_get_state(pb->pwm, &state);

    brightness = mapBrightness(pb, brightness);
	if (pb->levels){
		duty_cycle = pb->levels[brightness];
	}	
	else
	{
		duty_cycle = brightness;
	}

	duty_cycle *= state.period - lth;
	do_div(duty_cycle, pb->scale);

	return duty_cycle + lth;
}