static int asuspec_irq_ec_request(struct i2c_client *client)
{
int rc = 0 ;
unsigned gpio = asuspec_ecreq_gpio;
int irq = gpio_to_irq(gpio);
const char* label = "asuspec_request" ;
ASUSPEC_INFO("gpio = %d, irq = %d\n", gpio,irq);
ASUSPEC_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
rc = gpio_request(gpio, label);
if (rc) {
ASUSPEC_ERR("gpio_request failed for input %d\n", gpio);
goto err_exit;
}
rc = gpio_direction_output(gpio, 1) ;
if (rc) {
ASUSPEC_ERR("gpio_direction_output failed for input %d\n", gpio);
goto err_exit;
}
ASUSPEC_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
return 0 ;
err_exit:
return rc;
}
static int asuspec_chip_init(struct i2c_client *client)
{
int ret_val = 0;
int i = 0;
ec_chip->op_mode = 0;
for ( i = 0; i < 10; i++){
ret_val = asuspec_i2c_test(client);
if (ret_val < 0)
msleep(300);
else
break;
}
if(ret_val < 0){
goto fail_to_access_ec;
}
for ( i=0; i<8; i++){
asuspec_i2c_read_data(client);
}
if (asuspec_dockram_read_data(0x01) < 0){
goto fail_to_access_ec;
}
strcpy(ec_chip->ec_model_name, &ec_chip->i2c_dm_data[1]);
ASUSPEC_NOTICE("Model Name: %s\n", ec_chip->ec_model_name);
if (asuspec_dockram_read_data(0x02) < 0){
goto fail_to_access_ec;
}
strcpy(ec_chip->ec_version, &ec_chip->i2c_dm_data[1]);
ASUSPEC_NOTICE("EC-FW Version: %s\n", ec_chip->ec_version);
if (asuspec_dockram_read_data(0x03) < 0){
goto fail_to_access_ec;
}
ASUSPEC_INFO("EC-Config Format: %s\n", &ec_chip->i2c_dm_data[1]);
if (asuspec_dockram_read_data(0x04) < 0){
goto fail_to_access_ec;
}
strcpy(ec_chip->ec_pcba, &ec_chip->i2c_dm_data[1]);
ASUSPEC_NOTICE("PCBA Version: %s\n", ec_chip->ec_pcba);
if(factory_mode == 2)
asuspec_enter_factory_mode();
else
asuspec_enter_normal_mode();
ec_chip->status = 1;
switch_set_state(&ec_chip->pad_sdev, !ec_chip->pad_sdev.state);
fail_to_access_ec:
return 0;
}
static int asuspec_irq_ec_apwake(struct i2c_client *client)
{
int rc = 0 ;
unsigned gpio = asuspec_apwake_gpio;
int irq = gpio_to_irq(gpio);
const char* label = "asuspec_apwake" ;
ASUSPEC_INFO("GPIO = %d, irq = %d\n", gpio, irq);
ASUSPEC_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
tegra_gpio_enable(gpio);
rc = gpio_request(gpio, label);
if (rc) {
ASUSPEC_ERR("gpio_request failed for input %d\n", gpio);
goto err_request_input_gpio_failed;
}
rc = gpio_direction_input(gpio) ;
if (rc) {
ASUSPEC_ERR("gpio_direction_input failed for input %d\n", gpio);
goto err_gpio_direction_input_failed;
}
ASUSPEC_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
rc = request_irq(irq, asuspec_interrupt_handler,/*IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING|IRQF_TRIGGER_HIGH|*/IRQF_TRIGGER_LOW, label, client);
if (rc < 0) {
ASUSPEC_ERR("Could not register for %s interrupt, irq = %d, rc = %d\n", label, irq, rc);
rc = -EIO;
goto err_gpio_request_irq_fail ;
}
enable_irq_wake(gpio_to_irq(asuspec_apwake_gpio));
ASUSPEC_INFO("request irq = %d, rc = %d\n", irq, rc);
return 0 ;
err_gpio_request_irq_fail:
gpio_free(gpio);
err_gpio_direction_input_failed:
err_request_input_gpio_failed :
return rc;
return 0 ;
}
static irqreturn_t asuspec_interrupt_handler(int irq, void *dev_id){
int gpio = irq_to_gpio(irq);
ASUSPEC_INFO("interrupt irq = %d, gpio = %d\n", irq, gpio);
if (gpio == asuspec_apwake_gpio){
disable_irq_nosync(irq);
if (ec_chip->op_mode){
queue_delayed_work(asuspec_wq, &ec_chip->asuspec_fw_update_work, 0);
} else {
queue_delayed_work(asuspec_wq, &ec_chip->asuspec_work, 0);
}
}
return IRQ_HANDLED;
}
int asuspec_battery_monitor(char *cmd){
int ret_val = 0;
if (ec_chip->ec_in_s3){
asuspec_send_ec_req();
msleep(200);
}
ret_val = asuspec_dockram_read_battery(0x14);
if (ret_val == -1){
ASUSPEC_ERR("Fail to access battery info.\n");
return -1;
}
else {
#if FACTORY_MODE
if((factory_mode != 2) && (ec_chip->audio_recording == 0)){
mod_timer(&ec_chip->asuspec_timer,jiffies+(HZ * 1));
}
#else
if(ec_chip->audio_recording == 0){
mod_timer(&ec_chip->asuspec_timer,jiffies+(HZ * 1));
}
#endif
if (!strcmp(cmd, "status"))
ret_val = (ec_chip->i2c_dm_battery[2] << 8 ) | ec_chip->i2c_dm_battery[1];
else if (!strcmp(cmd, "temperature"))
ret_val = (ec_chip->i2c_dm_battery[8] << 8 ) | ec_chip->i2c_dm_battery[7];
else if (!strcmp(cmd, "voltage"))
ret_val = (ec_chip->i2c_dm_battery[10] << 8 ) | ec_chip->i2c_dm_battery[9];
else if (!strcmp(cmd, "current"))
ret_val = (ec_chip->i2c_dm_battery[12] << 8 ) | ec_chip->i2c_dm_battery[11];
else if (!strcmp(cmd, "capacity"))
ret_val = (ec_chip->i2c_dm_battery[14] << 8 ) | ec_chip->i2c_dm_battery[13];
else if (!strcmp(cmd, "remaining_capacity"))
ret_val = (ec_chip->i2c_dm_battery[16] << 8 ) | ec_chip->i2c_dm_battery[15];
else if (!strcmp(cmd, "avg_time_to_empty"))
ret_val = (ec_chip->i2c_dm_battery[18] << 8 ) | ec_chip->i2c_dm_battery[17];
else if (!strcmp(cmd, "avg_time_to_full"))
ret_val = (ec_chip->i2c_dm_battery[20] << 8 ) | ec_chip->i2c_dm_battery[19];
else {
ASUSPEC_ERR("Unknown command\n");
ret_val = -2;
}
ASUSPEC_INFO("cmd %s, return %d\n", cmd, ret_val);
return ret_val;
}
}
static int __devinit asuspec_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
ASUSPEC_INFO("asuspec probe\n");
err = sysfs_create_group(&client->dev.kobj, &asuspec_smbus_group);
if (err) {
ASUSPEC_ERR("Unable to create the sysfs\n");
goto exit;
}
ec_chip = kzalloc(sizeof (struct asuspec_chip), GFP_KERNEL);
if (!ec_chip) {
ASUSPEC_ERR("Memory allocation fails\n");
err = -ENOMEM;
goto exit;
}
ec_chip->pad_pid = tegra3_get_project_id();
i2c_set_clientdata(client, ec_chip);
ec_chip->client = client;
ec_chip->client->driver = &asuspec_driver;
ec_chip->client->flags = 1;
init_timer(&ec_chip->asuspec_timer);
ec_chip->asuspec_timer.function = asuspec_enter_s3_timer;
wake_lock_init(&ec_chip->wake_lock, WAKE_LOCK_SUSPEND, "asuspec_wake");
mutex_init(&ec_chip->lock);
mutex_init(&ec_chip->irq_lock);
mutex_init(&ec_chip->state_change_lock);
ec_chip->ec_ram_init = 0;
ec_chip->audio_recording = 0;
ec_chip->status = 0;
ec_chip->ec_in_s3 = 0;
ec_chip->apwake_disabled = 0;
ec_chip->storage_total = 0;
ec_chip->storage_avail = 0;
asuspec_dockram_init(client);
cdev_add(asuspec_cdev,asuspec_dev,1) ;
ec_chip->pad_sdev.name = PAD_SDEV_NAME;
ec_chip->pad_sdev.print_name = asuspec_switch_name;
ec_chip->pad_sdev.print_state = asuspec_switch_state;
if(switch_dev_register(&ec_chip->pad_sdev) < 0){
ASUSPEC_ERR("switch_dev_register for pad failed!\n");
}
switch_set_state(&ec_chip->pad_sdev, 0);
ec_chip->apower_sdev.name = APOWER_SDEV_NAME;
ec_chip->apower_sdev.print_name = apower_switch_name;
ec_chip->apower_sdev.print_state = apower_switch_state;
ec_chip->apower_state = 0;
if(switch_dev_register(&ec_chip->apower_sdev) < 0){
ASUSPEC_ERR("switch_dev_register for apower failed!\n");
}
switch_set_state(&ec_chip->apower_sdev, ec_chip->apower_state);
asuspec_wq = create_singlethread_workqueue("asuspec_wq");
INIT_DELAYED_WORK_DEFERRABLE(&ec_chip->asuspec_work, asuspec_work_function);
INIT_DELAYED_WORK_DEFERRABLE(&ec_chip->asuspec_init_work, asuspec_init_work_function);
INIT_DELAYED_WORK_DEFERRABLE(&ec_chip->asuspec_fw_update_work, asuspec_fw_update_work_function);
INIT_DELAYED_WORK_DEFERRABLE(&ec_chip->asuspec_enter_s3_work, asuspec_enter_s3_work_function);
INIT_DELAYED_WORK_DEFERRABLE(&asuspec_stress_work, asuspec_stresstest_work_function);
asuspec_irq_ec_request(client);
asuspec_irq_ec_apwake(client);
queue_delayed_work(asuspec_wq, &ec_chip->asuspec_init_work, 0);
return 0;
exit:
return err;
}