void main(int argc, char* argv[]) {
int c;
int ret=0;
int cmd;
i2c_init();
sscanf(argv[1],"%d",&cmd);
switch(cmd)
{
case HOOK:
printf("Hook Start\n");
ret=hook();
if(ret){
printf("HOOK FAIL\n");
return ;
}
printf("HOOK Up\n");
break;
case ERASE:
printf("Erasing Start\n");
ret=erase();
if(ret){
printf("ERASE FAIL\n");
return;
}
printf("Erase Done\n");
break;
case PROGRAM:
printf("Programming Start\n");
ret=program();
if(ret){
printf("PROGRAM FAIL\n");
return ;
}
printf("Program completed\n");
break;
case FW_VERSION:
ret=get_fw_version();
if(ret<0){
printf("GET FW_VERSION FAIL\n");
return ;
}
printf("%d\n",ret);
break;
default:
break;
}
close(i2c_fd);
//fclose(file);
return;
}
static ssize_t tc300k_firm_version_read_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tc300k_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
int ret;
ret = get_fw_version(data, false);
if (ret < 0)
dev_err(&client->dev, "%s: failed to read firmware version (%d)\n",
__func__, ret);
return sprintf(buf, "%d\n", data->fw_ver);
}
static int tc300k_fw_check(struct tc300k_data *data)
{
struct i2c_client *client = data->client;
int ret;
bool update = false;
ret = get_fw_version(data, true);
if (ret < 0) {
#if 0
if (info->pdata->lcd_connect) {
/* tsp connect check */
dev_err(&client->dev,
"%s: i2c fail. but lcd connected\n",
__func__);
dev_err(&client->dev,
"excute firm update\n");
update = true;
} else {
#endif
dev_err(&client->dev,
"%s: i2c fail...[%d], addr[%d]\n",
__func__, ret, data->client->addr);
dev_err(&client->dev,
"%s: touchkey driver unload\n", __func__);
return ret;
}
if (data->fw_ver < TC300K_FIRMWARE_VER) {
dev_notice(&client->dev,
"fw_version check excute firmware update(0x%x, 0x%x)\n",
data->fw_ver, TC300K_FIRMWARE_VER);
update = true;
}
if (update) {
ret = tc300k_fw_update(data, FW_INKERNEL, true);
if (ret)
return -1;
}
return 0;
}
static int __devinit tc300k_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct input_dev *input_dev;
struct tc300k_data *data;
int ret;
int i;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev,
"i2c_check_functionality fail\n");
return -EIO;
}
data = kzalloc(sizeof(struct tc300k_data), GFP_KERNEL);
if (!data) {
dev_err(&client->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_alloc_data;
}
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev,
"Failed to allocate memory for input device\n");
ret = -ENOMEM;
goto err_alloc_input;
}
data->client = client;
data->input_dev = input_dev;
data->pdata = client->dev.platform_data;
if (data->pdata == NULL) {
pr_err("failed to get platform data\n");
ret = -EINVAL;
goto err_platform_data;
}
data->irq = -1;
mutex_init(&data->lock);
data->key_num = data->pdata->key_num;
dev_info(&client->dev, "number of keys = %d\n", data->key_num);
data->keycode = data->pdata->keycode;
#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
for (i = 1; i < data->key_num; i++)
dev_info(&client->dev, "keycode[%d]= %3d\n", i, data->keycode[i]);
#endif
i2c_set_clientdata(client, data);
data->pdata->keyled(true);
data->pdata->power(true);
data->enabled = true;
msleep(TC300K_POWERON_DELAY);
ret = tc300k_fw_check(data);
if (ret) {
dev_err(&client->dev,
"failed to firmware check(%d)\n", ret);
goto err_fw_check;
}
snprintf(data->phys, sizeof(data->phys),
"%s/input0", dev_name(&client->dev));
input_dev->name = "sec_touchkey";
input_dev->phys = data->phys;
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
input_dev->open = tc300k_input_open;
input_dev->close = tc300k_input_close;
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_LED, input_dev->evbit);
set_bit(LED_MISC, input_dev->ledbit);
for (i = 1; i < data->key_num; i++)
set_bit(data->keycode[i], input_dev->keybit);
input_set_drvdata(input_dev, data);
ret = input_register_device(input_dev);
if (ret) {
dev_err(&client->dev, "fail to register input_dev (%d)\n",
ret);
goto err_register_input_dev;
}
ret = request_threaded_irq(client->irq, NULL, tc300k_interrupt,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
TC300K_NAME, data);
if (ret < 0) {
dev_err(&client->dev, "fail to request irq (%d).\n",
client->irq);
goto err_request_irq;
}
data->irq = client->irq;
#ifdef CONFIG_HAS_EARLYSUSPEND
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
data->early_suspend.suspend = tc300k_early_suspend;
data->early_suspend.resume = tc300k_late_resume;
register_early_suspend(&data->early_suspend);
#endif
data->sec_touchkey = device_create(sec_class,
NULL, 0, data, "sec_touchkey");
if (IS_ERR(data->sec_touchkey))
dev_err(&client->dev,
"Failed to create device for the touchkey sysfs\n");
ret = sysfs_create_group(&data->sec_touchkey->kobj,
&sec_touchkey_attr_group);
if (ret)
dev_err(&client->dev, "Failed to create sysfs group\n");
dev_info(&client->dev, "%s done\n", __func__);
return 0;
err_request_irq:
input_unregister_device(input_dev);
err_register_input_dev:
err_fw_check:
mutex_destroy(&data->lock);
data->pdata->keyled(false);
data->pdata->power(false);
err_platform_data:
input_free_device(input_dev);
err_alloc_input:
kfree(data);
err_alloc_data:
return ret;
}
static int __devexit tc300k_remove(struct i2c_client *client)
{
struct tc300k_data *data = i2c_get_clientdata(client);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
free_irq(data->irq, data);
input_unregister_device(data->input_dev);
input_free_device(data->input_dev);
mutex_destroy(&data->lock);
data->pdata->keyled(false);
data->pdata->power(false);
gpio_free(data->pdata->gpio_int);
gpio_free(data->pdata->gpio_sda);
gpio_free(data->pdata->gpio_scl);
kfree(data);
return 0;
}
static void tc300k_shutdown(struct i2c_client *client)
{
struct tc300k_data *data = i2c_get_clientdata(client);
data->pdata->keyled(false);
data->pdata->power(false);
}
#if defined(CONFIG_PM)
static int tc300k_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct tc300k_data *data = i2c_get_clientdata(client);
int i;
int ret;
mutex_lock(&data->lock);
if (!data->enabled)
return 0;
dev_notice(&data->client->dev, "%s: users=%d\n",
__func__, data->input_dev->users);
disable_irq(data->irq);
data->enabled = false;
release_all_fingers(data);
data->pdata->power(false);
data->pdata->keyled(false);
mutex_unlock(&data->lock);
return 0;
}
static int tc300k_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct tc300k_data *data = i2c_get_clientdata(client);
mutex_lock(&data->lock);
if (data->enabled)
return 0;
dev_notice(&data->client->dev, "%s: users=%d\n",
__func__, data->input_dev->users);
data->enabled = true;
data->pdata->keyled(true);
data->pdata->power(true);
msleep(50);
enable_irq(data->irq);
msleep(50);
mutex_unlock(&data->lock);
return 0;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void tc300k_early_suspend(struct early_suspend *h)
{
struct tc300k_data *data;
data = container_of(h, struct tc300k_data, early_suspend);
tc300k_suspend(&data->client->dev);
}
static void tc300k_late_resume(struct early_suspend *h)
{
struct tc300k_data *data;
data = container_of(h, struct tc300k_data, early_suspend);
tc300k_resume(&data->client->dev);
}
#endif
static void tc300k_input_close(struct input_dev *dev)
{
struct tc300k_data *data = input_get_drvdata(dev);
dev_info(&data->client->dev, "%s: users=%d\n", __func__,
data->input_dev->users);
tc300k_suspend(&data->client->dev);
}
static int tc300k_input_open(struct input_dev *dev)
{
struct tc300k_data *data = input_get_drvdata(dev);
dev_info(&data->client->dev, "%s: users=%d\n", __func__,
data->input_dev->users);
tc300k_resume(&data->client->dev);
return 0;
}
#endif /* CONFIG_PM */
#if 0
#if defined(CONFIG_PM) || defined(CONFIG_HAS_EARLYSUSPEND)
static const struct dev_pm_ops tc300k_pm_ops = {
.suspend = tc300k_suspend,
.resume = tc300k_resume,
};
#endif
#endif
static const struct i2c_device_id tc300k_id[] = {
{TC300K_NAME, 0},
{ }
};
MODULE_DEVICE_TABLE(i2c, tc300k_id);
static struct i2c_driver tc300k_driver = {
.probe = tc300k_probe,
.remove = __devexit_p(tc300k_remove),
.shutdown = tc300k_shutdown,
.driver = {
.name = TC300K_NAME,
.owner = THIS_MODULE,
#if 0
#if defined(CONFIG_PM) && !defined(CONFIG_HAS_EARLYSUSPEND)
.pm = &tc370_pm_ops,
#endif
#endif
},
.id_table = tc300k_id,
};
static int tc300k_fw_update(struct tc300k_data *data, u8 fw_path, bool force)
{
struct i2c_client *client = data->client;
int retry = 4;
int ret;
if (fw_path == FW_INKERNEL) {
if (!force) {
ret = get_fw_version(data, false);
if (ret)
return -1;
}
ret = load_fw_in_kernel(data);
if (ret)
return -1;
if (!force && (data->fw_ver >= data->fw_img->first_fw_ver)) {
dev_notice(&client->dev, "do not need firm update (0x%x, 0x%x)\n",
data->fw_ver, data->fw_img->first_fw_ver);
t300k_release_fw(data, fw_path);
return 0;
}
} else if (fw_path == FW_SDCARD) {
ret = load_fw_sdcard(data);
if (ret)
return -1;
}
while (retry--) {
data->fw_downloding = true;
ret = tc300k_flash_fw(data, fw_path);
data->fw_downloding = false;
if (ret) {
dev_err(&client->dev, "%s tc300k_flash_fw fail (%d)\n",
__func__, retry);
continue;
}
ret = get_fw_version(data, false);
if (ret) {
dev_err(&client->dev, "%s get_fw_version fail (%d)\n",
__func__, retry);
continue;
}
if (data->fw_ver != data->fw_img->first_fw_ver) {
dev_err(&client->dev, "%s fw version fail (0x%x, 0x%x)(%d)\n",
__func__, data->fw_ver, data->fw_img->first_fw_ver, retry);
continue;
}
ret = tc300k_crc_check(data);
if (ret) {
dev_err(&client->dev, "%s crc check fail (%d)\n",
__func__, retry);
continue;
}
break;
}
if (retry > 0)
dev_info(&client->dev, "%s success\n", __func__);
t300k_release_fw(data, fw_path);
return ret;
}
