static int handle_hs_rpc_call(struct msm_rpc_server *server,
struct rpc_request_hdr *req, unsigned len)
{
struct rpc_keypad_pass_key_code_args {
uint32_t key_code;
uint32_t key_parm;
};
switch (req->procedure) {
case RPC_KEYPAD_NULL_PROC:
return 0;
case RPC_KEYPAD_PASS_KEY_CODE_PROC: {
struct rpc_keypad_pass_key_code_args *args;
args = (struct rpc_keypad_pass_key_code_args *)(req + 1);
args->key_code = be32_to_cpu(args->key_code);
args->key_parm = be32_to_cpu(args->key_parm);
report_hs_key(args->key_code, args->key_parm);
return 0;
}
case RPC_KEYPAD_SET_PWR_KEY_STATE_PROC:
/* This RPC function must be available for the ARM9
* to function properly. This function is redundant
* when RPC_KEYPAD_PASS_KEY_CODE_PROC is handled. So
* input_report_key is not needed.
*/
return 0;
default:
return -ENODEV;
}
}
static int handle_hs_rpc_call(struct msm_rpc_server *server,
struct rpc_request_hdr *req, unsigned len)
{
struct rpc_keypad_pass_key_code_args {
uint32_t key_code;
uint32_t key_parm;
};
switch (req->procedure) {
case RPC_KEYPAD_NULL_PROC:
return 0;
case RPC_KEYPAD_PASS_KEY_CODE_PROC: {
struct rpc_keypad_pass_key_code_args *args;
args = (struct rpc_keypad_pass_key_code_args *)(req + 1);
args->key_code = be32_to_cpu(args->key_code);
args->key_parm = be32_to_cpu(args->key_parm);
report_hs_key(args->key_code, args->key_parm);
return 0;
}
case RPC_KEYPAD_SET_PWR_KEY_STATE_PROC:
/*
*/
return 0;
default:
return -ENODEV;
}
}
static int process_subs_srvc_callback(struct hs_event_cb_recv *recv)
{
if (!recv)
return -ENODATA;
report_hs_key(be32_to_cpu(recv->key.code), be32_to_cpu(recv->key.parm));
return 0;
}
static int process_subs_srvc_callback(struct hs_event_cb_recv *recv)
{
if (!recv)
return -ENODATA;
//n0p - disable dejitter
// report_hs_key(be32_to_cpu(recv->key.code), be32_to_cpu(recv->key.parm));
// return 0;
//--
getnstimeofday(&btime);
curtime = btime.tv_sec & 0xFFFFF;
curtime = (btime.tv_sec * 1000) + (btime.tv_nsec/1000000);
//printk("DSC: curtime: %d",btime.tv_sec);
if ((curtime-prevtime)>KEYDELAY) {
//filteron=0;
prevtime=curtime;
report_hs_key(be32_to_cpu(recv->key.code), be32_to_cpu(recv->key.parm));
//errorcount=0;
return 0;
}
//Stale timer workaround
if ((curtime-prevtime)<=0) {
//errorcount++;
//disarm filter
//if (errorcount>0) { prevtime=curtime; report_hs_key(be32_to_cpu(recv->key.code), be32_to_cpu(recv->key.parm)); errorcount=0; };
prevtime=curtime;
report_hs_key(be32_to_cpu(recv->key.code), be32_to_cpu(recv->key.parm));
//printk("DSC: DJT: Timer error count: %d", errorcount);
return 0;
}
return 0;
}
static int fbx_kybd_config_gpio(void)
{
struct pm8058_gpio button_configuration = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_DN,
.vin_sel = 2,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
.inv_int_pol = 0,
};
int rc = 0;
printk(KERN_INFO "%s\n", __func__);
rc = pm8058_gpio_config(rd->pmic_gpio_vol_up, &button_configuration);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_vol_up);
return rc;
} else {
rc = gpio_request(rd->sys_gpio_vol_up, "vol_up_key");
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d requested failed\n", __func__, rd->sys_gpio_vol_up);
return rc;
} else {
rc = gpio_direction_input(rd->sys_gpio_vol_up);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_vol_up);
return rc;
}
}
}
rc = pm8058_gpio_config(rd->pmic_gpio_vol_dn, &button_configuration);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_vol_dn);
return rc;
} else {
rc = gpio_request(rd->sys_gpio_vol_dn, "vol_down_key");
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d requested failed\n", __func__, rd->sys_gpio_vol_dn);
return rc;
} else {
rc = gpio_direction_input(rd->sys_gpio_vol_dn);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_vol_dn);
return rc;
}
}
}
if (rd->product_phase == Product_PR1 || rd->product_phase == Product_EVB) {
rc = pm8058_gpio_config(rd->pmic_gpio_cam_t, &button_configuration);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_cam_t);
return rc;
} else {
rc = gpio_request(rd->sys_gpio_cam_t, "camera_key");
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d requested failed\n", __func__, rd->sys_gpio_cam_t);
return rc;
} else {
rc = gpio_direction_input(rd->sys_gpio_cam_t);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_cam_t);
return rc;
}
}
}
rc = pm8058_gpio_config(rd->pmic_gpio_cam_f, &button_configuration);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d configured failed\n", __func__, rd->pmic_gpio_cam_f);
return rc;
} else {
rc = gpio_request(rd->sys_gpio_cam_f, "camera_focus_key");
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: gpio %d requested failed\n", __func__, rd->sys_gpio_cam_f);
return rc;
} else {
rc = gpio_direction_input(rd->sys_gpio_cam_f);
if (rc < 0) {
dev_err(rd->fbx_kybd_pdev, "%s: set gpio %d direction failed\n", __func__, rd->sys_gpio_cam_f);
return rc;
}
}
}
}
/* Div1-FW3-BSP-AUDIO */
rc = gpio_request(rd->hook_sw_pin, "gpio_hook_sw");
if (rc) {
printk("gpio_request failed on pin(rc=%d)\n", rc);
return rc;
}
rc = gpio_direction_input(rd->hook_sw_pin);
if (rc) {
printk("gpio_direction_input failed on pin rc=%d\n", rc);
return rc;
}
return rc;
}
static void fbx_kybd_volup(struct work_struct *work)
{
struct fbx_kybd_record *kbdrec = container_of(work, struct fbx_kybd_record, qkybd_volup);
struct input_dev *idev = kbdrec->fbx_kybd_idev;
bool gpio_val = (bool)gpio_get_value_cansleep(kbdrec->sys_gpio_vol_up);
dev_dbg(kbdrec->fbx_kybd_pdev, "%s: Key VOLUMEUP (%d) %s\n", __func__, KEY_VOLUMEUP, !gpio_val ? "was RELEASED" : "is PRESSING");
if (!gpio_val) {
input_report_key(idev, KEY_VOLUMEUP, KEYRELEASE);
} else {
input_report_key(idev, KEY_VOLUMEUP, KEYPRESS);
}
input_sync(idev);
}
static void fbx_kybd_voldn(struct work_struct *work)
{
struct fbx_kybd_record *kbdrec = container_of(work, struct fbx_kybd_record, qkybd_voldn);
struct input_dev *idev = kbdrec->fbx_kybd_idev;
bool gpio_val = (bool)gpio_get_value_cansleep(kbdrec->sys_gpio_vol_dn);
dev_dbg(kbdrec->fbx_kybd_pdev, "%s: Key VOLUMEDOWN (%d) %s\n", __func__, KEY_VOLUMEDOWN, !gpio_val ? "was RELEASED" : "is PRESSING");
if (!gpio_val) {
input_report_key(idev, KEY_VOLUMEDOWN, KEYRELEASE);
} else {
input_report_key(idev, KEY_VOLUMEDOWN, KEYPRESS);
}
input_sync(idev);
}
static void fbx_kybd_camf(struct work_struct *work)
{
struct fbx_kybd_record *kbdrec = container_of(work, struct fbx_kybd_record, qkybd_camf);
struct input_dev *idev = kbdrec->fbx_kybd_idev;
bool gpio_val = (bool)gpio_get_value_cansleep(kbdrec->sys_gpio_cam_f);
dev_dbg(kbdrec->fbx_kybd_pdev, "%s: Key FOCUS (%d) %s\n", __func__, KEY_FOCUS, !gpio_val ? "was RELEASED" : "is PRESSING");
if (!gpio_val) {
input_report_key(idev, KEY_FOCUS, KEYRELEASE);
} else {
input_report_key(idev, KEY_FOCUS, KEYPRESS);
}
input_sync(idev);
}
static void fbx_kybd_camt(struct work_struct *work)
{
struct fbx_kybd_record *kbdrec = container_of(work, struct fbx_kybd_record, qkybd_camt);
struct input_dev *idev = kbdrec->fbx_kybd_idev;
bool gpio_val = (bool)gpio_get_value_cansleep(kbdrec->sys_gpio_cam_t);
dev_dbg(kbdrec->fbx_kybd_pdev, "%s: Key CAMERA (%d) %s\n", __func__, KEY_CAMERA, !gpio_val ? "was RELEASED" : "is PRESSING");
if (!gpio_val) {
input_report_key(idev, KEY_CAMERA, KEYRELEASE);
} else {
input_report_key(idev, KEY_CAMERA, KEYPRESS);
}
input_sync(idev);
}
/* Div1-FW3-BSP-AUDIO */
static void fbx_kybd_hooksw(struct work_struct *work)
{
//MM-SL-DisableHookInFTM-oo*{
#ifndef CONFIG_FIH_FTM
struct fbx_kybd_record *kbdrec= container_of(work, struct fbx_kybd_record, hook_switchkey);
struct input_dev *idev = kbdrec->fbx_kybd_idev;
bool hook_sw_val = (bool)gpio_get_value_cansleep(kbdrec->hook_sw_pin);
bool headset_status = (bool)gpio_get_value_cansleep(26);
if((rd->hooksw_irq_enable == true) && (headset_status == 1)){
disable_irq(MSM_GPIO_TO_INT(kbdrec->hook_sw_pin));
if(idev)
{
if (hook_sw_val) {
report_hs_key(HS_HEADSET_SWITCH_K, HS_REL_K);
printk("FIH: keyrelease KEY_HEADSETHOOK\n");
} else {
report_hs_key(HS_HEADSET_SWITCH_K, HS_NONE_K);
printk("FIH: keypress KEY_HEADSETHOOK\n");
}
input_sync(idev);
}
enable_irq(MSM_GPIO_TO_INT(kbdrec->hook_sw_pin));
enable_irq_wake(MSM_GPIO_TO_INT(kbdrec->hook_sw_pin));
}
#endif
//MM-SL-DisableHookInFTM-oo*}
}
static void fbx_kybd_free_irq(void)
{
free_irq(PM8058_GPIO_IRQ(PMIC8058_IRQ_BASE, rd->pmic_gpio_vol_up), rd);
free_irq(PM8058_GPIO_IRQ(PMIC8058_IRQ_BASE, rd->pmic_gpio_vol_dn), rd);
if (rd->product_phase == Product_PR1 || rd->product_phase == Product_EVB) {
free_irq(PM8058_GPIO_IRQ(PMIC8058_IRQ_BASE, rd->pmic_gpio_cam_f), rd);
free_irq(PM8058_GPIO_IRQ(PMIC8058_IRQ_BASE, rd->pmic_gpio_cam_t), rd);
}
/* Div1-FW3-BSP-AUDIO */
free_irq(MSM_GPIO_TO_INT(rd->hook_sw_pin), rd);
}
void report_chg_err_key(uint32_t key_code, uint32_t key_parm)
{
report_hs_key(key_code,key_parm);
}
