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;
}
