static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
int i, error;
int wakeup = 0;
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input->name = pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
input_set_capability(input, type, button->code);
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
#if !defined(CONFIG_MACH_P1)
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_report_event(&ddata->data[i]);
input_sync(input);
#endif
device_init_wakeup(&pdev->dev, wakeup);
#if defined(CONFIG_MACH_P1)
if (device_create_file(&pdev->dev, &dev_attr_key_pressed) < 0)
{
pr_err("Failed to create device file(%s)!\n", dev_attr_key_pressed.attr.name);
}
#ifdef CONFIG_KERNEL_DEBUG_SEC
g_pdata = pdata;
init_timer(&debug_timer);
debug_timer.function = enter_upload_mode;
#endif
#endif
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0) {
free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
if (pdata->buttons[i].debounce_interval)
del_timer_sync(&ddata->data[i].timer);
cancel_work_sync(&ddata->data[i].work);
gpio_free(pdata->buttons[i].gpio);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
return error;
}
static irqreturn_t atmel_tsadcc_interrupt(int irq, void *dev)
{
struct atmel_tsadcc *ts_dev = (struct atmel_tsadcc *)dev;
struct input_dev *input_dev = ts_dev->input;
struct at91_tsadcc_data *pdata = input_dev->dev.parent->platform_data;
static int count = 0;
unsigned int status;
unsigned int reg;
unsigned int x, y;
unsigned int z1, z2;
unsigned int Rxp = 1;
unsigned int factor = 1000;
#if defined(CONFIG_MACH_AT91SAM9M10G45EK) || defined(CONFIG_MACH_AT91SAM9G45EKES) || defined(CONFIG_MACH_AT91SAM9M10EKES)
static unsigned int point_buffer_x[COUNT_MAX];
static unsigned int point_buffer_y[COUNT_MAX];
#endif
status = atmel_tsadcc_read(ATMEL_TSADCC_SR);
status &= atmel_tsadcc_read(ATMEL_TSADCC_IMR);
if (status & ATMEL_TSADCC_NOCNT) {
/* Contact lost */
if (cpu_has_9x5_adc()) {
/* 9X5 using TSMR to set PENDBC time */
reg = atmel_tsadcc_read(ATMEL_TSADCC_TSMR) | ((pdata->pendet_debounce << 28) & ATMEL_TSADCC_PENDBC);
atmel_tsadcc_write(ATMEL_TSADCC_TSMR, reg);
} else {
reg = atmel_tsadcc_read(ATMEL_TSADCC_MR) | ATMEL_TSADCC_PENDBC;
atmel_tsadcc_write(ATMEL_TSADCC_MR, reg);
}
atmel_tsadcc_write(ATMEL_TSADCC_TRGR, ATMEL_TSADCC_TRGMOD_NONE);
atmel_tsadcc_write(ATMEL_TSADCC_IDR,
ATMEL_TSADCC_CONVERSION_END | ATMEL_TSADCC_NOCNT);
atmel_tsadcc_write(ATMEL_TSADCC_IER, ATMEL_TSADCC_PENCNT);
input_report_key(input_dev, BTN_TOUCH, 0);
input_report_abs(input_dev, ABS_PRESSURE, 0);
input_sync(input_dev);
} else if (status & ATMEL_TSADCC_PENCNT) {
/* Pen detected */
if (cpu_has_9x5_adc()) {
reg = atmel_tsadcc_read(ATMEL_TSADCC_TSMR);
reg &= ~ATMEL_TSADCC_PENDBC;
atmel_tsadcc_write(ATMEL_TSADCC_TSMR, reg);
} else {
reg = atmel_tsadcc_read(ATMEL_TSADCC_MR);
reg &= ~ATMEL_TSADCC_PENDBC;
atmel_tsadcc_write(ATMEL_TSADCC_MR, reg);
}
atmel_tsadcc_write(ATMEL_TSADCC_IDR, ATMEL_TSADCC_PENCNT);
atmel_tsadcc_write(ATMEL_TSADCC_IER,
ATMEL_TSADCC_CONVERSION_END | ATMEL_TSADCC_NOCNT);
if (cpu_has_9x5_adc()) {
atmel_tsadcc_write(ATMEL_TSADCC_TRGR,
ATMEL_TSADCC_TRGMOD_PERIOD | (0x00D0 << 16));
}else{
atmel_tsadcc_write(ATMEL_TSADCC_TRGR,
ATMEL_TSADCC_TRGMOD_PERIOD | (trigger_period << 16));
}
count = 0;
} else if ((status & ATMEL_TSADCC_CONVERSION_END) == ATMEL_TSADCC_CONVERSION_END) {
/* Conversion finished */
/* make new measurement */
if (cpu_has_9x5_adc()) {
unsigned int xscale, yscale;
/* calculate position */
reg = atmel_tsadcc_read(ATMEL_TSADCC_XPOSR);
ts_dev->prev_absx = (reg & ATMEL_TSADCC_XPOS) << 10;
xscale = (reg & ATMEL_TSADCC_XSCALE) >> 16;
ts_dev->prev_absx /= xscale ? xscale: 1;
reg = atmel_tsadcc_read(ATMEL_TSADCC_YPOSR);
ts_dev->prev_absy = (reg & ATMEL_TSADCC_YPOS) << 10;
yscale = (reg & ATMEL_TSADCC_YSCALE) >> 16;
ts_dev->prev_absy /= yscale ? yscale: 1 << 10;
/* calculate the pressure */
reg = atmel_tsadcc_read(ATMEL_TSADCC_PRESSR);
z1 = reg & ATMEL_TSADCC_PRESSR_Z1;
z2 = (reg & ATMEL_TSADCC_PRESSR_Z2) >> 16;
if (z1 != 0)
ts_dev->prev_absz = Rxp * (ts_dev->prev_absx * factor / 1024) * (z2 * factor / z1 - factor) / factor;
else
ts_dev->prev_absz = 0;
} else {
ts_dev->prev_absx = atmel_tsadcc_read(ATMEL_TSADCC_CDR3) << 10;
ts_dev->prev_absx /= atmel_tsadcc_read(ATMEL_TSADCC_CDR2);
ts_dev->prev_absy = atmel_tsadcc_read(ATMEL_TSADCC_CDR1) << 10;
ts_dev->prev_absy /= atmel_tsadcc_read(ATMEL_TSADCC_CDR0);
}
#if defined(CONFIG_MACH_AT91SAM9M10G45EK) || defined(CONFIG_MACH_AT91SAM9G45EKES) || defined(CONFIG_MACH_AT91SAM9M10EKES)
if (count < COUNT_MAX) {
point_buffer_x[count] = ts_dev->prev_absx;
point_buffer_y[count] = ts_dev->prev_absy;
count++;
} else {
count = 0;
x = do_filter(point_buffer_x, COUNT_MAX, COUNT_MAX * 3 / 4);
y = do_filter(point_buffer_y, COUNT_MAX, COUNT_MAX * 3 / 4);
do_calibrate(&x,&y);
input_report_abs(input_dev, ABS_X, x);
input_report_abs(input_dev, ABS_Y, y);
input_report_key(input_dev, BTN_TOUCH, 1);
input_report_abs(input_dev, ABS_PRESSURE, 7500);
input_sync(input_dev);
}
#endif
#if defined(CONFIG_MACH_AT91SAM9X5EK)
/* report measurement to input layer */
if (ts_dev->prev_absz < ZTHRESHOLD) {
dev_dbg(&input_dev->dev,
"x = %d, y = %d, pressure = %d\n",
ts_dev->prev_absx, ts_dev->prev_absy,
ts_dev->prev_absz);
x = ts_dev->prev_absx;
y = ts_dev->prev_absy;
do_calibrate(&x,&y);
input_report_abs(input_dev, ABS_X, x);
input_report_abs(input_dev, ABS_Y, y);
if (cpu_has_9x5_adc())
input_report_abs(input_dev, ABS_PRESSURE, ts_dev->prev_absz);
input_report_key(input_dev, BTN_TOUCH, 1);
input_sync(input_dev);
} else {
dev_dbg(&input_dev->dev,
"pressure too low: not reporting\n");
}
#endif
}
static int
geomagnetic_work(struct yas_mag_data *magdata)
{
struct geomagnetic_data *data = i2c_get_clientdata(this_client);
uint32_t time_delay_ms = 100;
static int cnt = 0;
int rt, i, accuracy;
if (hwdep_driver.measure == NULL || hwdep_driver.get_offset == NULL) {
return time_delay_ms;
}
rt = hwdep_driver.measure(magdata, &time_delay_ms);
if (rt < 0) {
YLOGE(("measure failed[%d]\n", rt));
}
YLOGD(("xy1y2 [%d][%d][%d] raw[%d][%d][%d]\n",
magdata->xy1y2.v[0], magdata->xy1y2.v[1], magdata->xy1y2.v[2],
magdata->xyz.v[0], magdata->xyz.v[1], magdata->xyz.v[2]));
if (rt >= 0) {
accuracy = atomic_read(&data->last_status);
if ((rt & YAS_REPORT_OVERFLOW_OCCURED)
|| (rt & YAS_REPORT_HARD_OFFSET_CHANGED)
|| (rt & YAS_REPORT_CALIB_OFFSET_CHANGED)) {
static uint16_t count = 1;
int code = 0;
int value = 0;
hwdep_driver.get_offset(&data->driver_offset);
if (rt & YAS_REPORT_OVERFLOW_OCCURED) {
atomic_set(&data->last_status, 0);
accuracy = 0;
}
/* report event */
code |= (rt & YAS_REPORT_OVERFLOW_OCCURED);
code |= (rt & YAS_REPORT_HARD_OFFSET_CHANGED);
code |= (rt & YAS_REPORT_CALIB_OFFSET_CHANGED);
value = (count++ << 16) | (code);
input_report_abs(data->input_raw, ABS_RAW_REPORT, value);
}
if (rt & YAS_REPORT_DATA) {
/* report magnetic data in [nT] */
input_report_abs(data->input_data, ABS_X, magdata->xyz.v[0]);
input_report_abs(data->input_data, ABS_Y, magdata->xyz.v[1]);
input_report_abs(data->input_data, ABS_Z, magdata->xyz.v[2]);
if (atomic_read(&data->last_data[0]) == magdata->xyz.v[0]
&& atomic_read(&data->last_data[1]) == magdata->xyz.v[1]
&& atomic_read(&data->last_data[2]) == magdata->xyz.v[2]) {
input_report_abs(data->input_data, ABS_RUDDER, cnt++);
}
input_report_abs(data->input_data, ABS_STATUS, accuracy);
input_sync(data->input_data);
for (i = 0; i < 3; i++) {
atomic_set(&data->last_data[i], magdata->xyz.v[i]);
}
}
if (rt & YAS_REPORT_CALIB) {
/* report raw magnetic data */
input_report_abs(data->input_raw, ABS_X, magdata->raw.v[0]);
input_report_abs(data->input_raw, ABS_Y, magdata->raw.v[1]);
input_report_abs(data->input_raw, ABS_Z, magdata->raw.v[2]);
input_sync(data->input_raw);
}
}
else {
time_delay_ms = 100;
}
return time_delay_ms;
}
/* Sysfs method to input simulated
coordinates to the virtual
touch driver */
static ssize_t write_virtual_events(struct device *dev,
struct device_attribute *attr,
const char *buffer, size_t count)
{
static int previous_touch;
static int previous_x = -1;
static int previous_y = -1;
int type;
const unsigned char* charPtr;
const int* intPtr;
int x, y;
unsigned char touch;
int key;
int size;
if (count < 4)
return count;
intPtr = (int*) buffer;
type = *intPtr;
++intPtr;
switch (type) {
case 1:
// Keyboard input
size = 2 * sizeof(int) + 1;
if (count != size) {
printk("wrong number of bytes allocated: expected %d, got %d.\n", count, size);
break;
}
key = *intPtr;
intPtr++;
charPtr = (unsigned char *) intPtr;
touch = *charPtr;
if (touch == 1) { // press
input_report_key(virtual_input_dev, key, 1);
}
else if (touch == 0 && previous_touch == 1) { //touchdown
input_report_key(virtual_input_dev, key, 0);
}
input_sync(virtual_input_dev);
previous_touch = touch;
break;
case 2:
// Touch event
size = 3 * sizeof(int) + 1;
if (count != size) {
printk("wrong number of bytes allocated: expected %d, got %d.\n", count, size);
break;
}
x = *intPtr;
intPtr++;
y = *intPtr;
intPtr++;
charPtr = (unsigned char *) intPtr;
touch = *charPtr;
if (touch == 0 && previous_touch == 1) { //unpress
input_report_key(virtual_input_dev, BTN_TOUCH, 0);
previous_x = -1;
previous_y = -1;
}
else if (touch == 1) { //touchdown
if(previous_x != x) {
input_report_abs(virtual_input_dev, ABS_X, x);
previous_x = x;
}
if(previous_y != y) {
input_report_abs(virtual_input_dev, ABS_Y, y);
previous_y = y;
}
if(previous_touch == 0) {
input_report_key(virtual_input_dev, BTN_TOUCH, 1);
}
}
input_sync(virtual_input_dev);
previous_touch = touch;
break;
default:
break;
}
return count;
}
static int init_gpios(void){
int ret;
struct gpio_switch_data *p = head;
while(p){
ret = gpio_tlmm_config(GPIO_CFG(p->gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
if (ret){
pr_err("Could not configure gpio %d\n", p->gpio);
return -EINVAL;
}
gpio_request(p->gpio , p->name);
if(p->event_mode == PAN_INPUTEVENT){
p->input_dev = input_allocate_device();
if(p->input_dev == NULL){
pr_err("switch_gpio failed to allocate input device\n");
return -ENOMEM;
}
p->input_dev->name = p->name;
set_bit(EV_SW, p->input_dev->evbit);
set_bit(SW_LID, p->input_dev->swbit);
ret = input_register_device(p->input_dev);
if(ret){
pr_err("switch_gpio unable to register %s input device\n", p->input_dev->name);
return -EINVAL;
}
}
else if(p->event_mode == PAN_UEVENT){
p->sdev.print_state = gpio_switch_print_state;
p->sdev.name = p->name;
ret = switch_dev_register(&p->sdev);
if(ret < 0){
pr_err("%s Switch dev register is failed\n" , p->sdev.name);
return -EINVAL;
}
}
else{
pr_err("event_mode : %d does not exist\n" , p->event_mode);
return -EINVAL;
}
p->current_state = gpio_get_value(p->gpio) ^ p->flag;
if(p->event_mode == PAN_INPUTEVENT){
dbg("INPUTEVENT %s sent event : %d\n" , p->name , p->current_state);
input_report_switch(p->input_dev , SW_LID , p->current_state);
input_sync(p->input_dev);
}
else if(p->event_mode == PAN_UEVENT){
dbg("UEVENT %s sent event : %d\n" , p->name , p->current_state);
switch_set_state(&p->sdev , p->current_state);
}
p->last_state = p->current_state;
ret = request_threaded_irq(p->irq , NULL , gpio_switch_irq_handler , IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING , p->name , p);
if(ret){
pr_err("%s request_irq is failed reason : %d\n" , p->name , ret);
return -EINVAL;
}
hrtimer_init(&p->timer , CLOCK_MONOTONIC , HRTIMER_MODE_REL);
p->timer.function = gpio_switch_timer_func;
p->debounce = DEBOUNCE_UNKNOWN | DEBOUNCE_WAIT_IRQ;
p->debounce_count = 0;
p->notify = NULL;
p->emergency_notify = NULL;
INIT_WORK(&p->work , gpio_switch_work);
wake_lock_init(&p->wakelock, WAKE_LOCK_SUSPEND, p->name);
enable_irq_wake(p->irq);
p->disabled = false;
p = p->next;
}
return 0;
}
/* Scan the hardware keyboard and push any changes up through the input layer */
static void locomokbd_scankeyboard(struct locomokbd *locomokbd)
{
unsigned int row, col, rowd;
unsigned long flags;
unsigned int num_pressed;
unsigned long membase = locomokbd->base;
spin_lock_irqsave(&locomokbd->lock, flags);
locomokbd_charge_all(membase);
num_pressed = 0;
for (col = 0; col < KB_COLS; col++) {
locomokbd_activate_col(membase, col);
udelay(KB_DELAY);
rowd = ~locomo_readl(membase + LOCOMO_KIB);
for (row = 0; row < KB_ROWS; row++) {
unsigned int scancode, pressed, key;
scancode = SCANCODE(col, row);
pressed = rowd & KB_ROWMASK(row);
key = locomokbd->keycode[scancode];
input_report_key(locomokbd->input, key, pressed);
if (likely(!pressed))
continue;
num_pressed++;
/* The "Cancel/ESC" key is labeled "On/Off" on
* Collie and Poodle and should suspend the device
* if it was pressed for more than a second. */
if (unlikely(key == KEY_ESC)) {
if (!time_after(jiffies,
locomokbd->suspend_jiffies + HZ))
continue;
if (locomokbd->count_cancel++
!= (HZ/SCAN_INTERVAL + 1))
continue;
input_event(locomokbd->input, EV_PWR,
KEY_SUSPEND, 1);
locomokbd->suspend_jiffies = jiffies;
} else
locomokbd->count_cancel = 0;
}
locomokbd_reset_col(membase, col);
}
locomokbd_activate_all(membase);
input_sync(locomokbd->input);
/* if any keys are pressed, enable the timer */
if (num_pressed)
mod_timer(&locomokbd->timer, jiffies + SCAN_INTERVAL);
else
locomokbd->count_cancel = 0;
spin_unlock_irqrestore(&locomokbd->lock, flags);
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_button_data *bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static void earjack_det_func( struct work_struct *earjack_work)
{
int ret=0;
int nADCValue=0,nADCValue2=0;
//wake_lock_timeout(&headset_wakelock,HZ/2);
ret=gpio_get_value_cansleep(hspd->ear_det);
printk("EARJACK_DET=> %d\n", ret);
if(ret==hspd->ear_det_active) {
Regulator_L8_Enable(1);
msleep(100);
ret=Check_ADC_MPP(&nADCValue); // garbage value reading.
msleep(10);
ret=Check_ADC_MPP(&nADCValue);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto earjack_det_exit;
}
msleep(10);
ret=Check_ADC_MPP(&nADCValue2);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto earjack_det_exit;
}
hs_dbg("det nADCValue=%d %d\n",nADCValue,nADCValue2);
nADCValue=(nADCValue+nADCValue2)/2;
#if 0 // garbage value reading
msleep(10);
Check_ADC_MPP(&nADCValue2);
hs_dbg("dummy det nADCValue=%d\n",nADCValue2);
msleep(10);
Check_ADC_MPP(&nADCValue2);
hs_dbg("dummy det nADCValue=%d\n",nADCValue2);
msleep(10);
Check_ADC_MPP(&nADCValue2);
hs_dbg("dummy det nADCValue=%d\n",nADCValue2);
#endif
earjack_keycode=0;
if(nADCValue>=1000) { // 4 pole 2180
hspd->curr_state= MSM_HEADSET;
Remote_Interrupt_Enable(1);
} else { // 3pole
hspd->curr_state= MSM_HEADPHONE;
Regulator_L8_Enable(0);
}
} else {
Regulator_L8_Enable(0);
if(hspd->curr_state==MSM_HEADSET)
Remote_Interrupt_Enable(0);
hspd->curr_state=0;
}
report_headset_switch(hs->ipdev, SW_HEADPHONE_INSERT, hspd->curr_state);
input_sync(hs->ipdev);
earjack_det_exit:
//wake_unlock(&headset_wakelock);
return;
}
static void remotekey_det_func(struct work_struct * remotekey_work) {
int ret=0;
int nADCValue=0,nADCValue2=0;
int keycode=0,check_adc=0;
//printk("remotekey_det_func()\n");
ret=gpio_get_value_cansleep(hspd->ear_det);
if(ret!=hspd->ear_det_active) {
printk("EARJACK_DET %d\n",ret);
return;
}
//ret=gpio_get_value(hspd->remote_det);
ret=gpio_get_value_cansleep(hspd->remote_det);
//printk("remote gpio=%d\n",ret);
if(ret!=hspd->remote_det_active) {
keycode=earjack_keycode;
input_report_key(hs->ipdev, keycode,0);
input_sync(hs->ipdev);
earjack_keycode=0;
printk("remote key release %d\n",keycode);
goto remotekey_det_exit;
}
Check_ADC_MPP(&nADCValue);// garbage value reading.
msleep(10);
ret=Check_ADC_MPP(&nADCValue);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto remotekey_det_exit;
}
msleep(10);
ret=Check_ADC_MPP(&nADCValue2);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto remotekey_det_exit;
}
hs_dbg("remote nADCValue=%d %d\n",nADCValue,nADCValue2);
if(nADCValue>=nADCValue2) check_adc=nADCValue-nADCValue2;
else check_adc=nADCValue2-nADCValue;
#if 0 // garbage value reading
msleep(10);
ret=Check_ADC_MPP(&nADCValue2);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto remotekey_det_exit;
}
hs_dbg("dummy remote nADCValue=%d\n",nADCValue2);
msleep(10);
ret=Check_ADC_MPP(&nADCValue2);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto remotekey_det_exit;
}
hs_dbg("dummy remote nADCValue=%d\n",nADCValue2);
msleep(10);
ret=Check_ADC_MPP(&nADCValue2);
if(ret) {
printk("Check_ADC_MPP() error ret=%d\n",ret);
goto remotekey_det_exit;
}
hs_dbg("dummy remote nADCValue=%d\n",nADCValue2);
#endif
if(check_adc>=100) {
printk("adc range fail %d\n",check_adc);
goto remotekey_det_exit;
}
keycode=0;
if(nADCValue<150) { // 76
keycode=KEY_MEDIA;
} else if( nADCValue>=250 && nADCValue<=450) { // 340
keycode=KEY_VOLUMEUP;
} else if( nADCValue>=500 && nADCValue<=700) { // 600
keycode=KEY_VOLUMEDOWN;
}
if(keycode!=0) {
#if AT1_BDVER_GE(AT1_WS22)
ret=gpio_get_value_cansleep(hspd->remote_det);
if(ret!=hspd->remote_det_active) {
printk("remote key-2 %d\n",ret);
return;
}
#endif
earjack_keycode=keycode;
input_report_key(hs->ipdev, earjack_keycode,1);
input_sync(hs->ipdev);
printk("earjack key PUSH %d\n",keycode);
}
remotekey_det_exit:
//wake_unlock(&headset_wakelock);
return;
}
static void omap_kp_tasklet(unsigned long data)
{
struct omap_kp *omap_kp_data = (struct omap_kp *) data;
unsigned short *keycodes = omap_kp_data->input->keycode;
unsigned int row_shift = get_count_order(omap_kp_data->cols);
unsigned char new_state[8], changed, key_down = 0;
int col, row;
int spurious = 0;
/* */
omap_kp_scan_keypad(omap_kp_data, new_state);
/* */
for (col = 0; col < omap_kp_data->cols; col++) {
changed = new_state[col] ^ keypad_state[col];
key_down |= new_state[col];
if (changed == 0)
continue;
for (row = 0; row < omap_kp_data->rows; row++) {
int key;
if (!(changed & (1 << row)))
continue;
#ifdef NEW_BOARD_LEARNING_MODE
printk(KERN_INFO "omap-keypad: key %d-%d %s\n", col,
row, (new_state[col] & (1 << row)) ?
"pressed" : "released");
#else
key = keycodes[MATRIX_SCAN_CODE(row, col, row_shift)];
if (key < 0) {
printk(KERN_WARNING
"omap-keypad: Spurious key event %d-%d\n",
col, row);
/* */
spurious = 1;
continue;
}
if (!(kp_cur_group == (key & GROUP_MASK) ||
kp_cur_group == -1))
continue;
kp_cur_group = key & GROUP_MASK;
input_report_key(omap_kp_data->input, key & ~GROUP_MASK,
new_state[col] & (1 << row));
#endif
}
}
input_sync(omap_kp_data->input);
memcpy(keypad_state, new_state, sizeof(keypad_state));
if (key_down) {
int delay = HZ / 20;
/*
*/
if (spurious)
delay = 2 * HZ;
mod_timer(&omap_kp_data->timer, jiffies + delay);
} else {
/* */
if (cpu_is_omap24xx()) {
int i;
for (i = 0; i < omap_kp_data->rows; i++)
enable_irq(gpio_to_irq(row_gpios[i]));
} else {
omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
kp_cur_group = -1;
}
}
}
static void star_hall_intr_handler( void *arg )
{
NvU32 gpio_status;
//NvOdmGpioInterruptMask(g_hall->h_hall_intr, NV_TRUE );// NV_FALSE --> enable intr , NV_TRUE --> disable
NvOdmGpioGetState(g_hall->h_hall_gpio, g_hall->h_hall_gpio_pin, &gpio_status );
printk("--------------------------------------------------detecting value = %d\n", gpio_status);
if( gpio_status == 0 )
{atomic_set( &sensing_hall, 0 );input_report_abs(g_hall->input_device, ABS_HAT2X, 0);input_sync(g_hall->input_device);}
else if( gpio_status == 1 )
{atomic_set( &sensing_hall, 1 );input_report_abs(g_hall->input_device, ABS_HAT2X, 1);input_sync(g_hall->input_device);}
//NvOdmGpioInterruptMask(g_hall->h_hall_intr, NV_FALSE);// NV_FALSE --> enable intr , NV_TRUE --> disable
/* 2 == CAR */
switch_set_state(&g_hall->sdev, gpio_status ? 0 : 2);
NvOdmGpioInterruptDone(g_hall->h_hall_intr);
}
static int touch_event_handler(void *unused) {
struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
int i = 0,x1=0, y1=0, finger_num = 0;
char buffer[32];//[16];
u32 temp;
sched_setscheduler(current, SCHED_RR, ¶m);
g_temptimerdiff=get_jiffies_64();//jiffies;
do {
if(tpd_debuglog==1) {
TPD_DMESG("[mtk-tpd] %s\n", __FUNCTION__);
}
set_current_state(TASK_INTERRUPTIBLE);
if(tpd_debuglog==1)
TPD_DMESG("[mtk-tpd], %s, tpd_halt=%d\n", __FUNCTION__, tpd_halt);
while (tpd_halt) {tpd_flag = 0; msleep(20);}
wait_event_interruptible(waiter, tpd_flag != 0);
//tpd_flag = 0;
TPD_DEBUG_SET_TIME;
set_current_state(TASK_RUNNING);
i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 8, &(buffer[0]));
i2c_smbus_read_i2c_block_data(i2c_client, 0x08, 8, &(buffer[8]));
i2c_smbus_read_i2c_block_data(i2c_client, 0x10, 8, &(buffer[16]));
i2c_smbus_read_i2c_block_data(i2c_client, 0x18, 8, &(buffer[24]));
if((buffer[1]&0x01) != (buffer[30]&0x01))
{
i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 8, &(buffer[0]));
i2c_smbus_read_i2c_block_data(i2c_client, 0x08, 8, &(buffer[8]));
i2c_smbus_read_i2c_block_data(i2c_client, 0x10, 8, &(buffer[16]));
i2c_smbus_read_i2c_block_data(i2c_client, 0x18, 8, &(buffer[24]));
}
if((buffer[1]&0xf0) != 0x10)
{
buffer[0] = 0x00;
buffer[1] = 0x03;
i2c_master_send(i2c_client,buffer,2);
msleep(50);
buffer[0] = 0x00;
buffer[1] = 0x05;
i2c_master_send(i2c_client,buffer,2);
//status = i2c_master_recv(i2c_client, buffer, 3);
msleep(50);
buffer[0] = 0x00;
buffer[1] = 0x21;
buffer[2] = 0x07;
buffer[3] = 0x01;
buffer[4] = 0x00;
i2c_master_send(i2c_client,buffer,5);
msleep(50);
continue;
}
if(tpd_debuglog==1)
{
TPD_DMESG("[mtk-tpd]HST_MODE : %x\n", buffer[0]);
TPD_DMESG("[mtk-tpd]TT_MODE : %x\n", buffer[1]);
TPD_DMESG("[mtk-tpd]TT_STAT : %x\n", buffer[2]);
// TPD_DEBUG("[mtk-tpd]TOUCH_ID : %x\n", buffer[8]);
TPD_DMESG("[mtk-tpd]TOUCH_12ID : %x\n", buffer[8]);
TPD_DMESG("[mtk-tpd]TOUCH_34ID : %x\n", buffer[21]);
}
finger_num = 0;
for(i = 0; i < 7;i++)
{
x1 = buffer[4*i + 2] | ((buffer[4*i+4]&0x0f) << 8) ;
y1 = buffer[4*i + 3] | ((buffer[4*i+4]&0xf0) << 4) ;
if(x1 != 0xfff){
tpd_down(x1, y1, x1, y1, 100);
finger_num++;
//printk("-----x:%d,y:%d-------down\n",x1,y1);
}
}
//printk("-----finger_num = %d-------\n",finger_num);
if(finger_num > 0)
input_sync(tpd->dev);
else
{
//printk("-----x:%d,y:%d-------up\n",x1,y1);
tpd_up(x1, y1, x1, y1, 0);
//input_mt_sync(tpd->dev);
input_sync(tpd->dev);
}
tpd_flag = 0;
} while (!kthread_should_stop());
return 0;
}
static int pm800_jack_key_handle(struct pm800_headset_info *info, int voltage)
{
struct sec_jack_platform_data *pdata = info->pdata;
struct sec_jack_buttons_zone *btn_zones = pdata->buttons_zones;
int state;
int i;
if(voltage < pdata->press_release_th) {
/* press event */
if( info->hook_vol_status > HOOK_VOL_ALL_RELEASED ){
return -EINVAL;
}
for (i = 0; i < pdata->num_buttons_zones; i++){
if (voltage >= btn_zones[i].adc_low && voltage <= btn_zones[i].adc_high) {
info->pressed_code = btn_zones[i].code;
state = PM8XXX_HOOK_VOL_PRESSED;
if( info->pressed_code == KEY_MEDIA ){
hs_detect.hookswitch_status = state;
kobject_uevent(&hsdetect_dev->kobj, KOBJ_ONLINE);
info->hook_vol_status = HOOK_PRESSED;
} else if( info->pressed_code == KEY_VOLUMEDOWN ){
info->hook_vol_status = VOL_DOWN_PRESSED;
} else {
info->hook_vol_status = VOL_UP_PRESSED;
}
input_report_key(info->idev, info->pressed_code, state);
input_sync(info->idev);
gpadc4_set_threshold(info, 0, pdata->press_release_th);
pr_info("%s: keycode=%d, is pressed, adc= %d mv\n", __func__, info->pressed_code, voltage);
return 0;
}
}
pr_warn("%s: key is skipped. ADC value is %d\n", __func__, voltage);
}
else {
/* release event */
if(info->hook_vol_status <= HOOK_VOL_ALL_RELEASED){
return -EINVAL;
}
state = PM8XXX_HOOK_VOL_RELEASED;
if( info->pressed_code == KEY_MEDIA ){
hs_detect.hookswitch_status = state;
kobject_uevent(&hsdetect_dev->kobj, KOBJ_ONLINE);
info->hook_vol_status = HOOK_RELEASED;
} else if( info->pressed_code == KEY_VOLUMEDOWN ){
info->hook_vol_status = VOL_DOWN_RELEASED;
} else {
info->hook_vol_status = VOL_UP_RELEASED;
}
input_report_key(info->idev, info->pressed_code, state);
input_sync(info->idev);
gpadc4_set_threshold(info, pdata->press_release_th, 0);
pr_info("%s: keycode=%d, is released, adc=%d\n", __func__, info->pressed_code, voltage);
}
//pr_info("hook_vol switch to %d\n", info->hook_vol_status);
return 0;
}
static void hil_dev_handle_ptr_events(struct hil_dev *ptr)
{
struct input_dev *dev = ptr->dev;
int idx = ptr->idx4 / 4;
hil_packet p = ptr->data[idx - 1];
int i, cnt, laxis;
bool absdev, ax16;
if ((p & HIL_CMDCT_POL) != idx - 1) {
printk(KERN_WARNING PREFIX
"Malformed poll packet %x (idx = %i)\n", p, idx);
return;
}
i = (p & HIL_POL_AXIS_ALT) ? 3 : 0;
laxis = (p & HIL_POL_NUM_AXES_MASK) + i;
ax16 = ptr->idd[1] & HIL_IDD_HEADER_16BIT;
absdev = ptr->idd[1] & HIL_IDD_HEADER_ABS;
for (cnt = 1; i < laxis; i++) {
unsigned int lo, hi, val;
lo = ptr->data[cnt++] & HIL_PKT_DATA_MASK;
hi = ax16 ? (ptr->data[cnt++] & HIL_PKT_DATA_MASK) : 0;
if (absdev) {
val = lo + (hi << 8);
#ifdef TABLET_AUTOADJUST
if (val < input_abs_get_min(dev, ABS_X + i))
input_abs_set_min(dev, ABS_X + i, val);
if (val > input_abs_get_max(dev, ABS_X + i))
input_abs_set_max(dev, ABS_X + i, val);
#endif
if (i % 3)
val = input_abs_get_max(dev, ABS_X + i) - val;
input_report_abs(dev, ABS_X + i, val);
} else {
val = (int) (((int8_t) lo) | ((int8_t) hi << 8));
if (i % 3)
val *= -1;
input_report_rel(dev, REL_X + i, val);
}
}
while (cnt < idx - 1) {
unsigned int btn = ptr->data[cnt++];
int up = btn & 1;
btn &= 0xfe;
if (btn == 0x8e)
continue;
if (btn > 0x8c || btn < 0x80)
continue;
btn = (btn - 0x80) >> 1;
btn = ptr->btnmap[btn];
input_report_key(dev, btn, !up);
}
input_sync(dev);
}
static void gp2a_work_func_light(struct work_struct *work)
{
struct sensor_data *data = container_of((struct delayed_work *)work,
struct sensor_data, work);
int i;
int adc = 0;
adc = lightsensor_get_adcvalue();
for (i = 0; ARRAY_SIZE(adc_table); i++)
if (adc <= adc_table[i])
break;
if (data->light_buffer == i) {
#if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
if (data->light_count++ == LIGHT_BUFFER_NUM) {
input_report_abs(this_data, ABS_MISC, adc);
input_sync(this_data);
data->light_count = 0;
gprintk("realmode : adc(%d)\n", adc);
}
#else
if(data->light_level_state <= i || data->light_first_level == true){
if (data->light_count++ == LIGHT_BUFFER_UP) {
if (LightSensor_Log_Cnt == 10) {
printk("[LIGHT SENSOR] lux up 0x%0X (%d)\n", adc, adc);
LightSensor_Log_Cnt = 0;
}
LightSensor_Log_Cnt = LightSensor_Log_Cnt + 1;
input_report_abs(this_data, ABS_MISC, adc);
input_sync(this_data);
data->light_count = 0;
data->light_first_level = false;
data->light_level_state = data->light_buffer;
}
}else
{
if (data->light_count++ == LIGHT_BUFFER_DOWN) {
if (LightSensor_Log_Cnt == 10) {
printk("[LIGHT SENSOR] lux down 0x%0X (%d)\n", adc, adc);
LightSensor_Log_Cnt = 0;
}
LightSensor_Log_Cnt = LightSensor_Log_Cnt + 1;
input_report_abs(this_data, ABS_MISC, adc);
input_sync(this_data);
data->light_count = 0;
data->light_level_state = data->light_buffer;
}
}
#endif
} else {
data->light_buffer = i;
data->light_count = 0;
}
if(data->enabled)
queue_delayed_work(light_workqueue,&data->work, msecs_to_jiffies(data->delay));
}
static int __devinit pmic8xxx_kp_probe(struct platform_device *pdev)
{
const struct pm8xxx_keypad_platform_data *pdata =
dev_get_platdata(&pdev->dev);
const struct matrix_keymap_data *keymap_data;
struct pmic8xxx_kp *kp;
int rc;
u8 ctrl_val;
struct device *sec_key;
struct pm_gpio kypd_drv = {
.direction = PM_GPIO_DIR_OUT,
.output_buffer = PM_GPIO_OUT_BUF_OPEN_DRAIN,
.output_value = 0,
.pull = PM_GPIO_PULL_NO,
.vin_sel = PM_GPIO_VIN_S4,
.out_strength = PM_GPIO_STRENGTH_LOW,
.function = PM_GPIO_FUNC_1,
.inv_int_pol = 1,
};
struct pm_gpio kypd_sns = {
.direction = PM_GPIO_DIR_IN,
.pull = PM_GPIO_PULL_UP_31P5,
.vin_sel = PM_GPIO_VIN_S4,
.out_strength = PM_GPIO_STRENGTH_NO,
.function = PM_GPIO_FUNC_NORMAL,
.inv_int_pol = 1,
};
if (!pdata || !pdata->num_cols || !pdata->num_rows ||
pdata->num_cols > PM8XXX_MAX_COLS ||
pdata->num_rows > PM8XXX_MAX_ROWS ||
pdata->num_cols < PM8XXX_MIN_COLS) {
dev_err(&pdev->dev, "invalid platform data\n");
return -EINVAL;
}
if (!pdata->scan_delay_ms ||
pdata->scan_delay_ms > MAX_SCAN_DELAY ||
pdata->scan_delay_ms < MIN_SCAN_DELAY ||
!is_power_of_2(pdata->scan_delay_ms)) {
dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
return -EINVAL;
}
if (!pdata->row_hold_ns ||
pdata->row_hold_ns > MAX_ROW_HOLD_DELAY ||
pdata->row_hold_ns < MIN_ROW_HOLD_DELAY ||
((pdata->row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
return -EINVAL;
}
if (!pdata->debounce_ms ||
((pdata->debounce_ms % 5) != 0) ||
pdata->debounce_ms > MAX_DEBOUNCE_TIME ||
pdata->debounce_ms < MIN_DEBOUNCE_TIME) {
dev_err(&pdev->dev, "invalid debounce time supplied\n");
return -EINVAL;
}
keymap_data = pdata->keymap_data;
if (!keymap_data) {
dev_err(&pdev->dev, "no keymap data supplied\n");
return -EINVAL;
}
kp = kzalloc(sizeof(*kp), GFP_KERNEL);
if (!kp)
return -ENOMEM;
platform_set_drvdata(pdev, kp);
kp->pdata = pdata;
kp->dev = &pdev->dev;
kp->input = input_allocate_device();
if (!kp->input) {
dev_err(&pdev->dev, "unable to allocate input device\n");
rc = -ENOMEM;
goto err_alloc_device;
}
kp->key_sense_irq = platform_get_irq(pdev, 0);
if (kp->key_sense_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad sense irq\n");
rc = -ENXIO;
goto err_get_irq;
}
kp->key_stuck_irq = platform_get_irq(pdev, 1);
if (kp->key_stuck_irq < 0) {
dev_err(&pdev->dev, "unable to get keypad stuck irq\n");
rc = -ENXIO;
goto err_get_irq;
}
kp->input->name = pdata->input_name ? : "PMIC8XXX keypad";
kp->input->phys = pdata->input_phys_device ? : "pmic8xxx_keypad/input0";
kp->input->dev.parent = &pdev->dev;
kp->input->id.bustype = BUS_I2C;
kp->input->id.version = 0x0001;
kp->input->id.product = 0x0001;
kp->input->id.vendor = 0x0001;
kp->input->evbit[0] = BIT_MASK(EV_KEY);
if (pdata->rep)
__set_bit(EV_REP, kp->input->evbit);
kp->input->keycode = kp->keycodes;
kp->input->keycodemax = PM8XXX_MATRIX_MAX_SIZE;
kp->input->keycodesize = sizeof(kp->keycodes);
kp->input->open = pmic8xxx_kp_open;
kp->input->close = pmic8xxx_kp_close;
matrix_keypad_build_keymap(keymap_data, PM8XXX_ROW_SHIFT,
kp->input->keycode, kp->input->keybit);
get_volumekey_matrix(keymap_data,
&volup_matrix, &voldown_matrix);
input_set_capability(kp->input, EV_MSC, MSC_SCAN);
input_set_drvdata(kp->input, kp);
/* initialize keypad state */
memset(kp->keystate, 0xff, sizeof(kp->keystate));
memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
rc = pmic8xxx_kpd_init(kp);
if (rc < 0) {
dev_err(&pdev->dev, "unable to initialize keypad controller\n");
goto err_get_irq;
}
rc = pmic8xxx_kp_config_gpio(pdata->cols_gpio_start,
pdata->num_cols, kp, &kypd_sns);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad sense lines\n");
goto err_gpio_config;
}
rc = pmic8xxx_kp_config_gpio(pdata->rows_gpio_start,
pdata->num_rows, kp, &kypd_drv);
if (rc < 0) {
dev_err(&pdev->dev, "unable to configure keypad drive lines\n");
goto err_gpio_config;
}
rc = request_any_context_irq(kp->key_sense_irq, pmic8xxx_kp_irq,
IRQF_TRIGGER_RISING, "pmic-keypad", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad sense irq\n");
goto err_get_irq;
}
rc = request_any_context_irq(kp->key_stuck_irq, pmic8xxx_kp_stuck_irq,
IRQF_TRIGGER_RISING, "pmic-keypad-stuck", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
goto err_req_stuck_irq;
}
rc = pmic8xxx_kp_read_u8(kp, &ctrl_val, KEYP_CTRL);
if (rc < 0) {
dev_err(&pdev->dev, "failed to read KEYP_CTRL register\n");
goto err_pmic_reg_read;
}
rc = request_threaded_irq(MSM_GPIO_KEY_VOLUP_IRQ ,
NULL, pmic8058_volume_up_irq, IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING, "vol_up", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request vol_up irq\n");
goto err_req_sense_irq;
}
rc = request_threaded_irq(MSM_GPIO_KEY_VOLDOWN_IRQ ,
NULL, pmic8058_volume_down_irq, IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING, "vol_down", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request vol_down irq\n");
goto err_req_sense_irq;
}
kp->ctrl_reg = ctrl_val;
#if defined CONFIG_MACH_VITAL2REFRESH
gpio_tlmm_config(GPIO_CFG(MSM_HALL_IC, 1, GPIO_CFG_INPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
input_set_capability(kp->input, EV_SW, SW_LID);
if (gpio_get_value(MSM_HALL_IC)) {
input_report_switch(kp->input, SW_LID, 1);
}
else {
input_report_switch(kp->input, SW_LID, 0);
}
input_sync(kp->input);
printk(KERN_INFO "[input_report_switch] slide_int - !gpio_hall_ic %s\n",
gpio_get_value(MSM_HALL_IC) == 0 ? "OPEN" : "CLOSE");
rc = request_threaded_irq(MSM_GPIO_TO_INT(MSM_HALL_IC), NULL,
hall_ic_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"hall_ic", kp);
if (rc < 0) {
dev_err(&pdev->dev, "failed to request hall_ic irq\n");
goto err_hall_ic_irq;
}
#endif
rc = input_register_device(kp->input);
if (rc < 0) {
dev_err(&pdev->dev, "unable to register keypad input device\n");
goto err_pmic_reg_read;
}
sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key");
if (IS_ERR(sec_key))
pr_err("Failed to create device(sec_key)!\n");
rc = device_create_file(sec_key, &dev_attr_sec_key_pressed);
if (rc) {
pr_err("Failed to create device file - pressed(%s), err(%d)!\n",
dev_attr_sec_key_pressed.attr.name, rc);
}
dev_set_drvdata(sec_key, kp);
device_init_wakeup(&pdev->dev, pdata->wakeup);
return 0;
err_pmic_reg_read:
free_irq(kp->key_stuck_irq, kp);
err_req_stuck_irq:
free_irq(kp->key_sense_irq, kp);
#if defined CONFIG_MACH_VITAL2REFRESH
err_hall_ic_irq:
#endif
err_req_sense_irq:
err_gpio_config:
err_get_irq:
input_free_device(kp->input);
err_alloc_device:
platform_set_drvdata(pdev, NULL);
kfree(kp);
return rc;
}
static int __devexit pmic8xxx_kp_remove(struct platform_device *pdev)
{
struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
device_init_wakeup(&pdev->dev, 0);
free_irq(kp->key_stuck_irq, kp);
free_irq(kp->key_sense_irq, kp);
input_unregister_device(kp->input);
kfree(kp);
platform_set_drvdata(pdev, NULL);
return 0;
}
#ifdef CONFIG_PM_SLEEP
static int pmic8xxx_kp_suspend(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
struct input_dev *input_dev = kp->input;
if (device_may_wakeup(dev)) {
enable_irq_wake(kp->key_sense_irq);
} else {
mutex_lock(&input_dev->mutex);
#if defined CONFIG_MACH_VITAL2REFRESH
enable_irq_wake(MSM_GPIO_TO_INT(MSM_HALL_IC));
/* to wakeup in case of sleep */
#endif
if (input_dev->users)
pmic8xxx_kp_disable(kp);
mutex_unlock(&input_dev->mutex);
}
return 0;
}
static int pmic8xxx_kp_resume(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
struct input_dev *input_dev = kp->input;
if (device_may_wakeup(dev)) {
disable_irq_wake(kp->key_sense_irq);
} else {
mutex_lock(&input_dev->mutex);
#if defined CONFIG_MACH_VITAL2REFRESH
disable_irq_wake(MSM_GPIO_TO_INT(MSM_HALL_IC)); /* to match irq pair */
#endif
if (input_dev->users)
pmic8xxx_kp_enable(kp);
mutex_unlock(&input_dev->mutex);
}
return 0;
}
#endif
static SIMPLE_DEV_PM_OPS(pm8xxx_kp_pm_ops,
pmic8xxx_kp_suspend, pmic8xxx_kp_resume);
static struct platform_driver pmic8xxx_kp_driver = {
.probe = pmic8xxx_kp_probe,
.remove = __devexit_p(pmic8xxx_kp_remove),
.driver = {
.name = PM8XXX_KEYPAD_DEV_NAME,
.owner = THIS_MODULE,
.pm = &pm8xxx_kp_pm_ops,
},
};
static int __init pmic8xxx_kp_init(void)
{
return platform_driver_register(&pmic8xxx_kp_driver);
}
module_init(pmic8xxx_kp_init);
static void __exit pmic8xxx_kp_exit(void)
{
platform_driver_unregister(&pmic8xxx_kp_driver);
}
module_exit(pmic8xxx_kp_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("PMIC8XXX keypad driver");
MODULE_VERSION("1.0");
MODULE_ALIAS("platform:pmic8xxx_keypad");
MODULE_AUTHOR("Trilok Soni <*****@*****.**>");
/*
* tuple format: (key_code, key_param)
*
* old-architecture:
* key-press = (key_code, 0)
* key-release = (0xff, key_code)
*
* new-architecutre:
* key-press = (key_code, 0)
* key-release = (key_code, 0xff)
*/
static void report_hs_key(uint32_t key_code, uint32_t key_parm)
{
int key, temp_key_code;
#if defined(T_QCI_IS3)
if (key_code == CHG_ST_NTFY_CODE) {
switch(key_parm) {
case K_CHG_ST_NONE:
key = KEY_CHG_ST_NONE;
break;
case K_CHG_ST_OVP:
key = KEY_CHG_ST_OVP;
break;
case K_CHG_ST_OVC:
key = KEY_CHG_ST_OVC;
break;
case K_CHG_ST_OVD:
key = KEY_CHG_ST_OVD;
break;
case K_CHG_ST_EXP:
key = KEY_CHG_ST_EXP;
break;
case K_TEMP_MSM_OVER_LAYER1:
key = KEY_TEMP_MSM_OVER_LEYER_1;
break;
case K_TEMP_MSM_OVER_LAYER2:
key = KEY_TEMP_MSM_OVER_LEYER_2;
break;
case K_TEMP_MSM_OVER_LAYER3:
key = KEY_TEMP_MSM_OVER_LEYER_3;
break;
case K_TEMP_MSM_OVER_RESUME_NORMAL:
key = KEY_TEMP_MSM_OVER_RESUME_NORMAL;
break;
default:
key = 0;
break;
}
printk("got CHG_ST_NTFY_CODE key_code = %d, key_parm = %d, key = %d\n", key_code, key_parm,key);
input_report_key(hs->ipdev, key, (key_code != HS_REL_K));
input_sync(hs->ipdev);
input_report_key(hs->ipdev, key, 0);
input_sync(hs->ipdev);
return;
}
#endif
/* FUJITSU:2012.02.23 USB start */
if (key_code == USB_CABLE_DET) {
switch (key_parm) {
case K_CABLE_WAKEUP:
pr_info("%s: cable wakeup\n", __func__);
break;
case K_CABLE_USB_OTG_INIT_PHY:
pr_info("%s: cable USB OTG init PHY\n", __func__);
break;
case K_CABLE_USB_CONNECT_CLIENT:
pr_info("%s: cable USB connect client\n", __func__);
break;
case K_CABLE_USB_CONNECT_HOST:
pr_info("%s: cable USB connect host\n", __func__);
break;
case K_CABLE_USB_DISCONNECT:
pr_info("%s: cable USB disconnect\n", __func__);
break;
case K_CABLE_CRADLE_CONNECT:
pr_info("%s: cradle connect\n", __func__);
break;
case K_CABLE_CRADLE_DISCONNECT:
pr_info("%s: cradle disconnect\n", __func__);
break;
default:
pr_info("%s: unknown key_parm=0x%x\n", __func__, key_parm);
break;
}
return;
}
/* FUJITSU:2012.02.23 USB end */
if (key_code == HS_REL_K)
key = hs_find_key(key_parm);
else
key = hs_find_key(key_code);
temp_key_code = key_code;
if (key_parm == HS_REL_K)
key_code = key_parm;
switch (key) {
case KEY_POWER:
case KEY_END:
case KEY_VOLUMEUP:
case KEY_VOLUMEDOWN:
input_report_key(hs->ipdev, key, (key_code != HS_REL_K));
break;
#if defined(T_QCI_IS3)
/* FUJITSU:2011-12-01 for media key start */
case KEY_MEDIA:
if(mediakeyloop) {
if(key_code != HS_REL_K) mediakeyflg = true;
else mediakeyflg = false;
break;
}
if(mediakeyflg) {
if(key_code == HS_REL_K) mediakeyflg = false;
break;
}
if(ena_media_key)input_report_key(hs->ipdev, key, (key_code != HS_REL_K));
break;
/* FUJITSU:2011-12-01 for media key end */
#endif
case SW_HEADPHONE_INSERT_W_MIC:
hs->mic_on = hs->hs_on = (key_code != HS_REL_K) ? 1 : 0;
input_report_switch(hs->ipdev, SW_HEADPHONE_INSERT,
hs->hs_on);
input_report_switch(hs->ipdev, SW_MICROPHONE_INSERT,
hs->mic_on);
update_state();
break;
case SW_HEADPHONE_INSERT:
hs->hs_on = (key_code != HS_REL_K) ? 1 : 0;
input_report_switch(hs->ipdev, key, hs->hs_on);
update_state();
break;
case SW_MICROPHONE_INSERT:
hs->mic_on = (key_code != HS_REL_K) ? 1 : 0;
input_report_switch(hs->ipdev, key, hs->mic_on);
update_state();
break;
case -1:
printk(KERN_ERR "%s: No mapping for remote handset event %d\n",
__func__, temp_key_code);
return;
}
input_sync(hs->ipdev);
}
static void mma7660fc_report_values(void)
{
struct accel_data values;
struct mma7660fc_data *data = i2c_get_clientdata(this_client);
//int i;
mma7660fc_get_values(&values);
/* First samples are null (usually 1) and need to be skipped */
if(data->samples_to_skip > 0) {
data->samples_to_skip--;
return;
}
data->tmp_values.x += values.x;
data->tmp_values.y += values.y;
data->tmp_values.z += values.z;
data->sample_number++;
/* Do we have enough samples ? */
if(data->sample_number < SAMPLES_TO_AVERAGE && data->poll_delay < AVERAGE_DELAY_THRESHOLD)
return;
#ifdef FILTER_ENABLED
memcpy(&data->circular_buffer[data->circular_index], &data->tmp_values, sizeof(struct accel_data));
data->circular_index = (data->circular_index + 1) % FILTER_DEPTH;
if (data->poll_delay < FILER_DELAY_THRESHOLD) {
values.x = 0;
values.y = 0;
values.z = 0;
for (i = 0; i < FILTER_DEPTH; i++) {
values.x += data->circular_buffer[i].x * filter_coeff[(FILTER_DEPTH + data->circular_index - i) % FILTER_DEPTH];
values.y += data->circular_buffer[i].y * filter_coeff[(FILTER_DEPTH + data->circular_index - i) % FILTER_DEPTH];
values.z += data->circular_buffer[i].z * filter_coeff[(FILTER_DEPTH + data->circular_index - i) % FILTER_DEPTH];
}
values.x /= FILTER_DENOMINATOR * data->sample_number;
values.y /= FILTER_DENOMINATOR * data->sample_number;
values.z /= FILTER_DENOMINATOR * data->sample_number;
} else
#endif
{
values.x = data->tmp_values.x/data->sample_number;
values.y = data->tmp_values.y/data->sample_number;
values.z = data->tmp_values.z/data->sample_number;
}
#ifdef DEBUG_REPORT
printk("mma7660fc_report_values: X = %d, Y = %d, Z = %d\n", values.x, values.y, values.z);
#endif
input_report_abs(data->input_dev, ABS_X, (short) values.x);
input_report_abs(data->input_dev, ABS_Y, (short) values.y);
input_report_abs(data->input_dev, ABS_Z, (short) values.z);
data->tmp_values.x = 0;
data->tmp_values.y = 0;
data->tmp_values.z = 0;
data->sample_number = 0;
input_sync(data->input_dev);
return;
}
static void pixcir_read_work(struct work_struct *work)
{
u8 *p;
u8 touch, button;
u8 rdbuf[27]={0};
int ret, i;
int x=0,y=0,px,py,track_id,brn;
struct pixcir_data *pixcir=container_of(work, struct pixcir_data, read_work.work);
if(gpio_get_value(pixcir->igp_idx, pixcir->igp_bit) || pixcir->earlysus){
dbg("INT High Level.\n");
goto exit_penup;
}
ret = pixcir_read(pixcir, rdbuf, sizeof(rdbuf));
if (ret <= 0) {
dbg_err("pixcir_read failed, ret=%d\n",ret);
goto exit_penup;
}
touch = rdbuf[0]&0x07;
button = rdbuf[1];
p=&rdbuf[2];
dbg("%02x,%02x\n",touch,button);
if (touch) {
for(i=0; i<touch; i++) {
brn = (*(p+4))>>3;//broken line
track_id = (*(p+4))&0x7;
px = (*(p+1)<<8)+(*(p));
py = (*(p+3)<<8)+(*(p+2));
p+=5;
x = px;
y = py;
if(pixcir->swap) {
x = py;
y = px;
}
if (pixcir->xch) x = pixcir->xresl - px;
if (pixcir->ych) y = pixcir->yresl - py;
pixcir->penup = PEN_DOWN;
input_report_abs(pixcir->input_dev, ABS_MT_TRACKING_ID, track_id+1);
input_report_abs(pixcir->input_dev, ABS_MT_POSITION_X, x);
input_report_abs(pixcir->input_dev, ABS_MT_POSITION_Y, y);
input_mt_sync(pixcir->input_dev);
if(pixcir->dbg) printk("F%d: brn=%-2d Tid=%1d px=%-5d py=%-5d x=%-5d y=%-5d\n",i,brn,track_id,px,py,x,y);
}
input_sync(pixcir->input_dev);
}
#ifdef TOUCH_KEY
if(button){
if(!pixcir->tkey_pressed ){
pixcir->tkey_pressed = 1;
switch(button){
case 1:
pixcir->tkey_idx = SEARCH_IDX;
input_report_key(pixcir->input_dev, keycodes[SEARCH_IDX], 1);
break;
case 2:
pixcir->tkey_idx = BACK_IDX;
input_report_key(pixcir->input_dev, keycodes[BACK_IDX], 1);
break;
case 4:
pixcir->tkey_idx = HOME_IDX;
input_report_key(pixcir->input_dev, keycodes[HOME_IDX], 1);
break;
case 8:
pixcir->tkey_idx = MENU_IDX;
input_report_key(pixcir->input_dev, keycodes[MENU_IDX], 1);
break;
default:
pixcir->tkey_idx = NUM_KEYS;
break;
}
}
}
else{
if(pixcir->tkey_pressed){
if(pixcir->tkey_idx < NUM_KEYS ) {
dbg("Report virtual key.\n");
input_report_key(pixcir->input_dev, keycodes[pixcir->tkey_idx], 0);
input_sync(pixcir->input_dev);
}
pixcir->tkey_pressed = 0;
}
}
#endif
queue_delayed_work(pixcir->workqueue, &pixcir->read_work,16*HZ/1000);
return;
exit_penup:
if(pixcir->penup == PEN_DOWN){
dbg("Report pen up.\n");
input_mt_sync(pixcir->input_dev);
input_sync(pixcir->input_dev);
pixcir->penup = PEN_UP;
}
#ifdef TOUCH_KEY
if(pixcir->tkey_idx < NUM_KEYS && pixcir->tkey_pressed ) {
dbg("Report virtual key.\n");
input_report_key(pixcir->input_dev, keycodes[pixcir->tkey_idx], 0);
input_sync(pixcir->input_dev);
pixcir->tkey_pressed = 0;
}
#endif
gpio_enable_irq(pixcir->igp_idx, pixcir->igp_bit);
return;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
int i, error;
int wakeup = 0;
struct kobject *keyboard_kobj;
doCheck = true;
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
input_set_capability(input, type, button->code);
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
keyboard_kobj = kobject_create_and_add("keyboard", NULL);
if (keyboard_kobj == NULL) {
printk(KERN_ERR "[KEY] KEY_ERR: %s: subsystem_register failed\n", __func__);
return -ENOMEM;
}
if (sysfs_create_file(keyboard_kobj, &dev_attr_vol_wakeup.attr))
pr_err("%s: sysfs_create_file error", __func__);
wakeup_bitmask = 0;
set_wakeup = 0;
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_report_event(&ddata->data[i]);
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
wake_lock_init(&power_key_wake_lock, WAKE_LOCK_SUSPEND, "power_key_wake_lock");
pr_info("[KEY] gpio_keys_probe end.\n");
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0) {
free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
if (ddata->data[i].timer_debounce)
del_timer_sync(&ddata->data[i].timer);
cancel_work_sync(&ddata->data[i].work);
gpio_free(pdata->buttons[i].gpio);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
return error;
}
static void valve_sc_parse_input_events(struct valve_sc_device *sc,
const u8 *raw_data)
{
struct input_dev *input = sc->input;
unsigned int i, axis;
u32 buttons = 0;
s16 left[2] = {0}, right[2] = {0};
u8 triggers[2] = {0};
s16 accel[3] = {0};
s16 gyro[3] = {0};
/* Read fields */
for (i = 0; i < sizeof (u32); ++i)
buttons |= raw_data[SC_OFFSET_BUTTONS+i] << i*8;
for (axis = 0; axis < 2; ++axis) {
triggers[axis] = raw_data[SC_OFFSET_TRIGGERS_8+axis];
for (i = 0; i < sizeof (s16); ++i) {
left[axis] |= raw_data[SC_OFFSET_LEFT_AXES+2*axis+i] << i*8;
right[axis] |= raw_data[SC_OFFSET_RIGHT_AXES+2*axis+i] << i*8;
}
}
for (axis = 0; axis < 3; ++axis) {
for (i = 0; i < sizeof(s16); ++i) {
accel[axis] |= raw_data[SC_OFFSET_ACCEL+2*axis+i] << i*8;
gyro[axis] |= raw_data[SC_OFFSET_GYRO+2*axis+i] << i*8;
}
}
/* Update input state */
if (buttons & SC_BTN_TOUCH_LEFT) {
input_report_abs(input, ABS_HAT0X, left[0]);
input_report_abs(input, ABS_HAT0Y, -left[1]);
}
else if (sc->center_touchpads && left[0] == 0 && left[1] == 0) {
/* Left touch pad release is not detected if the stick
* is not centered at the same time. Since they are used
* with the same finger, it should not happen often. */
input_report_abs(input, ABS_HAT0X, 0);
input_report_abs(input, ABS_HAT0Y, 0);
}
if (sc->center_touchpads || buttons & SC_BTN_TOUCH_RIGHT) {
input_report_abs(input, ABS_HAT1X, right[0]);
input_report_abs(input, ABS_HAT1Y, -right[1]);
}
input_report_abs(input, ABS_BRAKE, triggers[0]);
input_report_abs(input, ABS_GAS, triggers[1]);
if (sc->orientation) {
input_report_abs(input, ABS_TILT_X,
angle(accel[2], accel[0]));
input_report_abs(input, ABS_TILT_Y,
angle(accel[2], accel[1]));
input_report_rel(input, REL_RX, gyro[0]);
input_report_rel(input, REL_RY, gyro[1]);
input_report_rel(input, REL_RZ, gyro[2]);
}
if (buttons & SC_BTN_TOUCH_LEFT) {
/* Left events are touchpad events */
SC_REPORT_BTN(input, buttons,
SC_BTN_CLICK_LEFT, BTN_THUMBL);
}
else {
/* Left events are stick events */
SC_REPORT_BTN(input, buttons,
SC_BTN_CLICK_LEFT, BTN_STICK_CLICK);
input_report_abs(input, ABS_X, left[0]);
input_report_abs(input, ABS_Y, -left[1]);
}
if (buttons & SC_BTN_TOUCH_RIGHT) {
SC_REPORT_BTN(input, buttons,
SC_BTN_CLICK_RIGHT, BTN_THUMBR);
}
SC_REPORT_BTN(input, buttons, SC_BTN_A, BTN_SOUTH);
SC_REPORT_BTN(input, buttons, SC_BTN_B, BTN_EAST);
SC_REPORT_BTN(input, buttons, SC_BTN_X, BTN_WEST);
SC_REPORT_BTN(input, buttons, SC_BTN_Y, BTN_NORTH);
SC_REPORT_BTN(input, buttons, SC_BTN_SELECT, BTN_SELECT);
SC_REPORT_BTN(input, buttons, SC_BTN_MODE, BTN_MODE);
SC_REPORT_BTN(input, buttons, SC_BTN_START, BTN_START);
SC_REPORT_BTN(input, buttons, SC_BTN_SHOULDER_LEFT, BTN_TL);
SC_REPORT_BTN(input, buttons, SC_BTN_SHOULDER_RIGHT, BTN_TR);
SC_REPORT_BTN(input, buttons, SC_BTN_TRIGGER_LEFT, BTN_TL2);
SC_REPORT_BTN(input, buttons, SC_BTN_TRIGGER_RIGHT, BTN_TR2);
SC_REPORT_BTN(input, buttons, SC_BTN_GRIP_LEFT, BTN_C);
SC_REPORT_BTN(input, buttons, SC_BTN_GRIP_RIGHT, BTN_Z);
input_sync(input);
}
void uts_input_key( unsigned int code, int value)
{
input_report_key(ts_data->input_dev, code, value);
input_sync(ts_data->input_dev);
}
static void goodix_ts_work_func(struct work_struct *work)
{
uint8_t point_data[READ_BYTES_NUM] = {0x7,0x21,0};
uint8_t check_sum = 0;
uint8_t read_position = 0;
uint8_t track_id[MAX_FINGER_NUM];
uint8_t point_index = 0;
uint8_t point_tmp = 0;
uint8_t point_count = 0;
uint16_t input_x = 0;
uint16_t input_y = 0;
uint8_t input_w = 0;
static uint8_t last_key = 0;
uint8_t finger = 0;
uint8_t key = 0;
unsigned int count = 0;
unsigned int position = 0;
int ret=-1;
int tmp = 0;
/*读取0x721寄存器，一次性获取XY坐标*/
ret=i2c_read_byte(point_data, sizeof(point_data)/sizeof(point_data[0]));
if(ret<0){
printk(KERN_ERR "read failed!\n");
return;
}
/*
前两个字节是寄存器地址， 对数据进行校验,找出校验码的位置
*/
switch(point_data[2]& 0x1f)
{
case 0:
read_position = 3;
break;
case 1:
for(count=2; count<9; count++)
check_sum += (int)point_data[count];
// read_position为硬件中的校验码,一般都在所有数据的最后
read_position = 9;
break;
case 2:
case 3:
for(count=2; count<14;count++)
check_sum += (int)point_data[count];
read_position = 14;
break;
default: //touch finger larger than 3
for(count=2; count<35;count++)
check_sum += (int)point_data[count];
read_position = 35;
}
//进行比较
if(check_sum != point_data[read_position])
{
printk(KERN_ERR "coor chksum error!\n");
}
//记录触控点的状态
//记录tp flags中低5bit
point_index = point_data[2]&0x1f;
point_tmp = point_index;
// 记录到底是哪个点被触控
for(position=0; (position<MAX_FINGER_NUM)&&point_tmp; position++)
{
if(point_tmp&0x01)
{
track_id[point_count++] = position;
}
point_tmp >>= 1;
}
// 记录被触控的点数
finger = point_count;
if(finger)
{
for(count=0; count<finger; count++)
{
if(track_id[count]!=3)
{
if(track_id[count]<3)
position = 4+track_id[count]*5;
else
position = 30;
// position表示触控点对应x,y,压力值所在的位置
input_x = (uint16_t)(point_data[position]<<8)+(uint16_t)point_data[position+1];
input_y = (uint16_t)(point_data[position+2]<<8)+(uint16_t)point_data[position+3];
input_w = point_data[position+4];
}
else
{
//第三个点
input_x = (uint16_t)(point_data[19]<<8)+(uint16_t)point_data[26];
input_y = (uint16_t)(point_data[27]<<8)+(uint16_t)point_data[28];
input_w = point_data[29];
}
//将x值翻转,一般只能在调试的时候出现
//input_x =480-input_x;
/*上报事件*/
gt811_touch_down(fs210_ts_dev,track_id[count],input_x,input_y,input_w); //添加此行代码
}
}
else
{
input_report_abs(fs210_ts_dev->ts_input, ABS_MT_TOUCH_MAJOR, 0);
input_mt_sync(fs210_ts_dev->ts_input);
}
//input_report_key(fs210_ts_dev->ts_input, BTN_TOUCH, finger > 0);
input_sync(fs210_ts_dev->ts_input);
}
static void report_input_data(struct ist30xx_data *data, int finger_counts, int key_counts)
{
int i, press, count;
finger_info *fingers = (finger_info *)data->fingers;
memset(data->prev_fingers, 0, sizeof(data->prev_fingers));
#if 1 //
if (finger_counts) {
for (i = 0; i < 5; i++) {
//tsp_debug("finger[%d]: %08x\n", i, data->prev_keys[i].full_field);
if (data->prev_keys[i].bit_field.id ==0)
continue;
if (data->prev_keys[i].bit_field.w == PRESS_MSG_KEY) {
tsp_warn("key cancel: %08x\n", data->prev_keys[i].full_field);
release_key(&data->prev_keys[i], CANCEL_KEY);
}
}
}
#endif
for (i = 0, count = 0; i < finger_counts; i++) {
press = fingers[i].bit_field.udmg & PRESS_MSG_MASK;
//print_tsp_event(&fingers[i]);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 0, 0))
input_mt_slot(data->input_dev, fingers[i].bit_field.id - 1);
input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER,
(press ? true : false));
if (press) {
input_report_abs(data->input_dev, ABS_MT_POSITION_X,
fingers[i].bit_field.x);
input_report_abs(data->input_dev, ABS_MT_POSITION_Y,
fingers[i].bit_field.y);
input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR,
fingers[i].bit_field.w);
}
printk("[ TSP ] id : %2d, press : %2d , x : %3d, y :%3d, width : %3d\n", fingers[i].bit_field.id - 1, press, fingers[i].bit_field.x, fingers[i].bit_field.y, fingers[i].bit_field.w);
#else
input_report_abs(data->input_dev, ABS_MT_POSITION_X,
fingers[i].bit_field.x);
input_report_abs(data->input_dev, ABS_MT_POSITION_Y,
fingers[i].bit_field.y);
input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR,
press);
input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR,
fingers[i].bit_field.w);
input_mt_sync(data->input_dev);
#endif // (LINUX_VERSION_CODE > KERNEL_VERSION(3, 0, 0)
data->prev_fingers[i] = fingers[i];
count++;
}
#if IST30XX_USE_KEY
for (i = finger_counts; i < finger_counts + key_counts; i++) {
key_id = fingers[i].bit_field.id;
key_press = (fingers[i].bit_field.w == PRESS_MSG_KEY) ? 1 : 0;
if (finger_on_screen()) { // Ignore touch key
tsp_warn("Ignore key id: %d\n", key_id);
continue;
}
tsp_debug("key(%08x) id: %d, press: %d, sensitivity: %d\n",
fingers[i].full_field, key_id, key_press, fingers[i].bit_field.y);
input_report_key(data->input_dev, ist30xx_key_code[key_id], key_press);
data->prev_keys[key_id-1] = fingers[i];
count++;
}
#endif // IST30XX_USE_KEY
if (count > 0)
input_sync(data->input_dev);
data->num_fingers = finger_counts;
ist30xx_error_cnt = 0;
}
static void sitronix_read_work(struct work_struct *work)
{
struct sitronix_data *sitronix= container_of(work, struct sitronix_data, read_work);
int ret = -1;
u8 buf[22] = {FINGERS,0};
u8 i = 0, fingers = 0, tskey = 0;
u16 px = 0, py = 0;
u16 x = 0, y = 0;
ret = sitronix_read(sitronix, buf,sizeof(buf));
if(ret <= 0){
dbg_err("get raw data failed!\n");
goto err_exit;
}
fingers = buf[0]&0x0f;
if( fingers ){
/* Report co-ordinates to the multi-touch stack */
for(i=0; i < fingers; i++){
if(sitronix->swap){
y = ((buf[i*4+2]<<4)&0x0700)|buf[i*4+3];
x = ((buf[i*4+2]<<8)&0x0700)|buf[i*4+4];
}else{
x = ((buf[i*4+2]<<4)&0x0700)|buf[i*4+3];
y = ((buf[i*4+2]<<8)&0x0700)|buf[i*4+4];
}
if(!(buf[i*4+2]&0x80)) continue; /*check valid bit */
if(x > sitronix->xresl ) x = sitronix->xresl ;
if(y > sitronix->yresl ) y = sitronix->yresl ;
px = x;
py = y;
if(sitronix->xch) px = sitronix->xresl - x;
if(sitronix->ych) py = sitronix->yresl - y;
input_report_abs(sitronix->input_dev, ABS_MT_POSITION_X, px);
input_report_abs(sitronix->input_dev, ABS_MT_POSITION_Y, py);
input_report_abs(sitronix->input_dev, ABS_MT_TRACKING_ID, i+1);
input_mt_sync(sitronix->input_dev);
sitronix->penup = 0;
if(sitronix->dbg) printk("F%d,raw data: x=%-4d, y=%-4d; report data: px=%-4d, py=%-4d\n", i, x, y, px, py);
}
input_sync(sitronix->input_dev);
}
else if(!sitronix->penup){
dbg("pen up.\n");
sitronix->penup = 1;
input_mt_sync(sitronix->input_dev);
input_sync(sitronix->input_dev);
}
/* virtual keys */
tskey = buf[1];
if(tskey){
if(!sitronix->tkey_idx){
sitronix->tkey_idx = tskey;
input_report_key(sitronix->input_dev,virtual_keys[sitronix->tkey_idx>>1] , 1);
input_sync(sitronix->input_dev);
dbg("virtual key down, idx=%d\n",sitronix->tkey_idx);
}
}else{
static void kp_work(struct kp *kp)
{
int i, code;
int tmp = 1;
/*******************************************************************************/
//add for adc keys(channel 4)
//report VOL+, VOL-, start, select
scan_android_key(kp);
i = 4;
code = kp->key_code[i];
if ((!code) && (!kp->cur_keycode[i])) {
;
} else if (code != kp->tmp_code[i]) {
kp->tmp_code[i] = code;
kp->count[i] = 0;
} else if(++kp->count[i] == 2) {
if (kp->cur_keycode[i] != code) {
if (!code) {
kp->cur_keycode_status[i] = 0;
//printk("key %d up\n", kp->cur_keycode[i]);
input_report_key(kp->input_joystick, kp->cur_keycode[i], 0);
kp->cur_keycode[i] = code;
} else if (kp->cur_keycode_status[i] == 1) {
//printk("key %d up(force)\n", kp->cur_keycode[i]);
input_report_key(kp->input_joystick, kp->cur_keycode[i], 0);
kp->cur_keycode_status[i] = 0;
kp->count[i] = 0;
} else {
kp->cur_keycode_status[i] = 1;
//printk("key %d down\n", code);
input_report_key(kp->input_joystick, code, 1);
kp->cur_keycode[i] = code;
}
}
}
//end
/*******************************************************************************/
/*******************************************************************************/
//report joystick
if (key_param[0] == 0 || key_param[1] < 0 || key_param[2] < 0) {
scan_left_joystick(kp);
js_report(kp, kp->js_value[2], 0); //left
js_report(kp, kp->js_value[3], 1); //left
input_sync(kp->input_joystick);
}
if (key_param[0] == 0) {
scan_right_joystick(kp);
js_report(kp, kp->js_value[0], 5); //right
js_report(kp, kp->js_value[1], 2); //right
input_sync(kp->input_joystick);
} else if (key_param[0] == 1 && (key_param[21] < 0 || key_param[22] < 0)) {
scan_right_joystick(kp);
js_report(kp, kp->js_value[0], 5); //right
js_report(kp, kp->js_value[1], 2); //right
input_sync(kp->input_joystick);
} else if (key_param[0] == 2 && (key_param[20] < 0 || key_param[21] < 0)) {
scan_right_joystick(kp);
js_report(kp, kp->js_value[0], 5); //right
js_report(kp, kp->js_value[1], 2); //right
input_sync(kp->input_joystick);
}
if (key_param[0] == 0) {
report_joystick_key(kp);
input_sync(kp->input_joystick);
}
//end
/*******************************************************************************/
/*******************************************************************************/
//report key mapping
//left joystick
if ((key_param[0] == 1 || key_param[0] == 2) && key_param[1] >= 0 && key_param[2] >= 0) {
scan_left_joystick_touchmapping(kp);
if ((kp->key_valid[2] == 1) || (kp->key_valid[3] == 1)) {
kp->circle_flag[0] = 1;
if(second0 < CENTER_TRY) {
if(second0 == 0)
keytouch_report(kp, key_param[1], key_param[2], 0);
if(second0 == 1)
keytouch_report(kp, key_param[1] + 1, key_param[2], 0);
if(second0 == 2)
keytouch_report(kp, key_param[1], key_param[2] + 1, 0);
if(second0 == 3)
keytouch_report(kp, key_param[1] - 1, key_param[2], 0);
if(second0 == 4)
keytouch_report(kp, key_param[1], key_param[2] - 1, 0);
second0++;
} else {
keytouch_report(kp, key_param[1] + (512 - kp->key_value[2]) * key_param[3] / 512,
key_param[2] + (512 - kp->key_value[3]) * key_param[3] / 512, 0);
}
} else if (kp->circle_flag[0] == 1) {
kp->circle_flag[0] = 0;
second0 = 0;
}
} else if (key_param[0] == 1 || key_param[0] == 2) {
kp->circle_flag[0] = 0;
second0 = 0;
}
//right joystick
if (key_param[0] == 1 && key_param[21] >= 0 && key_param[22] >= 0) { //mode 1
scan_right_joystick_touchmapping(kp);
if ((kp->key_valid[0] == 1) || (kp->key_valid[1] == 1)) {
kp->circle_flag[1] = 1;
if(!second1) {
keytouch_report(kp, key_param[21], key_param[22], 1);
second1 = 1;
} else {
circle_move(kp);
keytouch_report(kp, kp->key_value[1], kp->key_value[0], 1);
}
} else if (kp->circle_flag[1] == 1) {
kp->circle_flag[1] = 0;
second1 = 0;
kp->old_x = key_param[21];
kp->old_y = key_param[22];
}
} else if (key_param[0] == 2 && key_param[20] >= 0 && key_param[21] >= 0) { //mode 2
scan_right_joystick_touchmapping(kp);
if ((kp->key_valid[0] == 1) || (kp->key_valid[1] == 1)) {
kp->circle_flag[1] = 1;
if(second1 < CENTER_TRY) {
if(second1 == 0)
keytouch_report(kp, key_param[20], key_param[21], 1);
if(second1 == 1)
keytouch_report(kp, key_param[20] + 1, key_param[21], 1);
if(second1 == 2)
keytouch_report(kp, key_param[20], key_param[21] + 1, 1);
if(second1 == 3)
keytouch_report(kp, key_param[20] - 1, key_param[21], 1);
if(second1 == 4)
keytouch_report(kp, key_param[20], key_param[21] - 1, 1);
second1++;
} else {
keytouch_report(kp, key_param[20] + (512 - kp->key_value[1]) * key_param[22] / 512,
key_param[21] + (kp->key_value[0] - 512) * key_param[22] / 512, 1);
}
} else if (kp->circle_flag[1] == 1) {
kp->circle_flag[1] = 0;
second1 = 0;
}
} else if (key_param[0] == 1 || key_param[0] == 2) {
kp->circle_flag[1] = 0;
second1 = 0;
}
//end
if ((key_param[0] == 1 || key_param[0] == 2)) {
report_keytouch_key(kp);
input_sync(kp->input_keytouch);
if (release && (kp->circle_flag[0] == 0) && (kp->circle_flag[1] ==0)) {
for (i = 0; i < key_flag_num; i++) {
tmp = (tmp * gamekeys[i].flag);
}
if (tmp)
keytouch_release(kp);
}
}
/*******************************************************************************/
}
void carl9170_handle_command_response(struct ar9170 *ar, void *buf, u32 len)
{
struct carl9170_rsp *cmd = (void *) buf;
struct ieee80211_vif *vif;
if (carl9170_check_sequence(ar, cmd->hdr.seq))
return;
if ((cmd->hdr.cmd & CARL9170_RSP_FLAG) != CARL9170_RSP_FLAG) {
if (!(cmd->hdr.cmd & CARL9170_CMD_ASYNC_FLAG))
carl9170_cmd_callback(ar, len, buf);
return;
}
if (unlikely(cmd->hdr.len != (len - 4))) {
if (net_ratelimit()) {
wiphy_err(ar->hw->wiphy, "FW: received over-/under"
"sized event %x (%d, but should be %d).\n",
cmd->hdr.cmd, cmd->hdr.len, len - 4);
print_hex_dump_bytes("dump:", DUMP_PREFIX_NONE,
buf, len);
}
return;
}
/* hardware event handlers */
switch (cmd->hdr.cmd) {
case CARL9170_RSP_PRETBTT:
/* pre-TBTT event */
rcu_read_lock();
vif = carl9170_get_main_vif(ar);
if (!vif) {
rcu_read_unlock();
break;
}
switch (vif->type) {
case NL80211_IFTYPE_STATION:
carl9170_handle_ps(ar, cmd);
break;
case NL80211_IFTYPE_AP:
case NL80211_IFTYPE_ADHOC:
carl9170_update_beacon(ar, true);
break;
default:
break;
}
rcu_read_unlock();
break;
case CARL9170_RSP_TXCOMP:
/* TX status notification */
carl9170_tx_process_status(ar, cmd);
break;
case CARL9170_RSP_BEACON_CONFIG:
/*
* (IBSS) beacon send notification
* bytes: 04 c2 XX YY B4 B3 B2 B1
*
* XX always 80
* YY always 00
* B1-B4 "should" be the number of send out beacons.
*/
break;
case CARL9170_RSP_ATIM:
/* End of Atim Window */
break;
case CARL9170_RSP_WATCHDOG:
/* Watchdog Interrupt */
carl9170_restart(ar, CARL9170_RR_WATCHDOG);
break;
case CARL9170_RSP_TEXT:
/* firmware debug */
carl9170_dbg_message(ar, (char *)buf + 4, len - 4);
break;
case CARL9170_RSP_HEXDUMP:
wiphy_dbg(ar->hw->wiphy, "FW: HD %d\n", len - 4);
print_hex_dump_bytes("FW:", DUMP_PREFIX_NONE,
(char *)buf + 4, len - 4);
break;
case CARL9170_RSP_RADAR:
if (!net_ratelimit())
break;
wiphy_info(ar->hw->wiphy, "FW: RADAR! Please report this "
"incident to [email protected] !\n");
break;
case CARL9170_RSP_GPIO:
#ifdef CONFIG_CARL9170_WPC
if (ar->wps.pbc) {
bool state = !!(cmd->gpio.gpio & cpu_to_le32(
AR9170_GPIO_PORT_WPS_BUTTON_PRESSED));
if (state != ar->wps.pbc_state) {
ar->wps.pbc_state = state;
input_report_key(ar->wps.pbc, KEY_WPS_BUTTON,
state);
input_sync(ar->wps.pbc);
}
}
#endif /* CONFIG_CARL9170_WPC */
break;
case CARL9170_RSP_BOOT:
complete(&ar->fw_boot_wait);
break;
default:
wiphy_err(ar->hw->wiphy, "FW: received unhandled event %x\n",
cmd->hdr.cmd);
print_hex_dump_bytes("dump:", DUMP_PREFIX_NONE, buf, len);
break;
}
}
long kpd_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
//void __user *uarg = (void __user *)arg;
switch (cmd) {
#if KPD_AUTOTEST
case PRESS_OK_KEY://KPD_AUTOTEST disable auto test setting to resolve CR ALPS00464496
if(test_bit(KEY_OK, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS OK KEY!!\n");
input_report_key(kpd_input_dev, KEY_OK, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support OK KEY!!\n");
}
break;
case RELEASE_OK_KEY:
if(test_bit(KEY_OK, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE OK KEY!!\n");
input_report_key(kpd_input_dev, KEY_OK, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support OK KEY!!\n");
}
break;
case PRESS_MENU_KEY:
if(test_bit(KEY_MENU, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS MENU KEY!!\n");
input_report_key(kpd_input_dev, KEY_MENU, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support MENU KEY!!\n");
}
break;
case RELEASE_MENU_KEY:
if(test_bit(KEY_MENU, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE MENU KEY!!\n");
input_report_key(kpd_input_dev, KEY_MENU, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support MENU KEY!!\n");
}
break;
case PRESS_UP_KEY:
if(test_bit(KEY_UP, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS UP KEY!!\n");
input_report_key(kpd_input_dev, KEY_UP, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support UP KEY!!\n");
}
break;
case RELEASE_UP_KEY:
if(test_bit(KEY_UP, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE UP KEY!!\n");
input_report_key(kpd_input_dev, KEY_UP, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support UP KEY!!\n");
}
break;
case PRESS_DOWN_KEY:
if(test_bit(KEY_DOWN, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS DOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_DOWN, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support DOWN KEY!!\n");
}
break;
case RELEASE_DOWN_KEY:
if(test_bit(KEY_DOWN, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE DOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_DOWN, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support DOWN KEY!!\n");
}
break;
case PRESS_LEFT_KEY:
if(test_bit(KEY_LEFT, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS LEFT KEY!!\n");
input_report_key(kpd_input_dev, KEY_LEFT, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support LEFT KEY!!\n");
}
break;
case RELEASE_LEFT_KEY:
if(test_bit(KEY_LEFT, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE LEFT KEY!!\n");
input_report_key(kpd_input_dev, KEY_LEFT, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support LEFT KEY!!\n");
}
break;
case PRESS_RIGHT_KEY:
if(test_bit(KEY_RIGHT, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS RIGHT KEY!!\n");
input_report_key(kpd_input_dev, KEY_RIGHT, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support RIGHT KEY!!\n");
}
break;
case RELEASE_RIGHT_KEY:
if(test_bit(KEY_RIGHT, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE RIGHT KEY!!\n");
input_report_key(kpd_input_dev, KEY_RIGHT, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support RIGHT KEY!!\n");
}
break;
case PRESS_HOME_KEY:
if(test_bit(KEY_HOME, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS HOME KEY!!\n");
input_report_key(kpd_input_dev, KEY_HOME, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support HOME KEY!!\n");
}
break;
case RELEASE_HOME_KEY:
if(test_bit(KEY_HOME, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE HOME KEY!!\n");
input_report_key(kpd_input_dev, KEY_HOME, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support HOME KEY!!\n");
}
break;
case PRESS_BACK_KEY:
if(test_bit(KEY_BACK, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS BACK KEY!!\n");
input_report_key(kpd_input_dev, KEY_BACK, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support BACK KEY!!\n");
}
break;
case RELEASE_BACK_KEY:
if(test_bit(KEY_BACK, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE BACK KEY!!\n");
input_report_key(kpd_input_dev, KEY_BACK, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support BACK KEY!!\n");
}
break;
case PRESS_CALL_KEY:
if(test_bit(KEY_CALL, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS CALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_CALL, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support CALL KEY!!\n");
}
break;
case RELEASE_CALL_KEY:
if(test_bit(KEY_CALL, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE CALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_CALL, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support CALL KEY!!\n");
}
break;
case PRESS_ENDCALL_KEY:
if(test_bit(KEY_ENDCALL, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS ENDCALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_ENDCALL, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");
}
break;
case RELEASE_ENDCALL_KEY:
if(test_bit(KEY_ENDCALL, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE ENDCALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_ENDCALL, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");
}
break;
case PRESS_VLUP_KEY:
if(test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS VOLUMEUP KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEUP, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
}
break;
case RELEASE_VLUP_KEY:
if(test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE VOLUMEUP KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEUP, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
}
break;
case PRESS_VLDOWN_KEY:
if(test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS VOLUMEDOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
}
break;
case RELEASE_VLDOWN_KEY:
if(test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE VOLUMEDOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
}
break;
case PRESS_FOCUS_KEY:
if(test_bit(KEY_FOCUS, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS FOCUS KEY!!\n");
input_report_key(kpd_input_dev, KEY_FOCUS, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support FOCUS KEY!!\n");
}
break;
case RELEASE_FOCUS_KEY:
if(test_bit(KEY_FOCUS, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE FOCUS KEY!!\n");
input_report_key(kpd_input_dev, KEY_FOCUS, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support RELEASE KEY!!\n");
}
break;
case PRESS_CAMERA_KEY:
if(test_bit(KEY_CAMERA, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS CAMERA KEY!!\n");
input_report_key(kpd_input_dev, KEY_CAMERA, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support CAMERA KEY!!\n");
}
break;
case RELEASE_CAMERA_KEY:
if(test_bit(KEY_CAMERA, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE CAMERA KEY!!\n");
input_report_key(kpd_input_dev, KEY_CAMERA, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support CAMERA KEY!!\n");
}
break;
case PRESS_POWER_KEY:
if(test_bit(KEY_POWER, kpd_input_dev->keybit)){
printk("[AUTOTEST] PRESS POWER KEY!!\n");
input_report_key(kpd_input_dev, KEY_POWER, 1);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support POWER KEY!!\n");
}
break;
case RELEASE_POWER_KEY:
if(test_bit(KEY_POWER, kpd_input_dev->keybit)){
printk("[AUTOTEST] RELEASE POWER KEY!!\n");
input_report_key(kpd_input_dev, KEY_POWER, 0);
input_sync(kpd_input_dev);
}else{
printk("[AUTOTEST] Not Support POWER KEY!!\n");
}
break;
#endif
case SET_KPD_KCOL:
kpd_auto_test_for_factorymode();//API 3 for kpd factory mode auto-test
printk("[kpd_auto_test_for_factorymode] test performed!!\n");
break;
default:
return -EINVAL;
}
return 0;
}
static void gp2a_work_func_prox(struct work_struct *work)
{
struct gp2a_data *gp2a = container_of(work, struct gp2a_data, work_prox);
unsigned char value;
unsigned char int_val=REGS_PROX;
unsigned char vout=0;
#if defined(CONFIG_MACH_RANT3)
int err;
static int retry = 0;
#endif
/* Read VO & INT Clear */
printk("[PROXIMITY] %s \n",__func__);
if(INT_CLEAR)
{
// int_val = REGS_PROX | (1 <<7);
}
#if defined(CONFIG_MACH_RANT3)
err = opt_i2c_read((u8)(int_val),&value,1);
if(err < 0 && retry == 0)
{
printk("[PROXIMITY] I2C read error, try again==============================!!! \n");
retry++;
schedule_delayed_work(&gp2a->work_prox, 10);
return;
}
else
retry = 0;
#else
opt_i2c_read((u8)(int_val),&value,1);
#endif
vout = value & 0x01;
printk(KERN_INFO "[PROXIMITY] value = %d \n",vout);
/* Report proximity information */
proximity_value = vout;
if(proximity_value ==0)
{
/*
timeB = ktime_get();
timeSub = ktime_sub(timeB,timeA);
printk(KERN_INFO "[PROXIMITY] timeB = %d sec, timeA = %d sec \n",timeB.tv.sec,timeA.tv.sec);
printk(KERN_INFO "[PROXIMITY] timeSub sec = %d, timeSub nsec = %d \n",timeSub.tv.sec,timeSub.tv.nsec);
if (timeSub.tv.sec>=3 )
{
wake_lock_timeout(&prx_wake_lock,3*HZ);
printk(KERN_INFO "[PROXIMITY] wake_lock_timeout : 3sec \n");
}
else
printk(KERN_INFO "[PROXIMITY] wake_lock is already set \n");
*/
}
if(USE_INPUT_DEVICE)
{
input_report_abs(gp2a->input_dev,ABS_DISTANCE,(int)vout);
input_sync(gp2a->input_dev);
mdelay(1);
}
/* Write HYS Register */
if(!vout)
{
#if defined(CONFIG_MACH_RANT3)
value = 0x2F;
#else
value = 0x40;
#endif
}
else
{
#if defined(CONFIG_MACH_RANT3)
value = 0x0F;
#else
value = 0x20;
#endif
}
opt_i2c_write((u8)(REGS_HYS),&value);
/* Forcing vout terminal to go high */
value = 0x18;
opt_i2c_write((u8)(REGS_CON),&value);
/* enable INT */
enable_irq(gp2a->irq);
/* enabling VOUT terminal in nomal operation */
value = 0x00;
opt_i2c_write((u8)(REGS_CON),&value);
printk("[PROXIMITY] end %s \n",__func__);
}
static void gpio_keys_report_event(struct gpio_button_data *bdata)
{
struct gpio_keys_button *button = bdata->button;
struct input_dev *input = bdata->input;
unsigned int type = button->type ?: EV_KEY;
int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;
#if defined(CONFIG_MACH_P1)
#ifdef CONFIG_KERNEL_DEBUG_SEC
static bool first=false;
static bool second=false;
#ifdef CONFIG_TARGET_LOCALE_KOR
static bool third=false;
#endif /* CONFIG_TARGET_LOCALE_KOR */
if(state)
{
if(button->code == KEY_VOLUMEUP)
{
first = true;
}
if(button->code == KEY_VOLUMEDOWN)
{
second = true;
}
/* forced upload should be very quick and on time, omit the timer operation */
#ifdef CONFIG_TARGET_LOCALE_KOR
if(button->code == KEY_POWER)
{
third = true;
}
if(first&&second&&third)
enter_upload_mode();
#endif /* CONFIG_TARGET_LOCALE_KOR */
/* Entering the forced upload mode should be pressed both volume keys
before pressing the power key */
if(first&&second)
{
if(button->code == KEY_POWER)
{
mod_timer(&debug_timer, jiffies + HZ*2);
printk(KERN_WARNING "[Key] Waiting for upload mode for 2 seconds.\n");
}
}
}
else
{
if(button->code == KEY_VOLUMEUP)
{
first = false;
}
if(button->code == KEY_VOLUMEDOWN)
{
second = false;
}
#ifdef CONFIG_TARGET_LOCALE_KOR
if(button->code == KEY_POWER)
{
third = false;
}
#endif /* CONFIG_TARGET_LOCALE_KOR */
}
#endif // CONFIG_KERNEL_DEBUG_SEC
if(state)
{
button->pressed = true;
}
else
{
/*workaround irq bug in p1*/
if(!button->pressed)
{
}
else
{
input_event(input, type, button->code, 1);
input_sync(input);
msleep(1);
}
button->pressed = false;
}
#endif
input_event(input, type, button->code, !!state);
input_sync(input);
}
