qcom sdm660 led 分析

最新推荐文章于 2024-04-28 17:37:04 发布
最新推荐文章于 2024-04-28 17:37:04 发布
阅读量899 收藏 3
点赞数
分类专栏： led 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36247447/article/details/108291971
版权

msm-pm660l.dtsi相关节点。

qcom,leds@d000 {
			compatible = "qcom,leds-qpnp";
			reg = <0xd000 0x100>;
			label = "rgb";

			red_led: qcom,rgb_0 {
				label = "rgb";
				qcom,id = <3>;
				qcom,mode = "pwm";
				pwms = <&pm660l_pwm_3 0 0>;
				qcom,pwm-us = <2000>;
				qcom,max-current = <12>;
				qcom,default-state = "off";
				linux,name = "red";
				qcom,start-idx = <0>;
				qcom,idx-len = <10>;
				qcom,duty-pcts =
					[00 19 32 4b 64
					64 46 32 19 00];
				qcom,use-blink;
			};

qcom,mode = "pwm";模式为PWM ，另外的两个模式是manual、lpg。一个是手动模式，另一个不太清楚。

qcom,pwm-us = <2000>;表示PWM的一个周期是2s。

qcom,max-current = <12>;最大电流12mA

qcom,duty-pcts =  [00 19 32 4b 64 64 46 32 19 00];亮度值从0到64，再从64到0。实现呼吸灯功能，若想实现闪烁，值改为0与64即可。

LPG模式可选属性

qcom,pause-lo:在周期的低端暂停

qcom,pause-hi:在周期的高端暂停

qcom,ramp-step-ms:每个周期间隔(ms)

qcom,lut-flags:lut配置中使用的标志

Leds-qpnp.c (kernel\msm-4.4\drivers\leds)节点解析文件

static struct platform_driver qpnp_leds_driver = {
	.driver		= {
		.name		= "qcom,leds-qpnp",
		.of_match_table	= spmi_match_table,
	},
	.probe		= qpnp_leds_probe,
	.remove		= qpnp_leds_remove,
};
//进入probe函数
static int qpnp_leds_probe(struct platform_device *pdev)
{
	struct qpnp_led_data *led, *led_array;
	unsigned int base;
	struct device_node *node, *temp;
	int rc, i, num_leds = 0, parsed_leds = 0;
	const char *led_label;
	bool regulator_probe = false;

	node = pdev->dev.of_node;
	if (node == NULL)
		return -ENODEV;

	temp = NULL;
	while ((temp = of_get_next_child(node, temp)))
		num_leds++;

	if (!num_leds)
		return -ECHILD;

	led_array = devm_kcalloc(&pdev->dev, num_leds, sizeof(*led_array),
				GFP_KERNEL);
	if (!led_array)
		return -ENOMEM;

	for_each_child_of_node(node, temp) {
		led = &led_array[parsed_leds];
		led->num_leds = num_leds;
		led->regmap = dev_get_regmap(pdev->dev.parent, NULL);
		if (!led->regmap) {
			dev_err(&pdev->dev, "Couldn't get parent's regmap\n");
			return -EINVAL;
		}
		led->pdev = pdev;

		rc = of_property_read_u32(pdev->dev.of_node, "reg", &base);
		if (rc < 0) {
			dev_err(&pdev->dev,
				"Couldn't find reg in node = %s rc = %d\n",
				pdev->dev.of_node->full_name, rc);
			goto fail_id_check;
		}
		led->base = base;

		rc = of_property_read_string(temp, "label", &led_label);
		if (rc < 0) {
			dev_err(&led->pdev->dev,
				"Failure reading label, rc = %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_string(temp, "linux,name",
			&led->cdev.name);
		if (rc < 0) {
			dev_err(&led->pdev->dev,
				"Failure reading led name, rc = %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_u32(temp, "qcom,max-current",
			&led->max_current);
		if (rc < 0) {
			dev_err(&led->pdev->dev,
				"Failure reading max_current, rc =  %d\n", rc);
			goto fail_id_check;
		}

		rc = of_property_read_u32(temp, "qcom,id", &led->id);
		if (rc < 0) {
			dev_err(&led->pdev->dev,
				"Failure reading led id, rc =  %d\n", rc);
			goto fail_id_check;
		}

		rc = qpnp_get_common_configs(led, temp);
		if (rc) {
			dev_err(&led->pdev->dev, "Failure reading common led configuration, rc = %d\n",
				rc);
			goto fail_id_check;
		}

		led->cdev.brightness_set    = qpnp_led_set;
		led->cdev.brightness_get    = qpnp_led_get;

		if (strcmp(led_label, "wled") == 0) {
			rc = qpnp_get_config_wled(led, temp);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
					"Unable to read wled config data\n");
				goto fail_id_check;
			}
		} else if (strcmp(led_label, "flash") == 0) {
			if (!of_find_property(node, "flash-boost-supply", NULL))
				regulator_probe = true;
			rc = qpnp_get_config_flash(led, temp, &regulator_probe);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
					"Unable to read flash config data\n");
				goto fail_id_check;
			}
		} else if (strcmp(led_label, "rgb") == 0) {
			rc = qpnp_get_config_rgb(led, temp);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
					"Unable to read rgb config data\n");
				goto fail_id_check;
			}
		} else if (strcmp(led_label, "mpp") == 0) {
			rc = qpnp_get_config_mpp(led, temp);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
						"Unable to read mpp config data\n");
				goto fail_id_check;
			}
		} else if (strcmp(led_label, "gpio") == 0) {
			rc = qpnp_get_config_gpio(led, temp);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
						"Unable to read gpio config data\n");
				goto fail_id_check;
			}
		} else if (strcmp(led_label, "kpdbl") == 0) {
			bitmap_zero(kpdbl_leds_in_use, NUM_KPDBL_LEDS);
			is_kpdbl_master_turn_on = false;
			rc = qpnp_get_config_kpdbl(led, temp);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
					"Unable to read kpdbl config data\n");
				goto fail_id_check;
			}
		} else {
			dev_err(&led->pdev->dev, "No LED matching label\n");
			rc = -EINVAL;
			goto fail_id_check;
		}

		if (led->id != QPNP_ID_FLASH1_LED0 &&
					led->id != QPNP_ID_FLASH1_LED1)
			mutex_init(&led->lock);

		led->in_order_command_processing = of_property_read_bool
				(temp, "qcom,in-order-command-processing");

		if (led->in_order_command_processing) {
			/*
			 * the command order from user space needs to be
			 * maintained use ordered workqueue to prevent
			 * concurrency
			 */
			led->workqueue = alloc_ordered_workqueue
							("led_workqueue", 0);
			if (!led->workqueue) {
				rc = -ENOMEM;
				goto fail_id_check;
			}
		}

		INIT_WORK(&led->work, qpnp_led_work);

		rc =  qpnp_led_initialize(led);
		if (rc < 0)
			goto fail_id_check;

		rc = qpnp_led_set_max_brightness(led);
		if (rc < 0)
			goto fail_id_check;

		rc = led_classdev_register(&pdev->dev, &led->cdev);
		if (rc) {
			dev_err(&pdev->dev,
				"unable to register led %d,rc=%d\n",
						 led->id, rc);
			goto fail_id_check;
		}

		if (led->id == QPNP_ID_FLASH1_LED0 ||
			led->id == QPNP_ID_FLASH1_LED1) {
			rc = sysfs_create_group(&led->cdev.dev->kobj,
							&led_attr_group);
			if (rc)
				goto fail_id_check;

		}

		if (led->id == QPNP_ID_LED_MPP) {
			if (!led->mpp_cfg->pwm_cfg)
				break;
			if (led->mpp_cfg->pwm_cfg->mode == PWM_MODE) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&pwm_attr_group);
				if (rc)
					goto fail_id_check;
			}
			if (led->mpp_cfg->pwm_cfg->use_blink) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&blink_attr_group);
				if (rc)
					goto fail_id_check;

				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&lpg_attr_group);
				if (rc)
					goto fail_id_check;
			} else if (led->mpp_cfg->pwm_cfg->mode == LPG_MODE) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&lpg_attr_group);
				if (rc)
					goto fail_id_check;
			}
		} else if ((led->id == QPNP_ID_RGB_RED) ||
			(led->id == QPNP_ID_RGB_GREEN) ||
			(led->id == QPNP_ID_RGB_BLUE)) {
			if (led->rgb_cfg->pwm_cfg->mode == PWM_MODE) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&pwm_attr_group);
				if (rc)
					goto fail_id_check;
			}
			if (led->rgb_cfg->pwm_cfg->use_blink) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&blink_attr_group);
				if (rc)
					goto fail_id_check;

				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&lpg_attr_group);
				if (rc)
					goto fail_id_check;
			} else if (led->rgb_cfg->pwm_cfg->mode == LPG_MODE) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&lpg_attr_group);
				if (rc)
					goto fail_id_check;
			}
		} else if (led->id == QPNP_ID_KPDBL) {
			if (led->kpdbl_cfg->pwm_cfg->mode == PWM_MODE) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&pwm_attr_group);
				if (rc)
					goto fail_id_check;
			}
			if (led->kpdbl_cfg->pwm_cfg->use_blink) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&blink_attr_group);
				if (rc)
					goto fail_id_check;

				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&lpg_attr_group);
				if (rc)
					goto fail_id_check;
			} else if (led->kpdbl_cfg->pwm_cfg->mode == LPG_MODE) {
				rc = sysfs_create_group(&led->cdev.dev->kobj,
					&lpg_attr_group);
				if (rc)
					goto fail_id_check;
			}
		}

		/* configure default state */
		if (led->default_on) {
			led->cdev.brightness = led->cdev.max_brightness;
			__qpnp_led_work(led, led->cdev.brightness);
			if (led->turn_off_delay_ms > 0)
				qpnp_led_turn_off(led);
		} else
			led->cdev.brightness = LED_OFF;

		parsed_leds++;
	}
	dev_set_drvdata(&pdev->dev, led_array);
	return 0;

