static void pwm_test(void)
{
int32_T period = 0;
int32_T accelerator_rate = 5;
int32_T delay = 1000;
debug_log("前右后左分别%d%%油门运动%dms.\r\n", accelerator_rate, delay);
period = pwm_get_period();
pwm_set(PWM_FRONT, (int32_T)(period * accelerator_rate / 100.0));
pwm_set(PWM_RIGHT, (int32_T)(period * 0.0));
pwm_set(PWM_BACK, (int32_T)(period * 0.0));
pwm_set(PWM_LEFT, (int32_T)(period * 0.0));
HAL_Delay(delay);
pwm_set(PWM_FRONT, (int32_T)(period * 0.0));
pwm_set(PWM_RIGHT, (int32_T)(period * accelerator_rate / 100.0));
pwm_set(PWM_BACK, (int32_T)(period * 0.0));
pwm_set(PWM_LEFT, (int32_T)(period * 0.0));
HAL_Delay(delay);
pwm_set(PWM_FRONT, (int32_T)(period * 0.0));
pwm_set(PWM_RIGHT, (int32_T)(period * 0.0));
pwm_set(PWM_BACK, (int32_T)(period * accelerator_rate / 100.0));
pwm_set(PWM_LEFT, (int32_T)(period * 0.0));
HAL_Delay(delay);
pwm_set(PWM_FRONT, (int32_T)(period * 0.0));
pwm_set(PWM_RIGHT, (int32_T)(period * 0.0));
pwm_set(PWM_BACK, (int32_T)(period * 0.0));
pwm_set(PWM_LEFT, (int32_T)(period * accelerator_rate / 100.0));
HAL_Delay(delay);
}
static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV,
unsigned *selector)
{
struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
unsigned int ramp_delay = rdev->constraints->ramp_delay;
unsigned int period = pwm_get_period(drvdata->pwm);
int duty_cycle;
int ret;
duty_cycle = pwm_voltage_to_duty_cycle_percentage(rdev, min_uV);
ret = pwm_config(drvdata->pwm, (period / 100) * duty_cycle, period);
if (ret) {
dev_err(&rdev->dev, "Failed to configure PWM\n");
return ret;
}
ret = pwm_enable(drvdata->pwm);
if (ret) {
dev_err(&rdev->dev, "Failed to enable PWM\n");
return ret;
}
drvdata->volt_uV = min_uV;
/* Delay required by PWM regulator to settle to the new voltage */
usleep_range(ramp_delay, ramp_delay + 1000);
return 0;
}
static int pwm_regulator_set_voltage_sel(struct regulator_dev *dev,
unsigned selector)
{
struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
unsigned int pwm_reg_period;
int dutycycle;
int ret;
pwm_reg_period = pwm_get_period(drvdata->pwm);
dutycycle = (pwm_reg_period *
drvdata->duty_cycle_table[selector].dutycycle) / 100;
ret = pwm_config(drvdata->pwm, dutycycle, pwm_reg_period);
if (ret) {
dev_err(&dev->dev, "Failed to configure PWM\n");
return ret;
}
drvdata->state = selector;
if (!drvdata->enabled) {
ret = pwm_enable(drvdata->pwm);
if (ret) {
dev_err(&dev->dev, "Failed to enable PWM\n");
return ret;
}
drvdata->enabled = true;
}
return 0;
}
int servo_0_rotating(void *data)
{
double angle;
int duty_cycle;
int period;
period = pwm_get_period(servo_pin[0][0], servo_pin[0][1]);
duty_cycle = pwm_get_duty(servo_pin[0][0], servo_pin[0][1]);
angle = SERVO_DUTY_TO_ANGLE(duty_cycle);
if(angle > 90.0)
{
servo_rotate_direc = ROTATE_NEGATIVE;
}
if(angle < -90.0)
{
servo_rotate_direc = ROTATE_POSITIVE;
}
if(servo_rotate_direc == ROTATE_POSITIVE) {
servo_rotate_to(0, angle);
} else {
servo_rotate_to(0, angle);
}
}
void pwm_set(PWM_NAME pwm, int32_T val)
{
int32_T period = 0;
/* 参数检查 */
if(pwm > PWM_MAX)
{
ERR_STR("参数错误.");
}
/* 限制val在有效值范围内 [0,period] */
period = pwm_get_period();
if(val < 0)
{
val = 0;
}
if(val > period)
{
val = period;
}
/* 修改占空比 */
s_sConfig.Pulse = val;
if (HAL_TIM_PWM_ConfigChannel(&s_tim_handle, &s_sConfig, g_pwm_ch_list[pwm].ch) != HAL_OK)
{
ERR_STR("执行失败.");
}
/* 启动PWM */
if (HAL_TIM_PWM_Start(&s_tim_handle, g_pwm_ch_list[pwm].ch) != HAL_OK)
{
ERR_STR("执行失败.");
}
}
static bool test_pwm_get_set_period_before_init(void)
{
uint32_t period = 100;
return pwm_get_period(MIKROBUS_1, &period) == -1
&& pwm_set_period(MIKROBUS_1, period) == -1;
}
static unsigned ev3_output_port_get_duty_cycle(void *context)
{
struct ev3_output_port_data *data = context;
unsigned period = pwm_get_period(data->pwm);
if (unlikely(period == 0))
return 0;
return pwm_get_duty_cycle(data->pwm) * 100 / period;
}
static int ev3_output_port_set_duty_cycle(void *context, unsigned duty)
{
struct ev3_output_port_data *data = context;
unsigned period = pwm_get_period(data->pwm);
if (duty > 100)
return -EINVAL;
return pwm_config(data->pwm, period * duty / 100, period);
}
/******************************************************************************
* FunctionName : user_light_set_duty
* Description : set pwm frequency
* Parameters : uint16 freq : 100hz typically
* Returns : NONE
*******************************************************************************/
void
user_light_set_period(uint32 period)
{
if (period != light_param.pwm_period) {
pwm_set_period(period);
light_param.pwm_period = pwm_get_period();
}
}
/******************************************************************************
* FunctionName : user_light_set_duty
* Description : set pwm frequency
* Parameters : uint16 freq : 100hz typically
* Returns : NONE
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_light_set_period(uint32 period)
{
if (period != light_param.pwm_period) {
pwm_set_period(period);
light_param.pwm_period = pwm_get_period();
}
}
static void lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max)
{
unsigned int period = pwm_get_period(pchip->pwmd);
unsigned int duty = br * period / br_max;
pwm_config(pchip->pwmd, duty, period);
if (duty)
pwm_enable(pchip->pwmd);
else
pwm_disable(pchip->pwmd);
}
void ICACHE_FLASH_ATTR
light_save_target_duty() {
extern struct light_saved_param light_param;
os_memcpy(light_param.pwm_duty, current_duty, sizeof(light_param.pwm_duty));
light_param.pwm_period = pwm_get_period();
#if SAVE_LIGHT_PARAM
spi_flash_erase_sector(PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE);
spi_flash_write((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,
(uint32 *)&light_param, sizeof(struct light_saved_param));
#endif
}
static int backlight_pwm_of_probe(struct device_d *dev)
{
int ret;
struct pwm_backlight *pwm_backlight;
struct pwm_device *pwm;
pwm = of_pwm_request(dev->device_node, NULL);
if (IS_ERR(pwm)) {
dev_err(dev, "Cannot find PWM device\n");
return PTR_ERR(pwm);
}
pwm_backlight = xzalloc(sizeof(*pwm_backlight));
pwm_backlight->pwm = pwm;
pwm_backlight->period = pwm_get_period(pwm);
ret = pwm_backlight_parse_dt(dev, pwm_backlight);
if (ret)
return ret;
pwm_backlight->power = regulator_get(dev, "power");
if (IS_ERR(pwm_backlight->power)) {
dev_err(dev, "Cannot find regulator\n");
return PTR_ERR(pwm_backlight->power);
}
pwm_backlight->period = pwm_get_period(pwm_backlight->pwm);
pwm_backlight->backlight.brightness_set = backlight_pwm_set;
pwm_backlight->backlight.node = dev->device_node;
ret = backlight_register(&pwm_backlight->backlight);
if (ret)
return ret;
return 0;
}
/**
* Initialize the dimmer and start the RTOS task
*
* @param initial_status initial dimmer status structure
* @param pwm_period PWM period
* @param pwm_channel_num PWM channel number
*/
void dimmer_init(dimmer_status_t *initial_status, uint32_t pwm_period,
uint32_t pwm_channel_num)
{
/* There can be only one task, so return if already initialized. */
if (s_initialized)
return;
/* Create status mutex */
s_status_mutex = xSemaphoreCreateMutex();
/* Create notification message queue */
s_dimmer_queue = xQueueCreate(5, sizeof(dimmer_status_t));
s_pwm_period = pwm_period;
/* Initialize status struct */
s_status.power_on = initial_status->power_on;
s_status.dim_pct = initial_status->dim_pct;
/* Init PWM */
s_pwm_channel = pwm_channel_num;
if (s_status.power_on == true) {
pwm_init_dcs[0] = s_dimmer_pct_to_dc(s_status.dim_pct);
}
pwm_init(pwm_period, pwm_init_dcs, 1, pwm_init_info);
pwm_start();
printf("Dimmer: PWM initialized and started\r\n");
printf("Ch0 DC: %d\r\n", pwm_get_duty(0));
printf("Period: %d\r\n", pwm_get_period());
/* Create dimmer task */
xTaskCreate(dimmer_task, "Dimmer", configMINIMAL_STACK_SIZE,
NULL, 3, NULL);
/* Prevent further intialization */
s_initialized = 1;
}
static bool test_pwm_set_frequency(void)
{
uint32_t frequency = 5000;
uint32_t tmp;
uint32_t period;
if (pwm_set_frequency(MIKROBUS_1, frequency) == -1)
return false;
if (pwm_get_frequency(MIKROBUS_1, &tmp) == -1)
return false;
if (abs(tmp - frequency) > 1)
return false;
if (pwm_get_period(MIKROBUS_1, &period) == -1)
return false;
tmp = 1000000000/period;
return fabs(tmp - frequency) < 1.f;
}
static bool test_pwm_get_period_null_var(void)
{
return pwm_get_period(MIKROBUS_1, NULL) == -1;
}
irom static void dump(const gpio_config_t *cfgs, const gpio_t *gpio_in, unsigned int size, char *str)
{
unsigned int current;
unsigned int length;
const gpio_t *gpio;
const gpio_config_entry_t *cfg;
for(current = 0; current < gpio_size; current++)
{
gpio = &gpios[current];
cfg = &cfgs->entry[current];
if(!gpio_in || (gpio_in->id == gpio->id))
{
length = snprintf(str, size, "> gpio: %u, name: %s, mode: ", gpio->index, gpio->name);
size -= length;
str += length;
length = 0;
switch(cfg->mode)
{
case(gpio_disabled):
{
length = snprintf(str, size, "disabled");
break;
}
case(gpio_input):
{
length = snprintf(str, size, "input, state: %s", onoff(get_input(gpio)));
break;
}
case(gpio_counter):
{
length = snprintf(str, size, "counter, state: %s, counter: %u, debounce: %u/%u, reset on get: %s",
onoff(get_input(gpio)), gpio->counter.count,
cfg->counter.debounce, gpio->counter.debounce,
onoff(cfg->counter.reset_on_get));
break;
}
case(gpio_output):
{
length = snprintf(str, size, "output, state: %s, startup: %s",
onoff(get_input(gpio)), onoff(cfg->output.startup_state));
break;
}
case(gpio_timer):
{
length = snprintf(str, size, "timer, direction: %s, delay: %u ms, repeat: %s, autotrigger: %s, active: %s, current state: %s",
cfg->timer.direction == gpio_up ? "up" : "down",
cfg->timer.delay, onoff(cfg->timer.repeat),
onoff(cfg->timer.autotrigger), onoff(gpio->timer.delay > 0),
onoff(get_input(gpio)));
break;
}
case(gpio_pwm):
{
length = snprintf(str, size, "pwm, ");
str += length;
size -= length;
if(gpio_flags.pwm_subsystem_active)
length = snprintf(str, size, "active, channel: %u, current frequency: %u Hz, current duty: %u",
gpio->pwm.channel, 1000000 / pwm_get_period(), pwm_get_duty(gpio->pwm.channel));
else
length = snprintf(str, size, "inactive");
str += length;
size -= length;
length = snprintf(str, size, "\ndefault min duty: %u, max duty: %u, delay: %u",
cfg->pwm.min_duty, cfg->pwm.max_duty, cfg->pwm.delay);
str += length;
size -= length;
length = snprintf(str, size, "\ncurrent min duty: %u, max duty %u, delay: %u",
gpio->pwm.min_duty, gpio->pwm.max_duty, gpio->pwm.delay_top);
break;
}
case(gpio_i2c):
{
length = snprintf(str, size, "i2c, pin: %s", cfg->i2c.pin == gpio_i2c_sda ? "sda" : "scl");
break;
}
default:
{
length = snprintf(str, size, "unknown mode");
break;
}
}
str += length;
size =- length;
length = snprintf(str, size, "\n");
str += length;
size -= length;
}
}
}
static int pwm_test_probe(struct platform_device *pdev)
{
struct pwm_test *pwm_test;
struct pinctrl *pinctrl;
struct device_node *node = (&pdev->dev)->of_node;
int rc;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "unable to select pin group. PWM not muxed right\n");
pwm_test = devm_kzalloc(&pdev->dev, sizeof(*pwm_test), GFP_KERNEL);
if (!pwm_test) {
dev_err(&pdev->dev, "memory error\n");
return -ENOMEM;
}
if (pwm_test_class_init(&pdev->dev)) {
dev_err(&pdev->dev, "sysfs creation failed\n");
return -EINVAL;
}
pwm_test->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pwm_test->pwm)) {
dev_err(&pdev->dev, "unable to request PWM\n");
return -EINVAL;
}
pwm_test->requested = 1;
pr_debug("pwm_test got PWM\n");
/* Get the properties of the pwm. This is set in the device driver (tiehrpwm) */
pwm_test->period = pwm_get_period(pwm_test->pwm);
/* Determine running or not from the device tree */
rc = of_property_read_u32(node, "enabled", (u32*) &(pwm_test->run));
if (rc < 0)
return rc;
if(pwm_test->run){
rc = pwm_enable(pwm_test->pwm);
if (rc < 0)
return rc;
}
/* Determine the duty from the device tree */
rc = of_property_read_u32(node, "duty", (u32*) &(pwm_test->duty_s));
if (rc < 0)
return rc;
rc = pwm_config(pwm_test->pwm, pwm_test->duty_s, pwm_test->period);
if (rc) {
pr_err("Unable to set pwm duty %d\n", rc);
return rc;
}
platform_set_drvdata(pdev, pwm_test);
return 0;
}
static bool test_pwm_get_set_period_invalid_index(void)
{
uint32_t period = 100;
return pwm_set_period(3, period) == -1
&& pwm_get_period(3, &period) == -1;
}
static struct led_pwm_priv *led_pwm_create_of(struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
struct device_node *child;
struct led_pwm_priv *priv;
int count, ret;
/* count LEDs in this device, so we know how much to allocate */
count = of_get_child_count(node);
if (!count)
return NULL;
priv = devm_kzalloc(&pdev->dev, sizeof_pwm_leds_priv(count),
GFP_KERNEL);
if (!priv)
return NULL;
for_each_child_of_node(node, child) {
struct led_pwm_data *led_dat = &priv->leds[priv->num_leds];
led_dat->cdev.name = of_get_property(child, "label",
NULL) ? : child->name;
led_dat->pwm = devm_of_pwm_get(&pdev->dev, child, NULL);
if (IS_ERR(led_dat->pwm)) {
dev_err(&pdev->dev, "unable to request PWM for %s\n",
led_dat->cdev.name);
goto err;
}
/* Get the period from PWM core when n*/
led_dat->period = pwm_get_period(led_dat->pwm);
led_dat->cdev.default_trigger = of_get_property(child,
"linux,default-trigger", NULL);
of_property_read_u32(child, "max-brightness",
&led_dat->cdev.max_brightness);
led_dat->cdev.brightness_set = led_pwm_set;
led_dat->cdev.brightness = LED_OFF;
led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
led_dat->can_sleep = pwm_can_sleep(led_dat->pwm);
if (led_dat->can_sleep)
INIT_WORK(&led_dat->work, led_pwm_work);
ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
if (ret < 0) {
dev_err(&pdev->dev, "failed to register for %s\n",
led_dat->cdev.name);
of_node_put(child);
goto err;
}
priv->num_leds++;
}
return priv;
err:
while (priv->num_leds--)
led_classdev_unregister(&priv->leds[priv->num_leds].cdev);
return NULL;
}
static int pwm_backlight_probe(struct platform_device *pdev)
{
struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
struct platform_pwm_backlight_data defdata;
struct backlight_properties props;
struct backlight_device *bl;
struct pwm_bl_data *pb;
unsigned int max;
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) {
dev_err(&pdev->dev, "no memory for state\n");
ret = -ENOMEM;
goto err_alloc;
}
if (data->levels) {
max = data->levels[data->max_brightness];
pb->levels = data->levels;
} else
max = data->max_brightness;
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->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_alloc;
}
}
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 / max);
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_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;
backlight_update_status(bl);
platform_set_drvdata(pdev, bl);
return 0;
err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}
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;
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->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;
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;
}
}
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("lcd-bl", &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);
err_alloc:
if (data->exit)
data->exit(&pdev->dev);
return ret;
}
static int __init pwm_regulator_probe(struct platform_device *pdev)
{
struct pwm_platform_data *pdata = pdev->dev.platform_data;
struct pwm_regulator_board *pwm_pdev;
struct of_regulator_match *pwm_reg_matches = NULL;
struct regulator_init_data *reg_data;
struct regulator_config config = { };
const char *rail_name = NULL;
struct regulator_dev *pwm_rdev;
int ret, i = 0;
struct regulator *dc;
pwm_pdev = devm_kzalloc(&pdev->dev, sizeof(*pwm_pdev),
GFP_KERNEL);
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata),
GFP_KERNEL);
if (pdev->dev.of_node)
pwm_pdev = pwm_regulator_parse_dt(pdev, &pwm_reg_matches);
if (!pwm_pdev) {
dev_err(&pdev->dev, "Platform data not found\n");
return -EINVAL;
}
if (!pwm_pdev->pwm_init_vol)
pdata->pwm_voltage = 1100000; /* default 1.1v*/
else
pdata->pwm_voltage = pwm_pdev->pwm_init_vol;
if (!pwm_pdev->pwm_max_vol)
pdata->max_uV = 1400000;
else
pdata->max_uV = pwm_pdev->pwm_max_vol;
if (!pwm_pdev->pwm_min_vol)
pdata->min_uV = 1000000;
else
pdata->min_uV = pwm_pdev->pwm_min_vol;
if (pwm_pdev->pwm_suspend_vol < pwm_pdev->pwm_min_vol)
pdata->suspend_voltage = pwm_pdev->pwm_min_vol;
else if (pwm_pdev->pwm_suspend_vol > pwm_pdev->pwm_max_vol)
pdata->suspend_voltage = pwm_pdev->pwm_max_vol;
else
pdata->suspend_voltage = pwm_pdev->pwm_suspend_vol;
pdata->pwm_voltage_map = pwm_pdev->pwm_voltage_map;
pdata->pwm_id = pwm_pdev->pwm_id;
pdata->coefficient = pwm_pdev->pwm_coefficient;
pdata->pwm_vol_map_count = pwm_pdev->pwm_vol_map_count;
pdata->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pdata->pwm)) {
dev_err(&pdev->dev, "unable to request PWM, trying legacy API\n");
pdata->pwm = pwm_request(pdata->pwm_id, "pwm-regulator");
if (IS_ERR(pdata->pwm)) {
dev_err(&pdev->dev, "unable to request legacy PWM\n");
ret = PTR_ERR(pdata->pwm);
goto err;
}
}
if (pdata->pwm_period_ns > 0)
pwm_set_period(pdata->pwm, pdata->pwm_period_ns);
pdata->period = pwm_get_period(pdata->pwm);
mutex_init(&pdata->mutex_pwm);
if (pwm_pdev) {
pdata->num_regulators = pwm_pdev->num_regulators;
pdata->rdev = kcalloc(pdata->num_regulators, sizeof(struct regulator_dev *), GFP_KERNEL);
if (!pdata->rdev) {
return -ENOMEM;
}
/* Instantiate the regulators */
for (i = 0; i < pdata->num_regulators; i++) {
reg_data = pwm_pdev->pwm_init_data[i];
if (!reg_data)
continue;
config.dev = &pdev->dev;
config.driver_data = pdata;
if (&pdev->dev.of_node)
config.of_node = pwm_pdev->of_node[i];
if (reg_data && reg_data->constraints.name)
rail_name = reg_data->constraints.name;
else
rail_name = regulators[i].name;
reg_data->supply_regulator = rail_name;
config.init_data = reg_data;
pwm_rdev = regulator_register(®ulators[i], &config);
if (IS_ERR(pwm_rdev)) {
printk("failed to register %d regulator\n", i);
goto err;
}
pdata->rdev[i] = pwm_rdev;
/*********set pwm vol by defult***********/
dc = regulator_get(NULL, rail_name);
regulator_set_voltage(dc, pdata->pwm_voltage, pdata->pwm_voltage);
regulator_put(dc);
/**************************************/
}
}
return 0;
err:
printk("%s:error\n", __func__);
return ret;
}
