static ssize_t epen_reset_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
int val;
sscanf(buf, "%d", &val);
if (val == 1) {
wacom_enable_irq(wac_i2c, false);
/* Reset IC */
wacom_reset_hw(wac_i2c);
/* I2C Test */
wacom_i2c_query(wac_i2c);
wacom_enable_irq(wac_i2c, true);
dev_info(&wac_i2c->client->dev,
"%s, result %d\n", __func__,
wac_i2c->query_status);
}
return count;
}
static ssize_t epen_checksum_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
int val;
sscanf(buf, "%d", &val);
if (val != 1) {
dev_info(&wac_i2c->client->dev,
"%s: wrong cmd %d\n", __func__, val);
return count;
}
wacom_enable_irq(wac_i2c, false);
wacom_checksum(wac_i2c);
wacom_enable_irq(wac_i2c, true);
dev_info(&wac_i2c->client->dev,
"%s: result %d\n",
__func__, wac_i2c->checksum_result);
return count;
}
static void wacom_reset(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, work_wacom_reset.work);
dev_err(&wac_i2c->client->dev,
"%s: reset\n",
__func__);
wacom_enable_irq(wac_i2c, false);
/* Reset IC */
wacom_reset_hw(wac_i2c);
wacom_enable_irq(wac_i2c, true);
}
static void wacom_power_off(struct wacom_i2c *wac_i2c)
{
if (wac_i2c->power_enable) {
wacom_enable_irq(wac_i2c, false);
/* release pen, if it is pressed */
#if defined(CONFIG_MACH_P4NOTE)
#ifdef WACOM_PDCT_WORK_AROUND
if (wac_i2c->pen_pdct == PDCT_DETECT_PEN)
#else
if (wac_i2c->pen_pressed || wac_i2c->side_pressed
|| wac_i2c->pen_prox)
#endif
#else
if (wac_i2c->pen_pressed || wac_i2c->side_pressed
|| wac_i2c->pen_prox)
#endif
forced_release(wac_i2c);
if (!wake_lock_active(&wac_i2c->wakelock)) {
wac_i2c->power_enable = false;
wac_i2c->wac_pdata->suspend_platform_hw();
} else
printk(KERN_DEBUG"epen:wake_lock active\n");
}
}
static ssize_t epen_sampling_rate_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
int value;
char mode;
if (sscanf(buf, "%d", &value) == 1) {
switch (value) {
case 0:
mode = COM_SAMPLERATE_STOP;
break;
case 40:
mode = COM_SAMPLERATE_40;
break;
case 80:
mode = COM_SAMPLERATE_80;
break;
case 133:
mode = COM_SAMPLERATE_133;
break;
default:
pr_err("epen:Invalid sampling rate value\n");
count = -1;
goto fail;
}
wacom_enable_irq(wac_i2c, false);
if (1 == wacom_i2c_send(wac_i2c, &mode, 1, false)) {
printk(KERN_DEBUG "epen:sampling rate %d\n", value);
msleep(100);
} else {
pr_err("epen:I2C write error\n");
wacom_enable_irq(wac_i2c, true);
count = -1;
}
wacom_enable_irq(wac_i2c, true);
} else {
pr_err("epen:can't get sampling rate data\n");
count = -1;
}
fail:
return count;
}
static ssize_t epen_connection_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
printk(KERN_DEBUG"epen:%s\n", __func__);
wacom_enable_irq(wac_i2c, false);
wacom_open_test(wac_i2c);
wacom_enable_irq(wac_i2c, true);
printk(KERN_DEBUG
"epen:connection_check : %d\n",
wac_i2c->connection_check);
return sprintf(buf, "%s\n",
wac_i2c->connection_check ?
"OK" : "NG");
}
static void wacom_i2c_resume_work(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, resume_work.work);
#if defined(WACOM_PDCT_WORK_AROUND)
irq_set_irq_type(wac_i2c->irq_pdct, IRQ_TYPE_EDGE_BOTH);
#endif
wacom_enable_irq(wac_i2c, true);
printk(KERN_DEBUG "epen:%s\n", __func__);
}
static ssize_t epen_checksum_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
bool check_version = false;
int val;
sscanf(buf, "%d", &val);
#if defined(CONFIG_MACH_P4NOTE)
if (wac_i2c->checksum_result)
return count;
else
check_version = true;
#elif defined(CONFIG_MACH_Q1_BD)
if (wac_i2c->wac_feature->fw_version >= 0x31E)
check_version = true;
#elif defined(CONFIG_MACH_T0)
if (wac_i2c->wac_feature->fw_version == 0x179) {
wac_i2c->checksum_result = 1;
check_version = false;
} else
check_version = true;
#else
check_version = true;
#endif
if (val == 1 && check_version) {
wacom_enable_irq(wac_i2c, false);
wacom_checksum(wac_i2c);
wacom_enable_irq(wac_i2c, true);
}
printk(KERN_DEBUG "epen:%s, check %d, result %d\n",
__func__, check_version, wac_i2c->checksum_result);
return count;
}
static int wacom_firmware_update(struct wacom_i2c *wac_i2c)
{
int ret = 0;
ret = wacom_load_fw_from_req_fw(wac_i2c);
if (ret)
goto failure;
if (wac_i2c->wac_feature->fw_ic_version < wac_i2c->wac_feature->fw_version) {
/*start firm update*/
dev_info(&wac_i2c->client->dev,
"%s: Start firmware flashing (kernel image).\n",
__func__);
mutex_lock(&wac_i2c->lock);
wacom_enable_irq(wac_i2c, false);
wac_i2c->wac_feature->firm_update_status = 1;
ret = wacom_i2c_firm_update(wac_i2c);
if (ret)
goto update_err;
wacom_i2c_set_firm_data(NULL);
wacom_i2c_query(wac_i2c);
wac_i2c->wac_feature->firm_update_status = 2;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->lock);
} else {
dev_info(&wac_i2c->client->dev,
"%s: firmware update does not need.\n",
__func__);
}
return ret;
update_err:
wacom_i2c_set_firm_data(NULL);
wac_i2c->wac_feature->firm_update_status = -1;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->lock);
failure:
return ret;
}
static void wacom_i2c_disable(struct wacom_i2c *wac_i2c)
{
if (wac_i2c->power_enable) {
wacom_enable_irq(wac_i2c, false);
/* release pen, if it is pressed */
if (wac_i2c->pen_pressed || wac_i2c->side_pressed
|| wac_i2c->pen_prox)
forced_release(wac_i2c);
wac_i2c->wac_pdata->wacom_stop(wac_i2c);
}
}
static void wacom_power_off(struct wacom_i2c *wac_i2c)
{
mutex_lock(&wac_i2c->lock);
if (!wac_i2c->power_enable) {
printk(KERN_DEBUG"epen:pass pwr off\n");
goto out_power_off;
}
#ifdef WACOM_BOOSTER
wacom_set_dvfs_lock(wac_i2c, 2);
#endif
wacom_enable_irq(wac_i2c, false);
/* release pen, if it is pressed */
if (wac_i2c->pen_pressed || wac_i2c->side_pressed
|| wac_i2c->pen_prox)
forced_release(wac_i2c);
cancel_delayed_work_sync(&wac_i2c->resume_work);
#ifdef LCD_FREQ_SYNC
cancel_work_sync(&wac_i2c->lcd_freq_work);
cancel_delayed_work_sync(&wac_i2c->lcd_freq_done_work);
wac_i2c->lcd_freq_wait = false;
#endif
#ifdef WACOM_USE_SOFTKEY_BLOCK
cancel_delayed_work_sync(&wac_i2c->softkey_block_work);
wac_i2c->block_softkey = false;
#endif
if (wake_lock_active(&wac_i2c->fw_wakelock)) {
printk(KERN_DEBUG"epen:wake_lock active. pass pwr off\n");
goto out_power_off;
}
/* power off */
wac_i2c->power_enable = false;
wac_i2c->wac_pdata->suspend_platform_hw();
printk(KERN_DEBUG"epen:%s\n", __func__);
out_power_off:
mutex_unlock(&wac_i2c->lock);
}
static void wacom_i2c_resume_work(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, resume_work.work);
if (wac_i2c->init_fail)
return;
/* This Code is workaround code for S.LSI AP models. */
/*
#if defined(WACOM_PDCT_WORK_AROUND)
//irq_set_irq_type(wac_i2c->irq_pdct, IRQ_TYPE_EDGE_BOTH);
#endif
*/
wacom_enable_irq(wac_i2c, true);
dev_info(&wac_i2c->client->dev,
"%s\n", __func__);
}
static void wacom_i2c_resume_work(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, resume_work.work);
#if defined(WACOM_PDCT_WORK_AROUND)
irq_set_irq_type(wac_i2c->irq_pdct, IRQ_TYPE_EDGE_BOTH);
#endif
#if defined(CONFIG_MACH_P4NOTE)
irq_set_irq_type(wac_i2c->client->irq, IRQ_TYPE_EDGE_RISING);
#endif
wac_i2c->power_enable = true;
wacom_enable_irq(wac_i2c, true);
#ifdef WACOM_STATE_CHECK
schedule_delayed_work(&wac_i2c->wac_statecheck_work, HZ * 30);
#endif
printk(KERN_DEBUG "epen:%s\n", __func__);
}
static void wacom_i2c_resume_work(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, resume_work.work);
u8 irq_state = 0;
int ret = 0;
irq_state = wac_i2c->wac_pdata->get_irq_state();
wacom_enable_irq(wac_i2c, true);
if (unlikely(irq_state)) {
printk(KERN_DEBUG"epen:irq was enabled\n");
ret = wacom_i2c_recv(wac_i2c, wac_i2c->wac_feature->data, COM_COORD_NUM, false);
if (ret < 0) {
printk(KERN_ERR "epen:%s failed to read i2c.L%d\n", __func__,
__LINE__);
}
}
printk(KERN_DEBUG "epen:%s\n", __func__);
}
static void wacom_i2c_disable(struct wacom_i2c *wac_i2c)
{
#ifdef CONFIG_TOUCH_WAKE
// Don't change state if touchwake listening delay is active
if (!touchwake_is_active()) {
#ifdef TOUCHWAKE_DEBUG_PRINT
pr_info("[TOUCHWAKE] Wacom i2c disable\n");
#endif
#endif
if (wac_i2c->power_enable) {
wacom_enable_irq(wac_i2c, false);
/* release pen, if it is pressed */
if (wac_i2c->pen_pressed || wac_i2c->side_pressed
|| wac_i2c->pen_prox)
forced_release(wac_i2c);
wac_i2c->wac_pdata->wacom_stop(wac_i2c);
}
#ifdef CONFIG_TOUCH_WAKE
}
#endif
}
static ssize_t epen_firmware_update_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
int ret = 1;
u32 fw_ic_ver = wac_i2c->wac_feature->fw_ic_version;
bool need_update = false;
need_update = check_update_condition(wac_i2c, *buf);
if (need_update == false) {
dev_info(&wac_i2c->client->dev,
"%s:Pass Update. Cmd %c, IC ver %04x, Ker ver %04x\n",
__func__, *buf, fw_ic_ver, wac_i2c->wac_feature->fw_version);
return count;
} else {
dev_info(&wac_i2c->client->dev,
"%s:Update Start. IC fw ver : 0x%x, new fw ver : 0x%x\n",
__func__, wac_i2c->wac_feature->fw_ic_version,
wac_i2c->wac_feature->fw_version);
}
switch (*buf) {
/*ums*/
case 'I':
ret = wacom_fw_load_from_UMS(wac_i2c);
if (ret)
goto failure;
dev_info(&wac_i2c->client->dev,
"%s: Start firmware flashing (UMS image).\n",
__func__);
ums_binary = true;
break;
/*kernel*/
case 'K':
ret = wacom_load_fw_from_req_fw(wac_i2c);
if (ret)
goto failure;
break;
/*booting*/
case 'R':
ret = wacom_load_fw_from_req_fw(wac_i2c);
if (ret)
goto failure;
dev_info(&wac_i2c->client->dev,
"%s: Start firmware flashing (kernel image).\n",
__func__);
break;
default:
/*There's no default case*/
break;
}
/*start firm update*/
mutex_lock(&wac_i2c->lock);
wacom_enable_irq(wac_i2c, false);
wac_i2c->wac_feature->firm_update_status = 1;
ret = wacom_i2c_firm_update(wac_i2c);
if (ret)
goto update_err;
wacom_i2c_set_firm_data(NULL);
wacom_i2c_query(wac_i2c);
wac_i2c->wac_feature->firm_update_status = 2;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->lock);
return count;
update_err:
wacom_i2c_set_firm_data(NULL);
failure:
wac_i2c->wac_feature->firm_update_status = -1;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->lock);
return -1;
}
static void wacom_i2c_update_work(struct work_struct *work)
{
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, update_work);
u32 fw_ver_ic = wac_i2c->wac_feature->fw_version;
int ret;
int retry = 3;
mutex_lock(&wac_i2c->update_lock);
wacom_enable_irq(wac_i2c, false);
printk(KERN_DEBUG"epen:%s\n", __func__);
if (!wac_i2c->update_info.forced) {
#if defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
if (fw_ver_ic == fw_ver_file) {
#else
if (fw_ver_ic >= fw_ver_file) {
#endif
printk(KERN_DEBUG"epen:pass fw update, ic ver %#x, img ver %#x\n",
fw_ver_ic, fw_ver_file);
goto err_update_load_fw;
}
}
wac_i2c->wac_feature->firm_update_status = 1;
ret = wacom_i2c_load_fw(wac_i2c);
if (ret < 0) {
printk(KERN_DEBUG"epen:failed to load fw(%d)\n", ret);
goto err_update_load_fw;
}
while (retry--) {
ret = wacom_i2c_flash(wac_i2c);
if (ret) {
printk(KERN_DEBUG"epen:failed to flash fw(%d)\n", ret);
continue;
}
break;
}
if (ret)
goto err_update_fw;
ret = wacom_i2c_query(wac_i2c);
if (ret < 0) {
printk(KERN_DEBUG"epen:failed to query to IC(%d)\n", ret);
goto err_update_fw;
}
err_update_fw:
wacom_i2c_unload_fw(wac_i2c);
err_update_load_fw:
wac_i2c->wac_feature->firm_update_status = 2;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->update_lock);
}
static ssize_t epen_reset_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
int val;
sscanf(buf, "%d", &val);
if (val == 1) {
wacom_enable_irq(wac_i2c, false);
/* Reset IC */
wacom_i2c_reset_hw(wac_i2c->wac_pdata);
/* I2C Test */
wacom_i2c_query(wac_i2c);
wacom_enable_irq(wac_i2c, true);
printk(KERN_DEBUG "epen:%s, result %d\n", __func__,
wac_i2c->query_status);
}
return count;
}
static ssize_t epen_reset_result_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
if (wac_i2c->query_status) {
printk(KERN_DEBUG "epen:%s, PASS\n", __func__);
return sprintf(buf, "PASS\n");
} else {
printk(KERN_DEBUG "epen:%s, FAIL\n", __func__);
return sprintf(buf, "FAIL\n");
}
}
#ifdef WACOM_USE_AVE_TRANSITION
static ssize_t epen_ave_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int v1, v2, v3, v4, v5;
int height;
sscanf(buf, "%d%d%d%d%d%d", &height, &v1, &v2, &v3, &v4, &v5);
if (height < 0 || height > 2) {
printk(KERN_DEBUG"epen:Height err %d\n", height);
return count;
}
g_aveLevel_C[height] = v1;
g_aveLevel_X[height] = v2;
g_aveLevel_Y[height] = v3;
g_aveLevel_Trs[height] = v4;
g_aveLevel_Cor[height] = v5;
printk(KERN_DEBUG "epen:%s, v1 %d v2 %d v3 %d v4 %d\n", __func__,
v1, v2, v3, v4);
return count;
}
static ssize_t epen_firmware_update_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct wacom_i2c *wac_i2c = dev_get_drvdata(dev);
int ret = 1;
u32 fw_ic_ver = wac_i2c->wac_feature->fw_version;
bool need_update = false;
printk(KERN_DEBUG "epen:%s\n", __func__);
need_update = check_update_condition(wac_i2c, *buf);
if (need_update == false) {
printk(KERN_DEBUG"epen:Pass Update."
"Cmd %c, IC ver %04x, Ker ver %04x\n",
*buf, fw_ic_ver, Firmware_version_of_file);
return count;
}
/*start firm update*/
mutex_lock(&wac_i2c->lock);
wacom_enable_irq(wac_i2c, false);
wac_i2c->wac_feature->firm_update_status = 1;
switch (*buf) {
/*ums*/
case 'I':
ret = wacom_i2c_fw_update_UMS(wac_i2c);
break;
/*kernel*/
#ifdef CONFIG_MACH_P4NOTE
case 'K':
printk(KERN_ERR
"epen:Start firmware flashing (kernel image).\n");
ret = wacom_i2c_flash(wac_i2c);
break;
case 'R':
update_fw_p4(wac_i2c);
break;
#else
case 'K':
printk(KERN_ERR
"epen:Start firmware flashing (kernel image).\n");
case 'R':
ret = wacom_i2c_firm_update(wac_i2c);
break;
#endif
default:
/*There's no default case*/
break;
}
if (ret < 0) {
printk(KERN_ERR "epen:failed to flash firmware.\n");
goto failure;
}
printk(KERN_ERR "epen:Finish firmware flashing.\n");
wacom_i2c_query(wac_i2c);
wac_i2c->wac_feature->firm_update_status = 2;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->lock);
return count;
failure:
wac_i2c->wac_feature->firm_update_status = -1;
wacom_enable_irq(wac_i2c, true);
mutex_unlock(&wac_i2c->lock);
return -1;
}