fail_id_check:
	for (i = 0; i < parsed_leds; i++) {
		if (led_array[i].id != QPNP_ID_FLASH1_LED0 &&
				led_array[i].id != QPNP_ID_FLASH1_LED1)
			mutex_destroy(&led_array[i].lock);
		if (led_array[i].in_order_command_processing)
			destroy_workqueue(led_array[i].workqueue);
		led_classdev_unregister(&led_array[i].cdev);
	}

	return rc;
}

led->cdev.brightness_set    = qpnp_led_set;这里和led_class联系起来了。

static void qpnp_led_set(struct led_classdev *led_cdev,
				enum led_brightness value)
{
	struct qpnp_led_data *led;

	led = container_of(led_cdev, struct qpnp_led_data, cdev);
	if (value < LED_OFF) {
		dev_err(&led->pdev->dev, "Invalid brightness value\n");
		return;
	}

	if (value > led->cdev.max_brightness)
		value = led->cdev.max_brightness;

	led->cdev.brightness = value;
	if (led->in_order_command_processing)
		queue_work(led->workqueue, &led->work);
	else
		schedule_work(&led->work);
}

设置了灯的亮度值，并在 结尾开启了一个work队列，也就是INIT_WORK(&led->work, qpnp_led_work);最后调用到下面函数

