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); }