Skip to content

Commit

Permalink
[media] ir-core: remove remaining users of the ir-functions keyhandlers
Browse files Browse the repository at this point in the history 
This patch removes the remaining usages of the ir_input_nokey() and
ir_input_keydown() functions provided by drivers/media/IR/ir-functions.c
by using the corresponding functionality in ir-core instead.

Signed-off-by: David Härdeman <david@hardeman.nu>
Acked-by: Jarod Wilson <jarod@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
  • Loading branch information
David Härdeman authored and Mauro Carvalho Chehab committed Dec 29, 2010
1 parent 2997137 commit 62c6503
Show file tree
Hide file tree
Showing 12 changed files with 133 additions and 236 deletions.
9 changes: 2 additions & 7 deletions drivers/media/IR/imon.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1479,17 +1479,12 @@ static void imon_incoming_packet(struct imon_context *ictx,
bool norelease = false;
int i;
u64 scancode;
struct input_dev *rdev = NULL;
struct ir_input_dev *irdev = NULL;
int press_type = 0;
int msec;
struct timeval t;
static struct timeval prev_time = { 0, 0 };
u8 ktype;

rdev = ictx->rdev;
irdev = input_get_drvdata(rdev);

/* filter out junk data on the older 0xffdc imon devices */
if ((buf[0] == 0xff) && (buf[1] == 0xff) && (buf[2] == 0xff))
return;
Expand Down Expand Up @@ -1570,9 +1565,9 @@ static void imon_incoming_packet(struct imon_context *ictx,

if (ktype != IMON_KEY_PANEL) {
if (press_type == 0)
ir_keyup(irdev);
ir_keyup(ictx->rdev);
else {
ir_keydown(rdev, ictx->rc_scancode, ictx->rc_toggle);
ir_keydown(ictx->rdev, ictx->rc_scancode, ictx->rc_toggle);
spin_lock_irqsave(&ictx->kc_lock, flags);
ictx->last_keycode = ictx->kc;
spin_unlock_irqrestore(&ictx->kc_lock, flags);
Expand Down
101 changes: 9 additions & 92 deletions drivers/media/IR/ir-functions.c
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
/*
*
* some common structs and functions to handle infrared remotes via
* input layer ...
* some common functions to handle infrared remote protocol decoding for
* drivers which have not yet been (or can't be) converted to use the
* regular protocol decoders...
*
* (c) 2003 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
*
Expand Down Expand Up @@ -31,67 +31,6 @@
MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
MODULE_LICENSE("GPL");

static int repeat = 1;
module_param(repeat, int, 0444);
MODULE_PARM_DESC(repeat,"auto-repeat for IR keys (default: on)");

/* -------------------------------------------------------------------------- */

static void ir_input_key_event(struct input_dev *dev, struct ir_input_state *ir)
{
if (KEY_RESERVED == ir->keycode) {
printk(KERN_INFO "%s: unknown key: key=0x%02x down=%d\n",
dev->name, ir->ir_key, ir->keypressed);
return;
}
IR_dprintk(1,"%s: key event code=%d down=%d\n",
dev->name,ir->keycode,ir->keypressed);
input_report_key(dev,ir->keycode,ir->keypressed);
input_sync(dev);
}

/* -------------------------------------------------------------------------- */

int ir_input_init(struct input_dev *dev, struct ir_input_state *ir,
const u64 ir_type)
{
ir->ir_type = ir_type;

if (repeat)
set_bit(EV_REP, dev->evbit);

return 0;
}
EXPORT_SYMBOL_GPL(ir_input_init);


void ir_input_nokey(struct input_dev *dev, struct ir_input_state *ir)
{
if (ir->keypressed) {
ir->keypressed = 0;
ir_input_key_event(dev,ir);
}
}
EXPORT_SYMBOL_GPL(ir_input_nokey);

void ir_input_keydown(struct input_dev *dev, struct ir_input_state *ir,
u32 ir_key)
{
u32 keycode = ir_g_keycode_from_table(dev, ir_key);

if (ir->keypressed && ir->keycode != keycode) {
ir->keypressed = 0;
ir_input_key_event(dev,ir);
}
if (!ir->keypressed) {
ir->ir_key = ir_key;
ir->keycode = keycode;
ir->keypressed = 1;
ir_input_key_event(dev,ir);
}
}
EXPORT_SYMBOL_GPL(ir_input_keydown);

/* -------------------------------------------------------------------------- */
/* extract mask bits out of data and pack them into the result */
u32 ir_extract_bits(u32 data, u32 mask)
Expand All @@ -115,7 +54,7 @@ EXPORT_SYMBOL_GPL(ir_extract_bits);
* saa7134 */

/* decode raw bit pattern to RC5 code */
u32 ir_rc5_decode(unsigned int code)
static u32 ir_rc5_decode(unsigned int code)
{
unsigned int org_code = code;
unsigned int pair;
Expand Down Expand Up @@ -144,13 +83,12 @@ u32 ir_rc5_decode(unsigned int code)
RC5_TOGGLE(rc5), RC5_ADDR(rc5), RC5_INSTR(rc5));
return rc5;
}
EXPORT_SYMBOL_GPL(ir_rc5_decode);

void ir_rc5_timer_end(unsigned long data)
{
struct card_ir *ir = (struct card_ir *)data;
struct timeval tv;
unsigned long current_jiffies, timeout;
unsigned long current_jiffies;
u32 gap;
u32 rc5 = 0;

Expand Down Expand Up @@ -191,32 +129,11 @@ void ir_rc5_timer_end(unsigned long data)
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)) {
IR_dprintk(1, "ir-common: instruction %x, toggle %x\n", instr,
toggle);
ir_input_nokey(ir->dev, &ir->ir);
ir_input_keydown(ir->dev, &ir->ir, instr);
}

/* Set/reset key-up timer */
timeout = current_jiffies +
msecs_to_jiffies(ir->rc5_key_timeout);
mod_timer(&ir->timer_keyup, timeout);

/* Save code for repeat test */
ir->last_rc5 = rc5;
/* Good code */
ir_keydown(ir->dev, instr, toggle);
IR_dprintk(1, "ir-common: instruction %x, toggle %x\n",
instr, toggle);
}
}
}
EXPORT_SYMBOL_GPL(ir_rc5_timer_end);

