/*
* 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;
}