int wacom_i2c_fw_update_UMS(struct wacom_i2c *wac_i2c)
{
int ret = 0;
u8 *ums_data = NULL;
printk(KERN_ERR "epen:Start firmware flashing (UMS).\n");
/*read firmware data*/
ret = wacom_i2c_get_ums_data(wac_i2c, &ums_data);
if (ret < 0) {
printk(KERN_DEBUG"epen:file op is failed\n");
return 0;
}
/*start firm update*/
wacom_i2c_set_firm_data(ums_data);
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR
"epen:failed to write firmware(%d)\n", ret);
kfree(ums_data);
wacom_i2c_set_firm_data(NULL);
return ret;
}
wacom_i2c_set_firm_data(NULL);
kfree(ums_data);
return 0;
}
static void update_fw_p4(struct wacom_i2c *wac_i2c)
{
int ret = 0;
int retry = 3;
#if !defined(CONFIG_TARGET_LOCALE_USA)
/* the firmware should be updated in factory mode durring the boot */
if (!epen_check_factory_mode())
retry = 0;
#endif
while (retry--) {
printk(KERN_DEBUG "epen:INIT_FIRMWARE_FLASH is enabled.\n");
ret = wacom_i2c_flash(wac_i2c);
if (ret == 0)
break;
printk(KERN_DEBUG "epen:update failed. retry %d, ret %d\n",
retry, ret);
/* Reset IC */
wacom_i2c_reset_hw(wac_i2c->wac_pdata);
}
printk(KERN_DEBUG "epen:flashed.(%d)\n", ret);
}
static void update_work_func(struct work_struct *work)
{
int ret;
int retry = 2;
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, update_work);
printk(KERN_DEBUG "[E-PEN] %s\n", __func__);
disable_irq(wac_i2c->irq);
while (retry--) {
printk(KERN_DEBUG "[E-PEN] INIT_FIRMWARE_FLASH is enabled.\n");
ret = wacom_i2c_flash(wac_i2c);
if (ret == 0)
break;
printk(KERN_DEBUG "[E-PEN] update failed. retry %d, ret %d\n",
retry, ret);
/* Reset IC */
wacom_i2c_reset_hw(wac_i2c->wac_pdata);
}
msleep(800);
printk(KERN_DEBUG "[E-PEN] flashed.(%d)\n", ret);
wacom_i2c_query(wac_i2c);
enable_irq(wac_i2c->irq);
}
static void update_work_func(struct work_struct *work)
{
int ret;
int retry = 2;
struct wacom_i2c *wac_i2c =
container_of(work, struct wacom_i2c, update_work);
printk("[E-PEN] %s\n", __func__);
disable_irq(wac_i2c->irq);
while( retry-- ) {
printk(KERN_DEBUG "[E-PEN]: INIT_FIRMWARE_FLASH is enabled.\n");
ret = wacom_i2c_flash(wac_i2c);
if( ret == 0 )
break;
printk(KERN_DEBUG "[E-PEN] update failed. retry %d\n", retry);
/* Reset IC */
gpio_set_value(GPIO_PEN_RESET, 0);
msleep(200);
gpio_set_value(GPIO_PEN_RESET, 1);
msleep(200);
}
msleep(800);
printk(KERN_DEBUG "[E-PEN]: flashed.(%d)\n", ret);
wacom_i2c_query(wac_i2c);
enable_irq(wac_i2c->irq);
}
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);
u8 *data;
u8 buf_if;
int ret;
buf_if = COM_QUERY;
data = wac_i2c->wac_feature->data;
printk(KERN_DEBUG "[E-PEN]:%s:\n", __func__);
disable_irq(wac_i2c->irq);
wac_i2c->wac_feature->firm_update_status = 1;
if (*buf == 'F') {
printk(KERN_ERR "[E-PEN]: Start firmware flashing (UMS).\n");
ret = wacom_i2c_load_fw(wac_i2c->client);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]: failed to flash firmware.\n");
goto failure;
}
} else if (*buf == 'B') {
printk(KERN_ERR "[E-PEN]: Start firmware flashing (kernel image).\n");
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]: failed to flash firmware.\n");
goto failure;
}
} else {
printk(KERN_ERR "[E-PEN]: wrong parameter.\n");
goto param_err;
}
printk(KERN_ERR "[E-PEN]: Finish firmware flashing.\n");
msleep(800);
wacom_i2c_query(wac_i2c);
wac_i2c->wac_feature->firm_update_status = 2;
enable_irq(wac_i2c->irq);
return count;
param_err:
failure:
wac_i2c->wac_feature->firm_update_status = -1;
enable_irq(wac_i2c->irq);
return -1;
}
int wacom_i2c_load_fw(struct i2c_client *client)
{
struct file *fp;
mm_segment_t old_fs;
long fsize, nread;
int ret;
struct wacom_i2c *wac_i2c = i2c_get_clientdata(client);
old_fs = get_fs();
set_fs(KERNEL_DS);
fp = filp_open(WACOM_FW_PATH, O_RDONLY, S_IRUSR);
if (IS_ERR(fp)) {
printk(KERN_ERR "[E-PEN]: failed to open %s.\n", WACOM_FW_PATH);
goto open_err;
}
fsize = fp->f_path.dentry->d_inode->i_size;
printk(KERN_NOTICE "[E-PEN]: start, file path %s, size %ld Bytes\n", WACOM_FW_PATH, fsize);
nread = vfs_read(fp, (char __user *)Binary, fsize, &fp->f_pos);
printk(KERN_ERR "[E-PEN]: nread %ld Bytes\n", nread);
if (nread != fsize) {
printk(KERN_ERR "[E-PEN]: failed to read firmware file, nread %ld Bytes\n", nread);
goto read_err;
}
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]: failed to write firmware(%d)\n", ret);
goto fw_write_err;
}
filp_close(fp, current->files);
set_fs(old_fs);
return 0;
open_err :
set_fs(old_fs);
return -ENOENT;
read_err :
filp_close(fp, current->files);
set_fs(old_fs);
return -EIO;
fw_write_err :
filp_close(fp, current->files);
set_fs(old_fs);
return -1;
}
int wacom_i2c_firm_update(struct wacom_i2c *wac_i2c)
{
int ret;
int retry = 3;
const struct firmware *firm_data = NULL;
firmware_updating_state = true;
while (retry--) {
ret =
request_firmware(&firm_data, firmware_name,
&wac_i2c->client->dev);
if (ret < 0) {
printk(KERN_ERR
"[E-PEN] Unable to open firmware. ret %d retry %d\n",
ret, retry);
continue;
}
wacom_i2c_set_firm_data((unsigned char *)firm_data->data);
ret = wacom_i2c_flash(wac_i2c);
if (ret == 0) {
release_firmware(firm_data);
break;
}
printk(KERN_ERR "[E-PEN] failed to write firmware(%d)\n", ret);
release_firmware(firm_data);
/* Reset IC */
wacom_i2c_reset_hw(wac_i2c->wac_pdata);
}
firmware_updating_state = false;
if (ret < 0)
return -1;
return 0;
}
int wacom_i2c_firm_update(struct wacom_i2c *wac_i2c)
{
int ret = 0;
int retry = 3;
while (retry--) {
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0)
dev_err(&wac_i2c->client->dev,
"%s: failed to write firmware(%d)\n",
__func__, ret);
else
dev_err(&wac_i2c->client->dev,
"%s: Successed to write firmware(%d)\n",
__func__, ret);
/* Reset IC */
wac_i2c->reset_platform_hw(wac_i2c);
if (ret >= 0)
return 0;
}
return ret;
}
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;
}
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;
}
int wacom_i2c_load_fw(struct i2c_client *client)
{
struct file *fp;
mm_segment_t old_fs;
long fsize, nread;
int ret;
struct wacom_i2c *wac_i2c = i2c_get_clientdata(client);
unsigned char *Binary_UMS = NULL;
Binary_UMS = kmalloc(WACOM_FW_SIZE, GFP_KERNEL);
if (Binary_UMS == NULL) {
printk(KERN_DEBUG "[E-PEN] %s, kmalloc failed\n", __func__);
return -ENOENT;
}
Binary = Binary_UMS;
old_fs = get_fs();
set_fs(KERNEL_DS);
fp = filp_open(WACOM_FW_PATH, O_RDONLY, S_IRUSR);
if (IS_ERR(fp)) {
printk(KERN_ERR "[E-PEN]: failed to open %s.\n", WACOM_FW_PATH);
goto open_err;
}
fsize = fp->f_path.dentry->d_inode->i_size;
printk(KERN_NOTICE "[E-PEN]: start, file path %s, size %ld Bytes\n", WACOM_FW_PATH, fsize);
if(fsize > WACOM_FW_SIZE) {
kfree(Binary_UMS);
printk(KERN_ERR "[E-PEN]: UMS file size (%ld) > WACOM_FW_SIZE (%d)\n", fsize, WACOM_FW_SIZE);
return -ENOENT;
}
nread = vfs_read(fp, (char __user *)Binary, fsize, &fp->f_pos);
printk(KERN_ERR "[E-PEN]: nread %ld Bytes\n", nread);
if (nread != fsize) {
printk(KERN_ERR "[E-PEN]: failed to read firmware file, nread %ld Bytes\n", nread);
goto read_err;
}
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]: failed to write firmware(%d)\n", ret);
goto fw_write_err;
}
#if 0 //#if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
Binary = Binary_44;
#endif
kfree(Binary_UMS);
filp_close(fp, current->files);
set_fs(old_fs);
return 0;
open_err :
kfree(Binary_UMS);
set_fs(old_fs);
return -ENOENT;
read_err :
kfree(Binary_UMS);
filp_close(fp, current->files);
set_fs(old_fs);
return -EIO;
fw_write_err :
kfree(Binary_UMS);
filp_close(fp, current->files);
set_fs(old_fs);
return -1;
}
static int wacom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct wacom_g5_platform_data *wac_pdata = client->dev.platform_data;
struct wacom_i2c *wac_i2c;
struct input_dev *input;
struct device *sec_epen;
int ret = 0;
/*Check I2C functionality*/
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("[E-PEN]: No I2C functionality found\n");
ret = -ENODEV;
goto fail;
}
/*Obtain kernel memory space for wacom i2c*/
wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL);
if (NULL == wac_i2c) {
pr_err("[E-PEN]: failed to allocate wac_i2c.\n");
ret = -ENOMEM;
goto err_freemem;
}
input = input_allocate_device();
if (NULL == input) {
pr_err("[E-PEN]: failed to allocate input device.\n");
ret = -ENOMEM;
goto err_input_allocate_device;
}
wac_i2c->wac_feature = &wacom_feature_EMR;
wac_i2c->wac_pdata = wac_pdata;
wac_i2c->input_dev = input;
wac_i2c->client = client;
wac_i2c->irq = client->irq;
/*Change below if irq is needed*/
wac_i2c->irq_flag = 1;
/*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);
wacom_i2c_query(wac_i2c);
#if defined(INIT_FIRMWARE_FLASH)
if (0 == wac_i2c->wac_feature->fw_version)
wacom_i2c_flash(wac_i2c);
#endif
wacom_i2c_set_input_values(client, wac_i2c, input);
if (wac_i2c->wac_pdata->xy_switch) {
input_set_abs_params(input, ABS_X, 0,
wac_i2c->wac_feature->y_max, 4, 0);
input_set_abs_params(input, ABS_Y, 0,
wac_i2c->wac_feature->x_max, 4, 0);
} else {
input_set_abs_params(input, ABS_X, 0,
wac_i2c->wac_feature->x_max, 4, 0);
input_set_abs_params(input, ABS_Y, 0,
wac_i2c->wac_feature->y_max, 4, 0);
}
input_set_abs_params(input, ABS_PRESSURE, 0,
wac_i2c->wac_feature->pressure_max, 0, 0);
input_set_drvdata(input, wac_i2c);
/*Before registering input device, data in each input_dev must be set*/
ret = input_register_device(input);
if (ret) {
pr_err("[E-PEN]: failed to register input device.\n");
goto err_register_device;
}
i2c_set_clientdata(client, wac_i2c);
/* if(wac_i2c->irq_flag) */
/* disable_irq(wac_i2c->irq); */
/*Initializing for semaphor*/
mutex_init(&wac_i2c->lock);
/*Request IRQ*/
if (wac_i2c->irq_flag) {
ret = request_threaded_irq(wac_i2c->irq, NULL,
wacom_interrupt,
IRQF_TRIGGER_RISING | IRQF_ONESHOT,
wac_i2c->name, wac_i2c);
if (ret < 0) {
pr_err("[E-PEN]: failed to request irq!\n");
goto err_irq;
}
}
g_client = client;
#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
sec_epen = device_create(sec_class, NULL, 0, wac_i2c, "sec_epen");
if (IS_ERR(sec_epen)) {
pr_err("[E-PEN]: failed to create device(sec_epen)!\n");
goto err_sysfs_create_group;
}
ret = sysfs_create_group(&sec_epen->kobj, &epen_attr_group);
if (ret) {
pr_err("[E-PEN]: failed to create sysfs group\n");
goto err_sysfs_create_group;
}
return 0;
err_sysfs_create_group:
free_irq(wac_i2c->irq, wac_i2c);
err_irq:
err_register_device:
input_unregister_device(input);
input = NULL;
err_input_allocate_device:
input_free_device(input);
err_freemem:
kfree(wac_i2c);
fail:
pr_err("[E-PEN]: fail occured\n");
return ret;
}
int wacom_i2c_query(struct wacom_i2c *wac_i2c)
{
struct wacom_features *wac_feature = wac_i2c->wac_feature;
struct i2c_msg msg[2];
int ret;
char buf;
u8 *data;
buf = COM_QUERY;
data = wac_feature->data;
msg[0].addr = wac_i2c->client->addr;
msg[0].flags = 0x00;
msg[0].len = 2;
msg[0].buf = (u8 *) &buf;
msg[1].addr = wac_i2c->client->addr;
msg[1].flags = I2C_M_RD;
msg[1].len = COM_COORD_NUM;
msg[1].buf = (u8 *) data;
ret = i2c_transfer(wac_i2c->client->adapter, msg, 2);
printk(KERN_INFO "[E-PEN]:%s:ret of i2c_transfer=%d\n", __func__, ret);
if (ret == 2)
printk(KERN_INFO "[E-PEN]:mesg=%d\n", ret);
else {
printk(KERN_ERR "[E-PEN]:Digitizer is not active(%d)\n", ret);
// return -1;
}
wac_feature->x_max = ((u16)data[1]<<8)+(u16)data[2];
wac_feature->y_max = ((u16)data[3]<<8)+(u16)data[4];
wac_feature->pressure_max = (u16)data[6]+((u16)data[5]<<8);
wac_feature->fw_version = ((u16)data[7]<<8)+(u16)data[8];
printk(KERN_NOTICE "[E-PEN]: x_max=0x%X\n", wac_feature->x_max);
printk(KERN_NOTICE "[E-PEN]: y_max=0x%X\n", wac_feature->y_max);
printk(KERN_NOTICE "[E-PEN]: pressure_max=0x%X\n",
wac_feature->pressure_max);
printk(KERN_NOTICE "[E-PEN]: fw_version=0x%X\n",
wac_feature->fw_version);
if (ret >= 0) {
if (wac_feature->fw_version != Firmware_version_of_file) {
printk(KERN_WARNING "[E-PEN]: Need to flash wacom digitizer;"
"entering flashing\n");
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]:Flashing wacom digitizer failed\n");
return -1;
}
if (ret == 0) {
msleep(1000);
ret = i2c_master_send(wac_i2c->client,
&buf, sizeof(buf));
msleep(1);
do {
ret = i2c_master_recv(wac_i2c->client,
data, COM_COORD_NUM);
if (ret < 1) {
printk(KERN_ERR "[E-PEN]:failed to get wacom features\n");
return -1;
}
} while (data[0] != 0x0f);
if (ret >= 0)
wac_feature->fw_version = ((u16)data[7]<<8)+(u16)data[8];
}
}
} else {
ret = wacom_i2c_flash(wac_i2c);
printk(KERN_NOTICE "[E-PEN]: flashed.\n");
if (ret < 0) {
printk(KERN_ERR "Flashing wacom digitizer failed\n");
return -1;
}
msleep(1000);
ret = i2c_master_send(wac_i2c->client, &buf, sizeof(buf));
msleep(1);
do {
ret = i2c_master_recv(wac_i2c->client, data, COM_COORD_NUM);
if (ret < 1) {
printk(KERN_ERR "failed to get wacom features\n");
return -1;
}
} while (data[0] != 0x0f);
if (ret >= 0)
wac_feature->fw_version = ((u16)data[7]<<8)+(u16)data[8];
}
return 0;
}
int wacom_i2c_firm_update(struct wacom_i2c *wac_i2c)
{
int ret;
int retry = 3;
const struct firmware *firm_data = NULL;
#if defined(CONFIG_MACH_KONA)
u8 *flash_data;
flash_data = kmalloc(65536*2, GFP_KERNEL);
if (IS_ERR(flash_data)) {
printk(KERN_ERR
"[E-PEN] %s, kmalloc failed\n", __func__);
return -1;
}
memset((void *)flash_data, 0xff, 65536*2);
#endif
firmware_updating_state = true;
while (retry--) {
ret =
request_firmware(&firm_data, firmware_name,
&wac_i2c->client->dev);
if (ret < 0) {
printk(KERN_ERR
"[E-PEN] Unable to open firmware. ret %d retry %d\n",
ret, retry);
continue;
}
#if defined(CONFIG_MACH_KONA)
memcpy((void *)flash_data,
(const void *)firm_data->data,
firm_data->size);
wacom_i2c_set_firm_data((unsigned char *)flash_data);
#else
wacom_i2c_set_firm_data((unsigned char *)firm_data->data);
#endif
ret = wacom_i2c_flash(wac_i2c);
if (ret == 0) {
release_firmware(firm_data);
break;
}
printk(KERN_ERR "[E-PEN] failed to write firmware(%d)\n", ret);
release_firmware(firm_data);
/* Reset IC */
wacom_i2c_reset_hw(wac_i2c->wac_pdata);
}
firmware_updating_state = false;
#if defined(CONFIG_MACH_KONA)
kfree(flash_data);
#endif
if (ret < 0)
return -1;
return 0;
}
int wacom_i2c_load_fw(struct i2c_client *client)
{
struct file *fp;
mm_segment_t old_fs;
long fsize, nread;
int ret;
struct wacom_i2c *wac_i2c = i2c_get_clientdata(client);
unsigned char *Binary_UMS = NULL;
#if defined(CONFIG_MACH_P4NOTE)
Binary_UMS = kmalloc(MAX_ADDR_514 + 1, GFP_KERNEL);
#else
Binary_UMS = kmalloc(WACOM_FW_SIZE, GFP_KERNEL);
#endif
if (Binary_UMS == NULL) {
printk(KERN_DEBUG "[E-PEN] %s, kmalloc failed\n", __func__);
return -ENOENT;
}
wacom_i2c_set_firm_data(Binary_UMS);
old_fs = get_fs();
set_fs(KERNEL_DS);
fp = filp_open(WACOM_FW_PATH, O_RDONLY, S_IRUSR);
if (IS_ERR(fp)) {
printk(KERN_ERR "[E-PEN] failed to open %s.\n", WACOM_FW_PATH);
goto open_err;
}
fsize = fp->f_path.dentry->d_inode->i_size;
printk(KERN_NOTICE "[E-PEN] start, file path %s, size %ld Bytes\n",
WACOM_FW_PATH, fsize);
nread = vfs_read(fp, (char __user *)Binary, fsize, &fp->f_pos);
printk(KERN_ERR "[E-PEN] nread %ld Bytes\n", nread);
if (nread != fsize) {
printk(KERN_ERR
"[E-PEN] failed to read firmware file, nread %ld Bytes\n",
nread);
goto read_err;
}
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR "[E-PEN] failed to write firmware(%d)\n", ret);
goto fw_write_err;
}
wacom_i2c_set_firm_data(NULL);
kfree(Binary_UMS);
filp_close(fp, current->files);
set_fs(old_fs);
return 0;
open_err:
kfree(Binary_UMS);
set_fs(old_fs);
return -ENOENT;
read_err:
kfree(Binary_UMS);
filp_close(fp, current->files);
set_fs(old_fs);
return -EIO;
fw_write_err:
kfree(Binary_UMS);
filp_close(fp, current->files);
set_fs(old_fs);
return -1;
}
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;
disable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
disable_irq(wac_i2c->irq_pdct);
#endif
wac_i2c->wac_feature->firm_update_status = 1;
printk(KERN_DEBUG "[E-PEN] %s\n", __func__);
/* F and B are used by Factory app, and R is used when boot */
switch (*buf) {
#ifdef WACOM_UMS_UPDATE
/* Block UMS update for MR */
case 'F':
printk(KERN_ERR "[E-PEN] Start firmware flashing (UMS).\n");
ret = wacom_i2c_load_fw(wac_i2c->client);
break;
#endif
case 'B':
printk(KERN_ERR
"[E-PEN] Start firmware flashing (kernel image).\n");
#ifdef CONFIG_MACH_Q1_BD
ret = wacom_i2c_firm_update(wac_i2c);
#else
ret = wacom_i2c_flash(wac_i2c);
#endif
break;
#ifdef CONFIG_MACH_Q1_BD
case 'R':
/* Q1 board rev 0.3 */
if (system_rev >= 6) {
if (wac_i2c->wac_feature->fw_version <
Firmware_version_of_file)
ret = wacom_i2c_firm_update(wac_i2c);
} else {
if (wac_i2c->wac_feature->fw_version !=
Firmware_version_of_file)
ret = wacom_i2c_firm_update(wac_i2c);
}
if (ret > 0) {
enable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
enable_irq(wac_i2c->irq_pdct);
#endif
return count;
}
break;
#endif
#if defined(CONFIG_MACH_P4NOTE)
case 'W':
if (Firmware_version_of_file !=
wac_i2c->wac_feature->fw_version)
schedule_work(&wac_i2c->update_work);
break;
#endif
default:
printk(KERN_ERR "[E-PEN] wrong parameter.\n");
goto param_err;
break;
}
if (ret < 0) {
printk(KERN_ERR "[E-PEN] failed to flash firmware.\n");
goto failure;
}
printk(KERN_ERR "[E-PEN] Finish firmware flashing.\n");
msleep(800);
wacom_i2c_query(wac_i2c);
wac_i2c->wac_feature->firm_update_status = 2;
enable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
enable_irq(wac_i2c->irq_pdct);
#endif
return count;
param_err:
failure:
wac_i2c->wac_feature->firm_update_status = -1;
enable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
enable_irq(wac_i2c->irq_pdct);
#endif
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);
u8 *data;
u8 buf_if;
int ret;
disable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
disable_irq(wac_i2c->irq_pdct);
#endif
buf_if = COM_QUERY;
data = wac_i2c->wac_feature->data;
wac_i2c->wac_feature->firm_update_status = 1;
if (*buf == 'F') {
printk(KERN_ERR "[E-PEN]: Start firmware flashing (UMS).\n");
ret = wacom_i2c_load_fw(wac_i2c->client);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]: failed to flash firmware.\n");
goto failure;
}
} else if (*buf == 'B') {
printk(KERN_ERR "[E-PEN]: Start firmware flashing (kernel image).\n");
#if 0 //#if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
Binary = Binary_44;
#endif
ret = wacom_i2c_flash(wac_i2c);
if (ret < 0) {
printk(KERN_ERR "[E-PEN]: failed to flash firmware.\n");
goto failure;
}
} else {
printk(KERN_ERR "[E-PEN]: wrong parameter.\n");
goto param_err;
}
printk(KERN_ERR "[E-PEN]: Finish firmware flashing.\n");
msleep(800);
wacom_i2c_query(wac_i2c);
wac_i2c->wac_feature->firm_update_status = 2;
enable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
enable_irq(wac_i2c->irq_pdct);
#endif
return count;
param_err:
failure:
wac_i2c->wac_feature->firm_update_status = -1;
enable_irq(wac_i2c->irq);
#ifdef WACOM_PDCT_WORK_AROUND
enable_irq(wac_i2c->irq_pdct);
#endif
return -1;
}