void ir_rc5_timer_keyup(unsigned long data)
{
struct card_ir *ir = (struct card_ir *)data;

IR_dprintk(1, "ir-common: key released\n");
ir_input_nokey(ir->dev, &ir->ir);
}
EXPORT_SYMBOL_GPL(ir_rc5_timer_keyup);
110 changes: 83 additions & 27 deletions drivers/media/IR/ir-keytable.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -431,13 +431,13 @@ u32 ir_g_keycode_from_table(struct input_dev *dev, u32 scancode)
EXPORT_SYMBOL_GPL(ir_g_keycode_from_table);

/**
* ir_keyup() - generates input event to cleanup a key press
* ir_do_keyup() - internal function to signal the release of a keypress
* @ir: the struct ir_input_dev descriptor of the device
*
* This routine is used to signal that a key has been released on the
* remote control. It reports a keyup input event via input_report_key().
* This function is used internally to release a keypress, it must be
* called with keylock held.
*/
void ir_keyup(struct ir_input_dev *ir)
static void ir_do_keyup(struct ir_input_dev *ir)
{
if (!ir->keypressed)
return;
Expand All @@ -447,6 +447,23 @@ void ir_keyup(struct ir_input_dev *ir)
input_sync(ir->input_dev);
ir->keypressed = false;
}

/**
* ir_keyup() - generates input event to signal the release of a keypress
* @dev: the struct input_dev descriptor of the device
*
* This routine is used to signal that a key has been released on the
* remote control.
*/
void ir_keyup(struct input_dev *dev)
{
unsigned long flags;
struct ir_input_dev *ir = input_get_drvdata(dev);

spin_lock_irqsave(&ir->keylock, flags);
ir_do_keyup(ir);
spin_unlock_irqrestore(&ir->keylock, flags);
}
EXPORT_SYMBOL_GPL(ir_keyup);

/**
Expand All @@ -473,7 +490,7 @@ static void ir_timer_keyup(unsigned long cookie)
*/
spin_lock_irqsave(&ir->keylock, flags);
if (time_is_before_eq_jiffies(ir->keyup_jiffies))
ir_keyup(ir);
ir_do_keyup(ir);
spin_unlock_irqrestore(&ir->keylock, flags);
}