static int qpnp_rgb_set(struct qpnp_led_data *led)
{
	int rc;
	int duty_us, duty_ns, period_us;

	if (led->cdev.brightness) {
		if (!led->rgb_cfg->pwm_cfg->blinking)
			led->rgb_cfg->pwm_cfg->mode =
				led->rgb_cfg->pwm_cfg->default_mode;
		if (led->rgb_cfg->pwm_cfg->mode == PWM_MODE) {
			rc = pwm_change_mode(led->rgb_cfg->pwm_cfg->pwm_dev,
					PM_PWM_MODE_PWM);
			if (rc < 0) {
				dev_err(&led->pdev->dev,
					"Failed to set PWM mode, rc = %d\n",
					rc);
				return rc;
			}
			period_us = led->rgb_cfg->pwm_cfg->pwm_period_us;
			if (period_us > INT_MAX / NSEC_PER_USEC) {
				duty_us = (period_us * led->cdev.brightness) /
					LED_FULL;
				rc = pwm_config_us(
					led->rgb_cfg->pwm_cfg->pwm_dev,
					duty_us,
					period_us);
			} else {
				duty_ns = ((period_us * NSEC_PER_USEC) /
					LED_FULL) * led->cdev.brightness;
				rc = pwm_config(
					led->rgb_cfg->pwm_cfg->pwm_dev,
					duty_ns,
					period_us * NSEC_PER_USEC);
			}
			if (rc < 0) {
				dev_err(&led->pdev->dev,
					"pwm config failed\n");
				return rc;
			}
		}
		rc = qpnp_led_masked_write(led,
			RGB_LED_EN_CTL(led->base),
			led->rgb_cfg->enable, led->rgb_cfg->enable);
		if (rc) {
			dev_err(&led->pdev->dev,
				"Failed to write led enable reg\n");
			return rc;
		}
		if (!led->rgb_cfg->pwm_cfg->pwm_enabled) {
			pwm_enable(led->rgb_cfg->pwm_cfg->pwm_dev);
			led->rgb_cfg->pwm_cfg->pwm_enabled = 1;
		}
	} else {
		led->rgb_cfg->pwm_cfg->mode =
			led->rgb_cfg->pwm_cfg->default_mode;
		if (led->rgb_cfg->pwm_cfg->pwm_enabled) {
			pwm_disable(led->rgb_cfg->pwm_cfg->pwm_dev);
			led->rgb_cfg->pwm_cfg->pwm_enabled = 0;
		}
		rc = qpnp_led_masked_write(led,
			RGB_LED_EN_CTL(led->base),
			led->rgb_cfg->enable, RGB_LED_DISABLE);
		if (rc) {
			dev_err(&led->pdev->dev,
				"Failed to write led enable reg\n");
			return rc;
		}
	}

	led->rgb_cfg->pwm_cfg->blinking = false;
	qpnp_dump_regs(led, rgb_pwm_debug_regs, ARRAY_SIZE(rgb_pwm_debug_regs));

	return 0;
}

