static int vibrator_probe(struct platform_device *pdev) { int ret = 0; #if defined(CONFIG_HAS_WAKELOCK) wake_lock_init(&vib_wl, WAKE_LOCK_SUSPEND, __stringify(vib_wl)); #endif /* Setup timed_output obj */ vibrator_timed_dev.name = "vibrator"; vibrator_timed_dev.enable = vibrator_enable_set_timeout; vibrator_timed_dev.get_time = vibrator_get_remaining_time; vib_voltage = pdev->voltage; /* Vibrator dev register in /sys/class/timed_output/ */ ret = timed_output_dev_register(&vibrator_timed_dev); if (ret < 0) { printk(KERN_ERR "Vibrator: timed_output dev registration failure\n"); timed_output_dev_unregister(&vibrator_timed_dev); } init_timer(&vibrate_timer); vibrate_timer.function = on_vibrate_timer_expired; vibrate_timer.data = (unsigned long)NULL; INIT_WORK(&vibrator_off_work, vibrator_off_worker); Is_vib_shortly = false; return 0; }
static int incident_led_blink_probe(struct platform_device *pdev) { int ret =0; struct incident_led_blink_data *data; data = kzalloc(sizeof(struct incident_led_blink_data) ,GFP_KERNEL); if (!data) return -ENOMEM; INIT_WORK(&data->work_incident_led_blink_on, incident_led_blink_on); INIT_WORK(&data->work_incident_led_blink_off, incident_led_blink_off); INIT_WORK(&data->work_incident_led_on_all_long, incident_led_on_all_long); hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); data->timer.function = incident_led_blink_timer_func; spin_lock_init(&data->lock); data->dev.name = "incident_led"; data->dev.get_time = incident_led_blink_get_time; data->dev.enable = incident_led_blink_enable; ret = timed_output_dev_register(&data->dev); if (ret < 0){ timed_output_dev_unregister(&data->dev); kfree(data); return ret; } platform_set_drvdata(pdev, data); return 0; }
static int vibrator_probe(struct platform_device *pdev) { int ret; data = kzalloc(sizeof(struct vibrator_data), GFP_KERNEL); if (!data) return -ENOMEM; data->regulator = regulator_get(NULL, "vdd_vbrtr"); if (IS_ERR_OR_NULL(data->regulator)) { pr_err("vibrator_init:Couldn't get regulator vdd_vbrtr\n"); data->regulator = NULL; ret = PTR_ERR(data->regulator); goto err; } hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); /* Intialize the work queue */ INIT_WORK(&data->work, vibrator_work_func); data->timer.function = vibrator_timer_func; data->dev = vibrator_dev; data->vibrator_on = false; ret = timed_output_dev_register(&data->dev); if (ret) goto err2; return 0; err2: regulator_put(data->regulator); err: kfree(data); return ret; }
static void vibetonz_start(void) { int ret = 0; //printk("[VIBETONZ] %s : \n",__func__); spin_lock_init(&vib_lock); /* hrtimer settings */ hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); timer.function = vibetonz_timer_func; if (gpio_is_valid(GPIO_VIB_EN)) { if (gpio_request(GPIO_VIB_EN, S3C_GPIO_LAVEL(GPIO_VIB_EN))) printk(KERN_ERR "Failed to request GPIO_VIB_EN!\n"); gpio_direction_output(GPIO_VIB_EN,0); mdelay(10); gpio_set_value(GPIO_VIB_EN, GPIO_LEVEL_LOW); } s3c_gpio_setpull(GPIO_VIB_EN, S3C_GPIO_PULL_NONE); /* pwm timer settings */ s3c6410_timer_setup(1,10,VIBRATOR_ON_STRONG_PERIOD, VIBRATOR_OFF_STRONG_PERIOD); /* timed_output_device settings */ ret = timed_output_dev_register(&timed_output_vt); if(ret) printk(KERN_ERR "[VIBETONZ] timed_output_dev_register is fail \n"); }
static int __init s3c_keypad_probe(struct platform_device *pdev) { int ret; struct input_dev *input_dev; struct s3c_keypad *s3c_keypad; if (device_create_file(&(pdev->dev), &dev_attr_key_pressed) < 0) { printk("%s s3c_keypad_probe\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_key_pressed.attr.name); } #ifdef FLASH_MOVIE_MODE /* hrtimer settings */ hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); timer.function = aat1271_flash_timer_func; timed_output_dev_register(&timed_output_flash); #endif return 0; }
static int msm_vibrator_probe(struct platform_device *pdev) { int rc = 0; struct vibrator_platform_data_motor *pdata; if (pdev->dev.platform_data == NULL) { printk("Platform data is null"); return -EINVAL; } else { pdata = pdev->dev.platform_data; vibrator_drvdata.power_onoff = pdata->power_onoff; } printk("[VIB] Probe function is called\n"); INIT_WORK(&work_vibrator_on, msm_vibrator_on); INIT_WORK(&work_vibrator_off, msm_vibrator_off); hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; rc = timed_output_dev_register(&msm_vibrator); if (rc < 0) { goto err_read_vib; } return 0; err_read_vib: printk(KERN_ERR "[VIB] timed_output_dev_register fail (rc=%d)\n", rc); return rc; }
static int android_vibrator_probe(struct platform_device *pdev) { int ret = 0; vibe_data = (struct android_vibrator_platform_data *)pdev->dev.platform_data; atomic_set(&vibe_gain,vibe_data->amp_value); vibe_data->pwm_set(1, 32); if (android_vibrator_intialize() < 0) { printk(KERN_ERR "Android Vibrator Initialization was failed\n"); return -1; } android_vibrator_force_set(0); /* disable vibrator */ hrtimer_init(&android_vibrator_data.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); android_vibrator_data.timer.function = vibrator_timer_func; spin_lock_init(&android_vibrator_data.lock); ret = timed_output_dev_register(&android_vibrator_data.dev); if (ret < 0) { timed_output_dev_unregister(&android_vibrator_data.dev); return -ENODEV; } ret = device_create_file(android_vibrator_data.dev.dev, &dev_attr_amp); if (ret < 0) { timed_output_dev_unregister(&android_vibrator_data.dev); device_remove_file(android_vibrator_data.dev.dev, &dev_attr_amp); return -ENODEV; } printk(KERN_INFO "LGE: Android Vibrator Initialization was done\n"); return 0; }
int aat1271a_flash_init(void) { int ret; /* hrtimer settings */ hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); timer.function = aat1271_flash_timer_func; if (gpio_is_valid(GPIO_CAM_FLASH_SET)) { if (gpio_request(GPIO_CAM_FLASH_SET, S3C_GPIO_LAVEL(GPIO_CAM_FLASH_SET))) printk(KERN_ERR "Failed to request GPIO_CAM_FLASH_SET!\n"); gpio_direction_output(GPIO_CAM_FLASH_SET, GPIO_LEVEL_LOW); } s3c_gpio_setpull(GPIO_CAM_FLASH_SET, S3C_GPIO_PULL_NONE); if (gpio_is_valid(GPIO_CAM_FLASH_EN)) { if (gpio_request(GPIO_CAM_FLASH_EN, S3C_GPIO_LAVEL(GPIO_CAM_FLASH_EN))) printk(KERN_ERR "Failed to request GPIO_CAM_FLASH_EN!\n"); gpio_direction_output(GPIO_CAM_FLASH_EN, GPIO_LEVEL_LOW); } s3c_gpio_setpull(GPIO_CAM_FLASH_EN, S3C_GPIO_PULL_NONE); /* timed_output_device settings */ ret = timed_output_dev_register(&timed_output_flash); if(ret) printk(KERN_ERR "[VIBETONZ] timed_output_dev_register is fail \n"); }
void __init mx6_motor_init() { int ret =0; hrtimer_init(&vibdata.timer,CLOCK_MONOTONIC, HRTIMER_MODE_REL);//初始化定时器 vibdata.timer.function= mx6_vibrator_timer_func; //设置回调函数 INIT_WORK(&vibdata.work,mx6_vibrator_work); //初始化工作队列 ret =gpio_request(SABRESD_VIBRATOR_CTL, "vibrator-en"); //申请IO if (ret< 0) { printk("vibratorrequest IO err!:%d\n",ret); returnret; } wake_lock_init(&vibdata.wklock,WAKE_LOCK_SUSPEND, "vibrator"); //初始化 wake_lock mutex_init(&vibdata.lock); //初始化 互斥锁 ret=timed_output_dev_register(&mx6_motot_driver); //注册timed_output 设备 if (ret< 0) gotoerr_to_dev_reg; return 0; err_to_dev_reg: //错误了 就释放所有资源 mutex_destroy(&vibdata.lock); wake_lock_destroy(&vibdata.wklock); gpio_free(+_VIBRATOR_CTL); printk("vibrator err!:%d\n",ret); returnret; }
static int __init vibrator_init(void) { int ret; /* * Use GMI_AD15 pin as a software-controlled GPIO * to control vibrator */ printk(KERN_INFO "%s+ #####\n", __func__); ret = gpio_request(TEGRA_GPIO_PH7, "ENB_VIB"); if (ret) { pr_info("[VIB]: gpio_request failed.\n"); gpio_free(TEGRA_GPIO_PH7); return ret; } tegra_gpio_enable(TEGRA_GPIO_PH7); /* Turn off vibrator in default*/ gpio_direction_output(TEGRA_GPIO_PH7, 0); init_timer(&v_timer); v_timer.expires = jiffies; v_timer.data = 0; v_timer.function = stop_vibrator; ret = timed_output_dev_register(&tegra_vibrator); if (ret) pr_info("[VIB]: timed_output_dev_register failed.\n"); printk(KERN_INFO "%s- #####\n", __func__); return ret; }
static int msm_vibrator_probe(struct platform_device *pdev) { int rc = 0; printk("[VIB] Prob\n"); INIT_WORK(&work_vibrator_on, msm_vibrator_on); INIT_WORK(&work_vibrator_off, msm_vibrator_off); hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; rc = timed_output_dev_register(&msm_vibrator); if (rc < 0) { goto err_read_vib; } if (board_hw_revision >= 7) gpio_tlmm_config(GPIO_CFG(MOTOR_EN_GPIO, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_10MA),GPIO_CFG_ENABLE); return 0; err_read_vib: printk(KERN_ERR "[VIB] timed_output_dev_register fail (rc=%d)\n", rc); return rc; }
static int __init sprd_init_vibrator(void) { int ret = 0; vibrator_hw_init(); #if defined(CONFIG_HAS_WAKELOCK) wake_lock_init(&vib_wl, WAKE_LOCK_SUSPEND, __stringify(vib_wl)); #endif ret = timed_output_dev_register(&sprd_vibrator); if (ret < 0) { printk(KERN_ERR "Vibrator: timed_output dev registration failure\n"); goto error; } vib_workqueue = create_workqueue("vib_wq"); INIT_DELAYED_WORK(&vibrator_off_work, vibrator_off_worker); return 0; error: #if defined(CONFIG_HAS_WAKELOCK) wake_lock_destroy(&vib_wl); #endif return ret; }
static int __devinit lc898300_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lc898300_data *data; int rc; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; if (!client->dev.platform_data) return -EIO; data = kzalloc(sizeof(struct lc898300_data), GFP_KERNEL); if (!data) return -ENOMEM; data->client = client; data->dev = &client->dev; data->pdata = client->dev.platform_data; data->on = false; mutex_init(&data->lock); i2c_set_clientdata(client, data); rc = data->pdata->gpio_allocate(data->dev); if (rc) goto error; rc = data->pdata->power_config(data->dev, true); if (rc) goto error_gpio_release; rc = lc898300_resume(data); if (rc) { dev_err(&client->dev, "Configure failed rc = %d\n", rc); goto error; } hrtimer_init(&data->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); data->vib_timer.function = vibrator_timer_func; data->timed_dev.name = data->pdata->name; data->timed_dev.get_time = lc898300_vib_get_time; data->timed_dev.enable = lc898300_vib_enable; rc = timed_output_dev_register(&data->timed_dev); if (rc < 0) goto error; return rc; error_gpio_release: data->pdata->gpio_release(data->dev); error: i2c_set_clientdata(client, NULL); kfree(data); return rc; }
void mx6_motor_exit() { mutex_destroy(&vibdata.lock); wake_lock_destroy(&vibdata.wklock); gpio_free(SABRESD_VIBRATOR_CTL); printk("vibrator exit!\n"); timed_output_dev_register(&mx6_motot_driver); }
void __init ImmVibe_timed_output(void) { INIT_WORK(&vibrator_work, ImmVibeSPI_Control); hrtimer_init(&vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vib_timer.function = vibrator_timer_func; vib_state = 0; //Default is Vibrator OFF timed_output_dev_register(&timed_dev); }
void __init msm_init_pmic_vibrator(void) { INIT_WORK(&vibrator_work, update_vibrator); hrtimer_init(&vibrator_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibrator_timer.function = vibrator_timer_func; timed_output_dev_register(&pmic_vibrator); }
static int vib_pwm_probe(struct platform_device *pdev) { struct vib_pwm_platform_data *pdata = pdev->dev.platform_data; struct vib_pwm_data *pwm_data; int ret = 0; if (!pdata) { ret = -EBUSY; printk(KERN_ERR "vib-pwm platform data is null\n"); goto err0; } pwm_data = kzalloc(sizeof(struct vib_pwm_data), GFP_KERNEL); if (!pwm_data) { printk(KERN_ERR "vib-pwm: memory allocation failed\n"); ret = -ENOMEM; goto err0; } pwm_data->pdata = pdata; INIT_WORK(&pwm_data->vib_work, vib_pwm_update); hrtimer_init(&pwm_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); pwm_data->timer.function = pwm_timer_func; spin_lock_init(&pwm_data->lock); pwm_data->dev.name = pdata->device_name; pwm_data->dev.get_time = vib_pwm_get_time; pwm_data->dev.enable = vib_pwm_enable; ret = timed_output_dev_register(&pwm_data->dev); if (ret < 0) { printk(KERN_ERR "timed o/p dev. lvib. registration failed\n"); goto err1; } if (pwm_data->pdata->init) ret = pwm_data->pdata->init(); if (ret < 0) { printk(KERN_ERR "vib-pwm: platform data not available\n"); goto err2; } misc_data = pwm_data; platform_set_drvdata(pdev, pwm_data); printk(KERN_ALERT "vib-pwm probed\n"); return 0; err2: timed_output_dev_unregister(&pwm_data->dev); err1: kfree(pwm_data); err0: return ret; }
static int vib_gpio_probe(struct platform_device *pdev) { struct vib_gpio_platform_data *pdata = pdev->dev.platform_data; struct vib_gpio_data *gpio_data; int ret = 0; if (!pdata) { ret = -EBUSY; goto err0; } gpio_data = kzalloc(sizeof(struct vib_gpio_data), GFP_KERNEL); if (!gpio_data) { ret = -ENOMEM; goto err0; } gpio_data->pdata = pdata; INIT_WORK(&gpio_data->vib_work, vib_gpio_update); hrtimer_init(&gpio_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); gpio_data->timer.function = gpio_timer_func; spin_lock_init(&gpio_data->lock); gpio_data->dev.name = "vibrator"; gpio_data->dev.get_time = vib_gpio_get_time; gpio_data->dev.enable = vib_gpio_enable; ret = timed_output_dev_register(&gpio_data->dev); if (ret < 0) goto err1; if (gpio_data->pdata->init) ret = gpio_data->pdata->init(); if (ret < 0) goto err2; gpio_direction_output(gpio_data->pdata->gpio, gpio_data->pdata->active_low); misc_data = gpio_data; platform_set_drvdata(pdev, gpio_data); vib_gpio_enable(&gpio_data->dev, gpio_data->pdata->initial_vibrate); return 0; err2: timed_output_dev_unregister(&gpio_data->dev); err1: kfree(gpio_data->pdata); kfree(gpio_data); err0: return ret; }
static int __init msm_init_pmic_vibrator(void) { INIT_WORK(&work_vibrator_on, pmic_vibrator_on); INIT_WORK(&work_vibrator_off, pmic_vibrator_off); hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; return timed_output_dev_register(&pmic_vibrator); }
static int __init vibrator_init(void) { int status; status = timed_output_dev_register(&vibrator_dev); if (status) { printk("failed to register a timed_ouput dev\n"); } return status; }
void __init msm_init_pmic_vibrator(void) { pr_info(ZHY_VIB_TAG" msm_init_pmic_vibrator\n"); INIT_WORK(&work_vibrator_on, pmic_vibrator_on); INIT_WORK(&work_vibrator_off, pmic_vibrator_off); hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&pmic_vibrator); }
static int vib_probe(struct platform_device *pdev) { struct twl4030_codec_vibra_data *pdata = pdev->dev.platform_data; struct vib_data *data; int ret = 0; if (!pdata) { ret = -EBUSY; goto err0; } data = kzalloc(sizeof(struct vib_data), GFP_KERNEL); if (!data) { ret = -ENOMEM; goto err0; } data->pdata = pdata; data->twl6040 = dev_get_drvdata(pdev->dev.parent); INIT_WORK(&data->vib_work, vib_update); hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); data->timer.function = vib_timer_func; spin_lock_init(&data->lock); data->dev.name = "vibrator"; data->dev.get_time = vib_get_time; data->dev.enable = vib_enable; ret = timed_output_dev_register(&data->dev); if (ret < 0) goto err1; if (data->pdata->init) ret = data->pdata->init(); if (ret < 0) goto err2; misc_data = data; platform_set_drvdata(pdev, data); twl6040_enable(data->twl6040); vib_enable(&data->dev, data->pdata->initial_vibrate); return 0; err2: timed_output_dev_unregister(&data->dev); err1: kfree(data); err0: return ret; }
static void vibetonz_start(void) { int ret = 0; hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); timer.function = vibetonz_timer_func; ret = timed_output_dev_register(&timed_output_vt); if(ret) printk(KERN_ERR "[VIBETONZ] timed_output_dev_register is fail \n"); }
void __init msm_init_pmic_vibrator(void) { mutex_init(&vib_mutex); INIT_WORK(&work_vibrator_on, pmic_vibrator_on); INIT_DELAYED_WORK(&work_vibrator_off, pmic_vibrator_off); hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&pmic_vibrator); }
// chui101: registers timed output device in sysfs so libhardware_legacy can interface static void timed_output_register(void) { int ret = 0; hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); timer.function = tspdrv_timer_callback; ret = timed_output_dev_register(&timed_output_tspdrv); if(ret) printk(KERN_ERR "[ImmVibe] timed_output_dev_register is fail \n"); }
void __init msm_init_pmic_vibrator(void) { INIT_WORK(&work_vibrator_on, pmic_vibrator_on); INIT_WORK(&work_vibrator_off, pmic_vibrator_off); vibe_workqueue = create_singlethread_workqueue("vibe_workqueue"); spin_lock_init(&vibe_lock); hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&pmic_vibrator); }
/* ** Called at initialization time to set PWM freq, disable amp, etc... */ VibeStatus ImmVibeSPI_ForceOut_Initialize(void) { int Ret; /* Kick start the ISA1200 set up */ Ret = isa1000_setup(); if(Ret < 0) { printk(KERN_ERR "%s, ISA1000 initialization failed\n", __func__); return VIBE_E_FAIL; } /* Set PWM duty cycle to 50%, i.e. output level to 0 */ isa1000_vib_set_level(0); /* Set PWM frequency */ /* Xiaomi TODO: Please change to the PWM configuration procedures for ** setting the PWM output frequency on ** the Hong Mi 2A platform */ /* Compute the period of PWM cycle */ pwm_period_ns = NSEC_PER_SEC / PWM_FREQUENCY; /*add google interface*/ vib_dev = kmalloc(sizeof(struct isa1000_vib),GFP_KERNEL); mutex_init(&vib_dev->lock); INIT_WORK(&vib_dev->work, isa1000_vib_update); hrtimer_init(&vib_dev->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vib_dev->vib_timer.function = isa1000_vib_timer_func; vib_dev->timeout = ISA1000_VIB_DEFAULT_TIMEOUT; vib_dev->timed_dev.name = "vibrator"; vib_dev->timed_dev.get_time = isa1000_vib_get_time; vib_dev->timed_dev.enable = isa1000_vib_enable; Ret = timed_output_dev_register(&vib_dev->timed_dev); if (Ret < 0){ printk(KERN_ERR "%s, ISA1000 register failed\n", __func__); return VIBE_E_FAIL; } /**/ Ret = device_create_file(vib_dev->timed_dev.dev, &dev_attr_amp); if (Ret < 0) { pr_err("[VIB] %s, create sysfs fail: amp\n", __func__); } /* Disable amp */ ImmVibeSPI_ForceOut_AmpDisable(0); return VIBE_S_SUCCESS; }
static int __init sun4i_vibrator_init(void) { int vibe_used; int err = -1; pr_info("hello, sun4i_vibrator init\n"); err = script_parser_fetch("motor_para", "motor_used", &vibe_used, sizeof(vibe_used)/sizeof(int)); if(err) { pr_err("%s script_parser_fetch \"motor_para\" \"motor_used\" error = %d\n", __FUNCTION__, err); goto exit; } if(!vibe_used) { pr_err("%s motor is not used in config\n", __FUNCTION__); err = -1; goto exit; } err = script_parser_fetch("motor_para", "motor_shake", (int *)&vibe_gpio, sizeof(vibe_gpio)/sizeof(int)); if(err) { pr_err("%s script_parser_fetch \"motor_para\" \"motor_shaked\" error = %d\n", __FUNCTION__, err); goto exit; } vibe_off = vibe_gpio.data; pr_debug("vibe_off is %d\n", vibe_off); vibe_gpio_handler = gpio_request_ex("motor_para", "motor_shake"); if(!vibe_gpio_handler) { pr_err("%s request motor gpio err\n", __FUNCTION__); err = -1; goto exit; } INIT_WORK(&vibrator_work, update_vibrator); spin_lock_init(&vibe_lock); vibe_state = 0; hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&sun4i_vibrator); exit: return err; }
static int __init sprd_init_vibrator(void) { vibrator_hw_init(); INIT_WORK(&vibrator_work, update_vibrator); vibe_state = 0; hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&sprd_vibrator); return 0; }
void __init msm_init_pmic_vibrator(void) { INIT_WORK(&vibrator_work, update_vibrator); spin_lock_init(&vibe_lock); vibe_state = 0; hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&pmic_vibrator); printk(KERN_INFO "Vibrator: enable voltage %d(mV)\n", PM_VIBRATOR_LEVEL); }