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; }
static int android_vibrator_probe(struct platform_device *pdev) { int ret = 0; struct timed_vibrator_data *vib; platform_set_drvdata(pdev, &android_vibrator_data); vib = (struct timed_vibrator_data *)platform_get_drvdata(pdev); vib->vibe_data = (struct android_vibrator_platform_data *)pdev->dev.platform_data; if (vib->vibe_data->vibrator_init() < 0) { printk(KERN_ERR "%s Android Vreg, GPIO set failed\n", __FUNCTION__); return -1; } //[LS840][ICS][Display]<*****@*****.**> #ifdef CONFIG_MACH_LGE_C1_BOARD_SPR atomic_set(&vib->vibe_gain, LG_VIBRATOR_GAIN); #else atomic_set(&vib->vibe_gain, 128); #endif //[LS840][ICS][Display]<*****@*****.**> atomic_set(&vib->vib_status, false); // android_vibrator_force_set(vib, 0); /* disable vibrator just for initializing */ INIT_WORK(&vib->work_vibrator_off, android_vibrator_off); INIT_WORK(&vib->work_vibrator_on, android_vibrator_on); hrtimer_init(&vib->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vib->timer.function = vibrator_timer_func; spin_lock_init(&vib->lock); ret = timed_output_dev_register(&vib->dev); if (ret < 0) { timed_output_dev_unregister(&vib->dev); return -ENODEV; } ret = device_create_file(vib->dev.dev, &dev_attr_amp); if (ret < 0) { timed_output_dev_unregister(&vib->dev); device_remove_file(vib->dev.dev, &dev_attr_amp); return -ENODEV; } // printk(KERN_INFO "LGE: Android Vibrator Initialization was done\n"); return 0; }
static int android_vibrator_probe(struct platform_device *pdev) { int ret = 0; vibe_data = (struct lge_vibrator_platform_data *)pdev->dev.platform_data; atomic_set(&vibe_gain,vibe_data->amp_value); if (android_vibrator_intialize() < 0) { printk(KERN_ERR "Android Vibrator Initialization was failed\n"); return -1; } #ifdef CONFIG_VIB_USE_HIGH_VOL_OVERDRIVE INIT_WORK(&qcoin_overdrive_off_queue, vib_qcoin_off_work); #endif #if defined(CONFIG_VIB_USE_WORK_QUEUE) INIT_WORK(&vib_power_set_work_queue, vib_power_set_work); atomic_set(&nForce, 0); schedule_work(&vib_power_set_work_queue); /* disable vibrator */ #else /* CONFIG_VIB_USE_WORK_QUEUE */ android_vibrator_force_set(0); /* disable vibrator */ #endif 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; } #ifdef CONFIG_VIB_USE_HIGH_VOL_OVERDRIVE ret = device_create_file(android_vibrator_data.dev.dev, &dev_attr_rtime); ret = device_create_file(android_vibrator_data.dev.dev, &dev_attr_ftime); #endif 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; }
static int __devexit dc_motor_remove(struct platform_device *pdev) { struct dc_motor_drvdata *ddata = platform_get_drvdata(pdev); timed_output_dev_unregister(&ddata->dev); kfree(ddata); 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 incident_led_blink_remove(struct platform_device *pdev) { struct incident_led_blink_data *data = platform_get_drvdata(pdev); timed_output_dev_unregister(&data->dev); kfree(data); return 0; }
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 __devexit ss_brcm_haptic_remove(struct platform_device *pdev) { t_vib_desc *vib_iter = platform_get_drvdata(pdev); timed_output_dev_unregister(&vib_iter->timed_dev); regulator_put(vib_iter->vib_regulator); return 0; }
static int __devexit lge_isa1200_remove(struct i2c_client *client) { struct lge_isa1200_context *context = i2c_get_clientdata(client); dev_info(context->dev.dev, "%s()\n", __func__); context_for_debugfs = NULL; device_remove_file(context->dev.dev, &dev_attr_amp); hrtimer_cancel(&context->timer); cancel_work_sync(&context->work); lge_isa1200_hw_vib_on_off(context, false); timed_output_dev_unregister(&context->dev); gpio_free(context->pdata->gpio_hen); #if 0 /* */ mutex_destroy(&context->mutex); #endif i2c_set_clientdata(client, NULL); kfree(context); return 0; }
static void __exit sprd_exit_vibrator(void) { timed_output_dev_unregister(&sprd_vibrator); #if defined(CONFIG_HAS_WAKELOCK) wake_lock_destroy(&vib_wl); #endif destroy_workqueue(vib_workqueue); }
static void __exit exit_tegra_vibrator(void) { if(s_hOdmVibrate) { timed_output_dev_unregister(&tegra_vibrator); NvOdmVibClose(s_hOdmVibrate); s_hOdmVibrate = NULL; } }
static int vibrator_remove(struct platform_device *pdev) { timed_output_dev_unregister(&data->dev); regulator_put(data->regulator); kfree(data); return 0; }
static int vibrator_remove(struct platform_device *pdev) { struct pm80x_vibrator_info *info; info = platform_get_drvdata(pdev); timed_output_dev_unregister(&info->vibrator_timed_dev); return 0; }
static void __exit isa1400_vibrator_exit(void) { VibeOSKernelLinuxTerminateTimer(); wake_lock_destroy(&vib_wake_lock); mutex_destroy(&g_drvdata->mutex_lock); timed_output_dev_unregister(&g_drvdata->dev); i2c_del_driver(&isa1400_vibrator_i2c_driver); }
static int vibrator_remove(struct i2c_client *client) { struct drv2604_vibrator_info *info = i2c_get_clientdata(client); timed_output_dev_unregister(&info->vibrator_timed_dev); i2c_unregister_device(client); devm_kfree(&client->dev, info); return 0; }
static int android_vibrator_remove(struct platform_device *dev) { vibe_data->power_set(0); vibe_data->ic_enable_set(0); vibe_data->pwm_set(0, 0); timed_output_dev_unregister(&android_vibrator_data.dev); return 0; }
static int __devexit vibrator_remove(struct platform_device *pdev) { struct vibrator_drvdata *data = platform_get_drvdata(pdev); timed_output_dev_unregister(&data->dev); regulator_put(data->regulator); pwm_free(data->pwm); kfree(data); return 0; }
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 qsd_led_remove(struct platform_device *pdev) { MSG("%s+", __func__); timed_output_dev_unregister(&qsd_timed_vibrator); qsd_timed_vibrator_deinit(); MSG("%s-", __func__); return 0; }
static int __devexit pm8xxx_vib_remove(struct platform_device *pdev) { struct pm8xxx_vib *vib = platform_get_drvdata(pdev); hrtimer_cancel(&vib->vib_timer); timed_output_dev_unregister(&vib->timed_dev); platform_set_drvdata(pdev, NULL); kfree(vib); return 0; }
static void __exit wmt_vibrate_exit(void) { platform_device_unregister(vibrate_platform_device); platform_driver_unregister(&vibrate_driver); timed_output_dev_unregister(&l_vibratedev.vibtimedev); device_destroy(l_vibratedev.dev_class, MKDEV(WMT_VIBRATE_MAJOR, 0)); class_destroy(l_vibratedev.dev_class); unregister_chrdev(WMT_VIBRATE_MAJOR, WMT_VIBRATE_DEVICE_NAME); printk(KERN_ALERT "WMT vibrate driver is removed.\n"); }
static int __devexit pmic8058_vib_remove(struct platform_device *pdev) { struct pmic8058_vib *vib = platform_get_drvdata(pdev); cancel_work_sync(&vib->work); hrtimer_cancel(&vib->vib_timer); timed_output_dev_unregister(&vib->timed_dev); kfree(vib); return 0; }
static int __devexit qpnp_vibrator_remove(struct spmi_device *spmi) { struct qpnp_vib *vib = dev_get_drvdata(&spmi->dev); cancel_work_sync(&vib->work); hrtimer_cancel(&vib->vib_timer); timed_output_dev_unregister(&vib->timed_dev); mutex_destroy(&vib->lock); return 0; }
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_end(void) { printk("[VIBETONZ] %s \n",__func__); /* Disable Vibetonz */ gpio_set_value(GPIO_HAPTIC_EN, GPIO_LEVEL_LOW); gpio_free(GPIO_HAPTIC_EN); s5p6442_timer_setup(0, 10,0,0); destroy_workqueue(vib_wq); /* Deregister timed output devices */ timed_output_dev_unregister(&timed_output_vt); }
static int android_vibrator_remove(struct platform_device *pdev) { struct timed_vibrator_data *vib = (struct timed_vibrator_data *)platform_get_drvdata(pdev); // android_vibrator_force_set(vib, 0); schedule_work(&vib->work_vibrator_off); timed_output_dev_unregister(&vib->dev); return 0; }
static int vib_pwm_remove(struct platform_device *pdev) { struct vib_pwm_data *pwm_data = platform_get_drvdata(pdev); if (pwm_data->pdata->exit) pwm_data->pdata->exit(); timed_output_dev_unregister(&pwm_data->dev); kfree(pwm_data); return 0; }
static int __devexit vibrator_remove(struct platform_device *pdev) { timed_output_dev_unregister(&vibrator_timed_dev); if (vib_regulator) { regulator_put(vib_regulator); vib_regulator = NULL; } return 0; }
static int drv2605_remove(struct i2c_client *client) { struct drv2605_data *data = i2c_get_clientdata(client); mutex_destroy(&data->lock); timed_output_dev_unregister(&data->dev); hrtimer_cancel(&data->timer); cancel_work_sync(&data->work); cancel_work_sync(&data->work_play_eff); return 0; }