qpnp_led_masked_write，这个函数的作用就是把相应的信息写入到寄存器中 ，使能led。

中间部分的配置，根据led_label=rgb进入qpnp_get_config_rgb()开始配置led。

static int qpnp_get_config_rgb(struct qpnp_led_data *led,
				struct device_node *node)
{
	int rc;
	u8 led_mode;
	const char *mode;

	led->rgb_cfg = devm_kzalloc(&led->pdev->dev,
				sizeof(struct rgb_config_data), GFP_KERNEL);
	if (!led->rgb_cfg)
		return -ENOMEM;

	if (led->id == QPNP_ID_RGB_RED)
		led->rgb_cfg->enable = RGB_LED_ENABLE_RED;
	else if (led->id == QPNP_ID_RGB_GREEN)
		led->rgb_cfg->enable = RGB_LED_ENABLE_GREEN;
	else if (led->id == QPNP_ID_RGB_BLUE)
		led->rgb_cfg->enable = RGB_LED_ENABLE_BLUE;
	else
		return -EINVAL;

	rc = of_property_read_string(node, "qcom,mode", &mode);
	if (!rc) {
		led_mode = qpnp_led_get_mode(mode);
		if ((led_mode == MANUAL_MODE) || (led_mode == -EINVAL)) {
			dev_err(&led->pdev->dev, "Selected mode not supported for rgb\n");
			return -EINVAL;
		}
		led->rgb_cfg->pwm_cfg = devm_kzalloc(&led->pdev->dev,
					sizeof(struct pwm_config_data),
					GFP_KERNEL);
		if (!led->rgb_cfg->pwm_cfg) {
			dev_err(&led->pdev->dev,
				"Unable to allocate memory\n");
			return -ENOMEM;
		}
		led->rgb_cfg->pwm_cfg->mode = led_mode;
		led->rgb_cfg->pwm_cfg->default_mode = led_mode;
	} else {
		return rc;
	}

	rc = qpnp_get_config_pwm(led->rgb_cfg->pwm_cfg, led->pdev, node);
	if (rc < 0) {
		if (led->rgb_cfg->pwm_cfg->pwm_dev)
			pwm_put(led->rgb_cfg->pwm_cfg->pwm_dev);
		return rc;
	}

	return 0;
}

先解析出led的模式，有三种模式。

static int qpnp_led_get_mode(const char *mode)
{
	if (strcmp(mode, "manual") == 0)
		return MANUAL_MODE;
	else if (strcmp(mode, "pwm") == 0)
		return PWM_MODE;
	else if (strcmp(mode, "lpg") == 0)
		return LPG_MODE;
	else
		return -EINVAL;
};

随后解析出PWM的配置

static int qpnp_get_config_pwm(struct pwm_config_data *pwm_cfg,
				struct platform_device *pdev,
				struct device_node *node)
{
	struct property *prop;
	int rc, i, lut_max_size;
	u32 val;
	u8 *temp_cfg;
	const char *led_label;

	pwm_cfg->pwm_dev = of_pwm_get(node, NULL);

