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 __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 */ DbgOut((KERN_INFO "tspdrv: init_module.\n")); nRet = misc_register(&miscdev); printk("[VIBETONZ:WJYOO] MISC_REGISTER nRet = %d\n", nRet); if (nRet) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); return nRet; } nRet = platform_device_register(&platdev); if (nRet) { DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n")); } //android_vib_clk = clk_get(NULL,"sfpb_clk"); android_vib_clk = clk_get_sys("vibrator","core_clk"); if(IS_ERR(android_vib_clk)) { printk("android vib clk failed!!!\n"); } else { printk("THNAK YOU!!\n"); } #if defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() > 0x00 ){ nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #elif defined (CONFIG_KOR_MODEL_SHV_E120L) || defined(CONFIG_KOR_MODEL_SHV_E120K) || defined(CONFIG_KOR_MODEL_SHV_E120S) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() > 0x04 ){ nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577) nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) { pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x01 ){ nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #endif DbgRecorderInit(()); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); isa1200_enabled = 1; platform_driver_register(&platdrv); /* 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; } vibetonz_start(); // wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); return 0; // return nRet; }
static int __devinit isa1200_vibrator_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int nRet, i,error; /* initialized below */ DbgOut((KERN_INFO "tspdrv: Probe called.\n")); motor_min_strength = g_nlra_gp_clk_n*MOTOR_MIN_STRENGTH/100; vibrator_drvdata.client = client; if(!(client->dev.of_node)){ DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL"); return -ENODEV; } error = isa1200_parse_dt(&client->dev); if (error) return error; gpio_request(vibrator_drvdata.motor_en, "MOTOR_EN"); gpio_direction_output(vibrator_drvdata.motor_en, 0); gpio_export(vibrator_drvdata.motor_en, 0); virt_mmss_gp1_base = ioremap(MSM_MMSS_GP1_BASE,0x28); if (!virt_mmss_gp1_base) panic("tspdrv : Unable to ioremap MSM_MMSS_GP1 memory!"); #if defined(CONFIG_MACH_MATISSE3G_OPEN) || defined CONFIG_SEC_MATISSELTE_COMMON vibrator_drvdata.power_onoff = haptic_power_onoff; #endif nRet = misc_register(&miscdev); if (nRet) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); iounmap(virt_mmss_gp1_base); return nRet; } DbgRecorderInit(()); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); isa1200_enabled = 1; 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; }
int init_module(void) { int nRet, i; /* initialized below */ DbgOut((KERN_DEBUG "tspdrv: init_module.\n")); #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")); } if (IS_ERR_OR_NULL(regulator_motor)) { regulator_motor = regulator_get(NULL, "vcc_motor"); if (IS_ERR_OR_NULL(regulator_motor)) { pr_err("failed to get motor regulator"); return -EINVAL; } } if(gpio_is_valid(VIB_EN)) { gpio_request(VIB_EN, "VIB_EN"); s3c_gpio_cfgpin(VIB_EN, 1); gpio_set_value(VIB_EN, 0); s3c_gpio_setpull(VIB_EN, S3C_GPIO_PULL_NONE); } if(gpio_is_valid(VIB_PWM)) { gpio_request(VIB_PWM, "VIB_PWM"); /* s3c_gpio_cfgpin(VIB_PWM, S5PV210_GPD_0_1_TOUT_1); */ s3c_gpio_cfgpin(VIB_PWM, S3C_GPIO_OUTPUT); gpio_set_value(VIB_PWM, 0); s3c_gpio_setpull(VIB_PWM, S3C_GPIO_PULL_NONE); gpio_free(VIB_PWM); } INIT_WORK(&work_timer, work_timer_func); 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 VIBE_TUNING // ---------- file creation at '/sys/class/vibetonz/immTest'------------------------------ vibetonz_class = class_create(THIS_MODULE, "vibetonz"); if (IS_ERR(vibetonz_class)) pr_err("Failed to create class(vibetonz)!\n"); immTest_test = device_create(vibetonz_class, NULL, 0, NULL, "immTest"); if (IS_ERR(immTest_test)) pr_err("Failed to create device(switch)!\n"); if (device_create_file(immTest_test, &dev_attr_immTest) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_immTest.attr.name); #if 0 if (device_create_file(immTest_test, &dev_attr_vib_period) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_vib_period.attr.name); #endif #endif vibetonz_start(); return 0; }
static void __init vibetonz_init(void) { vibetonz_start(); }
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; }
int init_module(void) { int nRet, i; /* initialized below */ int ret = 0; /*Initialising vibrator spin_lock and mutex_lock*/ spin_lock_init(&vib_spin_lock); mutex_init(&vib_mut_lock); DbgOut((KERN_INFO "tspdrv: init_module.\n")); #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")); } 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_wakelock,WAKE_LOCK_SUSPEND,"vib_wakelock"); #ifdef VIBE_TUNING // ---------- file creation at '/sys/class/vibetonz/immTest'------------------------------ vibetonz_class = class_create(THIS_MODULE, "vibetonz"); if (IS_ERR(vibetonz_class)) pr_err("Failed to create class(vibetonz)!\n"); immTest_test = device_create(vibetonz_class, NULL, 0, NULL, "immTest"); if (IS_ERR(immTest_test)) pr_err("Failed to create device(switch)!\n"); if (device_create_file(immTest_test, &dev_attr_immTest) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_immTest.attr.name); #endif if((ret=vibetonz_start()) < 0) printk("[VIBETONZ] vibetonz_start failed \n"); return 0; }
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; }
static int __devinit drv2604_vibrator_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int nRet, i,error; /* initialized below */ char status; #if SKIP_AUTOCAL == 0 int nCalibrationCount = 0; #endif DbgOut((KERN_INFO "tspdrv: Probe called.\n")); vibrator_drvdata.client = client; if(!(client->dev.of_node)){ DbgOut(KERN_ERR "tspdrv: tspdrv probe failed, DT is NULL"); return -ENODEV; } error = drv2604_parse_dt(&client->dev); if (error) return error; if( gpio_request(vibrator_drvdata.motor_en, "MOTOR_EN") < 0) { return -EINVAL; } gpio_direction_output(vibrator_drvdata.motor_en, 0); gpio_export(vibrator_drvdata.motor_en, 0); nRet = misc_register(&miscdev); if (nRet) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); return nRet; } #if USE_DRV2604_EN_PIN drv2604_set_en(true); #endif #if USE_DRV2604_STANDBY /* Wait 1000 us for chip power to stabilize */ usleep_range(100000, 100000); drv2604_change_mode(MODE_DEVICE_READY); #endif /* Wait 1000 us for chip power to stabilize */ usleep_range(1000, 1000); #if SKIP_AUTOCAL usleep_range(100000, 100000); drv2604_write_reg_val(init_sequence, sizeof(init_sequence)); status = drv2604_read_reg(STATUS_REG); #else /* Run auto-calibration */ do{ drv2604_write_reg_val(autocal_sequence, sizeof(autocal_sequence)); /* Wait until the procedure is done */ drv2604_poll_go_bit(); /* Read status */ status = drv2604_read_reg(STATUS_REG); nCalibrationCount++; } while (((status & DIAG_RESULT_MASK) == AUTO_CAL_FAILED) && (nCalibrationCount < MAX_AUTOCALIBRATION_ATTEMPT)); /* Check result */ if ((status & DIAG_RESULT_MASK) == AUTO_CAL_FAILED) { DbgOut((DBL_ERROR, "drv2604 auto-calibration failed after %d attempts.\n", nCalibrationCount)); } else { /* Read calibration results */ drv2604_read_reg(AUTO_CALI_RESULT_REG); drv2604_read_reg(AUTO_CALI_BACK_EMF_RESULT_REG); drv2604_read_reg(FEEDBACK_CONTROL_REG); } #endif /* Read device ID */ g_nDeviceID = (status & DEV_ID_MASK); switch (g_nDeviceID) { case DRV2605: DbgOut((DBL_INFO, "drv2604 driver found: drv2605.\n")); break; case DRV2604: DbgOut((DBL_INFO, "drv2604 driver found: drv2604.\n")); break; case DRV2604L: DbgOut((DBL_INFO, "drv2604 driver found: drv2604L.\n")); break; case DRV2605L: DbgOut((DBL_INFO, "drv2604 driver found: drv2605L.\n")); break; default: DbgOut((DBL_INFO, "drv2604 driver found: unknown.\n")); break; } #if USE_DRV2604_STANDBY /* Put hardware in standby */ drv2604_change_mode(MODE_STANDBY); #elif USE_DRV2604_EN_PIN /* enable RTP mode that will be toggled on/off with EN pin */ #endif #if USE_DRV2604_EN_PIN /* turn off chip */ drv2604_set_en(false); #endif DbgRecorderInit(()); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); ResetOutputData(); /* 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); } vibetonz_start(); return 0; }
static __devinit int tspdrv_tsp5000_probe(struct platform_device *pdev) { int ret = 0, i; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_tsp5000_probe.\n")); atomic_set(&g_nDebugLevel, DBL_ERROR); if(!pdev->dev.of_node){ DbgOut(KERN_ERR "tspdrv_tsp5000: tspdrv_tsp5000 probe failed, DT is NULL"); return -ENODEV; } ret = tspdrv_tsp5000_parse_dt(pdev); if(ret) return ret; vibrator_tsp5000_drvdata.power_onoff = 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")); return g_nMajor; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); goto fail; } #endif DbgRecorderInit(()); vibetonz_ts2665_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); ResetOutputData(); /* 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 */ strlcat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchDeviceName += strnlen(szName, sizeof(szName)); } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; fail: return ret; }
int init_module(void) { int nRet, i; /* initialized below */ static struct regulator *l3; int rc = 0; DbgOut((KERN_INFO "tspdrv: init_module.\n")); nRet = misc_register(&miscdev); printk("[VIBETONZ:WJYOO] MISC_REGISTER nRet = %d\n", nRet); if (nRet) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); return nRet; } nRet = platform_device_register(&platdev); if (nRet) { DbgOut((KERN_ERR "tspdrv: platform_device_register failed.\n")); } android_vib_clk = clk_get(NULL,"sfpb_clk"); if(IS_ERR(android_vib_clk)) { printk("android vib clk failed!!!\n"); } else { printk("THNAK YOU!!\n"); } #if defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() > 0x00 ){ nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #elif defined (CONFIG_KOR_MODEL_SHV_E120L) || defined(CONFIG_KOR_MODEL_SHV_E120K) || defined(CONFIG_KOR_MODEL_SHV_E120S) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() > 0x04 ){ nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_CAN_MODEL_SGH_I577R) || defined(CONFIG_CAN_MODEL_SGH_I757M) nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) { pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x01 ){ nRet = i2c_add_driver(&vibrator_i2c_driver); if (nRet) pr_err("%s: i2c_add_driver() failed err = %d\n", __func__, nRet); } #endif ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); platform_driver_register(&platdrv); isa1200_enabled = 1; /* 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 VIBE_TUNING // ---------- file creation at '/sys/class/vibetonz/immTest'------------------------------ vibetonz_class = class_create(THIS_MODULE, "vibetonz"); if (IS_ERR(vibetonz_class)) pr_err("Failed to create class(vibetonz)!\n"); immTest_test = device_create(vibetonz_class, NULL, 0, NULL, "immTest"); if (IS_ERR(immTest_test)) pr_err("Failed to create device(switch)!\n"); if (device_create_file(immTest_test, &dev_attr_immTest) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_immTest.attr.name); #endif vibetonz_start(); return 0; }