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