	if (IS_ERR(pwm_cfg->pwm_dev)) {
		rc = PTR_ERR(pwm_cfg->pwm_dev);
		dev_err(&pdev->dev, "Cannot get PWM device rc:(%d)\n", rc);
		pwm_cfg->pwm_dev = NULL;
		return rc;
	}

	if (pwm_cfg->mode != MANUAL_MODE) {
		rc = of_property_read_u32(node, "qcom,pwm-us", &val);
		if (!rc)
			pwm_cfg->pwm_period_us = val;
		else
			return rc;
	}

	pwm_cfg->use_blink =
		of_property_read_bool(node, "qcom,use-blink");

	if (pwm_cfg->mode == LPG_MODE || pwm_cfg->use_blink) {
		pwm_cfg->duty_cycles =
			devm_kzalloc(&pdev->dev,
			sizeof(struct pwm_duty_cycles), GFP_KERNEL);
		if (!pwm_cfg->duty_cycles) {
			dev_err(&pdev->dev, "Unable to allocate memory\n");
			rc = -ENOMEM;
			goto bad_lpg_params;
		}

		prop = of_find_property(node, "qcom,duty-pcts",
			&pwm_cfg->duty_cycles->num_duty_pcts);
		if (!prop) {
			dev_err(&pdev->dev, "Looking up property node qcom,duty-pcts failed\n");
			rc =  -ENODEV;
			goto bad_lpg_params;
		} else if (!pwm_cfg->duty_cycles->num_duty_pcts) {
			dev_err(&pdev->dev, "Invalid length of duty pcts\n");
			rc =  -EINVAL;
			goto bad_lpg_params;
		}

		rc = of_property_read_string(node, "label", &led_label);

		if (rc < 0) {
			dev_err(&pdev->dev,
				"Failure reading label, rc = %d\n", rc);
			return rc;
		}

		if (strcmp(led_label, "kpdbl") == 0)
			lut_max_size = PWM_GPLED_LUT_MAX_SIZE;
		else
			lut_max_size = PWM_LUT_MAX_SIZE;

		pwm_cfg->duty_cycles->duty_pcts =
			devm_kzalloc(&pdev->dev,
			sizeof(int) * lut_max_size,
			GFP_KERNEL);
		if (!pwm_cfg->duty_cycles->duty_pcts) {
			dev_err(&pdev->dev, "Unable to allocate memory\n");
			rc = -ENOMEM;
			goto bad_lpg_params;
		}

		pwm_cfg->old_duty_pcts =
			devm_kzalloc(&pdev->dev,
			sizeof(int) * lut_max_size,
			GFP_KERNEL);
		if (!pwm_cfg->old_duty_pcts) {
			dev_err(&pdev->dev, "Unable to allocate memory\n");
			rc = -ENOMEM;
			goto bad_lpg_params;
		}

		temp_cfg = devm_kzalloc(&pdev->dev,
				pwm_cfg->duty_cycles->num_duty_pcts *
				sizeof(u8), GFP_KERNEL);
		if (!temp_cfg) {
			dev_err(&pdev->dev, "Failed to allocate memory for duty pcts\n");
			rc = -ENOMEM;
			goto bad_lpg_params;
		}

		memcpy(temp_cfg, prop->value,
			pwm_cfg->duty_cycles->num_duty_pcts);

		for (i = 0; i < pwm_cfg->duty_cycles->num_duty_pcts; i++)
			pwm_cfg->duty_cycles->duty_pcts[i] =
				(int) temp_cfg[i];

		rc = of_property_read_u32(node, "qcom,start-idx", &val);
		if (!rc) {
			pwm_cfg->lut_params.start_idx = val;
			pwm_cfg->duty_cycles->start_idx = val;
		} else
			goto bad_lpg_params;

		pwm_cfg->lut_params.lut_pause_hi = 0;
		rc = of_property_read_u32(node, "qcom,pause-hi", &val);
		if (!rc)
			pwm_cfg->lut_params.lut_pause_hi = val;
		else if (rc != -EINVAL)
			goto bad_lpg_params;

		pwm_cfg->lut_params.lut_pause_lo = 0;
		rc = of_property_read_u32(node, "qcom,pause-lo", &val);
		if (!rc)
			pwm_cfg->lut_params.lut_pause_lo = val;
		else if (rc != -EINVAL)
			goto bad_lpg_params;

		pwm_cfg->lut_params.ramp_step_ms =
				QPNP_LUT_RAMP_STEP_DEFAULT;
		rc = of_property_read_u32(node, "qcom,ramp-step-ms", &val);
		if (!rc)
			pwm_cfg->lut_params.ramp_step_ms = val;
		else if (rc != -EINVAL)
			goto bad_lpg_params;

		pwm_cfg->lut_params.flags = QPNP_LED_PWM_FLAGS;
		rc = of_property_read_u32(node, "qcom,lut-flags", &val);
		if (!rc)
			pwm_cfg->lut_params.flags = (u8) val;
		else if (rc != -EINVAL)
			goto bad_lpg_params;

		pwm_cfg->lut_params.idx_len =
			pwm_cfg->duty_cycles->num_duty_pcts;
	}
	return 0;

bad_lpg_params:
	pwm_cfg->use_blink = false;
	if (pwm_cfg->mode == PWM_MODE) {
		dev_err(&pdev->dev, "LPG parameters not set for blink mode, defaulting to PWM mode\n");
		return 0;
	}
	return rc;
};

