static void max77693_haptic_enable(struct max77693_haptic *haptic) { int error; if (haptic->enabled) return; error = pwm_enable(haptic->pwm_dev); if (error) { dev_err(haptic->dev, "failed to enable haptic pwm device: %d\n", error); return; } error = max77693_haptic_lowsys(haptic, true); if (error) goto err_enable_lowsys; error = max77693_haptic_configure(haptic, true); if (error) goto err_enable_config; haptic->enabled = true; return; err_enable_config: max77693_haptic_lowsys(haptic, false); err_enable_lowsys: pwm_disable(haptic->pwm_dev); }
static int pwm_backlight_remove(struct platform_device *pdev) { struct platform_pwm_backlight_data *data = pdev->dev.platform_data; struct backlight_device *bl = platform_get_drvdata(pdev); struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); struct pin_config new_pin_config; backlight_device_unregister(bl); pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); pwm_free(pb->pwm); if (data && data->exit) data->exit(&pdev->dev); if (data && pdev->dev.of_node) { kfree(data); pdev->dev.platform_data = NULL; } /*reset the pwm pin to GPIO function if defined in the kernel-dtb*/ if (pwm_pin >= 0 && pwm_pin_reboot_func >= 0) { pr_info("remove reset the pwm pin to GPIO function\r\n"); pr_err("remove reset the pwm pin to GPIO function\r\n"); new_pin_config.name = pwm_pin; pinmux_get_pin_config(&new_pin_config); new_pin_config.func = pwm_pin_reboot_func; pinmux_set_pin_config(&new_pin_config); gpio_direction_output( 24, 0 ); gpio_set_value( 24, 0 ); } return 0; }
void vibtonz_en(bool en) { struct vibrator_drvdata *data = g_data; if (en) { if (data->running) return ; if (data->pdata->motor_en) data->pdata->motor_en(true); else regulator_enable(data->regulator); i2c_max8997_hapticmotor(data, true); pwm_enable(data->pwm); data->running = true; } else { if (!data->running) return ; pwm_disable(data->pwm); i2c_max8997_hapticmotor(data, false); if (data->pdata->motor_en) data->pdata->motor_en(false); else regulator_force_disable(data->regulator); data->running = false; } }
void ev3_output_port_unregister(struct lego_port_device *port) { struct ev3_output_port_data *data; /* port can be null if disabled via module parameter */ if (!port) return; data = container_of(port, struct ev3_output_port_data, out_port); pwm_disable(data->pwm); pwm_put(data->pwm); hrtimer_cancel(&data->timer); cancel_work_sync(&data->change_uevent_work); cancel_work_sync(&data->work); if (data->motor) ev3_output_port_unregister_motor(&data->work); if (port->mode == EV3_OUTPUT_PORT_MODE_RAW) ev3_output_port_disable_raw_mode(data); lego_port_unregister(&data->out_port); ev3_output_port_float(data); gpio_free_array(data->gpio, ARRAY_SIZE(data->gpio)); put_legoev3_analog(data->analog); dev_set_drvdata(&port->dev, NULL); kfree(data); }
static int qpnp_vib_set(struct qpnp_vib *vib, int on) { int rc; u8 val; if (on) { if (vib->mode != QPNP_VIB_MANUAL) pwm_enable(vib->pwm_info.pwm_dev); else { val = vib->reg_en_ctl; val |= QPNP_VIB_EN; rc = qpnp_vib_write_u8(vib, &val, QPNP_VIB_EN_CTL(vib->base)); if (rc < 0) return rc; vib->reg_en_ctl = val; } } else { if (vib->mode != QPNP_VIB_MANUAL) pwm_disable(vib->pwm_info.pwm_dev); else { val = vib->reg_en_ctl; val &= ~QPNP_VIB_EN; rc = qpnp_vib_write_u8(vib, &val, QPNP_VIB_EN_CTL(vib->base)); if (rc < 0) return rc; vib->reg_en_ctl = val; } } return 0; }
/* set api for haptics */ static int qpnp_hap_set(struct qpnp_hap *hap, int on) { int rc = 0; if (hap->play_mode == QPNP_HAP_PWM) { if (on) rc = pwm_enable(hap->pwm_info.pwm_dev); else pwm_disable(hap->pwm_info.pwm_dev); } else if (hap->play_mode == QPNP_HAP_BUFFER || hap->play_mode == QPNP_HAP_DIRECT) { if (on) { rc = qpnp_hap_mod_enable(hap, on); if (rc < 0) return rc; rc = qpnp_hap_play(hap, on); } else { rc = qpnp_hap_play(hap, on); if (rc < 0) return rc; rc = qpnp_hap_mod_enable(hap, on); } } return rc; }
static void led_pwm_exit(struct led_t * led) { struct led_pwm_private_data_t * dat = (struct led_pwm_private_data_t *)led->priv; dat->brightness = 0; pwm_disable(dat->pwm); }
/* ** Called to disable amp (disable output force) */ IMMVIBESPIAPI VibeStatus ImmVibeSPI_ForceOut_AmpDisable(VibeUInt8 nActuatorIndex) { #if 0 #error Please review the code between the #if and #endif if (g_bAmpEnabled) { DbgOut((KERN_DEBUG "ImmVibeSPI_ForceOut_AmpDisable.\n")); g_bAmpEnabled = false; #if 0 mhn_gpio_set_level(GPIO_EN, GPIO_LEVEL_LOW); mz_ops.bstat &= ~HN_BATTERY_MOTOR; #endif } #endif if (g_bAmpEnabled) { g_bAmpEnabled = false; pwm_config(Immvib_pwm, 0, freq_count/2); pwm_disable(Immvib_pwm); //gpio_request(GPIO_VIBTONE_EN1, "GPIO_VIBTONE_EN1"); gpio_direction_output(GPIO_VIBTONE_EN1, GPIO_LEVEL_LOW); gpio_direction_input(GPIO_VIBTONE_EN1); s3c_gpio_setpull(GPIO_VIBTONE_EN1,S3C_GPIO_PULL_DOWN); //gpio_free(GPIO_VIBTONE_EN1); } return VIBE_S_SUCCESS; }
static int pwm_backlight_update_status(struct backlight_device *bl) { struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); int brightness = bl->props.brightness; int max = bl->props.max_brightness; if (bl->props.power != FB_BLANK_UNBLANK) brightness = 0; if (bl->props.fb_blank != FB_BLANK_UNBLANK) brightness = 0; if (pb->notify) brightness = pb->notify(pb->dev, brightness); if (brightness == 0) { pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } else { pwm_config(pb->pwm, asus_remapped_brightness[brightness] * (pb->period / 100) / max, pb->period); pwm_enable(pb->pwm); } if (pb->notify_after) pb->notify_after(pb->dev, brightness); return 0; }
static int pwm_beeper_event(struct input_dev *input, unsigned int type, unsigned int code, int value) { int ret = 0; struct pwm_beeper *beeper = input_get_drvdata(input); unsigned long period; if (type != EV_SND || value < 0) return -EINVAL; switch (code) { case SND_BELL: value = value ? 1000 : 0; break; case SND_TONE: break; default: return -EINVAL; } if (value == 0) { pwm_disable(beeper->pwm); } else { period = HZ_TO_NANOSECONDS(value); ret = pwm_config(beeper->pwm, period / 2, period); if (ret) return ret; ret = pwm_enable(beeper->pwm); if (ret) return ret; beeper->period = period; } return 0; }
int stopPwm(char *channel) { char key[8]; int allowed = -1; clear_error_msg(); if (!get_pwm_key(channel, key)) { printf("Invalid PWM key or name."); return 0; } // Check to see if PWM is allowed on the hardware // A 1 means we're good to go allowed = pwm_allowed(key); if (allowed == -1) { char err[2000]; snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg()); return 0; } else if (allowed == 0) { char err[2000]; snprintf(err, sizeof(err), "PWM %s not available on current Hardware", key); return 0; } if (pwm_disable(key) < 0) { char err[2000]; snprintf(err, sizeof(err), "PWM: %s issue: (%s)", channel, get_error_msg()); return 0; } }
static void mipi_toshiba_set_backlight(struct msm_fb_data_type *mfd) { int ret; static int bklight_pwm_cfg; if (bklight_pwm_cfg == 0) { mipi_bklight_pwm_cfg(); bklight_pwm_cfg++; } if (bl_lpm) { ret = pwm_config(bl_lpm, MIPI_TOSHIBA_PWM_DUTY_LEVEL * mfd->bl_level, MIPI_TOSHIBA_PWM_PERIOD_USEC); if (ret) { pr_err("pwm_config on lpm failed %d\n", ret); return; } if (mfd->bl_level) { ret = pwm_enable(bl_lpm); if (ret) pr_err("pwm enable/disable on lpm failed" "for bl %d\n", mfd->bl_level); } else { pwm_disable(bl_lpm); } } }
static int max77665_haptic_on(struct haptic_data *chip, bool en) { int ret = 0; if (en) { ret = max77665_update_reg(chip->pmic, MAX77665_PMIC_REG_LSCNFG, LSEN, LSEN_MASK); ret = max77665_update_reg(chip->client, MAX77665_HAPTIC_REG_CONFIG2, (0x1 << HAPTIC_CONF2_MEN_SHIFT), HAPTIC_CONF2_MEN_MASK); ret = pwm_config(chip->pwm, chip->duty, chip->period); ret = pwm_enable(chip->pwm); } else { pwm_disable(chip->pwm); ret = max77665_update_reg(chip->client, MAX77665_HAPTIC_REG_CONFIG2, (0x0 << HAPTIC_CONF2_MEN_SHIFT), HAPTIC_CONF2_MEN_MASK); ret = max77665_update_reg(chip->pmic, MAX77665_PMIC_REG_LSCNFG, LSDEN, LSEN_MASK); } return ret; }
static void msm_flashlight_led_set(struct led_classdev *led_cdev, enum led_brightness value) { int rc = 0; int PWM_PERIOD = NSEC_PER_SEC / 500; if(value==1) // some apps expect the flashlight to be either on or off value=100; if (!msm_flash_pwm) { rc = pm8058_gpio_config( 23, &camera_flash); if (rc) { pr_err("%s PMIC GPIO 23 write failed\n", __func__); return; } msm_flash_pwm = pwm_request(0, "camera-flash"); if (msm_flash_pwm == NULL) { pr_err("%s: FAIL pwm_request(): msm_flash_pwm=%p\n", __func__, msm_flash_pwm); msm_flash_pwm = NULL; return; } } if(value==0) { pwm_disable(msm_flash_pwm); } else { rc = pwm_config(msm_flash_pwm,(PWM_PERIOD/255)*value/NSEC_PER_USEC,PWM_PERIOD/NSEC_PER_USEC); if (rc >= 0) rc = pwm_enable(msm_flash_pwm); } }
static ssize_t pwm_test_store_run(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int rc; struct pwm_test *pwm_test = dev_get_drvdata(dev); int run; rc = kstrtoint(buf, 0, &run); if (rc) return rc; /* only 0 & 1 allowed */ if (run != 0 && run != 1) return -EINVAL; /* same state, don't bother */ if (run == pwm_test->run) return count; if (run) { rc = pwm_enable(pwm_test->pwm); if (rc != 0) { dev_err(dev, "pwm_enable failed\n"); return rc; } } else pwm_disable(pwm_test->pwm); pwm_test->run = run; return count; }
static void pm8058_pwm_led_brightness_set(struct led_classdev *led_cdev, enum led_brightness brightness) { struct pm8058_led_data *ldata; int enable = 0; /* struct pwm_device* pwm_led; */ ldata = container_of(led_cdev, struct pm8058_led_data, ldev); pwm_disable(ldata->pwm_led); brightness = (brightness > LED_FULL) ? LED_FULL : brightness; brightness = (brightness < LED_OFF) ? LED_OFF : brightness; LED_INFO_LOG("%s: bank %d brightness %d\n", __func__, ldata->bank, brightness); enable = (brightness) ? 1 : 0; if (strcmp(ldata->ldev.name, "charming-led") == 0) charming_led_enable(enable); if (brightness) { pwm_config(ldata->pwm_led, 64000, 64000); #if 0 pwm_conf.pwm_size = ldata->pwm_size; pwm_conf.clk = ldata->clk; pwm_conf.pre_div = ldata->pre_div; pwm_conf.pre_div_exp = ldata->pre_div_exp; pwm_conf.pwm_value = ldata->pwm_value; pwm_conf.bypass_lut = 1; pwm_configure(ldata->pwm_led, &pwm_conf); #endif pwm_enable(ldata->pwm_led); } }
static int pwm_backlight_update_status(struct backlight_device *bl) { struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); int brightness = bl->props.brightness; int max = bl->props.max_brightness; if (bl->props.power != FB_BLANK_UNBLANK) brightness = 0; if (bl->props.fb_blank != FB_BLANK_UNBLANK) brightness = 0; if (pb->notify) brightness = pb->notify(pb->dev, brightness); if (brightness == 0) { pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } else { brightness = pb->lth_brightness + (brightness * (pb->period - pb->lth_brightness) / max); pwm_config(pb->pwm, brightness, pb->period); pwm_enable(pb->pwm); } return 0; }
static int pwm_backlight_update_status(struct backlight_device *bl) { struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); int brightness = bl->props.brightness; int max = bl->props.max_brightness; if (bl->props.power != FB_BLANK_UNBLANK) brightness = 0; if (bl->props.fb_blank != FB_BLANK_UNBLANK) brightness = 0; if (pb->notify) brightness = pb->notify(pb->dev, brightness); #if defined(CONFIG_LCD_MIPI_TC358764) && defined(CONFIG_MACH_ODROIDXU) brightness = bl->props.max_brightness - brightness; #endif if (brightness == 0) { pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } else { brightness = pb->lth_brightness + (brightness * (pb->period - pb->lth_brightness) / max); pwm_config(pb->pwm, brightness, pb->period); pwm_enable(pb->pwm); } if (pb->notify_after) pb->notify_after(pb->dev, brightness); return 0; }
static void vibrator_work(struct work_struct *_work) { struct vibrator_drvdata *data = container_of(_work, struct vibrator_drvdata, work); printk(KERN_DEBUG "[VIB] time = %dms\n", data->timeout); if (0 == data->timeout) { if (!data->running) return ; regulator_force_disable(data->regulator); pwm_disable(data->pwm); i2c_max8997_hapticmotor(data, false); if (data->pdata->motor_en) data->pdata->motor_en(false); data->running = false; } else { if (data->running) return ; if (data->pdata->motor_en) data->pdata->motor_en(true); i2c_max8997_hapticmotor(data, true); pwm_config(data->pwm, data->pdata->duty, data->pdata->period); pwm_enable(data->pwm); regulator_enable(data->regulator); data->running = true; } }
static int pwm_fan_suspend(struct platform_device *pdev, pm_message_t state) { struct fan_dev_data *fan_data = platform_get_drvdata(pdev); int err; mutex_lock(&fan_data->fan_state_lock); cancel_delayed_work(&fan_data->fan_ramp_work); /*Turn the fan off*/ fan_data->fan_cur_pwm = 0; fan_data->next_target_pwm = 0; set_pwm_duty_cycle(0, fan_data); pwm_disable(fan_data->pwm_dev); pwm_free(fan_data->pwm_dev); err = gpio_request(fan_data->pwm_gpio, "pwm-fan"); if (err < 0) { dev_err(&pdev->dev, "%s:gpio request failed %d\n", __func__, fan_data->pwm_gpio); } gpio_direction_output(fan_data->pwm_gpio, 1); /*Stop thermal control*/ fan_data->fan_temp_control_flag = 0; mutex_unlock(&fan_data->fan_state_lock); return 0; }
static void max77660_haptic_enable(struct max77660_haptic *chip, bool enable) { // printk("Ivan max77660_haptic_enable = %d \n", enable); if (chip->enabled == enable) return; // mutex_lock(&chip->enable_lock); chip->enabled = enable; if (enable) { // printk("Ivan max77660_haptic_enable ENABLE! \n"); regulator_enable(chip->regulator); max77660_haptic_configure(chip); if (chip->mode == MAX77660_EXTERNAL_MODE) pwm_enable(chip->pwm); // haptic_enable_processing = 0; //Ivan } else { // printk("Ivan max77660_haptic_enable DISABLE! \n"); max77660_haptic_configure(chip); max77660_reg_write(chip->dev->parent, MAX77660_HAPTIC_SLAVE, MAX77660_HAPTIC_REG_CONF2, 2); if (chip->mode == MAX77660_EXTERNAL_MODE) pwm_disable(chip->pwm); regulator_disable(chip->regulator); } // mutex_unlock(&chip->enable_lock); }
static void pwm_backlight_edpcb(unsigned int new_state, void *priv_data) { struct backlight_device *bl = (struct backlight_device *) priv_data; struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); int max = bl->props.max_brightness; int brightness = pb->edp_brightness_states[new_state]; if (brightness == 0) { gpio_set_value(DSI_PANEL_BL_EN, 0); pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); } else { brightness = pb->lth_brightness + (brightness * (pb->period - pb->lth_brightness) / max); pwm_config(pb->pwm, brightness, pb->period); pwm_enable(pb->pwm); msleep(10); gpio_set_value(DSI_PANEL_BL_EN, 1); } if (pb->notify_after) pb->notify_after(pb->dev, brightness); }
void pwm_backlight_shutdown(struct platform_device *pdev) { struct backlight_device *bl = platform_get_drvdata(pdev); struct pwm_bl_data *pb = dev_get_drvdata(&bl->dev); pwm_config(pb->pwm, 0, pb->period); pwm_disable(pb->pwm); }
static int pwm_fan_suspend(struct device *dev) { struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); if (ctx->pwm_value) pwm_disable(ctx->pwm); return 0; }
static int sicilia_pwm_power_off(struct pwm_device **dev) { pwm_disable(*dev); pwm_put(*dev); *dev = NULL; return 0; }
static int pwm_fan_remove(struct platform_device *pdev) { struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev); if (ctx->pwm_value) pwm_disable(ctx->pwm); return 0; }
static int pwm_regulator_disable(struct regulator_dev *dev) { struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev); pwm_disable(drvdata->pwm); return 0; }
static void led_work_func(struct work_struct *work) { struct pm8058_led_data *ldata; ldata = container_of(work, struct pm8058_led_data, led_work); LED_ALM("%s led alarm led work -" , ldata->ldev.name); pwm_disable(ldata->pwm_led); }
static int pwm_beeper_suspend(struct device *dev) { struct pwm_beeper *beeper = dev_get_drvdata(dev); if (beeper->period) pwm_disable(beeper->pwm); return 0; }
void mdss_edp_set_backlight(struct mdss_panel_data *pdata, u32 bl_level) { int ret = 0; struct mdss_edp_drv_pdata *edp_drv = NULL; int bl_max; int period_ns; edp_drv = container_of(pdata, struct mdss_edp_drv_pdata, panel_data); if (!edp_drv) { pr_err("%s: Invalid input data\n", __func__); return; } if (edp_drv->bl_pwm != NULL) { bl_max = edp_drv->panel_data.panel_info.bl_max; if (bl_level > bl_max) bl_level = bl_max; /* In order to avoid overflow, use the microsecond version * of pwm_config if the pwm_period is greater than or equal * to 1 second. */ if (edp_drv->pwm_period >= USEC_PER_SEC) { ret = pwm_config_us(edp_drv->bl_pwm, bl_level * edp_drv->pwm_period / bl_max, edp_drv->pwm_period); if (ret) { pr_err("%s: pwm_config_us() failed err=%d.\n", __func__, ret); return; } } else { period_ns = edp_drv->pwm_period * NSEC_PER_USEC; ret = pwm_config(edp_drv->bl_pwm, bl_level * period_ns / bl_max, period_ns); if (ret) { pr_err("%s: pwm_config() failed err=%d.\n", __func__, ret); return; } } if (edp_drv->is_pwm_enabled) { pwm_disable(edp_drv->bl_pwm); edp_drv->is_pwm_enabled = 0; } ret = pwm_enable(edp_drv->bl_pwm); if (ret) { pr_err("%s: pwm_enable() failed err=%d\n", __func__, ret); return; } edp_drv->is_pwm_enabled = 1; } }