static int resume(struct platform_device *pdev) { /* Restart system timers */ vibetonz_clk_on(&pdev->dev); DbgOut((KERN_DEBUG "tspdrv: %s.\n", __func__)); return 0; }
static int max77843_haptic_resume(struct platform_device *pdev) { pr_info("[VIB] %s\n", __func__); vibetonz_clk_on(&pdev->dev, true); g_hap_data->resumed = true; return 0; }
int init_module(void) { int nRet, i; /* initialized below */ #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nMajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nMajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); return g_nMajor; } #else nRet = misc_register(&miscdev); if (nRet) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); return nRet; } #endif nRet = platform_device_register(&platdev); if (nRet) DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n")); nRet = platform_driver_register(&platdrv); if (nRet) DbgOut((KERN_ERR "tspdrv: platform_driver_register failed.\n")); nRet = platform_driver_register(&max8997_hapticmotor_driver); if (nRet) DbgOut((KERN_ERR "tspdrv: platform_driver_register failed (hapticmotor).\n")); DbgRecorderInit(()); vibetonz_clk_on(&platdev.dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchDeviceName = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szDeviceName + g_cchDeviceName; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strcat(szName, VERSION_STR); g_cchDeviceName += strlen(szName); g_SamplesBuffer[i].nIndexPlayingBuffer = -1; /* Not playing */ g_SamplesBuffer[i].actuatorSamples[0].nBufferSize = 0; g_SamplesBuffer[i].actuatorSamples[1].nBufferSize = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; }
static __devinit int tspdrv_probe(struct platform_device *pdev) { int ret, i, rc; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100; if(!pdev->dev.of_node){ DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL"); return -ENODEV; } rc = tspdrv_parse_dt(pdev); if(rc) return rc; virt_mmss_gp0_base = ioremap(MSM_MMSS_GP0_BASE,0x28); if (!virt_mmss_gp0_base) panic("tspdrv : Unable to ioremap MSM_MMSS_GP0 memory!"); vibrator_drvdata.power_onoff = NULL; vibrator_drvdata.pwm_dev = NULL; ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); iounmap(virt_mmss_gp0_base); return ret; } DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strlcat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, sizeof(szName)); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; }
static int max77833_haptic_suspend(struct platform_device *pdev, pm_message_t state) { struct max77833_haptic_data *data = platform_get_drvdata(pdev); pr_info("[VIB] %s\n", __func__); cancel_work_sync(&g_hap_data->work); hrtimer_cancel(&g_hap_data->timer); vibetonz_clk_on(&pdev->dev, false); max77833_haptic_i2c(data, false); return 0; }
static int resume(struct platform_device *pdev) { u32 __iomem *pram; /* Restart system timers */ vibetonz_clk_on(&pdev->dev); /* Restore system timers configuration */ pram = ioremap(S5P_PA_TIMER, 4); writel(0x0F00, pram); iounmap(pram); DbgOut((KERN_DEBUG "tspdrv: %s.\n", __func__)); return 0; }
static __devinit int tspdrv_probe(struct platform_device *pdev) { int ret, i, rc; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100; if(!pdev->dev.of_node){ DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL"); return -ENODEV; } rc = tspdrv_parse_dt(pdev); if(rc) return rc; #if defined(CONFIG_MACH_HLTEDCM) || defined(CONFIG_MACH_HLTEKDI) || defined(CONFIG_MACH_JS01LTEDCM) virt_mmss_gp1_base = ioremap(MSM_MMSS_GP3_BASE,0x28); #elif defined(CONFIG_SEC_BERLUTI_PROJECT) || defined(CONFIG_MACH_S3VE3G_EUR) virt_mmss_gp1_base = ioremap(MSM_MMSS_GP0_BASE,0x28); #else virt_mmss_gp1_base = ioremap(MSM_MMSS_GP1_BASE,0x28); #endif if (!virt_mmss_gp1_base) panic("tspdrv : Unable to ioremap MSM_MMSS_GP1 memory!"); #if defined(CONFIG_MOTOR_DRV_MAX77803) || defined(CONFIG_MOTOR_DRV_MAX77804K) || defined(CONFIG_MOTOR_DRV_MAX77828) vibrator_drvdata.power_onoff = max77803_haptic_power_onoff; #else vibrator_drvdata.power_onoff = NULL; #endif vibrator_drvdata.pwm_dev = NULL; #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nmajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nmajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); ret = g_nmajor; iounmap(virt_mmss_gp1_base); return ret; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); iounmap(virt_mmss_gp1_base); return ret; } #endif DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strlcat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, sizeof(szName)); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); vib_dev = device_create(sec_class, NULL, 0, NULL, "vib"); if (IS_ERR(vib_dev)) { pr_info("Failed to create device for samsung vib\n"); } ret = sysfs_create_file(&vib_dev->kobj, &dev_attr_vib_tuning.attr); if (ret) { pr_info("Failed to create sysfs group for samsung specific led\n"); } return 0; }
static int max77833_haptic_probe(struct platform_device *pdev) { int error = 0; struct max77833_dev *max77833 = dev_get_drvdata(pdev->dev.parent); struct max77833_platform_data *max77833_pdata = dev_get_platdata(max77833->dev); struct max77833_haptic_platform_data *pdata = max77833_pdata->haptic_data; struct max77833_haptic_data *hap_data; pr_info("[VIB] ++ %s\n", __func__); #if defined(CONFIG_OF) if (pdata == NULL) { pdata = of_max77833_haptic_dt(&pdev->dev); if (!pdata) { pr_err("[VIB] max77833-haptic : %s not found haptic dt!\n", __func__); return -1; } } #else if (pdata == NULL) { pr_err("[VIB] %s: no pdata\n", __func__); return -ENODEV; } #endif /* CONFIG_OF */ hap_data = kzalloc(sizeof(struct max77833_haptic_data), GFP_KERNEL); if (!hap_data) { pr_err("[VIB] %s: no hap_pdata\n", __func__); kfree(pdata); return -ENOMEM; } platform_set_drvdata(pdev, hap_data); g_hap_data = hap_data; hap_data->max77833 = max77833; hap_data->i2c = max77833->i2c; hap_data->pdata = pdata; hap_data->workqueue = create_singlethread_workqueue("hap_work"); if (NULL == hap_data->workqueue) { error = -EFAULT; pr_err("[VIB] Failed to create workqueue, err num: %d\n", error); goto err_work_queue; } INIT_WORK(&(hap_data->work), haptic_work); spin_lock_init(&(hap_data->lock)); hap_data->pwm = pwm_request(hap_data->pdata->pwm_id, "vibrator"); if (IS_ERR(hap_data->pwm)) { error = -EFAULT; pr_err("[VIB] Failed to request pwm, err num: %d\n", error); goto err_pwm_request; } pwm_config(hap_data->pwm, pdata->period / 2, pdata->period); prev_duty = hap_data->pdata->period / 2; vibetonz_clk_on(&pdev->dev, true); /* hrtimer init */ hrtimer_init(&hap_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hap_data->timer.function = haptic_timer_func; /* timed_output_dev init*/ hap_data->tout_dev.name = "vibrator"; hap_data->tout_dev.get_time = haptic_get_time; hap_data->tout_dev.enable = haptic_enable; motor_dev = sec_device_create(hap_data, "motor"); if (IS_ERR(motor_dev)) { error = -ENODEV; pr_err("[VIB] Failed to create device\ for samsung specific motor, err num: %d\n", error); goto exit_sec_devices; } error = sysfs_create_group(&motor_dev->kobj, &sec_motor_attr_group); if (error) { error = -ENODEV; pr_err("[VIB] Failed to create sysfs group\ for samsung specific motor, err num: %d\n", error); goto exit_sysfs; } #ifdef CONFIG_ANDROID_TIMED_OUTPUT error = timed_output_dev_register(&hap_data->tout_dev); if (error < 0) { error = -EFAULT; pr_err("[VIB] Failed to register timed_output : %d\n", error); goto err_timed_output_register; } #endif vibtonz_en = max77833_vibtonz_en; vibtonz_pwm = max77833_vibtonz_pwm; prev_temperature_level = 1; /* autoresonance range setting */ error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_CONFIG, 0x00); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_CONFIG, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_MIN_FREQ_LOW, pdata->auto_res_min_low); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_MIN_FREQ_LOW, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_MAX_FREQ_LOW, pdata->auto_res_max_low); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_MAX_FREQ_LOW, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_INIT_GUESS_LOW, pdata->auto_res_init_low); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_INIT_GUESS_LOW, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_NOMINAL_STRENGTH, pdata->nominal_strength); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_NOMINAL_STRENGTH, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_RES_MIN_FREQ_HIGH, pdata->auto_res_min_high); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_RES_MIN_FREQ_HIGH, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_RES_MAX_FREQ_HIGH, pdata->auto_res_max_high); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_RES_MAX_FREQ_HIGH, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_INIT_GUESS_HIGH, pdata->auto_res_init_high); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_INIT_GUESS_HIGH, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_LOCK_WINDOW, pdata->auto_res_lock_window); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_LOCK_WINDOW, error); } error = max77833_write_reg(hap_data->i2c, MAX77833_AUTORES_UPDATE_FREQ, pdata->auto_res_update_freq); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_AUTORES_UPDATE_FREQ, error); } if (!pdata->auto_res_enable) { error = max77833_write_reg(hap_data->i2c, MAX77833_OPTION_REG1, 0x11); if (error < 0) { pr_err("[VIB] %s Failed to write REG(0x%02x) [%d]\n", __func__, MAX77833_OPTION_REG1, error); } } return error; err_timed_output_register: sysfs_remove_group(&motor_dev->kobj, &sec_motor_attr_group); exit_sysfs: sec_device_destroy(motor_dev->devt); exit_sec_devices: pwm_free(hap_data->pwm); err_pwm_request: destroy_workqueue(hap_data->workqueue); err_work_queue: kfree(hap_data); kfree(pdata); g_hap_data = NULL; return error; }
static int max77828_haptic_suspend(struct platform_device *pdev, pm_message_t state) { vibetonz_clk_on(&pdev->dev, false); return 0; }
static int max77828_haptic_resume(struct platform_device *pdev) { vibetonz_clk_on(&pdev->dev, true); return 0; }
static int vibrator_resume(struct platform_device *pdev) { vibetonz_clk_on(&pdev->dev, true); return 0; }
static int max77693_haptic_probe(struct platform_device *pdev) { int error = 0; struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent); struct max77693_platform_data *max77693_pdata = dev_get_platdata(max77693->dev); struct max77693_haptic_platform_data *pdata = max77693_pdata->haptic_data; struct max77693_haptic_data *hap_data; pr_debug("[VIB] ++ %s\n", __func__); if (pdata == NULL) { pr_err("%s: no pdata\n", __func__); return -ENODEV; } hap_data = kzalloc(sizeof(struct max77693_haptic_data), GFP_KERNEL); if (!hap_data) return -ENOMEM; platform_set_drvdata(pdev, hap_data); g_hap_data = hap_data; hap_data->max77693 = max77693; hap_data->i2c = max77693->haptic; hap_data->pmic_i2c = max77693->i2c; hap_data->pdata = pdata; hap_data->workqueue = create_singlethread_workqueue("hap_work"); if (IS_ERR(hap_data->workqueue)) { pr_err("[VIB] Failed to create workqueue for hap_work\n"); error = -EFAULT; goto err_create_workqueue; } INIT_WORK(&(hap_data->work), haptic_work); spin_lock_init(&(hap_data->lock)); hap_data->pwm = pwm_request(hap_data->pdata->pwm_id, "vibrator"); if (IS_ERR(hap_data->pwm)) { pr_err("[VIB] Failed to request pwm\n"); error = -EFAULT; goto err_pwm_request; } pwm_config(hap_data->pwm, pdata->period / 2, pdata->period); vibetonz_clk_on(&pdev->dev, true); if (pdata->init_hw) pdata->init_hw(); hap_data->regulator = regulator_get(NULL, pdata->regulator_name); if (IS_ERR(hap_data->regulator)) { pr_err("[VIB] Failed to get vmoter regulator.\n"); error = -EFAULT; goto err_regulator_get; } /* hrtimer init */ hrtimer_init(&hap_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hap_data->timer.function = haptic_timer_func; /* timed_output_dev init*/ hap_data->tout_dev.name = "vibrator"; hap_data->tout_dev.get_time = haptic_get_time; hap_data->tout_dev.enable = haptic_enable; create_vibrator_sysfs(); #ifdef CONFIG_ANDROID_TIMED_OUTPUT error = timed_output_dev_register(&hap_data->tout_dev); if (error < 0) { pr_err("[VIB] Failed to register timed_output : %d\n", error); error = -EFAULT; goto err_timed_output_register; } pr_err("[VIB] timed_output device is registrated\n"); /* User controllable pwm level */ error = device_create_file(hap_data->tout_dev.dev, &dev_attr_pwm_value); if (error < 0) { pr_err("[VIB] create sysfs fail: pwm_value\n"); } #endif pr_debug("[VIB] -- %s\n", __func__); return error; err_timed_output_register: regulator_put(hap_data->regulator); err_regulator_get: pwm_free(hap_data->pwm); err_pwm_request: destroy_workqueue(hap_data->workqueue); err_create_workqueue: kfree(hap_data); g_hap_data = NULL; return error; }
static int __devinit vibrator_probe(struct platform_device *pdev) { struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent); struct max8997_platform_data *max8997_pdata = dev_get_platdata(max8997->dev); struct max8997_motor_data *pdata = max8997_pdata->motor; struct vibrator_drvdata *ddata; int error = 0; ddata = kzalloc(sizeof(struct vibrator_drvdata), GFP_KERNEL); if (NULL == ddata) { pr_err("[VIB] Failed to alloc memory\n"); error = -ENOMEM; goto err_free_mem; } if (pdata->init_hw) pdata->init_hw(); else { ddata->regulator = regulator_get(NULL, "vmotor"); if (IS_ERR(ddata->regulator)) { pr_err("[VIB] Failed to get vmoter regulator.\n"); error = -EFAULT; goto err_regulator_get; } } ddata->pdata = pdata; ddata->dev.name = "vibrator"; ddata->dev.get_time = vibrator_get_time; ddata->dev.enable = vibrator_enable; ddata->client = max8997->hmotor; platform_set_drvdata(pdev, ddata); hrtimer_init(&ddata->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); ddata->timer.function = vibrator_timer_func; INIT_WORK(&ddata->work, vibrator_work); spin_lock_init(&ddata->lock); ddata->pwm = pwm_request(pdata->pwm_id, "vibrator"); if (IS_ERR(ddata->pwm)) { pr_err("[VIB] Failed to request pwm.\n"); error = -EFAULT; goto err_pwm_request; } pwm_config(ddata->pwm, ddata->pdata->period/2, ddata->pdata->period); vibetonz_clk_on(&pdev->dev, true); error = timed_output_dev_register(&ddata->dev); if (error < 0) { pr_err("[VIB] Failed to register timed_output : %d\n", error); error = -EFAULT; goto err_timed_output_register; } /* User controllable pwm level */ error = device_create_file(ddata->dev.dev, &dev_attr_pwm_value); if (error < 0) { pr_err("[VIB] create sysfs fail: pwm_value\n"); } #ifdef CONFIG_VIBETONZ g_data = ddata; pwm_duty_max = g_data->pdata->duty; pwm_duty_min = pwm_duty_max/2; pwm_duty = (pwm_duty_min + pwm_duty_max)/2; #endif return 0; err_timed_output_register: timed_output_dev_unregister(&ddata->dev); err_regulator_get: regulator_put(ddata->regulator); err_pwm_request: pwm_free(ddata->pwm); err_free_mem: kfree(ddata); return error; }
static int max77843_haptic_probe(struct platform_device *pdev) { int error = 0; struct max77843_dev *max77843 = dev_get_drvdata(pdev->dev.parent); struct max77843_platform_data *max77843_pdata = dev_get_platdata(max77843->dev); struct max77843_haptic_platform_data *pdata = max77843_pdata->haptic_data; struct max77843_haptic_data *hap_data; pr_info("[VIB] ++ %s\n", __func__); #if defined(CONFIG_OF) if (pdata == NULL) { pdata = of_max77843_haptic_dt(&pdev->dev); if (!pdata) { pr_err("[VIB] max77843-haptic : %s not found haptic dt!\n", __func__); return -1; } } #else if (pdata == NULL) { pr_err("%s: no pdata\n", __func__); return -ENODEV; } #endif /* CONFIG_OF */ hap_data = kzalloc(sizeof(struct max77843_haptic_data), GFP_KERNEL); if (!hap_data) { kfree(pdata); return -ENOMEM; } platform_set_drvdata(pdev, hap_data); g_hap_data = hap_data; hap_data->max77843 = max77843; hap_data->i2c = max77843->i2c; hap_data->pdata = pdata; hap_data->workqueue = create_singlethread_workqueue("hap_work"); if (NULL == hap_data->workqueue) { error = -EFAULT; pr_err("[VIB] Failed to create workqueue, err num: %d\n", error); goto err_work_queue; } INIT_WORK(&(hap_data->work), haptic_work); spin_lock_init(&(hap_data->lock)); hap_data->pwm = pwm_request(hap_data->pdata->pwm_id, "vibrator"); if (IS_ERR(hap_data->pwm)) { error = -EFAULT; pr_err("[VIB] Failed to request pwm, err num: %d\n", error); goto err_pwm_request; } pwm_config(hap_data->pwm, pdata->period / 2, pdata->period); vibetonz_clk_on(&pdev->dev, true); if (pdata->init_hw) pdata->init_hw(); else hap_data->regulator = regulator_get(NULL, pdata->regulator_name); if (IS_ERR(hap_data->regulator)) { error = -EFAULT; pr_err("[VIB] Failed to get vmoter regulator, err num: %d\n", error); goto err_regulator_get; } /* hrtimer init */ hrtimer_init(&hap_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hap_data->timer.function = haptic_timer_func; /* timed_output_dev init*/ hap_data->tout_dev.name = "vibrator"; hap_data->tout_dev.get_time = haptic_get_time; hap_data->tout_dev.enable = haptic_enable; hap_data->resumed = false; motor_dev = sec_device_create(hap_data, "motor"); if (IS_ERR(motor_dev)) { error = -ENODEV; pr_err("[VIB] Failed to create device\ for samsung specific motor, err num: %d\n", error); goto exit_sec_devices; } error = sysfs_create_group(&motor_dev->kobj, &sec_motor_attr_group); if (error) { error = -ENODEV; pr_err("[VIB] Failed to create sysfs group\ for samsung specific motor, err num: %d\n", error); goto exit_sysfs; } #ifdef CONFIG_ANDROID_TIMED_OUTPUT error = timed_output_dev_register(&hap_data->tout_dev); if (error < 0) { error = -EFAULT; pr_err("[VIB] Failed to register timed_output : %d\n", error); goto err_timed_output_register; } #endif pr_debug("[VIB] -- %s\n", __func__); return error; err_timed_output_register: sysfs_remove_group(&motor_dev->kobj, &sec_motor_attr_group); exit_sysfs: sec_device_destroy(motor_dev->devt); exit_sec_devices: regulator_put(hap_data->regulator); err_regulator_get: pwm_free(hap_data->pwm); err_pwm_request: destroy_workqueue(hap_data->workqueue); err_work_queue: kfree(hap_data); kfree(pdata); g_hap_data = NULL; return error; }
static __devinit int tspdrv_probe(struct platform_device *pdev) { struct vibrator_platform_data *pdata; int ret, i; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); /* This condition will be removed,after all board files changes done */ if (pdev->dev.platform_data == NULL) { DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, pdata is NULL"); return -EINVAL; } else { pdata = pdev->dev.platform_data; vibrator_drvdata.vib_model = pdata->vib_model; vibrator_drvdata.is_pmic_haptic_pwr_en = \ pdata->is_pmic_haptic_pwr_en; if (pdata->vib_model == HAPTIC_PWM) { if (pdata->is_pmic_vib_pwm) vibrator_drvdata.vib_pwm_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->vib_pwm_gpio); else vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio; } vibrator_drvdata.power_onoff = pdata->power_onoff; } #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nmajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nmajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); ret = g_nmajor; return ret; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); return ret; } #endif DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strlcat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, (VIBE_MAX_DEVICE_NAME_LENGTH+VERSION_STR_LEN)*NUM_ACTUATORS); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; }
static __devinit int tspdrv_probe(struct platform_device *pdev) { struct vibrator_platform_data *pdata; int ret, i; /* initialized below */ struct device *sec_vibetonz; DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); /* This condition will be removed,after all board files changes done */ if (unlikely(pdev->dev.platform_data == NULL)) { DbgOut((KERN_ERR "tspdrv: can't get platform data.\n")); ret = -ENODATA; goto platform_data_err; } else { pdata = pdev->dev.platform_data; vibrator_drvdata.vib_en_gpio = \ pdata->vib_en_gpio; vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio; vibrator_drvdata.vib_pwm_gpio = \ pdata->vib_pwm_gpio; g_nlra_gp_clk_PreDiv = pdata->vib_pwm_PreDiv; g_nlra_gp_clk_m = pdata->vib_pwm_M; g_nlra_gp_clk_n = pdata->vib_pwm_N; g_nlra_gp_clk_d = pdata->vib_pwm_D; } #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nmajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nmajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); ret = g_nmajor; goto register_err; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); goto register_err; } #endif DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strncat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, sizeof(szName)); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vib_clk = clk_get(&pdev->dev, "core_clk"); if (IS_ERR(vib_clk)) printk(KERN_INFO "[VIB] android vib clk failed!!!\n"); else printk(KERN_INFO "[VIB] android vib clk is successful\n"); sec_vibetonz = device_create(sec_class, NULL, 0, NULL, "sec_vibetonz"); device_create_file(sec_vibetonz, &dev_attr_MND_M); device_create_file(sec_vibetonz, &dev_attr_MND_N); device_create_file(sec_vibetonz, &dev_attr_MND_D); device_create_file(sec_vibetonz, &dev_attr_MND_P); device_create_file(sec_vibetonz, &dev_attr_MND_SET); device_create_file(sec_vibetonz, &dev_attr_MND_CLK); vibetonz_start(); return 0; register_err: #ifdef IMPLEMENT_AS_CHAR_DRIVER unregister_chrdev(g_nmajor, MODULE_NAME); #else misc_deregister(&miscdev); #endif platform_data_err: return ret; }
int init_module(void) { int nRet, i; /* initialized below */ nRet = 0; #ifdef IMPLEMENT_AS_CHAR_DRIVER printk(KERN_ERR "[VIBRATOR]IMPLEMENT_AS_CHAR_DRIVER\n"); g_nMajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nMajor < 0) { printk(KERN_ERR"[VIBRATOR]tspdrv: can't get major number.\n"); return g_nMajor; } #else nRet = misc_register(&miscdev); if (nRet) { printk(KERN_ERR "[VIBRATOR]tspdrv: misc_register failed.\n"); return nRet; } #endif nRet = platform_device_register(&platdev); if (nRet) { printk(KERN_ERR "tspdrv: platform_device_register failed.\n"); goto err_platform_dev_reg; } nRet = platform_driver_register(&platdrv); if (nRet) { printk(KERN_ERR "tspdrv: platform_driver_register failed.\n"); goto err_platform_drv_reg; } DbgRecorderInit(()); vibetonz_clk_on(&platdev.dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchDeviceName = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szDeviceName + g_cchDeviceName; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strcat(szName, VERSION_STR); g_cchDeviceName += strlen(szName); g_SamplesBuffer[i].nIndexPlayingBuffer = -1; /* Not playing */ g_SamplesBuffer[i].actuatorSamples[0].nBufferSize = 0; g_SamplesBuffer[i].actuatorSamples[1].nBufferSize = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); #ifdef CONFIG_FEATURE_TGS2 if (device_create_file(&platdev.dev, &dev_attr_vibrator_level_max) < 0) { printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_vibrator_level_max.attr.name); } if (device_create_file(&platdev.dev, &dev_attr_vibrator_level) < 0) { printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_vibrator_level.attr.name); } #endif return 0; err_platform_drv_reg: platform_device_unregister(&platdev); err_platform_dev_reg: #ifdef IMPLEMENT_AS_CHAR_DRIVER unregister_chrdev(g_nMajor, MODULE_NAME); #else misc_deregister(&miscdev); #endif return nRet; }
static int vibrator_suspend(struct platform_device *pdev, pm_message_t state) { vibetonz_clk_on(&pdev->dev, false); return 0; }
static int max77828_haptic_probe(struct platform_device *pdev) { int error = 0; struct max77828_dev *max77828 = dev_get_drvdata(pdev->dev.parent); struct max77828_platform_data *max77828_pdata = dev_get_platdata(max77828->dev); struct max77828_haptic_platform_data *pdata = max77828_pdata->haptic_data; struct max77828_haptic_data *hap_data; pr_info("[VIB] ++ %s\n", __func__); #if defined(CONFIG_OF) if (pdata == NULL) { pdata = of_max77828_haptic_dt(&pdev->dev); if (!pdata) { pr_err("[VIB] max77828-haptic : %s not found haptic dt!\n", __func__); return -1; } } #else if (pdata == NULL) { pr_err("%s: no pdata\n", __func__); return -ENODEV; } #endif /* CONFIG_OF */ hap_data = kzalloc(sizeof(struct max77828_haptic_data), GFP_KERNEL); if (!hap_data) return -ENOMEM; platform_set_drvdata(pdev, hap_data); g_hap_data = hap_data; hap_data->max77828 = max77828; hap_data->i2c = max77828->i2c; hap_data->pdata = pdata; hap_data->workqueue = create_singlethread_workqueue("hap_work"); INIT_WORK(&(hap_data->work), haptic_work); spin_lock_init(&(hap_data->lock)); hap_data->pwm = pwm_request(hap_data->pdata->pwm_id, "vibrator"); if (IS_ERR(hap_data->pwm)) { pr_err("[VIB] Failed to request pwm\n"); error = -EFAULT; goto err_pwm_request; } pwm_config(hap_data->pwm, pdata->period / 2, pdata->period); prev_duty = pdata->period / 2; vibetonz_clk_on(&pdev->dev, true); if (pdata->init_hw) pdata->init_hw(); else hap_data->regulator = regulator_get(NULL, pdata->regulator_name); if (IS_ERR(hap_data->regulator)) { pr_err("[VIB] Failed to get vmoter regulator.\n"); error = -EFAULT; goto err_regulator_get; } /* hrtimer init */ hrtimer_init(&hap_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hap_data->timer.function = haptic_timer_func; /* timed_output_dev init*/ hap_data->tout_dev.name = "vibrator"; hap_data->tout_dev.get_time = haptic_get_time; hap_data->tout_dev.enable = haptic_enable; #ifdef CONFIG_ANDROID_TIMED_OUTPUT error = timed_output_dev_register(&hap_data->tout_dev); if (error < 0) { pr_err("[VIB] Failed to register timed_output : %d\n", error); error = -EFAULT; goto err_timed_output_register; } #endif pr_debug("[VIB] -- %s\n", __func__); return error; err_timed_output_register: regulator_put(hap_data->regulator); err_regulator_get: pwm_free(hap_data->pwm); err_pwm_request: kfree(hap_data); g_hap_data = NULL; return error; }
static __devinit int tspdrv_probe(struct platform_device *pdev) { struct vibrator_platform_data *pdata; int ret, i; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); /* This condition will be removed,after all board files changes done */ if (pdev->dev.platform_data == NULL) { vibrator_drvdata.is_pmic_vib_en = 0; #if defined(CONFIG_MACH_M2_ATT) || defined(CONFIG_MACH_M2_VZW) || \ defined(CONFIG_MACH_M2_SPR) || defined(CONFIG_MACH_M2_DCM) || \ defined(CONFIG_MACH_M2_SKT) || defined(CONFIG_MACH_JAGUAR) || \ defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_COMANCHE) vibrator_drvdata.vib_pwm_gpio = GPIO_VIB_PWM; vibrator_drvdata.vib_en_gpio = GPIO_VIB_ON; vibrator_drvdata.haptic_pwr_en_gpio = GPIO_HAPTIC_PWR_EN; vibrator_drvdata.vib_model = HAPTIC_PWM; #endif #if defined(CONFIG_MACH_APEXQ) || defined(CONFIG_MACH_JASPER) || \ defined(CONFIG_MACH_GOGH) || defined(CONFIG_MACH_ESPRESSO_ATT) vibrator_drvdata.vib_pwm_gpio = GPIO_MOTOR_EN; vibrator_drvdata.vib_en_gpio = GPIO_MOTOR_EN; vibrator_drvdata.haptic_pwr_en_gpio = GPIO_MOTOR_EN; vibrator_drvdata.vib_model = HAPTIC_MOTOR; #endif #ifdef CONFIG_MACH_M2_ATT if (system_rev >= BOARD_REV04) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } if (system_rev >= BOARD_REV08) { vibrator_drvdata.haptic_pwr_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_HAPTIC_PWR_EN); vibrator_drvdata.is_pmic_haptic_pwr_en = 1; } #endif #ifdef CONFIG_MACH_M2_VZW if (system_rev >= BOARD_REV09) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_M2_SPR if (system_rev >= BOARD_REV03) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_M2_DCM if (system_rev >= BOARD_REV01) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_AEGIS2 if (system_rev >= BOARD_REV01) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif } else { pdata = pdev->dev.platform_data; vibrator_drvdata.vib_model = pdata->vib_model; vibrator_drvdata.is_pmic_haptic_pwr_en = \ pdata->is_pmic_haptic_pwr_en; if (pdata->is_pmic_haptic_pwr_en) vibrator_drvdata.haptic_pwr_en_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->haptic_pwr_en_gpio); else vibrator_drvdata.haptic_pwr_en_gpio = \ pdata->haptic_pwr_en_gpio; if (pdata->vib_model == HAPTIC_PWM) { vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio; vibrator_drvdata.is_pmic_vib_en = \ pdata->is_pmic_vib_en; if (pdata->is_pmic_vib_en) vibrator_drvdata.vib_en_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->vib_en_gpio); else vibrator_drvdata.vib_en_gpio = \ pdata->vib_en_gpio; } } #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nmajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nmajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); ret = g_nmajor; goto register_err; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); goto register_err; } #endif DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strncat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, sizeof(szName)); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; register_err: #ifdef IMPLEMENT_AS_CHAR_DRIVER unregister_chrdev(g_nmajor, MODULE_NAME); #else misc_deregister(&miscdev); #endif return ret; }
int init_module(void) { int nRet, i; /* initialized below */ nRet = 0; if (system_rev < 0x5){ pr_notice("%s : Vibrator not support HW Rev =[%d] !!!\n",__func__,system_rev); return 0; } DbgOut((KERN_INFO "tspdrv: init_module.\n")); #ifdef IMPLEMENT_AS_CHAR_DRIVER printk(KERN_ERR "[VIBRATOR]IMPLEMENT_AS_CHAR_DRIVER\n"); g_nMajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nMajor < 0) { printk(KERN_ERR"[VIBRATOR]tspdrv: can't get major number.\n"); return g_nMajor; } #else nRet = misc_register(&miscdev); if (nRet) { printk(KERN_ERR "[VIBRATOR]tspdrv: misc_register failed.\n"); return nRet; } #endif nRet = platform_device_register(&platdev); if (nRet) { printk(KERN_ERR "tspdrv: platform_device_register failed.\n"); goto err_platform_dev_reg; } nRet = platform_driver_register(&platdrv); if (nRet) { printk(KERN_ERR "tspdrv: platform_driver_register failed.\n"); goto err_platform_drv_reg; } DbgRecorderInit(()); vibetonz_clk_on(&platdev.dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchDeviceName = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szDeviceName + g_cchDeviceName; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strcat(szName, VERSION_STR); g_cchDeviceName += strlen(szName); g_SamplesBuffer[i].nIndexPlayingBuffer = -1; /* Not playing */ g_SamplesBuffer[i].actuatorSamples[0].nBufferSize = 0; g_SamplesBuffer[i].actuatorSamples[1].nBufferSize = 0; } return 0; err_platform_drv_reg: platform_device_unregister(&platdev); err_platform_dev_reg: #ifdef IMPLEMENT_AS_CHAR_DRIVER unregister_chrdev(g_nMajor, MODULE_NAME); #else misc_deregister(&miscdev); #endif return nRet; }