Expand Down Expand Up @@ -506,60 +523,99 @@ void ir_repeat(struct input_dev *dev)
EXPORT_SYMBOL_GPL(ir_repeat);

/**
* ir_keydown() - generates input event for a key press
* ir_do_keydown() - internal function to process a keypress
* @dev: the struct input_dev descriptor of the device
* @scancode: the scancode that we're seeking
* @toggle: the toggle value (protocol dependent, if the protocol doesn't
* support toggle values, this should be set to zero)
* @scancode: the scancode of the keypress
* @keycode: the keycode of the keypress
* @toggle: the toggle value of the keypress
*
* This routine is used by the input routines when a key is pressed at the
* IR. It gets the keycode for a scancode and reports an input event via
* input_report_key().
* This function is used internally to register a keypress, it must be
* called with keylock held.
*/
void ir_keydown(struct input_dev *dev, int scancode, u8 toggle)
static void ir_do_keydown(struct input_dev *dev, int scancode,
u32 keycode, u8 toggle)
{
unsigned long flags;
struct ir_input_dev *ir = input_get_drvdata(dev);

u32 keycode = ir_g_keycode_from_table(dev, scancode);

spin_lock_irqsave(&ir->keylock, flags);

input_event(dev, EV_MSC, MSC_SCAN, scancode);

/* Repeat event? */
if (ir->keypressed &&
ir->last_scancode == scancode &&
ir->last_toggle == toggle)
goto set_timer;
return;

/* Release old keypress */
ir_keyup(ir);
ir_do_keyup(ir);

ir->last_scancode = scancode;
ir->last_toggle = toggle;
ir->last_keycode = keycode;


if (keycode == KEY_RESERVED)
goto out;

return;

/* Register a keypress */
ir->keypressed = true;
IR_dprintk(1, "%s: key down event, key 0x%04x, scancode 0x%04x\n",
dev->name, keycode, scancode);
input_report_key(dev, ir->last_keycode, 1);
input_sync(dev);
}

set_timer:
ir->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
mod_timer(&ir->timer_keyup, ir->keyup_jiffies);
out:
/**
* ir_keydown() - generates input event for a key press
* @dev: the struct input_dev descriptor of the device
* @scancode: the scancode that we're seeking
* @toggle: the toggle value (protocol dependent, if the protocol doesn't
* support toggle values, this should be set to zero)
*
* This routine is used by the input routines when a key is pressed at the
* IR. It gets the keycode for a scancode and reports an input event via
* input_report_key().
*/
void ir_keydown(struct input_dev *dev, int scancode, u8 toggle)
{
unsigned long flags;
struct ir_input_dev *ir = input_get_drvdata(dev);
u32 keycode = ir_g_keycode_from_table(dev, scancode);

spin_lock_irqsave(&ir->keylock, flags);
ir_do_keydown(dev, scancode, keycode, toggle);

if (ir->keypressed) {
ir->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
mod_timer(&ir->timer_keyup, ir->keyup_jiffies);
}
spin_unlock_irqrestore(&ir->keylock, flags);
}
EXPORT_SYMBOL_GPL(ir_keydown);

/**
* ir_keydown_notimeout() - generates input event for a key press without
* an automatic keyup event at a later time
* @dev: the struct input_dev descriptor of the device
* @scancode: the scancode that we're seeking
* @toggle: the toggle value (protocol dependent, if the protocol doesn't
* support toggle values, this should be set to zero)
*
* This routine is used by the input routines when a key is pressed at the
* IR. It gets the keycode for a scancode and reports an input event via
* input_report_key(). The driver must manually call ir_keyup() at a later
* stage.
*/
void ir_keydown_notimeout(struct input_dev *dev, int scancode, u8 toggle)
{
unsigned long flags;
struct ir_input_dev *ir = input_get_drvdata(dev);
u32 keycode = ir_g_keycode_from_table(dev, scancode);

spin_lock_irqsave(&ir->keylock, flags);
ir_do_keydown(dev, scancode, keycode, toggle);
spin_unlock_irqrestore(&ir->keylock, flags);
}
EXPORT_SYMBOL_GPL(ir_keydown_notimeout);

static int ir_open(struct input_dev *input_dev)
{
struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
Expand Down
Loading

0 comments on commit 62c6503

Please sign in to comment.