Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 62c65031 authored by David Härdeman's avatar David Härdeman Committed by Mauro Carvalho Chehab
Browse files

[media] ir-core: remove remaining users of the ir-functions keyhandlers 



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: default avatarDavid Härdeman <david@hardeman.nu>
Acked-by: default avatarJarod Wilson <jarod@redhat.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 2997137b

drivers/media/IR/imon.c

+2 −7
Original line number Diff line number Diff line
@@ -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;
@@ -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);

drivers/media/IR/ir-functions.c

+9 −92
Original line number Diff line number Diff line 
/*

 *

 * 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]

 *
@@ -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)
@@ -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;
@@ -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;
@@ -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);

drivers/media/IR/ir-keytable.c

+83 −27
Original line number Diff line number Diff line
@@ -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;
@@ -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);



/**
@@ -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);

}
@@ -506,44 +523,37 @@ out: 
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;
@@ -551,15 +561,61 @@ void ir_keydown(struct input_dev *dev, int scancode, u8 toggle) 
		   dev->name, keycode, scancode);

	input_report_key(dev, ir->last_keycode, 1);

	input_sync(dev);

}



/**

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



set_timer:

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

out:

	}

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

drivers/media/video/bt8xx/bttv-input.c

+9 −23
Original line number Diff line number Diff line
@@ -38,8 +38,6 @@ module_param(repeat_period, int, 0644); 


static int ir_rc5_remote_gap = 885;

module_param(ir_rc5_remote_gap, int, 0644);

static int ir_rc5_key_timeout = 200;

module_param(ir_rc5_key_timeout, int, 0644);



#undef dprintk

#define dprintk(arg...) do {	\
@@ -74,18 +72,17 @@ static void ir_handle_key(struct bttv *btv) 
		(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);

	if ((ir->mask_keydown && (gpio & ir->mask_keydown)) ||

	    (ir->mask_keyup   && !(gpio & ir->mask_keyup))) {

		ir_keydown_notimeout(ir->dev, data, 0);

	} else {

		/* HACK: Probably, ir->mask_keydown is missing

		   for this board */

		if (btv->c.type == BTTV_BOARD_WINFAST2000)

			ir_input_keydown(ir->dev, &ir->ir, data);

			ir_keydown_notimeout(ir->dev, data, 0);



		ir_input_nokey(ir->dev,&ir->ir);

		ir_keyup(ir->dev);

	}



}



static void ir_enltv_handle_key(struct bttv *btv)
@@ -107,9 +104,9 @@ static void ir_enltv_handle_key(struct bttv *btv) 
			gpio, data,

			(gpio & ir->mask_keyup) ? " up" : "up/down");



		ir_input_keydown(ir->dev, &ir->ir, data);

		ir_keydown_notimeout(ir->dev, data, 0);

		if (keyup)

			ir_input_nokey(ir->dev, &ir->ir);

			ir_keyup(ir->dev);

	} else {

		if ((ir->last_gpio & 1 << 31) == keyup)

			return;
@@ -119,9 +116,9 @@ static void ir_enltv_handle_key(struct bttv *btv) 
			(gpio & ir->mask_keyup) ? " up" : "down");



		if (keyup)

			ir_input_nokey(ir->dev, &ir->ir);

			ir_keyup(ir->dev);

		else

			ir_input_keydown(ir->dev, &ir->ir, data);

			ir_keydown_notimeout(ir->dev, data, 0);

	}



	ir->last_gpio = data | keyup;
@@ -215,14 +212,9 @@ static void bttv_ir_start(struct bttv *btv, struct card_ir *ir) 
		init_timer(&ir->timer_end);

		ir->timer_end.function = ir_rc5_timer_end;

		ir->timer_end.data = (unsigned long)ir;



		init_timer(&ir->timer_keyup);

		ir->timer_keyup.function = ir_rc5_timer_keyup;

		ir->timer_keyup.data = (unsigned long)ir;

		ir->shift_by = 1;

		ir->start = 3;

		ir->addr = 0x0;

		ir->rc5_key_timeout = ir_rc5_key_timeout;

		ir->rc5_remote_gap = ir_rc5_remote_gap;

	}

}
@@ -290,7 +282,6 @@ void __devinit init_bttv_i2c_ir(struct bttv *btv) 
		btv->init_data.name = "PV951";

		btv->init_data.get_key = get_key_pv951;

		btv->init_data.ir_codes = RC_MAP_PV951;

		btv->init_data.type = IR_TYPE_OTHER;

		info.addr = 0x4b;

		break;

	default:
@@ -327,7 +318,6 @@ int bttv_input_init(struct bttv *btv) 
	struct card_ir *ir;

	char *ir_codes = NULL;

	struct input_dev *input_dev;

	u64 ir_type = IR_TYPE_OTHER;

	int err = -ENOMEM;



	if (!btv->has_remote)
@@ -448,10 +438,6 @@ int bttv_input_init(struct bttv *btv) 
	snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",

		 pci_name(btv->c.pci));



	err = ir_input_init(input_dev, &ir->ir, ir_type);

	if (err < 0)

		goto err_out_free;



	input_dev->name = ir->name;

	input_dev->phys = ir->phys;

	input_dev->id.bustype = BUS_PCI;

drivers/media/video/bt8xx/bttvp.h

+0 −1
Original line number Diff line number Diff line
@@ -305,7 +305,6 @@ struct bttv_pll_info { 
/* for gpio-connected remote control */

struct bttv_input {

	struct input_dev      *dev;

	struct ir_input_state ir;

	char                  name[32];

	char                  phys[32];

	u32                   mask_keycode;