/* * Generate software autorepeat event. Note that we take * dev->event_lock here to avoid racing with input_event * which may cause keys get "stuck". */ static void input_repeat_key(unsigned long data) { struct input_dev *dev = (void *) data; unsigned long flags; spin_lock_irqsave(&dev->event_lock, flags); if (test_bit(dev->repeat_key, dev->key) && is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) { input_pass_event(dev, EV_KEY, dev->repeat_key, 2); if (dev->sync) { /* * Only send SYN_REPORT if we are not in a middle * of driver parsing a new hardware packet. * Otherwise assume that the driver will send * SYN_REPORT once it's done. */ input_pass_event(dev, EV_SYN, SYN_REPORT, 1); } if (dev->rep[REP_PERIOD]) mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_PERIOD])); } spin_unlock_irqrestore(&dev->event_lock, flags); }
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; if (is_event_supported(type, dev->evbit, EV_MAX)) { spin_lock_irqsave(&dev->event_lock, flags); input_handle_event(dev, type, code, value); spin_unlock_irqrestore(&dev->event_lock, flags); } }
/** * input_inject_event() - send input event from input handler * @handle: input handle to send event through * @type: type of the event * @code: event code * @value: value of the event * * Similar to input_event() but will ignore event if device is * "grabbed" and handle injecting event is not the one that owns * the device. */ void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value) { struct input_dev *dev = handle->dev; struct input_handle *grab; unsigned long flags; if (is_event_supported(type, dev->evbit, EV_MAX)) { spin_lock_irqsave(&dev->event_lock, flags); grab = rcu_dereference(dev->grab); if (!grab || grab == handle) input_handle_event(dev, type, code, value); spin_unlock_irqrestore(&dev->event_lock, flags); } }
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; if (is_event_supported(type, dev->evbit, EV_MAX)) { //henry+mouse speed setting if(type==EV_REL && (code==REL_X || code==REL_Y)){ //printk("Henry>>add speed!\n"); value=(int) ( (value * m_speed) / 4); } spin_lock_irqsave(&dev->event_lock, flags); add_input_randomness(type, code, value); input_handle_event(dev, type, code, value); spin_unlock_irqrestore(&dev->event_lock, flags); } }
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; if (is_event_supported(type, dev->evbit, EV_MAX)) { spin_lock_irqsave(&dev->event_lock, flags); add_input_randomness(type, code, value); #ifdef CONFIG_FAKE_PM if(code == 116) input_handle_event(dev, type, code, value); else if(if_in_suspend == 0) { #endif input_handle_event(dev, type, code, value); #ifdef CONFIG_FAKE_PM } #endif spin_unlock_irqrestore(&dev->event_lock, flags); } }
static void input_repeat_key(unsigned long data) { struct input_dev *dev = (void *) data; unsigned long flags; spin_lock_irqsave(&dev->event_lock, flags); if (test_bit(dev->repeat_key, dev->key) && is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) { struct input_value vals[] = { { EV_KEY, dev->repeat_key, 2 }, input_value_sync }; input_pass_values(dev, vals, ARRAY_SIZE(vals)); if (dev->rep[REP_PERIOD]) mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_PERIOD])); } spin_unlock_irqrestore(&dev->event_lock, flags); }
static void input_handle_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { int disposition = INPUT_IGNORE_EVENT; switch (type) { case EV_SYN: switch (code) { case SYN_CONFIG: disposition = INPUT_PASS_TO_ALL; break; case SYN_REPORT: if (!dev->sync) { dev->sync = 1; disposition = INPUT_PASS_TO_HANDLERS; } break; case SYN_MT_REPORT: dev->sync = 0; disposition = INPUT_PASS_TO_HANDLERS; break; } break; case EV_KEY: if (is_event_supported(code, dev->keybit, KEY_MAX) && !!test_bit(code, dev->key) != value) { if (value != 2) { __change_bit(code, dev->key); if (value) input_start_autorepeat(dev, code); } disposition = INPUT_PASS_TO_HANDLERS; } break; case EV_SW: if (is_event_supported(code, dev->swbit, SW_MAX) && !!test_bit(code, dev->sw) != value) { __change_bit(code, dev->sw); disposition = INPUT_PASS_TO_HANDLERS; } break; case EV_ABS: if (is_event_supported(code, dev->absbit, ABS_MAX)) { if (test_bit(code, input_abs_bypass)) { disposition = INPUT_PASS_TO_HANDLERS; break; } value = input_defuzz_abs_event(value, dev->abs[code], dev->absfuzz[code]); if (dev->abs[code] != value) { dev->abs[code] = value; disposition = INPUT_PASS_TO_HANDLERS; } } break; case EV_REL: if (is_event_supported(code, dev->relbit, REL_MAX) && value) disposition = INPUT_PASS_TO_HANDLERS; break; case EV_MSC: if (is_event_supported(code, dev->mscbit, MSC_MAX)) disposition = INPUT_PASS_TO_ALL; break; case EV_LED: if (is_event_supported(code, dev->ledbit, LED_MAX) && !!test_bit(code, dev->led) != value) { __change_bit(code, dev->led); disposition = INPUT_PASS_TO_ALL; } break; case EV_SND: if (is_event_supported(code, dev->sndbit, SND_MAX)) { if (!!test_bit(code, dev->snd) != !!value) __change_bit(code, dev->snd); disposition = INPUT_PASS_TO_ALL; } break; case EV_REP: if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) { dev->rep[code] = value; disposition = INPUT_PASS_TO_ALL; } break; case EV_FF: if (value >= 0) disposition = INPUT_PASS_TO_ALL; break; case EV_PWR: disposition = INPUT_PASS_TO_ALL; break; } if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN) dev->sync = 0; if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event) dev->event(dev, type, code, value); if (disposition & INPUT_PASS_TO_HANDLERS) input_pass_event(dev, type, code, value); }
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; /* * Forced upload mode key string (tkhwang) */ #ifdef CONFIG_KERNEL_DEBUG_SEC static bool first=0, second=0, third = 0; #if defined (CONFIG_KEYPAD_S3C) if(strcmp(dev->name,"s3c-keypad")==0) { if(value) { if(code==KERNEL_SEC_FORCED_UPLOAD_1ST_KEY) { first =1; } if(first==1 && code==KERNEL_SEC_FORCED_UPLOAD_2ND_KEY) { if ( (KERNEL_SEC_DEBUG_LEVEL_MID == kernel_sec_get_debug_level()) || KERNEL_SEC_DEBUG_LEVEL_HIGH == kernel_sec_get_debug_level() ) { // Display the working callstack for the debugging. dump_stack(); if (kernel_sec_viraddr_wdt_reset_reg) { kernel_sec_set_cp_upload(); kernel_sec_save_final_context(); // Save theh final context. kernel_sec_set_upload_cause(UPLOAD_CAUSE_FORCED_UPLOAD); kernel_sec_hw_reset(false); // Reboot. } } } } else { if(code==KERNEL_SEC_FORCED_UPLOAD_1ST_KEY) { first = 0; } } } #endif //CONFIG_KEYPAD_S3C #if defined (CONFIG_KEYBOARD_GPIO) if(strcmp(dev->name,"gpio-keys")==0) { if(value) { if(code == KEY_VOLUMEUP) first = true; if(code == KEY_POWER) second = true; if(code == KEY_VOLUMEDOWN) third = true; if(first&&second&&third) { if (kernel_sec_viraddr_wdt_reset_reg) { printk("[%s][line:%d]\n",__func__, __LINE__); kernel_sec_set_cp_upload(); kernel_sec_save_final_context(); // Save theh final context. kernel_sec_set_upload_cause(UPLOAD_CAUSE_FORCED_UPLOAD); kernel_sec_hw_reset(false); // Reboot. } } } else { if(code == KEY_VOLUMEUP) first = false; if(code == KEY_POWER) second = false; if(code == KEY_VOLUMEDOWN) third = false; } } #endif //CONFIG_KEYBOARD_GPIO #endif // CONFIG_KERNEL_DEBUG_SEC if (is_event_supported(type, dev->evbit, EV_MAX)) { spin_lock_irqsave(&dev->event_lock, flags); add_input_randomness(type, code, value); input_handle_event(dev, type, code, value); spin_unlock_irqrestore(&dev->event_lock, flags); } }
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; /* * Forced upload mode key string (tkhwang) */ #ifdef CONFIG_KERNEL_DEBUG_SEC static int first=0, second=0; if(strcmp(dev->name,"s3c-keypad")==0) { if(value) { if(code==KERNEL_SEC_FORCED_UPLOAD_1ST_KEY) { first =1; } if(first==1 && code==KERNEL_SEC_FORCED_UPLOAD_2ND_KEY) { printk(KERN_ERR"level %d reg %x \n",kernel_sec_get_debug_level(), kernel_sec_viraddr_wdt_reset_reg); if ( (KERNEL_SEC_DEBUG_LEVEL_MID == kernel_sec_get_debug_level()) || KERNEL_SEC_DEBUG_LEVEL_HIGH == kernel_sec_get_debug_level() ) { printk(KERN_ERR" USER Press volume key + Power key ==> Force RAM DUMP \n"); #if 0 // Display the working callstack for the debugging. dump_stack(); if (kernel_sec_viraddr_wdt_reset_reg) { kernel_sec_set_cp_upload(); kernel_sec_save_final_context(); // Save theh final context. kernel_sec_set_upload_cause(UPLOAD_CAUSE_FORCED_UPLOAD); kernel_sec_hw_reset(false); // Reboot. } #endif } } } else { if(code==KERNEL_SEC_FORCED_UPLOAD_1ST_KEY) { first = 0; } } } #endif // CONFIG_KERNEL_DEBUG_SEC if (is_event_supported(type, dev->evbit, EV_MAX)) { spin_lock_irqsave(&dev->event_lock, flags); add_input_randomness(type, code, value); input_handle_event(dev, type, code, value); spin_unlock_irqrestore(&dev->event_lock, flags); } }
static int set_parameters(struct quadd_parameters *p, uid_t *debug_app_uid) { int i, err, uid = 0; int pmu_events_id[QUADD_MAX_COUNTERS]; int pl310_events_id; int nr_pmu = 0, nr_pl310 = 0; struct task_struct *task; unsigned int extra; u64 *low_addr_p; if (!validate_freq(p->freq)) { pr_err("%s: incorrect frequency: %u\n", __func__, p->freq); return -EINVAL; } ctx.param.freq = p->freq; ctx.param.ma_freq = p->ma_freq; ctx.param.backtrace = p->backtrace; ctx.param.use_freq = p->use_freq; ctx.param.system_wide = p->system_wide; ctx.param.power_rate_freq = p->power_rate_freq; ctx.param.debug_samples = p->debug_samples; for (i = 0; i < ARRAY_SIZE(p->reserved); i++) ctx.param.reserved[i] = p->reserved[i]; /* Currently only one process */ if (p->nr_pids != 1) return -EINVAL; p->package_name[sizeof(p->package_name) - 1] = '\0'; rcu_read_lock(); task = pid_task(find_vpid(p->pids[0]), PIDTYPE_PID); rcu_read_unlock(); if (!task) { pr_err("Process not found: %u\n", p->pids[0]); return -ESRCH; } pr_info("owner/task uids: %u/%u\n", current_fsuid(), task_uid(task)); if (!capable(CAP_SYS_ADMIN)) { if (current_fsuid() != task_uid(task)) { uid = quadd_auth_is_debuggable((char *)p->package_name); if (uid < 0) { pr_err("Error: QuadD security service\n"); return uid; } else if (uid == 0) { pr_err("Error: app is not debuggable\n"); return -EACCES; } *debug_app_uid = uid; pr_info("debug_app_uid: %u\n", uid); } ctx.collect_kernel_ips = 0; } else { ctx.collect_kernel_ips = 1; } for (i = 0; i < p->nr_pids; i++) ctx.param.pids[i] = p->pids[i]; ctx.param.nr_pids = p->nr_pids; for (i = 0; i < p->nr_events; i++) { int event = p->events[i]; if (ctx.pmu && ctx.pmu_info.nr_supported_events > 0 && is_event_supported(&ctx.pmu_info, event)) { pmu_events_id[nr_pmu++] = p->events[i]; pr_info("PMU active event: %s\n", quadd_get_event_str(event)); } else if (ctx.pl310 && ctx.pl310_info.nr_supported_events > 0 && is_event_supported(&ctx.pl310_info, event)) { pl310_events_id = p->events[i]; pr_info("PL310 active event: %s\n", quadd_get_event_str(event)); if (nr_pl310++ > 1) { pr_err("error: multiply pl310 events\n"); return -EINVAL; } } else { pr_err("Bad event: %s\n", quadd_get_event_str(event)); return -EINVAL; } } if (ctx.pmu) { if (nr_pmu > 0) { err = ctx.pmu->set_events(pmu_events_id, nr_pmu); if (err) { pr_err("PMU set parameters: error\n"); return err; } ctx.pmu_info.active = 1; } else { ctx.pmu_info.active = 0; ctx.pmu->set_events(NULL, 0); } } if (ctx.pl310) { if (nr_pl310 == 1) { err = ctx.pl310->set_events(&pl310_events_id, 1); if (err) { pr_info("pl310 set_parameters: error\n"); return err; } ctx.pl310_info.active = 1; } else { ctx.pl310_info.active = 0; ctx.pl310->set_events(NULL, 0); } } extra = p->reserved[QUADD_PARAM_IDX_EXTRA]; if (extra & QUADD_PARAM_EXTRA_BT_UNWIND_TABLES) pr_info("unwinding: exception-handling tables\n"); if (extra & QUADD_PARAM_EXTRA_BT_FP) pr_info("unwinding: frame pointers\n"); if (extra & QUADD_PARAM_EXTRA_BT_MIXED) pr_info("unwinding: mixed mode\n"); low_addr_p = (u64 *)&p->reserved[QUADD_PARAM_IDX_BT_LOWER_BOUND]; ctx.hrt->low_addr = (unsigned long)*low_addr_p; pr_info("bt lower bound: %#lx\n", ctx.hrt->low_addr); err = quadd_unwind_start(task); if (err) return err; pr_info("New parameters have been applied\n"); return 0; }
static void input_handle_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { int disposition = INPUT_IGNORE_EVENT; switch (type) { case EV_SYN: switch (code) { case SYN_CONFIG: disposition = INPUT_PASS_TO_ALL; break; case SYN_REPORT: if (!dev->sync) { dev->sync = 1; disposition = INPUT_PASS_TO_HANDLERS; } break; case SYN_MT_REPORT: dev->sync = 0; disposition = INPUT_PASS_TO_HANDLERS; break; } break; case EV_KEY: if (is_event_supported(code, dev->keybit, KEY_MAX) && !!test_bit(code, dev->key) != value) { if (value != 2) { __change_bit(code, dev->key); if (value) input_start_autorepeat(dev, code); else input_stop_autorepeat(dev); } disposition = INPUT_PASS_TO_HANDLERS; } break; case EV_SW: if (is_event_supported(code, dev->swbit, SW_MAX) && !!test_bit(code, dev->sw) != value) { __change_bit(code, dev->sw); disposition = INPUT_PASS_TO_HANDLERS; } break; case EV_ABS: if (is_event_supported(code, dev->absbit, ABS_MAX)) { if (test_bit(code, input_abs_bypass)) { disposition = INPUT_PASS_TO_HANDLERS; break; } value = input_defuzz_abs_event(value, dev->abs[code], dev->absfuzz[code]); if (dev->abs[code] != value) { dev->abs[code] = value; disposition = INPUT_PASS_TO_HANDLERS; } //Div2D5-OwenHuang-BSP2030_FB0_FQC_ALS-01-{ //Div2D5-OwenHuang-BSP2030_FB0_FQC_ALS-00+{ //#if defined(CONFIG_NEW_YAMAHA_SENSORS) #if 0 //always report light sensor data if (strcmp(dev->name, "light") == 0 && dev->abs[code] == value) { ktime_get_ts(¤t_ts); //get current time if (current_ts.tv_sec - previous_ts.tv_sec > 2) //pending time is bigger than 2 second { //printk("[%s][Report]input device name(%s), value(%d)\n", __func__, // dev->name, value); previous_ts.tv_sec = current_ts.tv_sec; dev->abs[code] = value; disposition = INPUT_PASS_TO_HANDLERS; } } #endif //Div2D5-OwenHuang-BSP2030_FB0_FQC_ALS-00+} //Div2D5-OwenHuang-BSP2030_FB0_FQC_ALS-01-} } break; case EV_REL: if (is_event_supported(code, dev->relbit, REL_MAX) && value) disposition = INPUT_PASS_TO_HANDLERS; break; case EV_MSC: if (is_event_supported(code, dev->mscbit, MSC_MAX)) disposition = INPUT_PASS_TO_ALL; break; case EV_LED: if (is_event_supported(code, dev->ledbit, LED_MAX) && !!test_bit(code, dev->led) != value) { __change_bit(code, dev->led); disposition = INPUT_PASS_TO_ALL; } break; case EV_SND: if (is_event_supported(code, dev->sndbit, SND_MAX)) { if (!!test_bit(code, dev->snd) != !!value) __change_bit(code, dev->snd); disposition = INPUT_PASS_TO_ALL; } break; case EV_REP: if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) { dev->rep[code] = value; disposition = INPUT_PASS_TO_ALL; } break; case EV_FF: if (value >= 0) disposition = INPUT_PASS_TO_ALL; break; case EV_PWR: disposition = INPUT_PASS_TO_ALL; break; } if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN) dev->sync = 0; if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event) dev->event(dev, type, code, value); if (disposition & INPUT_PASS_TO_HANDLERS) input_pass_event(dev, type, code, value); }
static int set_parameters(struct quadd_parameters *param, uid_t *debug_app_uid) { int i, err; int pmu_events_id[QUADD_MAX_COUNTERS]; int pl310_events_id; int nr_pmu = 0, nr_pl310 = 0; int uid = 0; struct task_struct *task; if (ctx.param.freq != 100 && ctx.param.freq != 1000 && ctx.param.freq != 10000) return -EINVAL; ctx.param.freq = param->freq; ctx.param.ma_freq = param->ma_freq; ctx.param.backtrace = param->backtrace; ctx.param.use_freq = param->use_freq; ctx.param.system_wide = param->system_wide; ctx.param.power_rate_freq = param->power_rate_freq; ctx.param.debug_samples = param->debug_samples; /* Currently only one process */ if (param->nr_pids != 1) return -EINVAL; rcu_read_lock(); task = pid_task(find_vpid(param->pids[0]), PIDTYPE_PID); rcu_read_unlock(); if (!task) { pr_err("Process not found: %u\n", param->pids[0]); return -ESRCH; } pr_info("owner/task uids: %u/%u\n", current_fsuid(), task_uid(task)); if (!capable(CAP_SYS_ADMIN)) { if (current_fsuid() != task_uid(task)) { uid = quadd_auth_check_debug_flag(param->package_name); if (uid < 0) { pr_err("Error: QuadD security service\n"); return uid; } else if (uid == 0) { pr_err("Error: app is not debuggable\n"); return -EACCES; } *debug_app_uid = uid; pr_info("debug_app_uid: %u\n", uid); } ctx.collect_kernel_ips = 0; } else { ctx.collect_kernel_ips = 1; } for (i = 0; i < param->nr_pids; i++) ctx.param.pids[i] = param->pids[i]; ctx.param.nr_pids = param->nr_pids; for (i = 0; i < param->nr_events; i++) { int event = param->events[i]; if (ctx.pmu && ctx.pmu_info.nr_supported_events > 0 && is_event_supported(&ctx.pmu_info, event)) { pmu_events_id[nr_pmu++] = param->events[i]; pr_info("PMU active event: %s\n", quadd_get_event_str(event)); } else if (ctx.pl310 && ctx.pl310_info.nr_supported_events > 0 && is_event_supported(&ctx.pl310_info, event)) { pl310_events_id = param->events[i]; pr_info("PL310 active event: %s\n", quadd_get_event_str(event)); if (nr_pl310++ > 1) { pr_err("error: multiply pl310 events\n"); return -EINVAL; } } else { pr_err("Bad event: %s\n", quadd_get_event_str(event)); return -EINVAL; } } if (ctx.pmu) { if (nr_pmu > 0) { err = ctx.pmu->set_events(pmu_events_id, nr_pmu); if (err) { pr_err("PMU set parameters: error\n"); return err; } ctx.pmu_info.active = 1; } else { ctx.pmu_info.active = 0; ctx.pmu->set_events(NULL, 0); } } if (ctx.pl310) { if (nr_pl310 == 1) { err = ctx.pl310->set_events(&pl310_events_id, 1); if (err) { pr_info("pl310 set_parameters: error\n"); return err; } ctx.pl310_info.active = 1; } else { ctx.pl310_info.active = 0; ctx.pl310->set_events(NULL, 0); } } pr_info("New parameters have been applied\n"); return 0; }
static int input_get_disposition(struct input_dev *dev, unsigned int type, unsigned int code, int value) { int disposition = INPUT_IGNORE_EVENT; switch (type) { case EV_SYN: switch (code) { case SYN_CONFIG: case SYN_TIME_SEC: case SYN_TIME_NSEC: disposition = INPUT_PASS_TO_ALL; break; case SYN_REPORT: disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH; break; case SYN_MT_REPORT: disposition = INPUT_PASS_TO_HANDLERS; break; } break; case EV_KEY: if (is_event_supported(code, dev->keybit, KEY_MAX)) { if (value == 2) { disposition = INPUT_PASS_TO_HANDLERS; break; } if (!!test_bit(code, dev->key) != !!value) { __change_bit(code, dev->key); disposition = INPUT_PASS_TO_HANDLERS; } } break; case EV_SW: if (is_event_supported(code, dev->swbit, SW_MAX) && !!test_bit(code, dev->sw) != !!value) { __change_bit(code, dev->sw); disposition = INPUT_PASS_TO_HANDLERS; } break; case EV_ABS: if (is_event_supported(code, dev->absbit, ABS_MAX)) disposition = input_handle_abs_event(dev, code, &value); break; case EV_REL: if (is_event_supported(code, dev->relbit, REL_MAX) && value) disposition = INPUT_PASS_TO_HANDLERS; break; case EV_MSC: if (is_event_supported(code, dev->mscbit, MSC_MAX)) disposition = INPUT_PASS_TO_ALL; break; case EV_LED: if (is_event_supported(code, dev->ledbit, LED_MAX) && !!test_bit(code, dev->led) != !!value) { __change_bit(code, dev->led); disposition = INPUT_PASS_TO_ALL; } break; case EV_SND: if (is_event_supported(code, dev->sndbit, SND_MAX)) { if (!!test_bit(code, dev->snd) != !!value) __change_bit(code, dev->snd); disposition = INPUT_PASS_TO_ALL; } break; case EV_REP: if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) { dev->rep[code] = value; disposition = INPUT_PASS_TO_ALL; } break; case EV_FF: if (value >= 0) disposition = INPUT_PASS_TO_ALL; break; case EV_PWR: disposition = INPUT_PASS_TO_ALL; break; } return disposition; }