Lines Matching +full:spmi +full:- +full:sdam
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2017-2022 Linaro Ltd
4 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
9 #include <linux/led-class-multicolor.h>
40 #define PWM_DTEST_REG(x) (0xe2 + (x) - 1)
58 * struct lpg - LPG device context
62 * @pwm: PWM-chip object, if operating in PWM mode
68 * @triled_src: power-source for the TRILED
98 * struct lpg_channel - per channel data
162 * struct lpg_led - logical LED object
180 * struct lpg_channel_data - per channel initialization data
190 * struct lpg_data - initialization data
212 if (!lpg->triled_base) in triled_set()
215 return regmap_update_bits(lpg->map, lpg->triled_base + TRI_LED_EN_CTL, in triled_set()
226 idx = bitmap_find_next_zero_area(lpg->lut_bitmap, lpg->lut_size, in lpg_lut_store()
228 if (idx >= lpg->lut_size) in lpg_lut_store()
229 return -ENOMEM; in lpg_lut_store()
234 regmap_bulk_write(lpg->map, lpg->lut_base + LPG_LUT_REG(idx + i), in lpg_lut_store()
238 bitmap_set(lpg->lut_bitmap, idx, len); in lpg_lut_store()
241 *hi_idx = idx + len - 1; in lpg_lut_store()
250 len = hi_idx - lo_idx + 1; in lpg_lut_free()
254 bitmap_clear(lpg->lut_bitmap, lo_idx, len); in lpg_lut_free()
259 return regmap_write(lpg->map, lpg->lut_base + RAMP_CONTROL_REG, mask); in lpg_lut_sync()
286 * period = -------------------------- in lpg_calc_freq()
300 if (chan->subtype == LPG_SUBTYPE_HI_RES_PWM) { in lpg_calc_freq()
314 min_period = div64_u64((u64)NSEC_PER_SEC * ((1 << pwm_resolution_arr[0]) - 1), in lpg_calc_freq()
315 clk_rate_arr[clk_len - 1]); in lpg_calc_freq()
317 return -EINVAL; in lpg_calc_freq()
330 * M = log2 ------------------------------------- in lpg_calc_freq()
335 resolution = (1 << pwm_resolution_arr[i]) - 1; in lpg_calc_freq()
355 error = period - actual; in lpg_calc_freq()
367 chan->clk_sel = best_clk; in lpg_calc_freq()
368 chan->pre_div_sel = best_div; in lpg_calc_freq()
369 chan->pre_div_exp = best_m; in lpg_calc_freq()
370 chan->period = best_period; in lpg_calc_freq()
371 chan->pwm_resolution_sel = best_pwm_resolution_sel; in lpg_calc_freq()
381 if (chan->subtype == LPG_SUBTYPE_HI_RES_PWM) { in lpg_calc_duty()
382 max = BIT(lpg_pwm_resolution_hi_res[chan->pwm_resolution_sel]) - 1; in lpg_calc_duty()
383 clk_rate = lpg_clk_rates_hi_res[chan->clk_sel]; in lpg_calc_duty()
385 max = LPG_RESOLUTION_9BIT - 1; in lpg_calc_duty()
386 clk_rate = lpg_clk_rates[chan->clk_sel]; in lpg_calc_duty()
390 (u64)NSEC_PER_SEC * lpg_pre_divs[chan->pre_div_sel] * (1 << chan->pre_div_exp)); in lpg_calc_duty()
392 chan->pwm_value = min(val, max); in lpg_calc_duty()
398 struct lpg *lpg = chan->lpg; in lpg_apply_freq()
400 if (!chan->enabled) in lpg_apply_freq()
403 val = chan->clk_sel; in lpg_apply_freq()
406 switch (chan->subtype) { in lpg_apply_freq()
414 val |= FIELD_PREP(PWM_SIZE_HI_RES_MASK, chan->pwm_resolution_sel); in lpg_apply_freq()
422 regmap_write(lpg->map, chan->base + LPG_SIZE_CLK_REG, val); in lpg_apply_freq()
424 val = FIELD_PREP(PWM_FREQ_PRE_DIV_MASK, chan->pre_div_sel) | in lpg_apply_freq()
425 FIELD_PREP(PWM_FREQ_EXP_MASK, chan->pre_div_exp); in lpg_apply_freq()
426 regmap_write(lpg->map, chan->base + LPG_PREDIV_CLK_REG, val); in lpg_apply_freq()
433 struct lpg *lpg = chan->lpg; in lpg_enable_glitch()
435 regmap_update_bits(lpg->map, chan->base + PWM_TYPE_CONFIG_REG, in lpg_enable_glitch()
441 struct lpg *lpg = chan->lpg; in lpg_disable_glitch()
443 regmap_update_bits(lpg->map, chan->base + PWM_TYPE_CONFIG_REG, in lpg_disable_glitch()
450 struct lpg *lpg = chan->lpg; in lpg_apply_pwm_value()
451 u16 val = chan->pwm_value; in lpg_apply_pwm_value()
453 if (!chan->enabled) in lpg_apply_pwm_value()
456 regmap_bulk_write(lpg->map, chan->base + PWM_VALUE_REG, &val, sizeof(val)); in lpg_apply_pwm_value()
467 struct lpg *lpg = chan->lpg; in lpg_apply_lut_control()
471 unsigned int lo_idx = chan->pattern_lo_idx; in lpg_apply_lut_control()
472 unsigned int hi_idx = chan->pattern_hi_idx; in lpg_apply_lut_control()
473 u16 step = chan->ramp_tick_ms; in lpg_apply_lut_control()
475 if (!chan->ramp_enabled || chan->pattern_lo_idx == chan->pattern_hi_idx) in lpg_apply_lut_control()
478 hi_pause = DIV_ROUND_UP(chan->ramp_hi_pause_ms, step); in lpg_apply_lut_control()
479 lo_pause = DIV_ROUND_UP(chan->ramp_lo_pause_ms, step); in lpg_apply_lut_control()
481 if (!chan->ramp_reverse) in lpg_apply_lut_control()
483 if (!chan->ramp_oneshot) in lpg_apply_lut_control()
485 if (chan->ramp_ping_pong) in lpg_apply_lut_control()
487 if (chan->ramp_hi_pause_ms) in lpg_apply_lut_control()
489 if (chan->ramp_lo_pause_ms) in lpg_apply_lut_control()
492 regmap_write(lpg->map, chan->base + LPG_PATTERN_CONFIG_REG, conf); in lpg_apply_lut_control()
493 regmap_write(lpg->map, chan->base + LPG_HI_IDX_REG, hi_idx); in lpg_apply_lut_control()
494 regmap_write(lpg->map, chan->base + LPG_LO_IDX_REG, lo_idx); in lpg_apply_lut_control()
496 regmap_bulk_write(lpg->map, chan->base + LPG_RAMP_DURATION_REG, &step, sizeof(step)); in lpg_apply_lut_control()
497 regmap_write(lpg->map, chan->base + LPG_HI_PAUSE_REG, hi_pause); in lpg_apply_lut_control()
498 regmap_write(lpg->map, chan->base + LPG_LO_PAUSE_REG, lo_pause); in lpg_apply_lut_control()
509 struct lpg *lpg = chan->lpg; in lpg_apply_control()
513 if (chan->enabled) in lpg_apply_control()
516 if (chan->pattern_lo_idx != chan->pattern_hi_idx) in lpg_apply_control()
521 regmap_write(lpg->map, chan->base + PWM_ENABLE_CONTROL_REG, ctrl); in lpg_apply_control()
527 if (chan->enabled) in lpg_apply_control()
535 struct lpg *lpg = chan->lpg; in lpg_apply_sync()
537 regmap_write(lpg->map, chan->base + PWM_SYNC_REG, LPG_SYNC_PWM); in lpg_apply_sync()
543 struct device_node *np = lpg->dev->of_node; in lpg_parse_dtest()
549 if (count == -EINVAL) { in lpg_parse_dtest()
554 } else if (count != lpg->data->num_channels * 2) { in lpg_parse_dtest()
555 dev_err(lpg->dev, "qcom,dtest needs to be %d items\n", in lpg_parse_dtest()
556 lpg->data->num_channels * 2); in lpg_parse_dtest()
557 return -EINVAL; in lpg_parse_dtest()
560 for (i = 0; i < lpg->data->num_channels; i++) { in lpg_parse_dtest()
561 chan = &lpg->channels[i]; in lpg_parse_dtest()
564 &chan->dtest_line); in lpg_parse_dtest()
569 &chan->dtest_value); in lpg_parse_dtest()
577 dev_err(lpg->dev, "malformed qcom,dtest\n"); in lpg_parse_dtest()
583 struct lpg *lpg = chan->lpg; in lpg_apply_dtest()
585 if (!chan->dtest_line) in lpg_apply_dtest()
588 regmap_write(lpg->map, chan->base + PWM_SEC_ACCESS_REG, 0xa5); in lpg_apply_dtest()
589 regmap_write(lpg->map, chan->base + PWM_DTEST_REG(chan->dtest_line), in lpg_apply_dtest()
590 chan->dtest_value); in lpg_apply_dtest()
613 struct lpg *lpg = led->lpg; in lpg_brightness_set()
616 for (i = 0; i < led->num_channels; i++) { in lpg_brightness_set()
617 chan = led->channels[i]; in lpg_brightness_set()
621 chan->enabled = false; in lpg_brightness_set()
622 chan->ramp_enabled = false; in lpg_brightness_set()
623 } else if (chan->pattern_lo_idx != chan->pattern_hi_idx) { in lpg_brightness_set()
626 chan->enabled = true; in lpg_brightness_set()
627 chan->ramp_enabled = true; in lpg_brightness_set()
629 lut_mask |= chan->lut_mask; in lpg_brightness_set()
630 triled_enabled |= chan->triled_mask; in lpg_brightness_set()
634 duty = div_u64(brightness * chan->period, cdev->max_brightness); in lpg_brightness_set()
636 chan->enabled = true; in lpg_brightness_set()
637 chan->ramp_enabled = false; in lpg_brightness_set()
639 triled_enabled |= chan->triled_mask; in lpg_brightness_set()
642 triled_mask |= chan->triled_mask; in lpg_brightness_set()
662 mutex_lock(&led->lpg->lock); in lpg_brightness_single_set()
667 mutex_unlock(&led->lpg->lock); in lpg_brightness_single_set()
678 mutex_lock(&led->lpg->lock); in lpg_brightness_mc_set()
681 lpg_brightness_set(led, cdev, mc->subled_info); in lpg_brightness_mc_set()
683 mutex_unlock(&led->lpg->lock); in lpg_brightness_mc_set()
694 struct lpg *lpg = led->lpg; in lpg_blink_set()
706 for (i = 0; i < led->num_channels; i++) { in lpg_blink_set()
707 chan = led->channels[i]; in lpg_blink_set()
712 chan->enabled = true; in lpg_blink_set()
713 chan->ramp_enabled = false; in lpg_blink_set()
715 triled_mask |= chan->triled_mask; in lpg_blink_set()
723 chan = led->channels[0]; in lpg_blink_set()
724 duty = div_u64(chan->pwm_value * chan->period, LPG_RESOLUTION_9BIT); in lpg_blink_set()
726 *delay_off = div_u64(chan->period - duty, NSEC_PER_MSEC); in lpg_blink_set()
737 mutex_lock(&led->lpg->lock); in lpg_blink_single_set()
741 mutex_unlock(&led->lpg->lock); in lpg_blink_single_set()
753 mutex_lock(&led->lpg->lock); in lpg_blink_mc_set()
757 mutex_unlock(&led->lpg->lock); in lpg_blink_mc_set()
766 struct lpg *lpg = led->lpg; in lpg_pattern_set()
778 int ret = -EINVAL; in lpg_pattern_set()
781 if (repeat != -1 && repeat != 1) in lpg_pattern_set()
782 return -EINVAL; in lpg_pattern_set()
785 * The standardized leds-trigger-pattern format defines that the in lpg_pattern_set()
788 * describes that the way to perform instant transitions a zero-length in lpg_pattern_set()
793 * a zero-length transition. in lpg_pattern_set()
796 return -EINVAL; in lpg_pattern_set()
800 return -ENOMEM; in lpg_pattern_set()
844 brightness_b = pattern[len - i - 1].brightness; in lpg_pattern_set()
869 if (i != actual_len - 1) in lpg_pattern_set()
880 hi_pause = pattern[actual_len - 1].delta_t; in lpg_pattern_set()
882 mutex_lock(&lpg->lock); in lpg_pattern_set()
887 for (i = 0; i < led->num_channels; i++) { in lpg_pattern_set()
888 chan = led->channels[i]; in lpg_pattern_set()
890 chan->ramp_tick_ms = delta_t; in lpg_pattern_set()
891 chan->ramp_ping_pong = ping_pong; in lpg_pattern_set()
892 chan->ramp_oneshot = repeat != -1; in lpg_pattern_set()
894 chan->ramp_lo_pause_ms = lo_pause; in lpg_pattern_set()
895 chan->ramp_hi_pause_ms = hi_pause; in lpg_pattern_set()
897 chan->pattern_lo_idx = lo_idx; in lpg_pattern_set()
898 chan->pattern_hi_idx = hi_idx; in lpg_pattern_set()
902 mutex_unlock(&lpg->lock); in lpg_pattern_set()
938 lpg_brightness_set(led, cdev, mc->subled_info); in lpg_pattern_mc_set()
946 struct lpg *lpg = led->lpg; in lpg_pattern_clear()
949 mutex_lock(&lpg->lock); in lpg_pattern_clear()
951 chan = led->channels[0]; in lpg_pattern_clear()
952 lpg_lut_free(lpg, chan->pattern_lo_idx, chan->pattern_hi_idx); in lpg_pattern_clear()
954 for (i = 0; i < led->num_channels; i++) { in lpg_pattern_clear()
955 chan = led->channels[i]; in lpg_pattern_clear()
956 chan->pattern_lo_idx = 0; in lpg_pattern_clear()
957 chan->pattern_hi_idx = 0; in lpg_pattern_clear()
960 mutex_unlock(&lpg->lock); in lpg_pattern_clear()
983 struct lpg_channel *chan = &lpg->channels[pwm->hwpwm]; in lpg_pwm_request()
985 return chan->in_use ? -EBUSY : 0; in lpg_pwm_request()
990 * - Updating both duty and period is not done atomically, so the output signal
992 * - Changed parameters takes effect immediately.
993 * - A disabled channel outputs a logical 0.
999 struct lpg_channel *chan = &lpg->channels[pwm->hwpwm]; in lpg_pwm_apply()
1002 if (state->polarity != PWM_POLARITY_NORMAL) in lpg_pwm_apply()
1003 return -EINVAL; in lpg_pwm_apply()
1005 mutex_lock(&lpg->lock); in lpg_pwm_apply()
1007 if (state->enabled) { in lpg_pwm_apply()
1008 ret = lpg_calc_freq(chan, state->period); in lpg_pwm_apply()
1012 lpg_calc_duty(chan, state->duty_cycle); in lpg_pwm_apply()
1014 chan->enabled = state->enabled; in lpg_pwm_apply()
1018 triled_set(lpg, chan->triled_mask, chan->enabled ? chan->triled_mask : 0); in lpg_pwm_apply()
1021 mutex_unlock(&lpg->lock); in lpg_pwm_apply()
1030 struct lpg_channel *chan = &lpg->channels[pwm->hwpwm]; in lpg_pwm_get_state()
1039 ret = regmap_read(lpg->map, chan->base + LPG_SIZE_CLK_REG, &val); in lpg_pwm_get_state()
1043 if (chan->subtype == LPG_SUBTYPE_HI_RES_PWM) { in lpg_pwm_get_state()
1052 ret = regmap_read(lpg->map, chan->base + LPG_PREDIV_CLK_REG, &val); in lpg_pwm_get_state()
1059 ret = regmap_bulk_read(lpg->map, chan->base + PWM_VALUE_REG, &pwm_value, sizeof(pwm_value)); in lpg_pwm_get_state()
1063 state->period = DIV_ROUND_UP_ULL((u64)NSEC_PER_SEC * ((1 << resolution) - 1) * in lpg_pwm_get_state()
1065 state->duty_cycle = DIV_ROUND_UP_ULL((u64)NSEC_PER_SEC * pwm_value * pre_div * (1 << m), refclk); in lpg_pwm_get_state()
1067 state->period = 0; in lpg_pwm_get_state()
1068 state->duty_cycle = 0; in lpg_pwm_get_state()
1071 ret = regmap_read(lpg->map, chan->base + PWM_ENABLE_CONTROL_REG, &val); in lpg_pwm_get_state()
1075 state->enabled = FIELD_GET(LPG_ENABLE_CONTROL_OUTPUT, val); in lpg_pwm_get_state()
1076 state->polarity = PWM_POLARITY_NORMAL; in lpg_pwm_get_state()
1078 if (state->duty_cycle > state->period) in lpg_pwm_get_state()
1079 state->duty_cycle = state->period; in lpg_pwm_get_state()
1095 lpg->pwm.dev = lpg->dev; in lpg_add_pwm()
1096 lpg->pwm.npwm = lpg->num_channels; in lpg_add_pwm()
1097 lpg->pwm.ops = &lpg_pwm_ops; in lpg_add_pwm()
1099 ret = pwmchip_add(&lpg->pwm); in lpg_add_pwm()
1101 dev_err(lpg->dev, "failed to add PWM chip: ret %d\n", ret); in lpg_add_pwm()
1115 if (ret || !reg || reg > lpg->num_channels) { in lpg_parse_channel()
1116 dev_err(lpg->dev, "invalid \"reg\" of %pOFn\n", np); in lpg_parse_channel()
1117 return -EINVAL; in lpg_parse_channel()
1120 chan = &lpg->channels[reg - 1]; in lpg_parse_channel()
1121 chan->in_use = true; in lpg_parse_channel()
1124 if (ret < 0 && ret != -EINVAL) { in lpg_parse_channel()
1125 dev_err(lpg->dev, "failed to parse \"color\" of %pOF\n", np); in lpg_parse_channel()
1129 chan->color = color; in lpg_parse_channel()
1150 if (ret < 0 && ret != -EINVAL) { in lpg_add_led()
1151 dev_err(lpg->dev, "failed to parse \"color\" of %pOF\n", np); in lpg_add_led()
1160 led = devm_kzalloc(lpg->dev, struct_size(led, channels, num_channels), GFP_KERNEL); in lpg_add_led()
1162 return -ENOMEM; in lpg_add_led()
1164 led->lpg = lpg; in lpg_add_led()
1165 led->num_channels = num_channels; in lpg_add_led()
1168 info = devm_kcalloc(lpg->dev, num_channels, sizeof(*info), GFP_KERNEL); in lpg_add_led()
1170 return -ENOMEM; in lpg_add_led()
1173 ret = lpg_parse_channel(lpg, child, &led->channels[i]); in lpg_add_led()
1179 info[i].color_index = led->channels[i]->color; in lpg_add_led()
1184 led->mcdev.subled_info = info; in lpg_add_led()
1185 led->mcdev.num_colors = num_channels; in lpg_add_led()
1187 cdev = &led->mcdev.led_cdev; in lpg_add_led()
1188 cdev->brightness_set_blocking = lpg_brightness_mc_set; in lpg_add_led()
1189 cdev->blink_set = lpg_blink_mc_set; in lpg_add_led()
1192 if (lpg->lut_base) { in lpg_add_led()
1193 cdev->pattern_set = lpg_pattern_mc_set; in lpg_add_led()
1194 cdev->pattern_clear = lpg_pattern_mc_clear; in lpg_add_led()
1197 ret = lpg_parse_channel(lpg, np, &led->channels[0]); in lpg_add_led()
1201 cdev = &led->cdev; in lpg_add_led()
1202 cdev->brightness_set_blocking = lpg_brightness_single_set; in lpg_add_led()
1203 cdev->blink_set = lpg_blink_single_set; in lpg_add_led()
1206 if (lpg->lut_base) { in lpg_add_led()
1207 cdev->pattern_set = lpg_pattern_single_set; in lpg_add_led()
1208 cdev->pattern_clear = lpg_pattern_single_clear; in lpg_add_led()
1212 cdev->default_trigger = of_get_property(np, "linux,default-trigger", NULL); in lpg_add_led()
1213 cdev->max_brightness = LPG_RESOLUTION_9BIT - 1; in lpg_add_led()
1215 if (!of_property_read_string(np, "default-state", &state) && in lpg_add_led()
1217 cdev->brightness = cdev->max_brightness; in lpg_add_led()
1219 cdev->brightness = LED_OFF; in lpg_add_led()
1221 cdev->brightness_set_blocking(cdev, cdev->brightness); in lpg_add_led()
1226 ret = devm_led_classdev_multicolor_register_ext(lpg->dev, &led->mcdev, &init_data); in lpg_add_led()
1228 ret = devm_led_classdev_register_ext(lpg->dev, &led->cdev, &init_data); in lpg_add_led()
1230 dev_err(lpg->dev, "unable to register %s\n", cdev->name); in lpg_add_led()
1237 const struct lpg_data *data = lpg->data; in lpg_init_channels()
1241 lpg->num_channels = data->num_channels; in lpg_init_channels()
1242 lpg->channels = devm_kcalloc(lpg->dev, data->num_channels, in lpg_init_channels()
1244 if (!lpg->channels) in lpg_init_channels()
1245 return -ENOMEM; in lpg_init_channels()
1247 for (i = 0; i < data->num_channels; i++) { in lpg_init_channels()
1248 chan = &lpg->channels[i]; in lpg_init_channels()
1250 chan->lpg = lpg; in lpg_init_channels()
1251 chan->base = data->channels[i].base; in lpg_init_channels()
1252 chan->triled_mask = data->channels[i].triled_mask; in lpg_init_channels()
1253 chan->lut_mask = BIT(i); in lpg_init_channels()
1255 regmap_read(lpg->map, chan->base + LPG_SUBTYPE_REG, &chan->subtype); in lpg_init_channels()
1263 struct device_node *np = lpg->dev->of_node; in lpg_init_triled()
1267 if (!lpg->data->triled_base) in lpg_init_triled()
1270 lpg->triled_base = lpg->data->triled_base; in lpg_init_triled()
1271 lpg->triled_has_atc_ctl = lpg->data->triled_has_atc_ctl; in lpg_init_triled()
1272 lpg->triled_has_src_sel = lpg->data->triled_has_src_sel; in lpg_init_triled()
1274 if (lpg->triled_has_src_sel) { in lpg_init_triled()
1275 ret = of_property_read_u32(np, "qcom,power-source", &lpg->triled_src); in lpg_init_triled()
1276 if (ret || lpg->triled_src == 2 || lpg->triled_src > 3) { in lpg_init_triled()
1277 dev_err(lpg->dev, "invalid power source\n"); in lpg_init_triled()
1278 return -EINVAL; in lpg_init_triled()
1283 if (lpg->triled_has_atc_ctl) in lpg_init_triled()
1284 regmap_write(lpg->map, lpg->triled_base + TRI_LED_ATC_CTL, 0); in lpg_init_triled()
1287 if (lpg->triled_has_src_sel) in lpg_init_triled()
1288 regmap_write(lpg->map, lpg->triled_base + TRI_LED_SRC_SEL, lpg->triled_src); in lpg_init_triled()
1291 regmap_write(lpg->map, lpg->triled_base + TRI_LED_EN_CTL, 0); in lpg_init_triled()
1298 const struct lpg_data *data = lpg->data; in lpg_init_lut()
1300 if (!data->lut_base) in lpg_init_lut()
1303 lpg->lut_base = data->lut_base; in lpg_init_lut()
1304 lpg->lut_size = data->lut_size; in lpg_init_lut()
1306 lpg->lut_bitmap = devm_bitmap_zalloc(lpg->dev, lpg->lut_size, GFP_KERNEL); in lpg_init_lut()
1307 if (!lpg->lut_bitmap) in lpg_init_lut()
1308 return -ENOMEM; in lpg_init_lut()
1320 lpg = devm_kzalloc(&pdev->dev, sizeof(*lpg), GFP_KERNEL); in lpg_probe()
1322 return -ENOMEM; in lpg_probe()
1324 lpg->data = of_device_get_match_data(&pdev->dev); in lpg_probe()
1325 if (!lpg->data) in lpg_probe()
1326 return -EINVAL; in lpg_probe()
1330 lpg->dev = &pdev->dev; in lpg_probe()
1331 mutex_init(&lpg->lock); in lpg_probe()
1333 lpg->map = dev_get_regmap(pdev->dev.parent, NULL); in lpg_probe()
1334 if (!lpg->map) in lpg_probe()
1335 return dev_err_probe(&pdev->dev, -ENXIO, "parent regmap unavailable\n"); in lpg_probe()
1353 for_each_available_child_of_node(pdev->dev.of_node, np) { in lpg_probe()
1361 for (i = 0; i < lpg->num_channels; i++) in lpg_probe()
1362 lpg_apply_dtest(&lpg->channels[i]); in lpg_probe()
1371 pwmchip_remove(&lpg->pwm); in lpg_remove()
1419 /* PMI632 uses SDAM instead of LUT for pattern */
1518 { .compatible = "qcom,pm8150b-lpg", .data = &pm8150b_lpg_data },
1519 { .compatible = "qcom,pm8150l-lpg", .data = &pm8150l_lpg_data },
1520 { .compatible = "qcom,pm8350c-pwm", .data = &pm8350c_pwm_data },
1521 { .compatible = "qcom,pm8916-pwm", .data = &pm8916_pwm_data },
1522 { .compatible = "qcom,pm8941-lpg", .data = &pm8941_lpg_data },
1523 { .compatible = "qcom,pm8994-lpg", .data = &pm8994_lpg_data },
1524 { .compatible = "qcom,pmi632-lpg", .data = &pmi632_lpg_data },
1525 { .compatible = "qcom,pmi8994-lpg", .data = &pmi8994_lpg_data },
1526 { .compatible = "qcom,pmi8998-lpg", .data = &pmi8998_lpg_data },
1527 { .compatible = "qcom,pmc8180c-lpg", .data = &pm8150l_lpg_data },
1528 { .compatible = "qcom,pmk8550-pwm", .data = &pmk8550_pwm_data },
1537 .name = "qcom-spmi-lpg",