1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *
   4 * handle saa7134 IR remotes via linux kernel input layer.
   5 */
   6
   7#include "saa7134.h"
   8#include "saa7134-reg.h"
   9
  10#include <linux/module.h>
  11#include <linux/init.h>
  12#include <linux/delay.h>
  13#include <linux/interrupt.h>
  14#include <linux/slab.h>
  15
  16#define MODULE_NAME "saa7134"
  17
  18static unsigned int disable_ir;
  19module_param(disable_ir, int, 0444);
  20MODULE_PARM_DESC(disable_ir,"disable infrared remote support");
  21
  22static unsigned int ir_debug;
  23module_param(ir_debug, int, 0644);
  24MODULE_PARM_DESC(ir_debug,"enable debug messages [IR]");
  25
  26static int pinnacle_remote;
  27module_param(pinnacle_remote, int, 0644);    /* Choose Pinnacle PCTV remote */
  28MODULE_PARM_DESC(pinnacle_remote, "Specify Pinnacle PCTV remote: 0=coloured, 1=grey (defaults to 0)");
  29
  30#define input_dbg(fmt, arg...) do { \
  31	if (ir_debug) \
  32		printk(KERN_DEBUG pr_fmt("input: " fmt), ## arg); \
  33	} while (0)
  34#define ir_dbg(ir, fmt, arg...) do { \
  35	if (ir_debug) \
  36		printk(KERN_DEBUG pr_fmt("ir %s: " fmt), ir->rc->device_name, \
  37		       ## arg); \
  38	} while (0)
  39
  40/* Helper function for raw decoding at GPIO16 or GPIO18 */
  41static int saa7134_raw_decode_irq(struct saa7134_dev *dev);
  42
  43/* -------------------- GPIO generic keycode builder -------------------- */
  44
  45static int build_key(struct saa7134_dev *dev)
  46{
  47	struct saa7134_card_ir *ir = dev->remote;
  48	u32 gpio, data;
  49
  50	/* here comes the additional handshake steps for some cards */
  51	switch (dev->board) {
  52	case SAA7134_BOARD_GOTVIEW_7135:
  53		saa_setb(SAA7134_GPIO_GPSTATUS1, 0x80);
  54		saa_clearb(SAA7134_GPIO_GPSTATUS1, 0x80);
  55		break;
  56	}
  57	/* rising SAA7134_GPIO_GPRESCAN reads the status */
  58	saa_clearb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
  59	saa_setb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
  60
  61	gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
  62	if (ir->polling) {
  63		if (ir->last_gpio == gpio)
  64			return 0;
  65		ir->last_gpio = gpio;
  66	}
  67
  68	data = ir_extract_bits(gpio, ir->mask_keycode);
  69	input_dbg("build_key gpio=0x%x mask=0x%x data=%d\n",
  70		gpio, ir->mask_keycode, data);
  71
  72	switch (dev->board) {
  73	case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
  74		if (data == ir->mask_keycode)
  75			rc_keyup(ir->dev);
  76		else
  77			rc_keydown_notimeout(ir->dev, RC_PROTO_UNKNOWN, data,
  78					     0);
  79		return 0;
  80	}
  81
  82	if (ir->polling) {
  83		if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
  84		    (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
  85			rc_keydown_notimeout(ir->dev, RC_PROTO_UNKNOWN, data,
  86					     0);
  87		} else {
  88			rc_keyup(ir->dev);
  89		}
  90	}
  91	else {	/* IRQ driven mode - handle key press and release in one go */
  92		if ((ir->mask_keydown  &&  (0 != (gpio & ir->mask_keydown))) ||
  93		    (ir->mask_keyup    &&  (0 == (gpio & ir->mask_keyup)))) {
  94			rc_keydown_notimeout(ir->dev, RC_PROTO_UNKNOWN, data,
  95					     0);
  96			rc_keyup(ir->dev);
  97		}
  98	}
  99
 100	return 0;
 101}
 102
 103/* --------------------- Chip specific I2C key builders ----------------- */
 104
 105static int get_key_flydvb_trio(struct IR_i2c *ir, enum rc_proto *protocol,
 106			       u32 *scancode, u8 *toggle)
 107{
 108	int gpio, rc;
 109	int attempt = 0;
 110	unsigned char b;
 111
 112	/* We need this to access GPI Used by the saa_readl macro. */
 113	struct saa7134_dev *dev = ir->c->adapter->algo_data;
 114
 115	if (dev == NULL) {
 116		ir_dbg(ir, "get_key_flydvb_trio: ir->c->adapter->algo_data is NULL!\n");
 117		return -EIO;
 118	}
 119
 120	/* rising SAA7134_GPIGPRESCAN reads the status */
 121	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 122	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 123
 124	gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 125
 126	if (0x40000 & ~gpio)
 127		return 0; /* No button press */
 128
 129	/* poll IR chip */
 130	/* weak up the IR chip */
 131	b = 0;
 132
 133	while (1 != i2c_master_send(ir->c, &b, 1)) {
 134		if ((attempt++) < 10) {
 135			/*
 136			 * wait a bit for next attempt -
 137			 * I don't know how make it better
 138			 */
 139			msleep(10);
 140			continue;
 141		}
 142		ir_dbg(ir, "send wake up byte to pic16C505 (IR chip)failed %dx\n",
 143		       attempt);
 144		return -EIO;
 145	}
 146	rc = i2c_master_recv(ir->c, &b, 1);
 147	if (rc != 1) {
 148		ir_dbg(ir, "read error\n");
 149		if (rc < 0)
 150			return rc;
 151		return -EIO;
 152	}
 153
 154	*protocol = RC_PROTO_UNKNOWN;
 155	*scancode = b;
 156	*toggle = 0;
 157	return 1;
 158}
 159
 160static int get_key_msi_tvanywhere_plus(struct IR_i2c *ir,
 161				       enum rc_proto *protocol,
 162				       u32 *scancode, u8 *toggle)
 163{
 164	unsigned char b;
 165	int gpio, rc;
 166
 167	/* <dev> is needed to access GPIO. Used by the saa_readl macro. */
 168	struct saa7134_dev *dev = ir->c->adapter->algo_data;
 169	if (dev == NULL) {
 170		ir_dbg(ir, "get_key_msi_tvanywhere_plus: ir->c->adapter->algo_data is NULL!\n");
 171		return -EIO;
 172	}
 173
 174	/* rising SAA7134_GPIO_GPRESCAN reads the status */
 175
 176	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 177	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 178
 179	gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 180
 181	/* GPIO&0x40 is pulsed low when a button is pressed. Don't do
 182	   I2C receive if gpio&0x40 is not low. */
 183
 184	if (gpio & 0x40)
 185		return 0;       /* No button press */
 186
 187	/* GPIO says there is a button press. Get it. */
 188
 189	rc = i2c_master_recv(ir->c, &b, 1);
 190	if (rc != 1) {
 191		ir_dbg(ir, "read error\n");
 192		if (rc < 0)
 193			return rc;
 194		return -EIO;
 195	}
 196
 197	/* No button press */
 198
 199	if (b == 0xff)
 200		return 0;
 201
 202	/* Button pressed */
 203
 204	input_dbg("get_key_msi_tvanywhere_plus: Key = 0x%02X\n", b);
 205	*protocol = RC_PROTO_UNKNOWN;
 206	*scancode = b;
 207	*toggle = 0;
 208	return 1;
 209}
 210
 211/* copied and modified from get_key_msi_tvanywhere_plus() */
 212static int get_key_kworld_pc150u(struct IR_i2c *ir, enum rc_proto *protocol,
 213				 u32 *scancode, u8 *toggle)
 214{
 215	unsigned char b;
 216	unsigned int gpio;
 217	int rc;
 218
 219	/* <dev> is needed to access GPIO. Used by the saa_readl macro. */
 220	struct saa7134_dev *dev = ir->c->adapter->algo_data;
 221	if (dev == NULL) {
 222		ir_dbg(ir, "get_key_kworld_pc150u: ir->c->adapter->algo_data is NULL!\n");
 223		return -EIO;
 224	}
 225
 226	/* rising SAA7134_GPIO_GPRESCAN reads the status */
 227
 228	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 229	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 230
 231	gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 232
 233	/* GPIO&0x100 is pulsed low when a button is pressed. Don't do
 234	   I2C receive if gpio&0x100 is not low. */
 235
 236	if (gpio & 0x100)
 237		return 0;       /* No button press */
 238
 239	/* GPIO says there is a button press. Get it. */
 240
 241	rc = i2c_master_recv(ir->c, &b, 1);
 242	if (rc != 1) {
 243		ir_dbg(ir, "read error\n");
 244		if (rc < 0)
 245			return rc;
 246		return -EIO;
 247	}
 248
 249	/* No button press */
 250
 251	if (b == 0xff)
 252		return 0;
 253
 254	/* Button pressed */
 255
 256	input_dbg("get_key_kworld_pc150u: Key = 0x%02X\n", b);
 257	*protocol = RC_PROTO_UNKNOWN;
 258	*scancode = b;
 259	*toggle = 0;
 260	return 1;
 261}
 262
 263static int get_key_purpletv(struct IR_i2c *ir, enum rc_proto *protocol,
 264			    u32 *scancode, u8 *toggle)
 265{
 266	int rc;
 267	unsigned char b;
 268
 269	/* poll IR chip */
 270	rc = i2c_master_recv(ir->c, &b, 1);
 271	if (rc != 1) {
 272		ir_dbg(ir, "read error\n");
 273		if (rc < 0)
 274			return rc;
 275		return -EIO;
 276	}
 277
 278	/* no button press */
 279	if (b==0)
 280		return 0;
 281
 282	/* repeating */
 283	if (b & 0x80)
 284		return 1;
 285
 286	*protocol = RC_PROTO_UNKNOWN;
 287	*scancode = b;
 288	*toggle = 0;
 289	return 1;
 290}
 291
 292static int get_key_beholdm6xx(struct IR_i2c *ir, enum rc_proto *protocol,
 293			      u32 *scancode, u8 *toggle)
 294{
 295	int rc;
 296	unsigned char data[12];
 297	u32 gpio;
 298
 299	struct saa7134_dev *dev = ir->c->adapter->algo_data;
 300
 301	/* rising SAA7134_GPIO_GPRESCAN reads the status */
 302	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 303	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 304
 305	gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
 306
 307	if (0x400000 & ~gpio)
 308		return 0; /* No button press */
 309
 310	ir->c->addr = 0x5a >> 1;
 311
 312	rc = i2c_master_recv(ir->c, data, 12);
 313	if (rc != 12) {
 314		ir_dbg(ir, "read error\n");
 315		if (rc < 0)
 316			return rc;
 317		return -EIO;
 318	}
 319
 320	if (data[9] != (unsigned char)(~data[8]))
 321		return 0;
 322
 323	*protocol = RC_PROTO_NECX;
 324	*scancode = RC_SCANCODE_NECX(data[11] << 8 | data[10], data[9]);
 325	*toggle = 0;
 326	return 1;
 327}
 328
 329/* Common (grey or coloured) pinnacle PCTV remote handling
 330 *
 331 */
 332static int get_key_pinnacle(struct IR_i2c *ir, enum rc_proto *protocol,
 333			    u32 *scancode, u8 *toggle, int parity_offset,
 334			    int marker, int code_modulo)
 335{
 336	int rc;
 337	unsigned char b[4];
 338	unsigned int start = 0,parity = 0,code = 0;
 339
 340	/* poll IR chip */
 341	rc = i2c_master_recv(ir->c, b, 4);
 342	if (rc != 4) {
 343		ir_dbg(ir, "read error\n");
 344		if (rc < 0)
 345			return rc;
 346		return -EIO;
 347	}
 348
 349	for (start = 0; start < ARRAY_SIZE(b); start++) {
 350		if (b[start] == marker) {
 351			code=b[(start+parity_offset + 1) % 4];
 352			parity=b[(start+parity_offset) % 4];
 353		}
 354	}
 355
 356	/* Empty Request */
 357	if (parity == 0)
 358		return 0;
 359
 360	/* Repeating... */
 361	if (ir->old == parity)
 362		return 0;
 363
 364	ir->old = parity;
 365
 366	/* drop special codes when a key is held down a long time for the grey controller
 367	   In this case, the second bit of the code is asserted */
 368	if (marker == 0xfe && (code & 0x40))
 369		return 0;
 370
 371	code %= code_modulo;
 372
 373	*protocol = RC_PROTO_UNKNOWN;
 374	*scancode = code;
 375	*toggle = 0;
 376
 377	ir_dbg(ir, "Pinnacle PCTV key %02x\n", code);
 378	return 1;
 379}
 380
 381/* The grey pinnacle PCTV remote
 382 *
 383 *  There are one issue with this remote:
 384 *   - I2c packet does not change when the same key is pressed quickly. The workaround
 385 *     is to hold down each key for about half a second, so that another code is generated
 386 *     in the i2c packet, and the function can distinguish key presses.
 387 *
 388 * Sylvain Pasche <sylvain.pasche@gmail.com>
 389 */
 390static int get_key_pinnacle_grey(struct IR_i2c *ir, enum rc_proto *protocol,
 391				 u32 *scancode, u8 *toggle)
 392{
 393
 394	return get_key_pinnacle(ir, protocol, scancode, toggle, 1, 0xfe, 0xff);
 395}
 396
 397
 398/* The new pinnacle PCTV remote (with the colored buttons)
 399 *
 400 * Ricardo Cerqueira <v4l@cerqueira.org>
 401 */
 402static int get_key_pinnacle_color(struct IR_i2c *ir, enum rc_proto *protocol,
 403				  u32 *scancode, u8 *toggle)
 404{
 405	/* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
 406	 *
 407	 * this is the only value that results in 42 unique
 408	 * codes < 128
 409	 */
 410
 411	return get_key_pinnacle(ir, protocol, scancode, toggle, 2, 0x80, 0x88);
 412}
 413
 414void saa7134_input_irq(struct saa7134_dev *dev)
 415{
 416	struct saa7134_card_ir *ir;
 417
 418	if (!dev || !dev->remote)
 419		return;
 420
 421	ir = dev->remote;
 422	if (!ir->running)
 423		return;
 424
 425	if (!ir->polling && !ir->raw_decode) {
 426		build_key(dev);
 427	} else if (ir->raw_decode) {
 428		saa7134_raw_decode_irq(dev);
 429	}
 430}
 431
 432static void saa7134_input_timer(struct timer_list *t)
 433{
 434	struct saa7134_card_ir *ir = from_timer(ir, t, timer);
 435	struct saa7134_dev *dev = ir->dev->priv;
 436
 437	build_key(dev);
 438	mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling));
 439}
 440
 441int saa7134_ir_open(struct rc_dev *rc)
 442{
 443	struct saa7134_dev *dev = rc->priv;
 444	struct saa7134_card_ir *ir = dev->remote;
 445
 446	/* Moved here from saa7134_input_init1() because the latter
 447	 * is not called on device resume */
 448	switch (dev->board) {
 449	case SAA7134_BOARD_MD2819:
 450	case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
 451	case SAA7134_BOARD_AVERMEDIA_305:
 452	case SAA7134_BOARD_AVERMEDIA_307:
 453	case SAA7134_BOARD_AVERMEDIA_505:
 454	case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
 455	case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
 456	case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
 457	case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
 458	case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
 459	case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
 460	case SAA7134_BOARD_AVERMEDIA_M102:
 461	case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
 462		/* Without this we won't receive key up events */
 463		saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
 464		saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
 465		break;
 466	case SAA7134_BOARD_AVERMEDIA_777:
 467	case SAA7134_BOARD_AVERMEDIA_A16AR:
 468		/* Without this we won't receive key up events */
 469		saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
 470		saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
 471		break;
 472	case SAA7134_BOARD_AVERMEDIA_A16D:
 473		/* Without this we won't receive key up events */
 474		saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
 475		saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
 476		break;
 477	case SAA7134_BOARD_GOTVIEW_7135:
 478		saa_setb(SAA7134_GPIO_GPMODE1, 0x80);
 479		break;
 480	}
 481
 482	ir->running = true;
 483
 484	if (ir->polling) {
 485		timer_setup(&ir->timer, saa7134_input_timer, 0);
 486		ir->timer.expires = jiffies + HZ;
 487		add_timer(&ir->timer);
 488	}
 489
 490	return 0;
 491}
 492
 493void saa7134_ir_close(struct rc_dev *rc)
 494{
 495	struct saa7134_dev *dev = rc->priv;
 496	struct saa7134_card_ir *ir = dev->remote;
 497
 498	if (ir->polling)
 499		del_timer_sync(&ir->timer);
 500
 501	ir->running = false;
 502}
 503
 504int saa7134_input_init1(struct saa7134_dev *dev)
 505{
 506	struct saa7134_card_ir *ir;
 507	struct rc_dev *rc;
 508	char *ir_codes = NULL;
 509	u32 mask_keycode = 0;
 510	u32 mask_keydown = 0;
 511	u32 mask_keyup   = 0;
 512	unsigned polling = 0;
 513	bool raw_decode  = false;
 514	int err;
 515
 516	if (dev->has_remote != SAA7134_REMOTE_GPIO)
 517		return -ENODEV;
 518	if (disable_ir)
 519		return -ENODEV;
 520
 521	/* detect & configure */
 522	switch (dev->board) {
 523	case SAA7134_BOARD_FLYVIDEO2000:
 524	case SAA7134_BOARD_FLYVIDEO3000:
 525	case SAA7134_BOARD_FLYTVPLATINUM_FM:
 526	case SAA7134_BOARD_FLYTVPLATINUM_MINI2:
 527	case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM:
 528		ir_codes     = RC_MAP_FLYVIDEO;
 529		mask_keycode = 0xEC00000;
 530		mask_keydown = 0x0040000;
 531		break;
 532	case SAA7134_BOARD_CINERGY400:
 533	case SAA7134_BOARD_CINERGY600:
 534	case SAA7134_BOARD_CINERGY600_MK3:
 535		ir_codes     = RC_MAP_CINERGY;
 536		mask_keycode = 0x00003f;
 537		mask_keyup   = 0x040000;
 538		break;
 539	case SAA7134_BOARD_ECS_TVP3XP:
 540	case SAA7134_BOARD_ECS_TVP3XP_4CB5:
 541		ir_codes     = RC_MAP_EZTV;
 542		mask_keycode = 0x00017c;
 543		mask_keyup   = 0x000002;
 544		polling      = 50; // ms
 545		break;
 546	case SAA7134_BOARD_KWORLD_XPERT:
 547	case SAA7134_BOARD_AVACSSMARTTV:
 548		ir_codes     = RC_MAP_PIXELVIEW;
 549		mask_keycode = 0x00001F;
 550		mask_keyup   = 0x000020;
 551		polling      = 50; // ms
 552		break;
 553	case SAA7134_BOARD_MD2819:
 554	case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
 555	case SAA7134_BOARD_AVERMEDIA_305:
 556	case SAA7134_BOARD_AVERMEDIA_307:
 557	case SAA7134_BOARD_AVERMEDIA_505:
 558	case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
 559	case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
 560	case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
 561	case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
 562	case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
 563	case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
 564	case SAA7134_BOARD_AVERMEDIA_M102:
 565	case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
 566		ir_codes     = RC_MAP_AVERMEDIA;
 567		mask_keycode = 0x0007C8;
 568		mask_keydown = 0x000010;
 569		polling      = 50; // ms
 570		/* GPIO stuff moved to saa7134_ir_open() */
 571		break;
 572	case SAA7134_BOARD_AVERMEDIA_M135A:
 573		ir_codes     = RC_MAP_AVERMEDIA_M135A;
 574		mask_keydown = 0x0040000;	/* Enable GPIO18 line on both edges */
 575		mask_keyup   = 0x0040000;
 576		mask_keycode = 0xffff;
 577		raw_decode   = true;
 578		break;
 579	case SAA7134_BOARD_AVERMEDIA_M733A:
 580		ir_codes     = RC_MAP_AVERMEDIA_M733A_RM_K6;
 581		mask_keydown = 0x0040000;
 582		mask_keyup   = 0x0040000;
 583		mask_keycode = 0xffff;
 584		raw_decode   = true;
 585		break;
 586	case SAA7134_BOARD_AVERMEDIA_777:
 587	case SAA7134_BOARD_AVERMEDIA_A16AR:
 588		ir_codes     = RC_MAP_AVERMEDIA;
 589		mask_keycode = 0x02F200;
 590		mask_keydown = 0x000400;
 591		polling      = 50; // ms
 592		/* GPIO stuff moved to saa7134_ir_open() */
 593		break;
 594	case SAA7134_BOARD_AVERMEDIA_A16D:
 595		ir_codes     = RC_MAP_AVERMEDIA_A16D;
 596		mask_keycode = 0x02F200;
 597		mask_keydown = 0x000400;
 598		polling      = 50; /* ms */
 599		/* GPIO stuff moved to saa7134_ir_open() */
 600		break;
 601	case SAA7134_BOARD_KWORLD_TERMINATOR:
 602		ir_codes     = RC_MAP_PIXELVIEW;
 603		mask_keycode = 0x00001f;
 604		mask_keyup   = 0x000060;
 605		polling      = 50; // ms
 606		break;
 607	case SAA7134_BOARD_MANLI_MTV001:
 608	case SAA7134_BOARD_MANLI_MTV002:
 609		ir_codes     = RC_MAP_MANLI;
 610		mask_keycode = 0x001f00;
 611		mask_keyup   = 0x004000;
 612		polling      = 50; /* ms */
 613		break;
 614	case SAA7134_BOARD_BEHOLD_409FM:
 615	case SAA7134_BOARD_BEHOLD_401:
 616	case SAA7134_BOARD_BEHOLD_403:
 617	case SAA7134_BOARD_BEHOLD_403FM:
 618	case SAA7134_BOARD_BEHOLD_405:
 619	case SAA7134_BOARD_BEHOLD_405FM:
 620	case SAA7134_BOARD_BEHOLD_407:
 621	case SAA7134_BOARD_BEHOLD_407FM:
 622	case SAA7134_BOARD_BEHOLD_409:
 623	case SAA7134_BOARD_BEHOLD_505FM:
 624	case SAA7134_BOARD_BEHOLD_505RDS_MK5:
 625	case SAA7134_BOARD_BEHOLD_505RDS_MK3:
 626	case SAA7134_BOARD_BEHOLD_507_9FM:
 627	case SAA7134_BOARD_BEHOLD_507RDS_MK3:
 628	case SAA7134_BOARD_BEHOLD_507RDS_MK5:
 629		ir_codes     = RC_MAP_MANLI;
 630		mask_keycode = 0x003f00;
 631		mask_keyup   = 0x004000;
 632		polling      = 50; /* ms */
 633		break;
 634	case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM:
 635		ir_codes     = RC_MAP_BEHOLD_COLUMBUS;
 636		mask_keycode = 0x003f00;
 637		mask_keyup   = 0x004000;
 638		polling      = 50; // ms
 639		break;
 640	case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS:
 641		ir_codes     = RC_MAP_PCTV_SEDNA;
 642		mask_keycode = 0x001f00;
 643		mask_keyup   = 0x004000;
 644		polling      = 50; // ms
 645		break;
 646	case SAA7134_BOARD_GOTVIEW_7135:
 647		ir_codes     = RC_MAP_GOTVIEW7135;
 648		mask_keycode = 0x0003CC;
 649		mask_keydown = 0x000010;
 650		polling	     = 5; /* ms */
 651		/* GPIO stuff moved to saa7134_ir_open() */
 652		break;
 653	case SAA7134_BOARD_VIDEOMATE_TV_PVR:
 654	case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS:
 655	case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII:
 656		ir_codes     = RC_MAP_VIDEOMATE_TV_PVR;
 657		mask_keycode = 0x00003F;
 658		mask_keyup   = 0x400000;
 659		polling      = 50; // ms
 660		break;
 661	case SAA7134_BOARD_PROTEUS_2309:
 662		ir_codes     = RC_MAP_PROTEUS_2309;
 663		mask_keycode = 0x00007F;
 664		mask_keyup   = 0x000080;
 665		polling      = 50; // ms
 666		break;
 667	case SAA7134_BOARD_VIDEOMATE_DVBT_300:
 668	case SAA7134_BOARD_VIDEOMATE_DVBT_200:
 669		ir_codes     = RC_MAP_VIDEOMATE_TV_PVR;
 670		mask_keycode = 0x003F00;
 671		mask_keyup   = 0x040000;
 672		break;
 673	case SAA7134_BOARD_FLYDVBS_LR300:
 674	case SAA7134_BOARD_FLYDVBT_LR301:
 675	case SAA7134_BOARD_FLYDVBTDUO:
 676		ir_codes     = RC_MAP_FLYDVB;
 677		mask_keycode = 0x0001F00;
 678		mask_keydown = 0x0040000;
 679		break;
 680	case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
 681	case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA:
 682	case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
 683		ir_codes     = RC_MAP_ASUS_PC39;
 684		mask_keydown = 0x0040000;	/* Enable GPIO18 line on both edges */
 685		mask_keyup   = 0x0040000;
 686		mask_keycode = 0xffff;
 687		raw_decode   = true;
 688		break;
 689	case SAA7134_BOARD_ASUSTeK_PS3_100:
 690		ir_codes     = RC_MAP_ASUS_PS3_100;
 691		mask_keydown = 0x0040000;
 692		mask_keyup   = 0x0040000;
 693		mask_keycode = 0xffff;
 694		raw_decode   = true;
 695		break;
 696	case SAA7134_BOARD_ENCORE_ENLTV:
 697	case SAA7134_BOARD_ENCORE_ENLTV_FM:
 698		ir_codes     = RC_MAP_ENCORE_ENLTV;
 699		mask_keycode = 0x00007f;
 700		mask_keyup   = 0x040000;
 701		polling      = 50; // ms
 702		break;
 703	case SAA7134_BOARD_ENCORE_ENLTV_FM53:
 704	case SAA7134_BOARD_ENCORE_ENLTV_FM3:
 705		ir_codes     = RC_MAP_ENCORE_ENLTV_FM53;
 706		mask_keydown = 0x0040000;	/* Enable GPIO18 line on both edges */
 707		mask_keyup   = 0x0040000;
 708		mask_keycode = 0xffff;
 709		raw_decode   = true;
 710		break;
 711	case SAA7134_BOARD_10MOONSTVMASTER3:
 712		ir_codes     = RC_MAP_ENCORE_ENLTV;
 713		mask_keycode = 0x5f80000;
 714		mask_keyup   = 0x8000000;
 715		polling      = 50; //ms
 716		break;
 717	case SAA7134_BOARD_GENIUS_TVGO_A11MCE:
 718		ir_codes     = RC_MAP_GENIUS_TVGO_A11MCE;
 719		mask_keycode = 0xff;
 720		mask_keydown = 0xf00000;
 721		polling = 50; /* ms */
 722		break;
 723	case SAA7134_BOARD_REAL_ANGEL_220:
 724		ir_codes     = RC_MAP_REAL_AUDIO_220_32_KEYS;
 725		mask_keycode = 0x3f00;
 726		mask_keyup   = 0x4000;
 727		polling = 50; /* ms */
 728		break;
 729	case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
 730		ir_codes     = RC_MAP_KWORLD_PLUS_TV_ANALOG;
 731		mask_keycode = 0x7f;
 732		polling = 40; /* ms */
 733		break;
 734	case SAA7134_BOARD_VIDEOMATE_S350:
 735		ir_codes     = RC_MAP_VIDEOMATE_S350;
 736		mask_keycode = 0x003f00;
 737		mask_keydown = 0x040000;
 738		break;
 739	case SAA7134_BOARD_LEADTEK_WINFAST_DTV1000S:
 740		ir_codes     = RC_MAP_WINFAST;
 741		mask_keycode = 0x5f00;
 742		mask_keyup   = 0x020000;
 743		polling      = 50; /* ms */
 744		break;
 745	case SAA7134_BOARD_VIDEOMATE_M1F:
 746		ir_codes     = RC_MAP_VIDEOMATE_K100;
 747		mask_keycode = 0x0ff00;
 748		mask_keyup   = 0x040000;
 749		break;
 750	case SAA7134_BOARD_HAUPPAUGE_HVR1150:
 751	case SAA7134_BOARD_HAUPPAUGE_HVR1120:
 752		ir_codes     = RC_MAP_HAUPPAUGE;
 753		mask_keydown = 0x0040000;	/* Enable GPIO18 line on both edges */
 754		mask_keyup   = 0x0040000;
 755		mask_keycode = 0xffff;
 756		raw_decode   = true;
 757		break;
 758	case SAA7134_BOARD_LEADTEK_WINFAST_TV2100_FM:
 759		ir_codes     = RC_MAP_LEADTEK_Y04G0051;
 760		mask_keydown = 0x0040000;	/* Enable GPIO18 line on both edges */
 761		mask_keyup   = 0x0040000;
 762		mask_keycode = 0xffff;
 763		raw_decode   = true;
 764		break;
 765	}
 766	if (NULL == ir_codes) {
 767		pr_err("Oops: IR config error [card=%d]\n", dev->board);
 768		return -ENODEV;
 769	}
 770
 771	ir = kzalloc(sizeof(*ir), GFP_KERNEL);
 772	rc = rc_allocate_device(RC_DRIVER_SCANCODE);
 773	if (!ir || !rc) {
 774		err = -ENOMEM;
 775		goto err_out_free;
 776	}
 777
 778	ir->dev = rc;
 779	dev->remote = ir;
 780
 781	/* init hardware-specific stuff */
 782	ir->mask_keycode = mask_keycode;
 783	ir->mask_keydown = mask_keydown;
 784	ir->mask_keyup   = mask_keyup;
 785	ir->polling      = polling;
 786	ir->raw_decode	 = raw_decode;
 787
 788	/* init input device */
 789	snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
 790		 pci_name(dev->pci));
 791
 792	rc->priv = dev;
 793	rc->open = saa7134_ir_open;
 794	rc->close = saa7134_ir_close;
 795	if (raw_decode) {
 796		rc->driver_type = RC_DRIVER_IR_RAW;
 797		rc->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
 798	}
 799
 800	rc->device_name = saa7134_boards[dev->board].name;
 801	rc->input_phys = ir->phys;
 802	rc->input_id.bustype = BUS_PCI;
 803	rc->input_id.version = 1;
 804	if (dev->pci->subsystem_vendor) {
 805		rc->input_id.vendor  = dev->pci->subsystem_vendor;
 806		rc->input_id.product = dev->pci->subsystem_device;
 807	} else {
 808		rc->input_id.vendor  = dev->pci->vendor;
 809		rc->input_id.product = dev->pci->device;
 810	}
 811	rc->dev.parent = &dev->pci->dev;
 812	rc->map_name = ir_codes;
 813	rc->driver_name = MODULE_NAME;
 814	rc->min_timeout = 1;
 815	rc->timeout = IR_DEFAULT_TIMEOUT;
 816	rc->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
 817
 818	err = rc_register_device(rc);
 819	if (err)
 820		goto err_out_free;
 821
 822	return 0;
 823
 824err_out_free:
 825	rc_free_device(rc);
 826	dev->remote = NULL;
 827	kfree(ir);
 828	return err;
 829}
 830
 831void saa7134_input_fini(struct saa7134_dev *dev)
 832{
 833	if (NULL == dev->remote)
 834		return;
 835
 836	rc_unregister_device(dev->remote->dev);
 837	kfree(dev->remote);
 838	dev->remote = NULL;
 839}
 840
 841void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
 842{
 843	struct i2c_board_info info;
 844	struct i2c_msg msg_msi = {
 845		.addr = 0x50,
 846		.flags = I2C_M_RD,
 847		.len = 0,
 848		.buf = NULL,
 849	};
 850	int rc;
 851
 852	if (disable_ir) {
 853		input_dbg("IR has been disabled, not probing for i2c remote\n");
 854		return;
 855	}
 856
 857	memset(&info, 0, sizeof(struct i2c_board_info));
 858	memset(&dev->init_data, 0, sizeof(dev->init_data));
 859	strscpy(info.type, "ir_video", I2C_NAME_SIZE);
 860
 861	switch (dev->board) {
 862	case SAA7134_BOARD_PINNACLE_PCTV_110i:
 863	case SAA7134_BOARD_PINNACLE_PCTV_310i:
 864		dev->init_data.name = "Pinnacle PCTV";
 865		if (pinnacle_remote == 0) {
 866			dev->init_data.get_key = get_key_pinnacle_color;
 867			dev->init_data.ir_codes = RC_MAP_PINNACLE_COLOR;
 868			info.addr = 0x47;
 869		} else {
 870			dev->init_data.get_key = get_key_pinnacle_grey;
 871			dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
 872			info.addr = 0x47;
 873		}
 874		break;
 875	case SAA7134_BOARD_UPMOST_PURPLE_TV:
 876		dev->init_data.name = "Purple TV";
 877		dev->init_data.get_key = get_key_purpletv;
 878		dev->init_data.ir_codes = RC_MAP_PURPLETV;
 879		info.addr = 0x7a;
 880		break;
 881	case SAA7134_BOARD_MSI_TVATANYWHERE_PLUS:
 882		dev->init_data.name = "MSI TV@nywhere Plus";
 883		dev->init_data.get_key = get_key_msi_tvanywhere_plus;
 884		dev->init_data.ir_codes = RC_MAP_MSI_TVANYWHERE_PLUS;
 885		/*
 886		 * MSI TV@nyware Plus requires more frequent polling
 887		 * otherwise it will miss some keypresses
 888		 */
 889		dev->init_data.polling_interval = 50;
 890		info.addr = 0x30;
 891		/* MSI TV@nywhere Plus controller doesn't seem to
 892		   respond to probes unless we read something from
 893		   an existing device. Weird...
 894		   REVISIT: might no longer be needed */
 895		rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
 896		input_dbg("probe 0x%02x @ %s: %s\n",
 897			msg_msi.addr, dev->i2c_adap.name,
 898			(1 == rc) ? "yes" : "no");
 899		break;
 900	case SAA7134_BOARD_SNAZIO_TVPVR_PRO:
 901		dev->init_data.name = "SnaZio* TVPVR PRO";
 902		dev->init_data.get_key = get_key_msi_tvanywhere_plus;
 903		dev->init_data.ir_codes = RC_MAP_MSI_TVANYWHERE_PLUS;
 904		/*
 905		 * MSI TV@nyware Plus requires more frequent polling
 906		 * otherwise it will miss some keypresses
 907		 */
 908		dev->init_data.polling_interval = 50;
 909		info.addr = 0x30;
 910		/*
 911		 * MSI TV@nywhere Plus controller doesn't seem to
 912		 *  respond to probes unless we read something from
 913		 *  an existing device. Weird...
 914		 * REVISIT: might no longer be needed
 915		 */
 916		rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
 917		input_dbg("probe 0x%02x @ %s: %s\n",
 918			msg_msi.addr, dev->i2c_adap.name,
 919			(rc == 1) ? "yes" : "no");
 920		break;
 921	case SAA7134_BOARD_KWORLD_PC150U:
 922		/* copied and modified from MSI TV@nywhere Plus */
 923		dev->init_data.name = "Kworld PC150-U";
 924		dev->init_data.get_key = get_key_kworld_pc150u;
 925		dev->init_data.ir_codes = RC_MAP_KWORLD_PC150U;
 926		info.addr = 0x30;
 927		/* MSI TV@nywhere Plus controller doesn't seem to
 928		   respond to probes unless we read something from
 929		   an existing device. Weird...
 930		   REVISIT: might no longer be needed */
 931		rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
 932		input_dbg("probe 0x%02x @ %s: %s\n",
 933			msg_msi.addr, dev->i2c_adap.name,
 934			(1 == rc) ? "yes" : "no");
 935		break;
 936	case SAA7134_BOARD_HAUPPAUGE_HVR1110:
 937		dev->init_data.name = saa7134_boards[dev->board].name;
 938		dev->init_data.ir_codes = RC_MAP_HAUPPAUGE;
 939		dev->init_data.type = RC_PROTO_BIT_RC5 |
 940				RC_PROTO_BIT_RC6_MCE | RC_PROTO_BIT_RC6_6A_32;
 941		dev->init_data.internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
 942		info.addr = 0x71;
 943		break;
 944	case SAA7134_BOARD_BEHOLD_607FM_MK3:
 945	case SAA7134_BOARD_BEHOLD_607FM_MK5:
 946	case SAA7134_BOARD_BEHOLD_609FM_MK3:
 947	case SAA7134_BOARD_BEHOLD_609FM_MK5:
 948	case SAA7134_BOARD_BEHOLD_607RDS_MK3:
 949	case SAA7134_BOARD_BEHOLD_607RDS_MK5:
 950	case SAA7134_BOARD_BEHOLD_609RDS_MK3:
 951	case SAA7134_BOARD_BEHOLD_609RDS_MK5:
 952	case SAA7134_BOARD_BEHOLD_M6:
 953	case SAA7134_BOARD_BEHOLD_M63:
 954	case SAA7134_BOARD_BEHOLD_M6_EXTRA:
 955	case SAA7134_BOARD_BEHOLD_H6:
 956	case SAA7134_BOARD_BEHOLD_X7:
 957	case SAA7134_BOARD_BEHOLD_H7:
 958	case SAA7134_BOARD_BEHOLD_A7:
 959		dev->init_data.name = "BeholdTV";
 960		dev->init_data.get_key = get_key_beholdm6xx;
 961		dev->init_data.ir_codes = RC_MAP_BEHOLD;
 962		dev->init_data.type = RC_PROTO_BIT_NECX;
 963		info.addr = 0x2d;
 964		break;
 965	case SAA7134_BOARD_AVERMEDIA_CARDBUS_501:
 966	case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
 967		info.addr = 0x40;
 968		break;
 969	case SAA7134_BOARD_AVERMEDIA_A706:
 970		info.addr = 0x41;
 971		break;
 972	case SAA7134_BOARD_FLYDVB_TRIO:
 973		dev->init_data.name = "FlyDVB Trio";
 974		dev->init_data.get_key = get_key_flydvb_trio;
 975		dev->init_data.ir_codes = RC_MAP_FLYDVB;
 976		info.addr = 0x0b;
 977		break;
 978	default:
 979		input_dbg("No I2C IR support for board %x\n", dev->board);
 980		return;
 981	}
 982
 983	if (dev->init_data.name)
 984		info.platform_data = &dev->init_data;
 985	i2c_new_client_device(&dev->i2c_adap, &info);
 986}
 987
 988static int saa7134_raw_decode_irq(struct saa7134_dev *dev)
 989{
 990	struct saa7134_card_ir *ir = dev->remote;
 991	int space;
 992
 993	/* Generate initial event */
 994	saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 995	saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
 996	space = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & ir->mask_keydown;
 997	ir_raw_event_store_edge(dev->remote->dev, !space);
 998
 999	return 1;
1000}