void touchkey_resume_func(struct work_struct *p) { // int err = 0; // int rc = 0; enable_irq(IRQ_TOUCHKEY_INT); touchkey_enable = 1; msleep(50); #if defined (CONFIG_USA_MODEL_SGH_T989)||defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_I717)\ || defined (CONFIG_USA_MODEL_SGH_T769) || defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_CAN_MODEL_SGH_I577R)\ || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I757M) touchkey_auto_calibration(1/*on*/); #elif defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() >= 0x02) touchkey_auto_calibration(1/*on*/); #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x02) touchkey_auto_calibration(1/*on*/); #endif #if 0 { // temporary code for touchkey led int int_data = 0x10; msleep(100); printk("[TKEY] i2c_touchkey_write : key backligh on\n"); i2c_touchkey_write((u8*)&int_data, 1); } #endif }
static void vibrator_hw_init(void) { #ifdef CONFIG_MACH_CORSICA_VE if(get_hw_rev() > 0x01) #else if(1) #endif return; else { sci_adi_write(ANA_VIBR_WR_PROT, VIBRATOR_REG_UNLOCK, 0xffff); #ifdef CONFIG_ARCH_SCX35 sci_adi_write(ANA_REG_GLB_RTC_CLK_EN, BIT_RTC_VIBR_EN, BIT_RTC_VIBR_EN); #else sci_adi_set(ANA_VIBRATOR_CTRL0, VIBR_RTC_EN); sci_adi_clr(ANA_VIBRATOR_CTRL0, VIBR_BP_EN); #endif /* set init current level */ sci_adi_write(ANA_VIBRATOR_CTRL0, (VIBRATOR_INIT_LEVEL << VIBR_INIT_V_SHIFT), VIBR_INIT_V_MSK); sci_adi_write(ANA_VIBRATOR_CTRL0, (VIBRATOR_STABLE_LEVEL << VIBR_STABLE_V_SHIFT), VIBR_STABLE_V_MSK); /* set stable current level */ sci_adi_write(ANA_VIBRATOR_CTRL1, VIBRATOR_INIT_STATE_CNT, 0xffff); sci_adi_write(ANA_VIBR_WR_PROT, VIBRATOR_REG_LOCK, 0xffff); } }
static void melfas_touchkey_early_resume(struct early_suspend *h) { set_touchkey_debug('R'); printk(KERN_DEBUG "[TKEY] melfas_touchkey_early_resume\n"); if (touchkey_enable < 0) { printk("[TKEY] %s touchkey_enable: %d\n", __FUNCTION__, touchkey_enable); return; } tkey_vdd_enable(1); gpio_request(GPIO_TOUCHKEY_SCL, "TKEY_SCL"); gpio_direction_input(GPIO_TOUCHKEY_SCL); gpio_request(GPIO_TOUCHKEY_SDA, "TKEY_SDA"); gpio_direction_input(GPIO_TOUCHKEY_SDA); init_hw(); if(touchled_cmd_reversed) { touchled_cmd_reversed = 0; msleep(100); if(!touchkey_enable ) touchkey_enable = 1; i2c_touchkey_write(&touchkey_led_status, 1); printk("[TKEY] LED RESERVED !! LED returned on touchkey_led_status = %d\n", touchkey_led_status); } if (get_hw_rev() >=0x02){ tkey_led_vdd_enable(1); } enable_irq(IRQ_TOUCHKEY_INT); touchkey_enable = 1; msleep(50); touchkey_auto_calibration(1/*on*/); }
// kmj_el15.pm8901_patch int pm8901_is_old_PCB_with_PM8901(void) { int rev; unsigned char retval=0; rev = get_hw_rev(); #if defined(CONFIG_KOR_MODEL_SHV_E110S) if( rev <= 8 ) retval = 1; else if( rev >=9 ) retval = 0; #elif defined(CONFIG_KOR_MODEL_SHV_E120S) if( rev <= 10 ) retval = 1; else if( rev >=11 ) retval = 0; #elif defined(CONFIG_KOR_MODEL_SHV_E120K) if( rev <= 10 ) retval = 1; else if( rev >=12 ) retval = 0; #elif defined(CONFIG_KOR_MODEL_SHV_E120L) if( rev <= 6 ) retval = 1; else if( rev >=7 ) retval = 0; #elif defined(CONFIG_KOR_MODEL_SHV_E160S) if( rev <= 10 ) retval = 1; else if( rev >=11 ) retval = 0; #elif defined(CONFIG_KOR_MODEL_SHV_E160K) if( rev <= 10 ) retval = 1; else if( rev >=11 ) retval = 0; #elif defined(CONFIG_KOR_MODEL_SHV_E160L) // TODO: change condition for 160L if( rev <= 9 ) retval = 1; else if( rev >=10 ) retval = 0; #elif defined(CONFIG_JPN_MODEL_SC_05D) if( rev <= 3 ) retval = 1; else if( rev >=4 ) retval = 0; #elif defined (CONFIG_USA_MODEL_SGH_I717) if( rev <= 11 ) retval = 1; else if( rev >=12 ) retval = 0; #endif return retval; }
static int sec_esd_probe(struct platform_device *pdev) { struct sec_esd_info *hi; struct sec_esd_platform_data *pdata = pdev->dev.platform_data; int ret; #if defined(CONFIG_KOR_MODEL_SHV_E160S) if( get_hw_rev() < 0x05 ){ DPRINT( "%s : Esd driver END (HW REV < 05)\n", __func__); return 0; } #endif DPRINT( "%s : Registering esd driver\n", __func__); if (!pdata) { DPRINT("%s : pdata is NULL.\n", __func__); return -ENODEV; } hi = kzalloc(sizeof(struct sec_esd_info), GFP_KERNEL); if (hi == NULL) { DPRINT("%s : Failed to allocate memory.\n", __func__); return -ENOMEM; } p_sec_esd_info = hi; hi->pdata = pdata; hi->esd_cnt = 0; hi->esd_ignore = FALSE; wake_lock_init(&hi->det_wake_lock, WAKE_LOCK_SUSPEND, "sec_mipi_lcd_esd_det"); INIT_WORK(&hi->det_work, sec_esd_work_func); ret = request_threaded_irq(pdata->esd_int, NULL, sec_esd_irq_handler, // IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "esd_detect", hi); if (ret) { pr_err("%s : Failed to request_irq.\n", __func__); goto err_request_detect_irq; } dev_set_drvdata(&pdev->dev, hi); return 0; #if 0 err_enable_irq_wake: free_irq(pdata->esd_int, hi); #endif err_request_detect_irq: wake_lock_destroy(&hi->det_wake_lock); kfree(hi); return ret; }
void __init exynos4_smdk4270_modem_init(void) { /* It is possible to change modem by changing platform data */ exynos4_device_modem.dev.platform_data = &carmen_modem_pdata; pr_debug("[Modem] modem initialization.\n"); carmen_modem_pdata.package_id = get_package_id(); carmen_modem_pdata.hw_revision = get_hw_rev(); platform_device_register(&exynos4_device_modem); }
static ssize_t akmd_read(struct file *file, char __user *buf, size_t count, loff_t *pos) { struct akm8975_data *akm = container_of(file->private_data, struct akm8975_data, akmd_device); short x = 0, y = 0, z = 0; #if defined (CONFIG_EUR_MODEL_GT_I9210) short tmp = 0; #endif int ret; u8 data[8]; mutex_lock(&akm->lock); ret = akm8975_ecs_set_mode(akm, AK8975_MODE_SNG_MEASURE); if (ret) { mutex_unlock(&akm->lock); goto done; } ret = akm8975_wait_for_data_ready(akm); if (ret) { mutex_unlock(&akm->lock); goto done; } ret = i2c_smbus_read_i2c_block_data(akm->this_client, AK8975_REG_ST1, sizeof(data), data); mutex_unlock(&akm->lock); if (ret != sizeof(data)) { pr_err("%s: failed to read %d bytes of mag data\n", __func__, sizeof(data)); goto done; } if (data[0] & 0x01) { x = (data[2] << 8) + data[1]; y = (data[4] << 8) + data[3]; z = (data[6] << 8) + data[5]; #if defined (CONFIG_EUR_MODEL_GT_I9210) if (get_hw_rev() >= 6 ) { tmp = x; x = y; y = tmp; } #endif } else pr_err("%s: invalid raw data(st1 = %d)\n", __func__, data[0] & 0x01); done: return sprintf(buf, "%d,%d,%d\n", x, y, z); }
int checkboard(void) { char str[32]; puts("Board: esd ARM9 HMI Panel - OTC570"); if (getenv_r("serial#", str, sizeof(str)) > 0) { puts(", serial# "); puts(str); } printf("\nHardware-revision: 1.%d\n", get_hw_rev()); printf("Mach-type: %lu\n", gd->bd->bi_arch_number); return 0; }
static void init_offset_tables(void) { short hand, rotate; if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) { printk("[E-PEN] Use 4.4mm pitch Offset tables\n"); }else { printk("[E-PEN] Use 4.8mm pitch Offset tables\n"); origin_offset[0] = origin_offset_48[0]; origin_offset[1] = origin_offset_48[1]; for( hand = 0 ; hand < 2 ; ++hand) { for( rotate = 0 ; rotate < 3 ; ++rotate) { tableX[hand][rotate] = tableX_48[hand][rotate]; tableY[hand][rotate] = tableY_48[hand][rotate]; tilt_offsetX[hand][rotate] = tilt_offsetX_48[hand][rotate]; tilt_offsetY[hand][rotate] = tilt_offsetY_48[hand][rotate]; } } } }
static int update_hw_spec_par(void) { hw_rev_t rev; if(get_hw_rev(&rev)<0){ return -1; } switch(rev){ case eHwRevC: g_spectr_fpga_adc_max_v=c_spectr_fpga_adc_max_v_revC; break; case eHwRevD: g_spectr_fpga_adc_max_v=c_spectr_fpga_adc_max_v_revD; break; default: return -1; break; } return 0; }
static void set_vibrator(int on) { #ifdef CONFIG_MACH_CORSICA_VE if(get_hw_rev() > 0x01) #else if(1) #endif { if (on) { printk("###############vibrator on##################\n"); sci_adi_write(ANA_REG_GLB_BA_CTRL3, 0x1,0xffff); sci_adi_write(ANA_REG_GLB_BA_CTRL2, 0x3ad2,0xffff); sci_adi_write(ANA_REG_GLB_BA_CTRL3,0x2,0xffff); } else { printk("###############vibrator off##################\n"); sci_adi_write(ANA_REG_GLB_BA_CTRL2, 0x3bd2,0xffff); } } else { /* unlock vibrator registor */ sci_adi_write(ANA_VIBR_WR_PROT, VIBRATOR_REG_UNLOCK, 0xffff); #ifdef CONFIG_ARCH_SCX35 if (on) sci_adi_write(ANA_VIBRATOR_CTRL0, BIT_VIBR_PON, BIT_VIBR_PON); else sci_adi_write(ANA_VIBRATOR_CTRL0, 0, BIT_VIBR_PON); #else sci_adi_clr(ANA_VIBRATOR_CTRL0, VIBR_PD_SET | VIBR_PD_RST); if (on) sci_adi_set(ANA_VIBRATOR_CTRL0, VIBR_PD_RST); else sci_adi_set(ANA_VIBRATOR_CTRL0, VIBR_PD_SET); #endif /* lock vibrator registor */ sci_adi_write(ANA_VIBR_WR_PROT, VIBRATOR_REG_LOCK, 0xffff); } }
void lcd_show_board_info(void) { ulong dram_size, nand_size; int i; char temp[32]; dram_size = 0; for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) dram_size += gd->bd->bi_dram[i].size; nand_size = 0; for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) nand_size += nand_info[i].size; lcd_printf("\n%s\n", U_BOOT_VERSION); lcd_printf("CPU at %s MHz\n", strmhz(temp, get_cpu_clk_rate())); lcd_printf(" %ld MB SDRAM, %ld MB NAND\n", dram_size >> 20, nand_size >> 20 ); lcd_printf(" Board : esd ARM9 HMI Panel - OTC570\n"); lcd_printf(" Hardware-revision: 1.%d\n", get_hw_rev()); lcd_printf(" Mach-type : %lu\n", gd->bd->bi_arch_number); }
static void star_panel_early_suspend(struct early_suspend *h) { if (num_registered_fb > 0) { printk("calling %s !\n", __func__); gpio_set_value(star_bl_enb, 0); msleep(500); gpio_set_value(star_lvds_shutdown, 0); msleep(1); mutex_lock(&v3_3_control); is_early_suspend = 1; mutex_unlock(&v3_3_control); if (get_hw_rev() >= REV_F) { disable_irq(gpio_to_irq(star_hdmi_hpd)); gpio_set_value(star_panel_enb, 0); printk("v3.3 off in %s !\n", __func__); tegra_panel_hdmi_earlysuspend(); } fb_blank(registered_fb[0], FB_BLANK_POWERDOWN); } printk("leaving %s !\n", __func__); }
static void star_panel_late_resume(struct early_suspend *h) { if (num_registered_fb > 0) { printk("calling %s !\n", __func__); tegra_panel_cancel_early_work(); if (get_hw_rev() >= REV_F) { gpio_set_value(star_panel_enb, 1); printk("v3.3 on in %s !\n", __func__); } mutex_lock(&v3_3_control); is_early_suspend = 0; mutex_unlock(&v3_3_control); fb_blank(registered_fb[0], FB_BLANK_UNBLANK); msleep(1); gpio_set_value(star_lvds_shutdown, 1); msleep(200); gpio_set_value(star_bl_enb, 1); tegra_panel_hdmi_detect(); } printk("leaving %s !\n", __func__); }
int checkboard(void) { char str[32]; u_char hw_type; /* hardware type */ /* read the "Type" register of the ET1100 controller */ hw_type = readb(CONFIG_ET1100_BASE); switch (hw_type) { case 0x11: case 0x3F: /* ET1100 present, arch number of MEESC-Board */ gd->bd->bi_arch_number = MACH_TYPE_MEESC; puts("Board: CAN-EtherCAT Gateway"); break; case 0xFF: /* no ET1100 present, arch number of EtherCAN/2-Board */ gd->bd->bi_arch_number = MACH_TYPE_ETHERCAN2; puts("Board: EtherCAN/2 Gateway"); /* switch on LED1D */ at91_set_gpio_output(AT91_PIN_PB12, 1); break; default: /* assume, no ET1100 present, arch number of EtherCAN/2-Board */ gd->bd->bi_arch_number = MACH_TYPE_ETHERCAN2; printf("ERROR! Read invalid hw_type: %02X\n", hw_type); puts("Board: EtherCAN/2 Gateway"); break; } if (getenv_r("serial#", str, sizeof(str)) > 0) { puts(", serial# "); puts(str); } printf("\nHardware-revision: 1.%d\n", get_hw_rev()); printf("Mach-type: %lu\n", gd->bd->bi_arch_number); return 0; }
static int suspend(struct platform_device *pdev, pm_message_t state) { int ret; if (g_bIsPlaying) { ret = -EBUSY; } else { DbgOut((KERN_INFO "tspdrv: suspend.\n")); #if defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() > 0x00){ if(isa1200_enabled){ vibrator_write_register(0x30, 0x09); gpio_set_value(VIB_EN, VIBRATION_OFF); isa1200_enabled = 0; } printk(KERN_ERR "[VIBTONZ] isa1200_early_suspend \n"); } #elif defined (CONFIG_KOR_SHV_E120L_HD720) || 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) || defined (CONFIG_KOR_MODEL_SHV_E120L) if(isa1200_enabled){ vibrator_write_register(0x30, 0x09); gpio_set_value(VIB_EN, VIBRATION_OFF); isa1200_enabled = 0; } printk(KERN_ERR "[VIBTONZ] isa1200_early_suspend \n"); #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() > 0x04){ if(isa1200_enabled){ vibrator_write_register(0x30, 0x09); gpio_set_value(VIB_EN, VIBRATION_OFF); isa1200_enabled = 0; } printk(KERN_ERR "[VIBTONZ] isa1200_early_suspend \n"); } #elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577) if(isa1200_enabled){ vibrator_write_register(0x30, 0x09); gpio_set_value(VIB_EN, VIBRATION_OFF); isa1200_enabled = 0; } printk(KERN_ERR "[VIBTONZ] isa1200_early_suspend \n"); #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() > 0x00){ if(isa1200_enabled){ vibrator_write_register(0x30, 0x09); gpio_set_value(VIB_EN, VIBRATION_OFF); isa1200_enabled = 0; } printk(KERN_ERR "[VIBTONZ] isa1200_early_suspend \n"); } #endif } return 0; }
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 set_vibetonz(int timeout) { if(!timeout) { printk("[VIBETONZ] DISABLE\n"); #if defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() > 0x00 ){ vib_isa1200_onoff(0); vibtonz_en(0); } else { gpio_set_value(VIB_EN, VIBRATION_OFF); } #elif defined (CONFIG_KOR_SHV_E120L_HD720) || 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) || defined (CONFIG_KOR_MODEL_SHV_E120L) vib_isa1200_onoff(0); vibtonz_en(0); #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() > 0x04 ){ vib_isa1200_onoff(0); vibtonz_en(0); } else { gpio_set_value(VIB_EN, VIBRATION_OFF); } #elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577) vib_isa1200_onoff(0); vibtonz_en(0); #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() > 0x00 ){ vib_isa1200_onoff(0); vibtonz_en(0); } else { gpio_set_value(VIB_EN, VIBRATION_OFF); } #else gpio_set_value(VIB_EN, VIBRATION_OFF); #endif } else { printk("[VIBETONZ] ENABLE\n"); #if defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() > 0x00 ){ vibtonz_en(1); vibe_set_pwm_freq(258); vib_isa1200_onoff(1); } else { gpio_set_value(VIB_EN, VIBRATION_ON); } #elif defined (CONFIG_KOR_SHV_E120L_HD720) || 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) || defined (CONFIG_KOR_MODEL_SHV_E120L) vibtonz_en(1); vibe_set_pwm_freq(258); vib_isa1200_onoff(1); #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() > 0x04 ){ vibtonz_en(1); vibe_set_pwm_freq(258); vib_isa1200_onoff(1); } else { gpio_set_value(VIB_EN, VIBRATION_ON); } #elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_USA_MODEL_SGH_I577) vibtonz_en(1); vibe_set_pwm_freq(258); vib_isa1200_onoff(1); #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() > 0x00 ){ vibtonz_en(1); vibe_set_pwm_freq(258); vib_isa1200_onoff(1); } else { gpio_set_value(VIB_EN, VIBRATION_ON); } #else gpio_set_value(VIB_EN, VIBRATION_ON); #endif } vibrator_value = timeout; return 0; }
int akm8975_probe(struct i2c_client *client, const struct i2c_device_id *devid) { struct akm8975_data *akm; int err; struct akm8975_platform_data *pdata = client->dev.platform_data; printk("ak8975 probe start!\n"); if (pdata == NULL) { dev_err(&client->dev, "platform data is NULL. exiting.\n"); err = -ENODEV; goto exit_platform_data_null; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "I2C check failed, exiting.\n"); err = -ENODEV; goto exit_check_functionality_failed; } akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL); if (!akm) { dev_err(&client->dev, "failed to allocate memory for module data\n"); err = -ENOMEM; goto exit_alloc_data_failed; } akm->pdata = pdata; if(pdata->power_on) akm->power_on = pdata->power_on; if(pdata->power_off) akm->power_off = pdata->power_off; #if defined (CONFIG_KOR_MODEL_SHV_E110S) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) || defined(CONFIG_EUR_MODEL_GT_I9210) \ || defined(CONFIG_USA_MODEL_SGH_I577) #if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev() >= 0x04 ) { #elif defined(CONFIG_USA_MODEL_SGH_I577) if (get_hw_rev() >= 0x06 ) { #else if (get_hw_rev() >= 0x08 ) { #endif /* For Magnetic sensor POR condition */ if(pdata->power_on_mag) pdata->power_on_mag(); msleep(1); if(pdata->power_off_mag) pdata->power_off_mag(); msleep(10); /* For Magnetic sensor POR condition */ } #endif #if defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev() >= 0x5) { /* For Magnetic sensor POR condition */ if(pdata->power_on_mag) pdata->power_on_mag(); msleep(1); if(pdata->power_off_mag) pdata->power_off_mag(); msleep(10); /* For Magnetic sensor POR condition */ } #endif if(akm->power_on) akm->power_on(); mutex_init(&akm->lock); init_completion(&akm->data_ready); i2c_set_clientdata(client, akm); akm->this_client = client; err = akm8975_ecs_set_mode_power_down(akm); if (err < 0) goto exit_set_mode_power_down_failed; err = akm8975_setup_irq(akm); if (err) { pr_err("%s: could not setup irq\n", __func__); goto exit_setup_irq; } akm->akmd_device.minor = MISC_DYNAMIC_MINOR; akm->akmd_device.name = "akm8975"; akm->akmd_device.fops = &akmd_fops; err = misc_register(&akm->akmd_device); if (err) goto exit_akmd_device_register_failed; #if defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I577R) || defined(CONFIG_CAN_MODEL_SGH_I757M) /* creating class/device for test */ akm->akm8975_class = class_create(THIS_MODULE, "magnetometer"); if(IS_ERR(akm->akm8975_class)) { pr_err("%s: class create failed(magnetometer)\n", __func__); err = PTR_ERR(akm->akm8975_class); goto exit_class_create_failed; } akm->akm8975_dev = device_create(akm->akm8975_class, NULL, 0, "%s", "magnetometer"); if(IS_ERR(akm->akm8975_dev)) { pr_err("%s: device create failed(magnetometer)\n", __func__); err = PTR_ERR(akm->akm8975_dev); goto exit_device_create_failed; } err = device_create_file(akm->akm8975_dev, &dev_attr_raw_data); if (err < 0) { pr_err("%s: failed to create device file(%s)\n", __func__, dev_attr_raw_data.attr.name); goto exit_device_create_file_failed; } dev_set_drvdata(akm->akm8975_dev, akm); #endif init_waitqueue_head(&akm->state_wq); printk("ak8975 probe success!\n"); return 0; #if defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I577R) || defined(CONFIG_CAN_MODEL_SGH_I757M) exit_device_create_file_failed: device_destroy(akm->akm8975_class, 0); exit_device_create_failed: class_destroy(akm->akm8975_class); exit_class_create_failed: misc_deregister(&akm->akmd_device); #endif exit_akmd_device_register_failed: free_irq(akm->irq, akm); // gpio_free(akm->pdata->gpio_data_ready_int); exit_setup_irq: exit_set_mode_power_down_failed: if(akm->power_off) akm->power_off(); mutex_destroy(&akm->lock); kfree(akm); exit_alloc_data_failed: exit_check_functionality_failed: exit_platform_data_null: return err; } static int __devexit akm8975_remove(struct i2c_client *client) { struct akm8975_data *akm = i2c_get_clientdata(client); misc_deregister(&akm->akmd_device); free_irq(akm->irq, akm); // gpio_free(akm->pdata->gpio_data_ready_int); mutex_destroy(&akm->lock); kfree(akm); return 0; } static const struct i2c_device_id akm8975_id[] = { {AKM8975_I2C_NAME, 0 }, { } }; static struct i2c_driver akm8975_driver = { .probe = akm8975_probe, .remove = akm8975_remove, .id_table = akm8975_id, .driver = { .pm = &akm8975_pm_ops, .name = AKM8975_I2C_NAME, }, }; #ifdef CONFIG_BATTERY_SEC extern unsigned int is_lpcharging_state(void); #endif static int __init akm8975_init(void) { #ifdef CONFIG_BATTERY_SEC if (is_lpcharging_state()) { pr_info("%s : LPM Charging Mode! return 0\n", __func__); return 0; } #endif return i2c_add_driver(&akm8975_driver); } static void __exit akm8975_exit(void) { i2c_del_driver(&akm8975_driver); } module_init(akm8975_init); module_exit(akm8975_exit); MODULE_DESCRIPTION("AKM8975 compass driver"); MODULE_LICENSE("GPL");
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; }
static irqreturn_t touchkey_interrupt(int irq, void *dummy) // ks 79 - threaded irq(becuase of pmic gpio int pin)-> when reg is read in work_func, data0 is always release. so temporarily move the work_func to threaded irq. { u8 data[3]; int ret; int retry = 10; set_touchkey_debug('I'); disable_irq_nosync(IRQ_TOUCHKEY_INT); tkey_vdd_enable(1); set_touchkey_debug('a'); ret = i2c_touchkey_read(KEYCODE_REG, data, 1); if(g_debug_switch) printk("[TKEY] DATA0 %d\n", data[0]); if (get_hw_rev() <= 0x04){ if (data[0] > 80) { data[0] = data[0] - 80; printk("[TKEY] DATA0 change [%d] \n", data[0]); } } set_touchkey_debug(data[0]); if ((data[0] & ESD_STATE_BIT) || (ret != 0)) { printk("[TKEY] ESD_STATE_BIT set or I2C fail: data: %d, retry: %d\n", data[0], retry); //releae key input_report_key(touchkey_driver->input_dev, touchkey_keycode[1], 0); input_report_key(touchkey_driver->input_dev, touchkey_keycode[2], 0); retry = 10; while (retry--) { mdelay(300); init_hw(); if (i2c_touchkey_read(KEYCODE_REG, data, 3) >= 0) { printk("[TKEY] %s touchkey init success\n", __func__); set_touchkey_debug('O'); enable_irq(IRQ_TOUCHKEY_INT); return IRQ_NONE; } printk("[TKEY] %s %d i2c transfer error retry = %d\n", __func__, __LINE__, retry); } //touchkey die , do not enable touchkey //enable_irq(IRQ_TOUCH_INT); touchkey_enable = -1; printk("[TKEY] %s touchkey died\n", __func__); set_touchkey_debug('D'); return IRQ_NONE; } if (data[0] & UPDOWN_EVENT_BIT) { if(press_check == touchkey_keycode[data[0] & KEYCODE_BIT]){ input_report_key(touchkey_driver->input_dev, touchkey_keycode[data[0] & KEYCODE_BIT], 0); touchkey_pressed &= ~(1 << (data[0] & KEYCODE_BIT)); input_sync(touchkey_driver->input_dev); if(g_debug_switch) printk(KERN_DEBUG "touchkey release keycode:%d \n", touchkey_keycode[data[0] & KEYCODE_BIT]); }else{ input_report_key(touchkey_driver->input_dev, press_check, 0); } press_check = 0; } else { if (touch_is_pressed) { printk(KERN_DEBUG "touchkey pressed but don't send event because touch is pressed. \n"); set_touchkey_debug('P'); } else { if ((data[0] & KEYCODE_BIT) == 2) { // if back key is pressed, release multitouch } input_report_key(touchkey_driver->input_dev, touchkey_keycode[data[0] & KEYCODE_BIT], 1); touchkey_pressed |= (1 << (data[0] & KEYCODE_BIT)); input_sync(touchkey_driver->input_dev); press_check = touchkey_keycode[data[0] & KEYCODE_BIT]; if(g_debug_switch) printk(KERN_DEBUG "touchkey press keycode:%d \n", touchkey_keycode[data[0] & KEYCODE_BIT]); } } set_touchkey_debug('A'); enable_irq(IRQ_TOUCHKEY_INT); //queue_work(touchkey_wq, &touchkey_work); return IRQ_HANDLED; }
int sub_cam_ldo_power(int onoff) { int ret = 0; printk("%s: %d\n", __func__, onoff); if(onoff) { // power on cam_mclk_onoff(OFF); mdelay(5); //ISP CORE 1.2V i_core12 = regulator_get(NULL, "8901_s2"); //CORE 1.2V if (IS_ERR(i_core12)) goto sub_cam_power_fail; #if defined (CONFIG_JPN_MODEL_SC_03D) ret = regulator_set_voltage(i_core12, 1300000, 1300000); #else ret = regulator_set_voltage(i_core12, 1200000, 1200000); #endif if (ret) { printk("%s: i_core12 error setting voltage\n", __func__); } ret = regulator_enable(i_core12); if (ret) { printk("%s: i_core12 error enabling regulator\n", __func__); } mdelay(2); //SENSOR A2.8V gpio_set_value_cansleep(CAM_IO_EN, HIGH); mdelay(1); //min 20us //DVDD 1.5V (sub) #if defined (CONFIG_USA_MODEL_SGH_T989) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() >= 0x09) vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() >= 0x05) //celox_REV05 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) if (get_hw_rev() >= 0x06) //daliS_REV03 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev() >= 0x02) //QuincyS_REV02 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_KOR_MODEL_SHV_E120L) if (get_hw_rev() >= 0x02) //dali LGT REV02 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev() >= 0x01) //Q1_REV01 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev() >= 0x08) vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x05) vt_core15 = regulator_get(NULL, "8058_l24"); else #endif { printk("DVDD1.5V : 8058_l10\n"); vt_core15 = regulator_get(NULL, "8058_l10"); } if (IS_ERR(vt_core15)) goto sub_cam_power_fail; ret = regulator_set_voltage(vt_core15, 1500000, 1500000); if (ret) { printk("%s:vt_core15 error setting voltage\n", __func__); } ret = regulator_enable(vt_core15); if (ret) { printk("%s:vt_core15 error enabling regulator\n", __func__); } udelay(50); //min 15us //HOST 1.8V #if defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x02) i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_KOR_MODEL_SHV_E110S) || defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) if (get_hw_rev() >= 0x04) i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev() >= 0x02) i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_KOR_MODEL_SHV_E120L) if (get_hw_rev() >= 0x02) //dali LGT REV02 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev()>=0x01) //Q1_REV01 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev()>=0x06) //celox_REV06 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev()>=0x0D) //Hercules_rev06 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #endif { printk("Host1.8V : 8058_l8\n"); i_host18 = regulator_get(NULL, "8058_l8"); if (IS_ERR(i_host18)) goto sub_cam_power_fail; ret = regulator_set_voltage(i_host18, 1800000, 1800000); if (ret) { printk("%s:i_host18 error setting voltage\n", __func__); } } if (IS_ERR(i_host18)) goto sub_cam_power_fail; ret = regulator_enable(i_host18); if (ret) { printk("%s: i_host18 error enabling regulator\n", __func__); } mdelay(1); #if !defined (CONFIG_KOR_MODEL_SHV_E120L) //SENSOR IO 1.8V - ISP //i2c #if defined (CONFIG_KOR_MODEL_SHV_E110S) || defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) if (get_hw_rev()< 0x5) //celoxS_REV03, DaliS_REV02 #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev()< 0x2) //celoxS_REV03, DaliS_REV02 #elif defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev()< 0x01) //Q1_REV01 #elif defined (CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev()< 0x06) //celoxS_REV06 #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev()< 0x0D) //Hercules_rev06 #endif { s_io18 = regulator_get(NULL, "8058_lvs0"); if (IS_ERR(s_io18)) goto sub_cam_power_fail; ret = regulator_enable(s_io18); if (ret) { printk("%s:s_io18 error enabling regulator\n", __func__); } mdelay(1); } #endif gpio_set_value_cansleep(CAM_VGA_EN, HIGH); // STBY mdelay(2); //udelay(50); cam_mclk_onoff(ON); mdelay(1); // min50us } else { //off cam_mclk_onoff(OFF);// Disable MCLK mdelay(2); //udelay(50); gpio_set_value_cansleep(CAM_VGA_EN, LOW); mdelay(1); //SENSOR IO 1.8V - ISP #if !defined (CONFIG_KOR_MODEL_SHV_E120L) //SENSOR IO 1.8V - ISP //i2c #if defined (CONFIG_KOR_MODEL_SHV_E110S) || defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) if (get_hw_rev()< 0x5) //celoxS_REV03, DaliS_REV02 #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev()< 0x2) //celoxS_REV03, DaliS_REV02 #elif defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev()< 0x01) //Q1_REV01 #elif defined (CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev()< 0x06) //celoxS_REV06 #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev()< 0x0D) //Hercules_rev06 #endif { if (regulator_is_enabled(s_io18)) { ret = regulator_disable(s_io18); if (ret) { printk("%s: s_io18 error disabling regulator\n", __func__); } //regulator_put(lvs0); } mdelay(1); } #endif //HOST 1.8V if (regulator_is_enabled(i_host18)) { ret=regulator_disable(i_host18); if (ret) { printk("%s:i_host18 error disabling regulator\n", __func__); } //regulator_put(l8); } mdelay(1); //DVDD 1.5V (sub) if (regulator_is_enabled(vt_core15)) { ret=regulator_disable(vt_core15); if (ret) { printk("%s:vt_core15 error disabling regulator\n", __func__); } //regulator_put(l24); } mdelay(1); //SENSOR A2.8V gpio_set_value_cansleep(CAM_IO_EN, LOW); //HOST 1.8V mdelay(1); //ISP CORE 1.2V if (regulator_is_enabled(i_core12)) { ret=regulator_disable(i_core12); if (ret) { printk("%s:i_core12 error disabling regulator\n", __func__); } //regulator_put(s2); } mdelay(5); } return ret; sub_cam_power_fail: return -1; }
static int wacom_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct wacom_i2c *wac_i2c; struct wacom_g5_platform_data *pdata = client->dev.platform_data; int i, ret; i = ret = 0; printk(KERN_DEBUG "[E-PEN]:%s:\n", __func__); /*Check I2C functionality*/ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) goto err3; /*Obtain kernel memory space for wacom i2c*/ wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL); if (wac_i2c == NULL) goto fail; wac_i2c->wac_feature = &wacom_feature_EMR; pdata->init_platform_hw(); /*Initializing for semaphor*/ mutex_init(&wac_i2c->lock); /*Register platform data*/ wac_i2c->wac_pdata = client->dev.platform_data; /*Register callbacks*/ wac_i2c->callbacks.check_prox = wacom_check_emr_prox; if (wac_i2c->wac_pdata->register_cb) wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks); /*Register wacom i2c to input device*/ wac_i2c->input_dev = input_allocate_device(); if (wac_i2c == NULL || wac_i2c->input_dev == NULL) goto fail; wacom_i2c_set_input_values(client, wac_i2c, wac_i2c->input_dev); wac_i2c->client = client; wac_i2c->irq = client->irq; /*Change below if irq is needed*/ wac_i2c->irq_flag = 1; #ifdef CONFIG_HAS_EARLYSUSPEND wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend; wac_i2c->early_suspend.resume = wacom_i2c_late_resume; register_early_suspend(&wac_i2c->early_suspend); #endif /*Init Featreus by hw rev*/ #if defined(CONFIG_USA_MODEL_SGH_I717) if( get_hw_rev() == 0x01 ) { printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = 0x340; Binary = Binary_44; } else if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) { printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = Firmware_version_of_file_44; Binary = Binary_44; } #else if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) { printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = Firmware_version_of_file_44; Binary = Binary_44; } else { printk("[E-PEN] Wacom driver is working for 4.8mm pitch pad.\n"); /* Firmware Feature */ Firmware_version_of_file = Firmware_version_of_file_48; Binary = Binary_48; } #endif init_offset_tables(); INIT_WORK(&wac_i2c->update_work, update_work_func); INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work); /* Reset IC */ gpio_set_value(GPIO_PEN_RESET, 0); msleep(200); gpio_set_value(GPIO_PEN_RESET, 1); msleep(200); ret = wacom_i2c_query(wac_i2c); if( ret < 0 ) epen_reset_result = false; else epen_reset_result = true; input_set_abs_params(wac_i2c->input_dev, ABS_X, pdata->min_x, pdata->max_x, 4, 0); input_set_abs_params(wac_i2c->input_dev, ABS_Y, pdata->min_y, pdata->max_y, 4, 0); input_set_abs_params(wac_i2c->input_dev, ABS_PRESSURE, pdata->min_pressure, pdata->max_pressure, 0, 0); input_set_drvdata(wac_i2c->input_dev, wac_i2c); /*Set client data*/ i2c_set_clientdata(client, wac_i2c); /*Before registering input device, data in each input_dev must be set*/ if (input_register_device(wac_i2c->input_dev)) goto err2; g_client = client; /* if(wac_i2c->irq_flag) */ /* disable_irq(wac_i2c->irq); */ sec_epen= device_create(sec_class, NULL, 0, NULL, "sec_epen"); dev_set_drvdata(sec_epen, wac_i2c); if (IS_ERR(sec_epen)) printk(KERN_ERR "Failed to create device(sec_epen)!\n"); if (device_create_file(sec_epen, &dev_attr_epen_firm_update)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_firm_update_status)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update_status.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_firm_version)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_version.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_rotation)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_rotation.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_hand)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_hand.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_reset)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_reset_result)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset_result.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_checksum)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_checksum.attr.name); if (device_create_file(sec_epen, &dev_attr_epen_checksum_result)< 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_checksum_result.attr.name); if (device_create_file(sec_epen, &dev_attr_set_epen_module_off) < 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_set_epen_module_off.attr.name); if (device_create_file(sec_epen, &dev_attr_set_epen_module_on) < 0) printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_set_epen_module_on.attr.name); /*Request IRQ*/ if (wac_i2c->irq_flag) { ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED|IRQF_TRIGGER_RISING|IRQF_ONESHOT, wac_i2c->name, wac_i2c); if (ret < 0) goto err1; } /* firmware update */ printk(KERN_NOTICE "[E-PEN] wacom fw ver : 0x%x, new fw ver : 0x%x\n", wac_i2c->wac_feature->fw_version, Firmware_version_of_file); if( wac_i2c->wac_feature->fw_version < Firmware_version_of_file ) { #if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) || defined(CONFIG_JPN_MODEL_SC_05D) printk("[E-PEN] %s\n", __func__); disable_irq(wac_i2c->irq); printk(KERN_NOTICE "[E-PEN]: INIT_FIRMWARE_FLASH is enabled.\n"); ret = wacom_i2c_flash(wac_i2c); msleep(800); printk(KERN_ERR "[E-PEN]: flashed.(%d)\n", ret); wacom_i2c_query(wac_i2c); enable_irq(wac_i2c->irq); #else schedule_work(&wac_i2c->update_work); #endif } /* To send exact checksum data at sleep state ... Xtopher */ printk(KERN_ERR"[E-PEN]: Verify CHECKSUM.\n"); epen_checksum_read_atBoot(wac_i2c); msleep(20); return 0; err3: printk(KERN_ERR "[E-PEN]: No I2C functionality found\n"); return -ENODEV; err2: printk(KERN_ERR "[E-PEN]: err2 occured\n"); input_free_device(wac_i2c->input_dev); return -EIO; err1: printk(KERN_ERR "[E-PEN]: err1 occured(num:%d)\n", ret); input_free_device(wac_i2c->input_dev); wac_i2c->input_dev = NULL; return -EIO; fail: printk(KERN_ERR "[E-PEN]: fail occured\n"); return -ENOMEM; }
/* Customer function to control hw specific wlan gpios */ void dhd_customer_gpio_wlan_ctrl(int onoff) { switch (onoff) { case WLAN_RESET_OFF: WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n", __FUNCTION__)); #if defined(CONFIG_LGE_BCM432X_PATCH) if (get_hw_rev() <= REV_1_2) { disable_irq(gpio_to_irq(TEGRA_GPIO_PQ5)); //by sjpark 11-03-10 gpio_set_value(TEGRA_GPIO_PQ5, 0); interrupt_en_flag = 1; //by sjpark 11-03-11 } else { disable_irq(gpio_to_irq(TEGRA_GPIO_PU2)); //by sjpark 11-03-10 gpio_set_value(TEGRA_GPIO_PU2, 0); interrupt_en_flag = 1; //by sjpark 11-03-11 } #endif #ifdef CUSTOMER_HW bcm_wlan_power_off(2); #endif /* CUSTOMER_HW */ #ifdef CUSTOMER_HW2 wifi_set_power(0, 0); #endif WL_ERROR(("=========== WLAN placed in RESET ========\n")); break; case WLAN_RESET_ON: WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n", __FUNCTION__)); #if defined(CONFIG_LGE_BCM432X_PATCH) if (get_hw_rev() <= REV_1_2) gpio_set_value(TEGRA_GPIO_PQ5, 1); else gpio_set_value(TEGRA_GPIO_PU2, 1); mdelay(150); #endif #ifdef CUSTOMER_HW bcm_wlan_power_on(2); #endif /* CUSTOMER_HW */ #ifdef CUSTOMER_HW2 wifi_set_power(1, 0); #endif WL_ERROR(("=========== WLAN going back to live ========\n")); break; case WLAN_POWER_OFF: WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n", __FUNCTION__)); #if defined(CONFIG_LGE_BCM432X_PATCH) if (get_hw_rev() <= REV_1_2) { gpio_set_value(TEGRA_GPIO_PQ5, 0); if(interrupt_en_flag == 1){ printk("[sj-debug] POWER OFF : enable irq.\n"); enable_irq(gpio_to_irq(TEGRA_GPIO_PQ5)); //by sjpark 11-03-10 interrupt_en_flag = 0; //by sjpark 11-03-11 } } else { gpio_set_value(TEGRA_GPIO_PU2, 0); if(interrupt_en_flag == 1){ printk("[sj-debug] POWER OFF : enable irq.\n"); enable_irq(gpio_to_irq(TEGRA_GPIO_PU2)); //by sjpark 11-03-10 interrupt_en_flag = 0; //by sjpark 11-03-11 } } mdelay(150); /* always turn on 32k clock */ // clk_disable(wifi_32k_clk); #endif #ifdef CUSTOMER_HW bcm_wlan_power_off(1); #endif /* CUSTOMER_HW */ break; case WLAN_POWER_ON: WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n", __FUNCTION__)); #if defined(CONFIG_LGE_BCM432X_PATCH) /* Always turn on 32k clock wifi_32k_clk = clk_get_sys(NULL, "blink"); if (IS_ERR(wifi_32k_clk)) { pr_err("%s: unable to get blink clock\n", __func__); //return PTR_ERR(wifi_32k_clk); } clk_enable(wifi_32k_clk); printk("[Wi-Fi] wifi_32k_clk is enabled\n"); */ if (get_hw_rev() <= REV_1_2) { gpio_set_value(TEGRA_GPIO_PQ5, 1); } else { gpio_set_value(TEGRA_GPIO_PU2, 1); } mdelay(150); #endif #ifdef CUSTOMER_HW bcm_wlan_power_on(1); #endif /* CUSTOMER_HW */ /* Lets customer power to get stable */ OSL_DELAY(200); break; } }
// ********************* LOW-LEVEL ISSP SUBROUTINE SECTION ******************** // **************************************************************************** // **** PROCESSOR SPECIFIC **** // **************************************************************************** // **** USER ATTENTION REQUIRED **** // **************************************************************************** // LoadProgramData() // The final application should load program data from HEX file generated by // PSoC Designer into a 64 byte host ram buffer. // 1. Read data from next line in hex file into ram buffer. One record // (line) is 64 bytes of data. // 2. Check host ram buffer + record data (Address, # of bytes) against hex // record checksum at end of record line // 3. If error reread data from file or abort // 4. Exit this Function and Program block or verify the block. // This demo program will, instead, load predetermined data into each block. // The demo does it this way because there is no comm link to get data. // **************************************************************************** void LoadProgramData(unsigned char bBlockNum, unsigned char bBankNum, int touchkey_pba_rev) { // >>> The following call is for demo use only. <<< // Function InitTargetTestData fills buffer for demo // InitTargetTestData(bBlockNum, bBankNum); // create unique data for each block int dataNum=0; #if defined(CONFIG_USA_MODEL_SGH_T769) #elif defined(CONFIG_USA_MODEL_SGH_T989) if(touchkey_pba_rev==TOUCHKEY_PBA_REV_02)//JSJEONG { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev02[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (touchkey_pba_rev==TOUCHKEY_PBA_REV_03) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev03[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (touchkey_pba_rev==TOUCHKEY_PBA_REV_04) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev04[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (touchkey_pba_rev==TOUCHKEY_PBA_REV_05) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev05[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_JPN_MODEL_SC_03D) if(touchkey_pba_rev==TOUCHKEY_PBA_REV_02)//JSJEONG { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev02[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if(touchkey_pba_rev==TOUCHKEY_PBA_REV_04)//JSJEONG { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev04[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if(touchkey_pba_rev >=TOUCHKEY_PBA_REV_05) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_activehigh_rev05[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() == 0x05) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (get_hw_rev() == 0x06) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_activehigh_rev06[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (get_hw_rev() >= 0x07) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_activehigh_rev08[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_KOR_MODEL_SHV_E120S) || defined(CONFIG_KOR_MODEL_SHV_E120K) printk(KERN_ERR "%s get_hw_rev(): %d data_mdule_rev = %x\n",__func__,get_hw_rev(),data_mdule_rev); if ((get_hw_rev() >= 0x0a)) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev10[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if ((get_hw_rev() == 0x09)) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev09[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } }else if ((get_hw_rev() == 0x08)) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev03[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } }else if ((get_hw_rev() == 0x06) && (data_mdule_rev>=0x02)) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev02[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } }else if ((get_hw_rev() == 0x06) && (data_mdule_rev<=0x01)){ for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) //printk(KERN_ERR "[TKEY] 160S %s get_hw_rev(): %d data_module_rev = %x\n",__func__,get_hw_rev(),data_mdule_rev); if (get_hw_rev() >= 0x02) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { // abTargetDataOUT[dataNum] = firmware_data[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[dataNum] = firmware_data_rev02[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[dataNum] = firmware_data_rev03[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; abTargetDataOUT[dataNum] = firmware_data_rev07[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; } } else #elif defined(CONFIG_KOR_SHV_E120L_HD720) printk(KERN_ERR "%s get_hw_rev(): %d \n",__func__,get_hw_rev()); if (get_hw_rev() >= 0x04) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev04[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (get_hw_rev() == 0x03) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev03[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (get_hw_rev() == 0x02) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key_rev02[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else if (get_hw_rev() == 0x01) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_3key[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_CAN_MODEL_SGH_I577R) if (get_hw_rev() >= 0x0d) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_activehigh[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev() >= 0x0a) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_activehigh[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #elif defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I757M) if (get_hw_rev() >= 0x04) { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data_rev04[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } else #endif { for (dataNum = 0; dataNum < TARGET_DATABUFF_LEN; dataNum++) { abTargetDataOUT[dataNum] = firmware_data[bBlockNum*TARGET_DATABUFF_LEN + dataNum]; // abTargetDataOUT[bTargetDataPtr] = bTargetDataPtr + bBlockNum + bBankNum; } } // Note: // Error checking should be added for the final version as noted above. // For demo use this function just returns VOID. }
static int __init misc_probe(struct platform_device *pdev) { int err; struct device *dev = &pdev->dev; printk(KERN_INFO "%s: start.....\n",__func__); memset(&s_misc, 0x00, sizeof(s_misc)); // set speak change gpio if (get_hw_rev() >= REV_F) GPIO_SPK_SWITCH = TEGRA_GPIO_PK5; else GPIO_SPK_SWITCH = TEGRA_GPIO_PV7; gpio_request(GPIO_SPK_SWITCH, "spk_switch"); tegra_gpio_enable(GPIO_SPK_SWITCH); gpio_direction_output(GPIO_SPK_SWITCH, 0); if (is_modem_connected()) { sumproc_root_fp = proc_mkdir( "modem", 0 ); //create_proc_entry( "exist", S_IFREG | S_IRWXU, sumproc_root_fp ); create_proc_entry( "exist", S_IFREG | S_IRWXO, sumproc_root_fp ); printk(KERN_INFO ">>>Modem exist\n"); } else printk(KERN_ERR ">>>Modem is not exist\n"); //hary.cho #ifndef CONFIG_STARTABLET_XMM6160 spin_lock_init(&mdm_reset_lock); gpio_request(GPIO_MDM_RESET_INT_N, "mdm_reset_int_n"); tegra_gpio_enable(GPIO_MDM_RESET_INT_N); gpio_direction_input(GPIO_MDM_RESET_INT_N); s_misc.mdm_reset_irq = gpio_to_irq(GPIO_MDM_RESET_INT_N); mdm_reset_wq = create_singlethread_workqueue("mdm_reset"); if (!mdm_reset_wq) { printk(KERN_ERR "%s: Failed: allocate workqueue for mdm reset", __func__); } INIT_DELAYED_WORK(&work, mdm_reset_delayed_work); err = request_irq(s_misc.mdm_reset_irq, mdm_reset_interrupt_handler, IRQF_TRIGGER_FALLING, "mdm_reset_int_n", (void*)&s_misc); if(err) { printk(KERN_ERR "%s: Failed: request_irq for mdm_reset_irq!!! (err:%d)\n", __func__, err); } err = set_irq_wake(s_misc.mdm_reset_irq, !!is_modem_connected()); if(err) { printk(KERN_ERR "%s: Failed: set_irq_wake for mdm_reset_irq!!! (err:%d)\n", __func__, err); } #else spin_lock_init(&ifx_trap_lock); gpio_request(GPIO_IFX_TRAP_INT_N, "ifx_trap_int_n"); tegra_gpio_enable(GPIO_IFX_TRAP_INT_N); gpio_direction_input(GPIO_IFX_TRAP_INT_N); s_misc.ifx_trap_irq = gpio_to_irq(GPIO_IFX_TRAP_INT_N); err = request_irq(s_misc.ifx_trap_irq, ifx_trap_interrupt_handler, IRQF_TRIGGER_RISING, "ifx_trap_int_n", (void*)&s_misc); if(err) { printk(KERN_ERR "%s: Failed: request_irq for ifx_trapped_irq!!! (err:%d)\n", __func__, err); } err = set_irq_wake(s_misc.ifx_trap_irq, !!is_modem_connected()); if(err) { printk(KERN_ERR "%s: Failed: set_irq_wake for ifx_reset_irq!!! (err:%d)\n", __func__, err); } ifx_trap_wq = create_singlethread_workqueue("ifx_trap"); if (!ifx_trap_wq) { printk(KERN_ERR "%s: Failed: allocate workqueue for ifx trap", __func__); } INIT_DELAYED_WORK(&work, ifx_trap_delayed_work); #endif if ((err = sysfs_create_group(&dev->kobj, &misc_group))) { printk(KERN_ERR "%s: Failed: sysfs_create_group \n", __func__); goto err_sysfs_create; } return 0; err_sysfs_create: printk("%s: misc_device_register_failed\n", __func__); return err; }
static int resume(struct platform_device *pdev) { DbgOut((KERN_INFO "tspdrv: resume.\n")); #if defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() > 0x00){ if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x34, 0x19); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); } #elif defined (CONFIG_KOR_SHV_E120L_HD720) || defined(CONFIG_KOR_MODEL_SHV_E120S) || defined(CONFIG_KOR_MODEL_SHV_E120K) || defined (CONFIG_KOR_MODEL_SHV_E120L) if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x32, 0x00); vibrator_write_register(0x33, 0x13); vibrator_write_register(0x34, 0x05); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); #elif defined (CONFIG_KOR_MODEL_SHV_E160L) if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x32, 0x00); vibrator_write_register(0x33, 0x13); vibrator_write_register(0x34, 0x02); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x32, 0x00); vibrator_write_register(0x33, 0x13); vibrator_write_register(0x34, 0x03); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); #elif defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_CAN_MODEL_SGH_I577R) if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x34, 0x02); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_I727) || defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev() > 0x04){ if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); #if defined (CONFIG_USA_MODEL_SGH_T989) if (get_hw_rev() >= 0x0d) vibrator_write_register(0x34, 0x01); else vibrator_write_register(0x34, 0x16); #elif defined (CONFIG_USA_MODEL_SGH_T769) vibrator_write_register(0x34, 0x17); #else vibrator_write_register(0x34, 0x19); #endif vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); } #elif defined (CONFIG_USA_MODEL_SGH_I717) || defined(CONFIG_USA_MODEL_SGH_I757) if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x34, 0x02); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() > 0x00){ if(!isa1200_enabled){ gpio_set_value(VIB_EN, VIBRATION_ON); vibrator_write_register(0x30, 0x09); vibrator_write_register(0x31, 0x40); vibrator_write_register(0x34, 0x19); vibrator_write_register(0x35, 0x00); vibrator_write_register(0x36, 0x00); isa1200_enabled = 1; } printk(KERN_ERR "[VIBTONZ] isa1200_late_resume \n"); } #endif return 0; /* can resume */ }
static int i2c_touchkey_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct input_dev *input_dev; int err = 0; int touch_auto_calibration_on_off = 0; u8 data[6]; printk("[TKEY] melfas i2c_touchkey_probe\n"); touchkey_driver = kzalloc(sizeof(struct i2c_touchkey_driver), GFP_KERNEL); if (touchkey_driver == NULL) { dev_err(dev, "failed to create our state\n"); return -ENOMEM; } touchkey_driver->client = client; touchkey_driver->client->irq = IRQ_TOUCHKEY_INT; strlcpy(touchkey_driver->client->name, "melfas-touchkey", I2C_NAME_SIZE); // i2c_set_clientdata(client, state); input_dev = input_allocate_device(); if (!input_dev) return -ENOMEM; touchkey_driver->input_dev = input_dev; input_dev->name = DEVICE_NAME; input_dev->phys = "melfas-touchkey/input0"; input_dev->id.bustype = BUS_HOST; if(get_hw_rev() >= 0x02) { touchkey_keycode[1] = KEY_MENU; touchkey_keycode[2] = KEY_BACK; } else { touchkey_keycode[1] = KEY_MENU; touchkey_keycode[2] = KEY_BACK; } set_bit(EV_SYN, input_dev->evbit); set_bit(EV_LED, input_dev->evbit); set_bit(LED_MISC, input_dev->ledbit); set_bit(EV_KEY, input_dev->evbit); set_bit(touchkey_keycode[1], input_dev->keybit); set_bit(touchkey_keycode[2], input_dev->keybit); set_bit(touchkey_keycode[3], input_dev->keybit); set_bit(touchkey_keycode[4], input_dev->keybit); err = input_register_device(input_dev); if (err) { input_free_device(input_dev); return err; } // gpio_pend_mask_mem = ioremap(INT_PEND_BASE, 0x10); //temp ks INIT_DELAYED_WORK(&touch_resume_work, touchkey_resume_func); #ifdef CONFIG_HAS_EARLYSUSPEND // touchkey_driver->early_suspend.level = EARLY_SUSPEND_LEVEL_STOP_DRAWING + 1; touchkey_driver->early_suspend.suspend = melfas_touchkey_early_suspend; touchkey_driver->early_suspend.resume = melfas_touchkey_early_resume; register_early_suspend(&touchkey_driver->early_suspend); #endif touchkey_enable = 1; err= request_threaded_irq( IRQ_TOUCHKEY_INT, NULL, touchkey_interrupt, IRQF_DISABLED , "touchkey_int", NULL); if (err) { printk(KERN_ERR "%s Can't allocate irq .. %d\n", __FUNCTION__, err); return -EBUSY; } if (get_hw_rev() >=0x02) { touchkey_auto_calibration(1/*on*/); mdelay(30); i2c_touchkey_read (0x00, data, 6); touch_auto_calibration_on_off = (data[5] & 0x80)>>7; printk("[TKEY] after touchkey_auto_calibration result = %d \n",touch_auto_calibration_on_off); }
int cam_ldo_power_on(void) { int ret; cam_mclk_onoff(OFF); mdelay(5); //preempt_disable(); //ISP CORE 1.2V i_core12 = regulator_get(NULL, "8901_s2"); //CORE 1.2V if (IS_ERR(i_core12)) goto main_cam_power_fail; ret = regulator_set_voltage(i_core12, 1200000, 1200000); if (ret) { printk("%s:i_core12 error setting voltage\n", __func__); } ret = regulator_enable(i_core12); if (ret) { printk("%s:i_core12 error enabling regulator\n", __func__); } mdelay(1); //SENSOR CORE 1.2V s_core12 = regulator_get(NULL, "8901_lvs1"); if (IS_ERR(s_core12)) goto main_cam_power_fail; ret = regulator_enable(s_core12); if (ret) { printk("%s:s_core12 error enabling regulator\n", __func__); } mdelay(1); //SENSOR A2.8V gpio_set_value_cansleep(CAM_IO_EN, HIGH); mdelay(1); //min 20us //DVDD 1.5V (sub) #if defined (CONFIG_USA_MODEL_SGH_T989) if (get_hw_rev() >= 0x09) vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_KOR_MODEL_SHV_E110S) if (get_hw_rev() >= 0x05) //celox_REV05 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) if (get_hw_rev() >= 0x06) //daliS_REV03 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev() >= 0x02) //QuincyS_REV02 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_KOR_MODEL_SHV_E120L) if (get_hw_rev() >= 0x02) //dali LGT REV02 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev() >= 0x01) //Q1_REV01 vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev() >= 0x08) vt_core15 = regulator_get(NULL, "8058_l24"); else #elif defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x05) vt_core15 = regulator_get(NULL, "8058_l24"); else #endif { printk("DVDD1.5V : 8058_l10\n"); vt_core15 = regulator_get(NULL, "8058_l10"); } if (IS_ERR(vt_core15)) goto main_cam_power_fail; ret = regulator_set_voltage(vt_core15, 1500000, 1500000); if (ret) { printk("%s:vt_core15 error setting voltage\n", __func__); } ret = regulator_enable(vt_core15); if (ret) { printk("%s:vt_core15 error enabling regulator\n", __func__); } mdelay(1); //min 15us //AF 2.8V af28 = regulator_get(NULL, "8058_l15"); //AF 2.8V if (IS_ERR(af28)) goto main_cam_power_fail; ret = regulator_set_voltage(af28, 2850000, 2850000); if (ret) { printk("%s:af28 error setting voltage\n", __func__); } ret = regulator_enable(af28); if (ret) { printk("%s:af28 error enabling regulator\n", __func__); } mdelay(5); // min 5ms~max 10ms, //HOST 1.8V #if defined (CONFIG_JPN_MODEL_SC_03D) if (get_hw_rev() >= 0x02) i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_KOR_MODEL_SHV_E110S) || defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) if (get_hw_rev() >= 0x04) i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if (get_hw_rev() >= 0x02) i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_KOR_MODEL_SHV_E120L) if (get_hw_rev() >= 0x02) //dali LGT REV02 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_USA_MODEL_SGH_I717) if (get_hw_rev()>=0x01) //Q1_REV01 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_USA_MODEL_SGH_I727) if (get_hw_rev()>=0x06) //celox_REV06 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #elif defined (CONFIG_USA_MODEL_SGH_T989)|| defined (CONFIG_USA_MODEL_SGH_T769) if (get_hw_rev()>=0x0D) //Hercules_rev06 i_host18 = regulator_get(NULL, "8901_usb_otg"); else #endif { printk("Host1.8V : 8058_l8\n"); i_host18 = regulator_get(NULL, "8058_l8"); if (IS_ERR(i_host18)) goto main_cam_power_fail; ret = regulator_set_voltage(i_host18, 1800000, 1800000); if (ret) { printk("%s:i_host18 error setting voltage\n", __func__); } } if (IS_ERR(i_host18)) goto main_cam_power_fail; ret = regulator_enable(i_host18); if (ret) { printk("%s:i_host18 error enabling regulator\n", __func__); } mdelay(1); //SENSOR IO 1.8V - ISP s_io18 = regulator_get(NULL, "8058_lvs0"); if (IS_ERR(s_io18)) goto main_cam_power_fail; ret = regulator_enable(s_io18); if (ret) { printk("%s:s_io18 error enabling regulator\n", __func__); } mdelay(1); //preempt_enable(); cam_mclk_onoff(ON); mdelay(1); return ret; main_cam_power_fail: return -1; }
//Firmware update packet handler void handle_udp_fw_update_packet(struct socket_address src, struct socket_address dst, unsigned char *payload, int payload_len) { const usrp2_fw_update_data_t *update_data_in = (usrp2_fw_update_data_t *) payload; usrp2_fw_update_data_t update_data_out; usrp2_fw_update_id_t update_data_in_id = update_data_in->id; //ensure that the protocol versions match /* if (payload_len >= sizeof(uint32_t) && update_data_in->proto_ver != USRP2_FW_COMPAT_NUM){ printf("!Error in update packet handler: Expected compatibility number %d, but got %d\n", USRP2_FW_COMPAT_NUM, update_data_in->proto_ver ); update_data_in_id = USRP2_FW_UPDATE_ID_OHAI_LOL; //so we can respond } */ //ensure that this is not a short packet if (payload_len < sizeof(usrp2_fw_update_data_t)){ printf("!Error in update packet handler: Expected payload length %d, but got %d\n", (int)sizeof(usrp2_fw_update_data_t), payload_len ); update_data_in_id = USRP2_FW_UPDATE_ID_WAT; } switch(update_data_in_id) { case USRP2_FW_UPDATE_ID_OHAI_LOL: //why hello there you handsome devil update_data_out.id = USRP2_FW_UPDATE_ID_OHAI_OMG; memcpy(&update_data_out.data.ip_addr, (void *)get_ip_addr(), sizeof(struct ip_addr)); //this is to stop streaming for the folks who think updating while streaming is a good idea sr_rx_ctrl0->cmd = 1 << 31 | 1 << 28; //no samples now sr_rx_ctrl0->time_secs = 0; sr_rx_ctrl0->time_ticks = 0; //latch the command sr_rx_ctrl1->cmd = 1 << 31 | 1 << 28; //no samples now sr_rx_ctrl1->time_secs = 0; sr_rx_ctrl1->time_ticks = 0; //latch the command sr_tx_ctrl->cyc_per_up = 0; break; case USRP2_FW_UPDATE_ID_WATS_TEH_FLASH_INFO_LOL: //query sector size, memory size so the host can mind the boundaries update_data_out.data.flash_info_args.sector_size_bytes = spi_flash_sector_size(); update_data_out.data.flash_info_args.memory_size_bytes = spi_flash_memory_size(); update_data_out.id = USRP2_FW_UPDATE_ID_HERES_TEH_FLASH_INFO_OMG; break; case USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL: //get the hardware revision of the platform for validation checking update_data_out.data.hw_rev = (uint32_t) get_hw_rev(); update_data_out.id = USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG; break; case USRP2_FW_UPDATE_ID_ERASE_TEH_FLASHES_LOL: //out with the old spi_flash_async_erase_start(&spi_flash_async_state, update_data_in->data.flash_args.flash_addr, update_data_in->data.flash_args.length); update_data_out.id = USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG; break; case USRP2_FW_UPDATE_ID_R_U_DONE_ERASING_LOL: //poll for done, set something in the reply packet //spi_flash_async_erase_poll() also advances the state machine, so you should call it reasonably often to get things done quicker if(spi_flash_async_erase_poll(&spi_flash_async_state)) update_data_out.id = USRP2_FW_UPDATE_ID_IM_DONE_ERASING_OMG; else update_data_out.id = USRP2_FW_UPDATE_ID_NOPE_NOT_DONE_ERASING_OMG; break; case USRP2_FW_UPDATE_ID_WRITE_TEH_FLASHES_LOL: //and in with the new //spi_flash_program() goes pretty quick compared to page erases, so we don't bother polling -- it'll come back in some milliseconds //if it doesn't come back fast enough, we'll just write smaller packets at a time until it does spi_flash_program(update_data_in->data.flash_args.flash_addr, update_data_in->data.flash_args.length, update_data_in->data.flash_args.data); update_data_out.id = USRP2_FW_UPDATE_ID_WROTE_TEH_FLASHES_OMG; break; case USRP2_FW_UPDATE_ID_READ_TEH_FLASHES_LOL: //for verify spi_flash_read(update_data_in->data.flash_args.flash_addr, update_data_in->data.flash_args.length, update_data_out.data.flash_args.data); update_data_out.id = USRP2_FW_UPDATE_ID_KK_READ_TEH_FLASHES_OMG; break; case USRP2_FW_UPDATE_ID_RESET_MAH_COMPUTORZ_LOL: //for if we ever get the ICAP working //should reset via icap_reload_fpga(uint32_t flash_address); update_data_out.id = USRP2_FW_UPDATE_ID_RESETTIN_TEH_COMPUTORZ_OMG; //you should note that if you get a reply packet to this the reset has obviously failed icap_reload_fpga(0); break; // case USRP2_FW_UPDATE_ID_KTHXBAI: //see ya // break; default: //uhhhh update_data_out.id = USRP2_FW_UPDATE_ID_WAT; } send_udp_pkt(USRP2_UDP_UPDATE_PORT, src, &update_data_out, sizeof(update_data_out)); }