配置完后就能通过brightness_set调用qpnp_led_set了。

极创it
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全志基于asoc音频驱动编写
11-23
全志基于asoc音频驱动编写全志基于asoc音频驱动编写全志基于asoc音频驱动编写
第19章　Linux电源管理的系统架构和驱动之Regulator驱动
xiezhi123456的博客
06-08 3511
19.5　Regulator驱动    Regulator是Linux系统中电源管理的基础设施之一，用于稳压电源的管理，是各种驱动子系统中设置电压的标准接口。CPUFreq驱动经常使用Regulator来设定电压。    Regulator可以管理系统中的供电单元，即稳压器（Low Dropout Regulator，LDO，即低压差线性稳压器），并提供获取和设置这些供电单元电压的接口。一般在AR...
高通平台背光设置
chen245250566的专栏
08-05 1736
qcom,mdss-dsi-bl-min-level = <1>; qcom,mdss-dsi-bl-max-level = <4095>;//如果为4095说明屏支持的背光位数为12bit 为屏支持的背光范围 qcom,mdss-brightness-max-level = <255>;//可以为4095 为用户的设置范围 cat /sys/class/backlight/panel0-backlight/max_brightness ...
ALSA驱动源码之devm_snd_soc_register_component源码分析
阿里云专家博主，51CTO专家博主、2022年博客之星Top96，嵌入式与物联网赛道Top2
08-29 1227
ALSA驱动源码之devm_snd_soc_register_component源码分析
高通PWM调试笔记
lgc1990的博客
08-13 1699
本笔记基于SDM660平台记录 一、PWM信号电平转换不能用普通三极管或者二极管，需要用高速三极管或者分压 否则出来的信号可能因为PN结的电容效应而变得不是方波，比如如下图： 蓝色是4V的PWM信号，黄色是通过三极管反向输出的波形，显然因为三极管的电容效应，无法得到转换后的波形。 二、改变PWM的高电平电压 路径：kernel\msm-4.4\arch\arm64\boot\dts\qcom\sdm660-mtp.dtsi gpio@c500->qcom,vin-sel = <0&
Linux电源管理-Linux Regulator Framework代码分析
半月旋空
11-15 6201
示例分析 在内核kernel/drivers/regulator/dummy.c文件中构造了一个虚拟的regulator，参考此文件编写一个虚拟的regulator driver。 #include #include #include #include #include #include #include static struct regulator_dev *dummy_
audio子系统笔记
ask_true的博客
04-01 650
platform、codec、machine的关系： Linux ALSA音频系统:platform,machine,codec - JavaShuo machine：机器，完整的产品；codec和platform都是该机器下的某个部件。
Carbide LED-qpnp相关问题
qq_24614807的博客
08-14 645
首先，根据测试所汇报的情况，了解了目前的情况是在充电的条件下，先亮绿灯，再亮红灯。通过最初的分析，在往节点写值的时候，亮灯的情况是正常的，也就是说三色灯的节点是可控的，由此，理论上是可以排除驱动上面的问题，但是仍然无法解决和分析到问题。在查看相关设备树文件msm-pmi8994后发现，相应的linux-default-trigger是有一些问题的，这些问题的造成主要是由于linux-default-
[SDM660 Android9.0]LCD点屏过程
但行前路 无问西东
05-23 844
adb:wm size 800x1280 手动调整分辨率 1。现象：黑屏 对应的dtsi 的timing和command等不对都有可能 2.设备起到系统后挂掉 xbl文件里的fb大小不一致导致的 查看分辨率：wm size console:/ # wm size Physical size: 800x1280 查看分辨率： dumpsys window displays |head -n
【高通SDM660平台 Android 10.0】(22) --- Flashlight 及 Kernel Flashlight 代码分析
|~~~热爱生活、努力学习的小伙汁~~~|
06-22 2577
【高通SDM660平台 Android 10.0】22 --- Flashlight 及 Kernel Flashlight 代码分析一、[硬件] 闪光灯硬件原理图二、[vendor] 库文件 lib三、[vendor] 通用代码 flash.c 初始化3.1 module_sensor_flash_init()3.2 flash_process()四、[Kernel] flashlight 驱动4.1 Kernel probe 初始化 msm_flash_platform_probe()4.2 CFG_F
qcom高通平台qcat音频分析文档
02-08
qcom高通平台qcat音频分析文档
hardware_qcom_sdm845_display
02-18
hardware_qcom_sdm845_display
移远EC20 QCOM at配置工具
03-31
移远EC20 QCOM at配置工具
QCOM车机平台v4l2 camera hal
10-18
QCOM车机平台v4l2 camera hal，车载相机hal流程
hardware_qcom-caf_sdm845_display
03-26
hardware_qcom-caf_sdm845_display
Android 11 裁剪系统显示区域(适配异形屏)
ansondroider的博客
04-27 814
在显示技术中，"OverScan"（超扫描）是一种调整显示图像边界的技术。通常情况下，OverScan 会在显示屏的边缘周围裁剪一小部分图像。这种裁剪是为了确保显示内容在屏幕上的完整可见性，尤其是在老式电视或投影仪等设备上，可能存在图像边缘出现失真或过多噪点的问题。OverScan 通过裁剪图像边缘，可以隐藏显示器边缘的任何不完美之处，例如边缘上的噪点、失真或黑边。这有助于确保图像在屏幕上的边缘部分看起来整洁且不受干扰，提供更好的观看体验。
如何使用PHP进行图片处理？
Xs_layla的博客
04-26 482
如何使用PHP进行图片处理？使用PHP进行图片处理是一项强大的功能，它可以让你在服务器端对图像进行各种操作，如裁剪、缩放、添加水印、调整颜色等。这通常通过使用GD库或Imagick扩展来实现。下面将详细介绍如何使用PHP和这两个工具进行图片处理。
AndroidStudio中虚拟机(AVD)无法启动,出现unable to locate adb错误
qq_58156721的博客
04-24 444
手机连上电脑 ——> 打开开发者模式，开启usb调试——>驱动管理类软件(360驱动大师/驱动人生/驱动精灵)检测可安装的驱动——>根据手机安装对应驱动，问题解决。首先通过File-Project Structure-Project SDK检查SDK有没有被选中。1.检查Android SDK Platform-Tools是否安装(个人是通过这个方法解决的)步骤：打开file -> settings ，搜索SDK。之后点击"-",在点击Apply进行安装。3.端口被占用(概率极小)2.可能是驱动的问题。
翻译插件Translation和AndroidLocalize
最新发布
qq_45649553的博客
04-28 325
翻译插件Translation和AndroidLocalize
qcom SDM660平台外接aw35615CSR芯片驱动调试
06-08
要在SDM660平台上驱动AW35615CSR芯片，你需要进行以下步骤： 1. 确保你的SDM660平台上已经安装了相应版本的Linux内核，并且内核中已经包含了AW35615CSR芯片的驱动程序。 2. 连接SDM660平台和AW35615CSR芯片，确保硬件连接正常。 3. 在Linux内核中加载AW35615CSR芯片的驱动程序。你可以使用modprobe命令来加载模块，例如： ``` modprobe aw35615csr ``` 4. 确认AW35615CSR芯片已经被成功识别并加载了驱动程序。你可以使用dmesg命令来查看内核日志，例如： ``` dmesg | grep aw35615csr ``` 如果AW35615CSR芯片已经被成功识别并加载了驱动程序，你应该能够在日志中看到对应的信息。 5. 进行调试。如果你遇到了问题，可以通过打印日志、使用调试工具等方式进行调试。 需要注意的是，这只是一个大致的调试流程，具体的调试步骤和方法可能因具体情况而异。在实际调试中，你还需要深入了解AW35615CSR芯片的硬件和软件特性，以及SDM660平台的驱动程序实现方式等方面的知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值