static int build_key(struct saa7134_dev *dev) { struct card_ir *ir = dev->remote; u32 gpio, data; /* here comes the additional handshake steps for some cards */ switch (dev->board) { case SAA7134_BOARD_GOTVIEW_7135: saa_setb(SAA7134_GPIO_GPSTATUS1, 0x80); saa_clearb(SAA7134_GPIO_GPSTATUS1, 0x80); break; } /* rising SAA7134_GPIO_GPRESCAN reads the status */ saa_clearb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN); saa_setb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN); gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2); if (ir->polling) { if (ir->last_gpio == gpio) return 0; ir->last_gpio = gpio; } data = ir_extract_bits(gpio, ir->mask_keycode); dprintk("build_key gpio=0x%x mask=0x%x data=%d\n", gpio, ir->mask_keycode, data); switch (dev->board) { case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG: if (data == ir->mask_keycode) ir_input_nokey(ir->dev, &ir->ir); else ir_input_keydown(ir->dev, &ir->ir, data); return 0; } if (ir->polling) { if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) || (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) { ir_input_keydown(ir->dev, &ir->ir, data); } else { ir_input_nokey(ir->dev, &ir->ir); } } else { /* IRQ driven mode - handle key press and release in one go */ if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) || (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) { ir_input_keydown(ir->dev, &ir->ir, data); ir_input_nokey(ir->dev, &ir->ir); } } return 0; }
static void ir_handle_key(struct bttv *btv) { struct bttv_ir *ir = btv->remote; u32 gpio,data; /* read gpio value */ gpio = bttv_gpio_read(&btv->c); if (ir->polling) { if (ir->last_gpio == gpio) return; ir->last_gpio = gpio; } /* extract data */ data = ir_extract_bits(gpio, ir->mask_keycode); dprintk(KERN_INFO DEVNAME ": irq gpio=0x%x code=%d | %s%s%s\n", gpio, data, ir->polling ? "poll" : "irq", (gpio & ir->mask_keydown) ? " down" : "", (gpio & ir->mask_keyup) ? " up" : ""); if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) || (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) { ir_input_keydown(ir->dev,&ir->ir,data,data); } else { ir_input_nokey(ir->dev,&ir->ir); } }
static void bttv_rc5_timer_keyup(unsigned long data) { struct bttv_ir *ir = (struct bttv_ir *)data; dprintk(KERN_DEBUG "key released\n"); ir_input_nokey(ir->dev, &ir->ir); }
void ir_rc5_timer_keyup(unsigned long data) { struct card_ir *ir = (struct card_ir *)data; dprintk(1, "ir-common: key released\n"); ir_input_nokey(ir->dev, &ir->ir); }
static void cx231xx_ir_handle_key(struct cx231xx_IR *ir) { int result; int do_sendkey = 0; struct cx231xx_ir_poll_result poll_result; /* read the registers containing the IR status */ result = ir->get_key(ir, &poll_result); if (result < 0) { dprintk("ir->get_key() failed %d\n", result); return; } dprintk("ir->get_key result tb=%02x rc=%02x lr=%02x data=%02x\n", poll_result.toggle_bit, poll_result.read_count, ir->last_readcount, poll_result.rc_data[0]); if (ir->dev->chip_id == CHIP_ID_EM2874) { /* The em2874 clears the readcount field every time the register is read. The em2860/2880 datasheet says that it is supposed to clear the readcount, but it doesn't. So with the em2874, we are looking for a non-zero read count as opposed to a readcount that is incrementing */ ir->last_readcount = 0; } if (poll_result.read_count == 0) { /* The button has not been pressed since the last read */ } else if (ir->last_toggle != poll_result.toggle_bit) { /* A button has been pressed */ dprintk("button has been pressed\n"); ir->last_toggle = poll_result.toggle_bit; ir->repeat_interval = 0; do_sendkey = 1; } else if (poll_result.toggle_bit == ir->last_toggle && poll_result.read_count > 0 && poll_result.read_count != ir->last_readcount) { /* The button is still being held down */ dprintk("button being held down\n"); /* Debouncer for first keypress */ if (ir->repeat_interval++ > 9) { /* Start repeating after 1 second */ do_sendkey = 1; } } if (do_sendkey) { dprintk("sending keypress\n"); ir_input_keydown(ir->input, &ir->ir, poll_result.rc_data[0], poll_result.rc_data[0]); ir_input_nokey(ir->input, &ir->ir); } ir->last_readcount = poll_result.read_count; return; }
static void cx231xx_ir_handle_key(struct cx231xx_IR *ir) { int result; int do_sendkey = 0; struct cx231xx_ir_poll_result poll_result; result = ir->get_key(ir, &poll_result); if (result < 0) { dprintk("ir->get_key() failed %d\n", result); return; } dprintk("ir->get_key result tb=%02x rc=%02x lr=%02x data=%02x\n", poll_result.toggle_bit, poll_result.read_count, ir->last_readcount, poll_result.rc_data[0]); if (ir->dev->chip_id == CHIP_ID_EM2874) { ir->last_readcount = 0; } if (poll_result.read_count == 0) { } else if (ir->last_toggle != poll_result.toggle_bit) { dprintk("button has been pressed\n"); ir->last_toggle = poll_result.toggle_bit; ir->repeat_interval = 0; do_sendkey = 1; } else if (poll_result.toggle_bit == ir->last_toggle && poll_result.read_count > 0 && poll_result.read_count != ir->last_readcount) { dprintk("button being held down\n"); if (ir->repeat_interval++ > 9) { do_sendkey = 1; } } if (do_sendkey) { dprintk("sending keypress\n"); ir_input_keydown(ir->input, &ir->ir, poll_result.rc_data[0], poll_result.rc_data[0]); ir_input_nokey(ir->input, &ir->ir); } ir->last_readcount = poll_result.read_count; return; }
static void ir_enltv_handle_key(struct bttv *btv) { struct card_ir *ir = btv->remote; u32 gpio, data, keyup; gpio = bttv_gpio_read(&btv->c); data = ir_extract_bits(gpio, ir->mask_keycode); keyup = (gpio & ir->mask_keyup) ? 1 << 31 : 0; if ((ir->last_gpio & 0x7f) != data) { dprintk(KERN_INFO DEVNAME ": gpio=0x%x code=%d | %s\n", gpio, data, (gpio & ir->mask_keyup) ? " up" : "up/down"); ir_input_keydown(ir->dev, &ir->ir, data, data); if (keyup) ir_input_nokey(ir->dev, &ir->ir); } else { if ((ir->last_gpio & 1 << 31) == keyup) return; dprintk(KERN_INFO DEVNAME ":(cnt) gpio=0x%x code=%d | %s\n", gpio, data, (gpio & ir->mask_keyup) ? " up" : "down"); if (keyup) ir_input_nokey(ir->dev, &ir->ir); else ir_input_keydown(ir->dev, &ir->ir, data, data); } ir->last_gpio = data | keyup; }
static void cx23885_input_process_raw_rc5(struct cx23885_dev *dev) { struct card_ir *ir_input = dev->ir_input; unsigned int code, command; u32 rc5; /* Ignore codes that are too short to be valid RC-5 */ if (ir_input->last_bit < (RC5_HALF_BITS - 1)) return; /* The library has the manchester coding backwards; XOR to adapt. */ code = (ir_input->code & RC5_HALF_BITS_MASK) ^ RC5_HALF_BITS_MASK; rc5 = ir_rc5_decode(code); switch (RC5_START(rc5)) { case RC5_START_BITS_NORMAL: break; case RC5_START_BITS_EXTENDED: /* Don't allow if the remote only emits standard commands */ if (ir_input->start == RC5_START_BITS_NORMAL) return; break; default: return; } if (ir_input->addr != RC5_ADDR(rc5)) return; /* Don't generate a keypress for RC-5 auto-repeated keypresses */ command = rc5_command(rc5); if (RC5_TOGGLE(rc5) != RC5_TOGGLE(ir_input->last_rc5) || command != rc5_command(ir_input->last_rc5) || /* Catch T == 0, CMD == 0 (e.g. '0') as first keypress after init */ RC5_START(ir_input->last_rc5) == 0) { /* This keypress is differnet: not an auto repeat */ ir_input_nokey(ir_input->dev, &ir_input->ir); ir_input_keydown(ir_input->dev, &ir_input->ir, command); } ir_input->last_rc5 = rc5; /* Schedule when we should do the key up event: ir_input_nokey() */ mod_timer(&ir_input->timer_keyup, jiffies + msecs_to_jiffies(ir_input->rc5_key_timeout)); }
static void tm6000_ir_handle_key(struct tm6000_IR *ir) { int result; struct tm6000_ir_poll_result poll_result; /* read the registers containing the IR status */ result = ir->get_key(ir, &poll_result); if (result < 0) { printk(KERN_INFO "ir->get_key() failed %d\n", result); return; } dprintk("ir->get_key result data=%04x\n", poll_result.rc_data); if (ir->key) { ir_input_keydown(ir->input->input_dev, &ir->ir, (u32)poll_result.rc_data); ir_input_nokey(ir->input->input_dev, &ir->ir); ir->key = 0; } return; }
static void bttv_rc5_timer_end(unsigned long data) { struct bttv_ir *ir = (struct bttv_ir *)data; struct timeval tv; unsigned long current_jiffies, timeout; u32 gap; /* get time */ current_jiffies = jiffies; do_gettimeofday(&tv); /* avoid overflow with gap >1s */ if (tv.tv_sec - ir->base_time.tv_sec > 1) { gap = 200000; } else { gap = 1000000 * (tv.tv_sec - ir->base_time.tv_sec) + tv.tv_usec - ir->base_time.tv_usec; } /* Allow some timmer jitter (RC5 is ~24ms anyway so this is ok) */ if (gap < 28000) { dprintk(KERN_WARNING "spurious timer_end\n"); return; } ir->active = 0; if (ir->last_bit < 20) { /* ignore spurious codes (caused by light/other remotes) */ dprintk(KERN_WARNING "short code: %x\n", ir->code); } else { u32 rc5 = rc5_decode(ir->code); /* two start bits? */ if (RC5_START(rc5) != 3) { dprintk(KERN_WARNING "rc5 start bits invalid: %u\n", RC5_START(rc5)); /* right address? */ } else if (RC5_ADDR(rc5) == 0x0) { u32 toggle = RC5_TOGGLE(rc5); u32 instr = RC5_INSTR(rc5); /* Good code, decide if repeat/repress */ if (toggle != RC5_TOGGLE(ir->last_rc5) || instr != RC5_INSTR(ir->last_rc5)) { dprintk(KERN_WARNING "instruction %x, toggle %x\n", instr, toggle); ir_input_nokey(ir->dev, &ir->ir); ir_input_keydown(ir->dev, &ir->ir, instr, instr); } /* Set/reset key-up timer */ timeout = current_jiffies + (500 + rc5_key_timeout * HZ) / 1000; mod_timer(&ir->timer_keyup, timeout); /* Save code for repeat test */ ir->last_rc5 = rc5; } } }