saa7134-input.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931
  1. /*
  2. *
  3. * handle saa7134 IR remotes via linux kernel input layer.
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18. *
  19. */
  20. #include <linux/module.h>
  21. #include <linux/init.h>
  22. #include <linux/delay.h>
  23. #include <linux/interrupt.h>
  24. #include <linux/slab.h>
  25. #include "saa7134-reg.h"
  26. #include "saa7134.h"
  27. #define MODULE_NAME "saa7134"
  28. static unsigned int disable_ir;
  29. module_param(disable_ir, int, 0444);
  30. MODULE_PARM_DESC(disable_ir,"disable infrared remote support");
  31. static unsigned int ir_debug;
  32. module_param(ir_debug, int, 0644);
  33. MODULE_PARM_DESC(ir_debug,"enable debug messages [IR]");
  34. static int pinnacle_remote;
  35. module_param(pinnacle_remote, int, 0644); /* Choose Pinnacle PCTV remote */
  36. MODULE_PARM_DESC(pinnacle_remote, "Specify Pinnacle PCTV remote: 0=coloured, 1=grey (defaults to 0)");
  37. #define dprintk(fmt, arg...) if (ir_debug) \
  38. printk(KERN_DEBUG "%s/ir: " fmt, dev->name , ## arg)
  39. #define i2cdprintk(fmt, arg...) if (ir_debug) \
  40. printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg)
  41. /* Helper function for raw decoding at GPIO16 or GPIO18 */
  42. static int saa7134_raw_decode_irq(struct saa7134_dev *dev);
  43. /* -------------------- GPIO generic keycode builder -------------------- */
  44. static int build_key(struct saa7134_dev *dev)
  45. {
  46. struct saa7134_card_ir *ir = dev->remote;
  47. u32 gpio, data;
  48. /* here comes the additional handshake steps for some cards */
  49. switch (dev->board) {
  50. case SAA7134_BOARD_GOTVIEW_7135:
  51. saa_setb(SAA7134_GPIO_GPSTATUS1, 0x80);
  52. saa_clearb(SAA7134_GPIO_GPSTATUS1, 0x80);
  53. break;
  54. }
  55. /* rising SAA7134_GPIO_GPRESCAN reads the status */
  56. saa_clearb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
  57. saa_setb(SAA7134_GPIO_GPMODE3,SAA7134_GPIO_GPRESCAN);
  58. gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
  59. if (ir->polling) {
  60. if (ir->last_gpio == gpio)
  61. return 0;
  62. ir->last_gpio = gpio;
  63. }
  64. data = ir_extract_bits(gpio, ir->mask_keycode);
  65. dprintk("build_key gpio=0x%x mask=0x%x data=%d\n",
  66. gpio, ir->mask_keycode, data);
  67. switch (dev->board) {
  68. case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
  69. if (data == ir->mask_keycode)
  70. rc_keyup(ir->dev);
  71. else
  72. rc_keydown_notimeout(ir->dev, data, 0);
  73. return 0;
  74. }
  75. if (ir->polling) {
  76. if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) ||
  77. (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) {
  78. rc_keydown_notimeout(ir->dev, data, 0);
  79. } else {
  80. rc_keyup(ir->dev);
  81. }
  82. }
  83. else { /* IRQ driven mode - handle key press and release in one go */
  84. if ((ir->mask_keydown && (0 != (gpio & ir->mask_keydown))) ||
  85. (ir->mask_keyup && (0 == (gpio & ir->mask_keyup)))) {
  86. rc_keydown_notimeout(ir->dev, data, 0);
  87. rc_keyup(ir->dev);
  88. }
  89. }
  90. return 0;
  91. }
  92. /* --------------------- Chip specific I2C key builders ----------------- */
  93. static int get_key_flydvb_trio(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  94. {
  95. int gpio;
  96. int attempt = 0;
  97. unsigned char b;
  98. /* We need this to access GPI Used by the saa_readl macro. */
  99. struct saa7134_dev *dev = ir->c->adapter->algo_data;
  100. if (dev == NULL) {
  101. i2cdprintk("get_key_flydvb_trio: "
  102. "ir->c->adapter->algo_data is NULL!\n");
  103. return -EIO;
  104. }
  105. /* rising SAA7134_GPIGPRESCAN reads the status */
  106. saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  107. saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  108. gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
  109. if (0x40000 & ~gpio)
  110. return 0; /* No button press */
  111. /* No button press - only before first key pressed */
  112. if (b == 0xFF)
  113. return 0;
  114. /* poll IR chip */
  115. /* weak up the IR chip */
  116. b = 0;
  117. while (1 != i2c_master_send(ir->c, &b, 1)) {
  118. if ((attempt++) < 10) {
  119. /*
  120. * wait a bit for next attempt -
  121. * I don't know how make it better
  122. */
  123. msleep(10);
  124. continue;
  125. }
  126. i2cdprintk("send wake up byte to pic16C505 (IR chip)"
  127. "failed %dx\n", attempt);
  128. return -EIO;
  129. }
  130. if (1 != i2c_master_recv(ir->c, &b, 1)) {
  131. i2cdprintk("read error\n");
  132. return -EIO;
  133. }
  134. *ir_key = b;
  135. *ir_raw = b;
  136. return 1;
  137. }
  138. static int get_key_msi_tvanywhere_plus(struct IR_i2c *ir, u32 *ir_key,
  139. u32 *ir_raw)
  140. {
  141. unsigned char b;
  142. int gpio;
  143. /* <dev> is needed to access GPIO. Used by the saa_readl macro. */
  144. struct saa7134_dev *dev = ir->c->adapter->algo_data;
  145. if (dev == NULL) {
  146. i2cdprintk("get_key_msi_tvanywhere_plus: "
  147. "ir->c->adapter->algo_data is NULL!\n");
  148. return -EIO;
  149. }
  150. /* rising SAA7134_GPIO_GPRESCAN reads the status */
  151. saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  152. saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  153. gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
  154. /* GPIO&0x40 is pulsed low when a button is pressed. Don't do
  155. I2C receive if gpio&0x40 is not low. */
  156. if (gpio & 0x40)
  157. return 0; /* No button press */
  158. /* GPIO says there is a button press. Get it. */
  159. if (1 != i2c_master_recv(ir->c, &b, 1)) {
  160. i2cdprintk("read error\n");
  161. return -EIO;
  162. }
  163. /* No button press */
  164. if (b == 0xff)
  165. return 0;
  166. /* Button pressed */
  167. dprintk("get_key_msi_tvanywhere_plus: Key = 0x%02X\n", b);
  168. *ir_key = b;
  169. *ir_raw = b;
  170. return 1;
  171. }
  172. static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  173. {
  174. unsigned char b;
  175. /* poll IR chip */
  176. if (1 != i2c_master_recv(ir->c, &b, 1)) {
  177. i2cdprintk("read error\n");
  178. return -EIO;
  179. }
  180. /* no button press */
  181. if (b==0)
  182. return 0;
  183. /* repeating */
  184. if (b & 0x80)
  185. return 1;
  186. *ir_key = b;
  187. *ir_raw = b;
  188. return 1;
  189. }
  190. static int get_key_hvr1110(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  191. {
  192. unsigned char buf[5], cod4, code3, code4;
  193. /* poll IR chip */
  194. if (5 != i2c_master_recv(ir->c, buf, 5))
  195. return -EIO;
  196. cod4 = buf[4];
  197. code4 = (cod4 >> 2);
  198. code3 = buf[3];
  199. if (code3 == 0)
  200. /* no key pressed */
  201. return 0;
  202. /* return key */
  203. *ir_key = code4;
  204. *ir_raw = code4;
  205. return 1;
  206. }
  207. static int get_key_beholdm6xx(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  208. {
  209. unsigned char data[12];
  210. u32 gpio;
  211. struct saa7134_dev *dev = ir->c->adapter->algo_data;
  212. /* rising SAA7134_GPIO_GPRESCAN reads the status */
  213. saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  214. saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  215. gpio = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2);
  216. if (0x400000 & ~gpio)
  217. return 0; /* No button press */
  218. ir->c->addr = 0x5a >> 1;
  219. if (12 != i2c_master_recv(ir->c, data, 12)) {
  220. i2cdprintk("read error\n");
  221. return -EIO;
  222. }
  223. if (data[9] != (unsigned char)(~data[8]))
  224. return 0;
  225. *ir_raw = ((data[10] << 16) | (data[11] << 8) | (data[9] << 0));
  226. *ir_key = *ir_raw;
  227. return 1;
  228. }
  229. /* Common (grey or coloured) pinnacle PCTV remote handling
  230. *
  231. */
  232. static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
  233. int parity_offset, int marker, int code_modulo)
  234. {
  235. unsigned char b[4];
  236. unsigned int start = 0,parity = 0,code = 0;
  237. /* poll IR chip */
  238. if (4 != i2c_master_recv(ir->c, b, 4)) {
  239. i2cdprintk("read error\n");
  240. return -EIO;
  241. }
  242. for (start = 0; start < ARRAY_SIZE(b); start++) {
  243. if (b[start] == marker) {
  244. code=b[(start+parity_offset + 1) % 4];
  245. parity=b[(start+parity_offset) % 4];
  246. }
  247. }
  248. /* Empty Request */
  249. if (parity == 0)
  250. return 0;
  251. /* Repeating... */
  252. if (ir->old == parity)
  253. return 0;
  254. ir->old = parity;
  255. /* drop special codes when a key is held down a long time for the grey controller
  256. In this case, the second bit of the code is asserted */
  257. if (marker == 0xfe && (code & 0x40))
  258. return 0;
  259. code %= code_modulo;
  260. *ir_raw = code;
  261. *ir_key = code;
  262. i2cdprintk("Pinnacle PCTV key %02x\n", code);
  263. return 1;
  264. }
  265. /* The grey pinnacle PCTV remote
  266. *
  267. * There are one issue with this remote:
  268. * - I2c packet does not change when the same key is pressed quickly. The workaround
  269. * is to hold down each key for about half a second, so that another code is generated
  270. * in the i2c packet, and the function can distinguish key presses.
  271. *
  272. * Sylvain Pasche <sylvain.pasche@gmail.com>
  273. */
  274. static int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  275. {
  276. return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
  277. }
  278. /* The new pinnacle PCTV remote (with the colored buttons)
  279. *
  280. * Ricardo Cerqueira <v4l@cerqueira.org>
  281. */
  282. static int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
  283. {
  284. /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
  285. *
  286. * this is the only value that results in 42 unique
  287. * codes < 128
  288. */
  289. return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
  290. }
  291. void saa7134_input_irq(struct saa7134_dev *dev)
  292. {
  293. struct saa7134_card_ir *ir;
  294. if (!dev || !dev->remote)
  295. return;
  296. ir = dev->remote;
  297. if (!ir->running)
  298. return;
  299. if (!ir->polling && !ir->raw_decode) {
  300. build_key(dev);
  301. } else if (ir->raw_decode) {
  302. saa7134_raw_decode_irq(dev);
  303. }
  304. }
  305. static void saa7134_input_timer(unsigned long data)
  306. {
  307. struct saa7134_dev *dev = (struct saa7134_dev *)data;
  308. struct saa7134_card_ir *ir = dev->remote;
  309. build_key(dev);
  310. mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling));
  311. }
  312. static void ir_raw_decode_timer_end(unsigned long data)
  313. {
  314. struct saa7134_dev *dev = (struct saa7134_dev *)data;
  315. struct saa7134_card_ir *ir = dev->remote;
  316. ir_raw_event_handle(dev->remote->dev);
  317. ir->active = false;
  318. }
  319. static int __saa7134_ir_start(void *priv)
  320. {
  321. struct saa7134_dev *dev = priv;
  322. struct saa7134_card_ir *ir;
  323. if (!dev || !dev->remote)
  324. return -EINVAL;
  325. ir = dev->remote;
  326. if (ir->running)
  327. return 0;
  328. ir->running = true;
  329. ir->active = false;
  330. if (ir->polling) {
  331. setup_timer(&ir->timer, saa7134_input_timer,
  332. (unsigned long)dev);
  333. ir->timer.expires = jiffies + HZ;
  334. add_timer(&ir->timer);
  335. } else if (ir->raw_decode) {
  336. /* set timer_end for code completion */
  337. setup_timer(&ir->timer_end, ir_raw_decode_timer_end,
  338. (unsigned long)dev);
  339. }
  340. return 0;
  341. }
  342. static void __saa7134_ir_stop(void *priv)
  343. {
  344. struct saa7134_dev *dev = priv;
  345. struct saa7134_card_ir *ir;
  346. if (!dev || !dev->remote)
  347. return;
  348. ir = dev->remote;
  349. if (!ir->running)
  350. return;
  351. if (ir->polling)
  352. del_timer_sync(&ir->timer);
  353. else if (ir->raw_decode)
  354. del_timer_sync(&ir->timer_end);
  355. ir->active = false;
  356. ir->running = false;
  357. return;
  358. }
  359. int saa7134_ir_start(struct saa7134_dev *dev)
  360. {
  361. if (dev->remote->users)
  362. return __saa7134_ir_start(dev);
  363. return 0;
  364. }
  365. void saa7134_ir_stop(struct saa7134_dev *dev)
  366. {
  367. if (dev->remote->users)
  368. __saa7134_ir_stop(dev);
  369. }
  370. static int saa7134_ir_open(struct rc_dev *rc)
  371. {
  372. struct saa7134_dev *dev = rc->priv;
  373. dev->remote->users++;
  374. return __saa7134_ir_start(dev);
  375. }
  376. static void saa7134_ir_close(struct rc_dev *rc)
  377. {
  378. struct saa7134_dev *dev = rc->priv;
  379. dev->remote->users--;
  380. if (!dev->remote->users)
  381. __saa7134_ir_stop(dev);
  382. }
  383. int saa7134_input_init1(struct saa7134_dev *dev)
  384. {
  385. struct saa7134_card_ir *ir;
  386. struct rc_dev *rc;
  387. char *ir_codes = NULL;
  388. u32 mask_keycode = 0;
  389. u32 mask_keydown = 0;
  390. u32 mask_keyup = 0;
  391. unsigned polling = 0;
  392. bool raw_decode = false;
  393. int err;
  394. if (dev->has_remote != SAA7134_REMOTE_GPIO)
  395. return -ENODEV;
  396. if (disable_ir)
  397. return -ENODEV;
  398. /* detect & configure */
  399. switch (dev->board) {
  400. case SAA7134_BOARD_FLYVIDEO2000:
  401. case SAA7134_BOARD_FLYVIDEO3000:
  402. case SAA7134_BOARD_FLYTVPLATINUM_FM:
  403. case SAA7134_BOARD_FLYTVPLATINUM_MINI2:
  404. case SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM:
  405. ir_codes = RC_MAP_FLYVIDEO;
  406. mask_keycode = 0xEC00000;
  407. mask_keydown = 0x0040000;
  408. break;
  409. case SAA7134_BOARD_CINERGY400:
  410. case SAA7134_BOARD_CINERGY600:
  411. case SAA7134_BOARD_CINERGY600_MK3:
  412. ir_codes = RC_MAP_CINERGY;
  413. mask_keycode = 0x00003f;
  414. mask_keyup = 0x040000;
  415. break;
  416. case SAA7134_BOARD_ECS_TVP3XP:
  417. case SAA7134_BOARD_ECS_TVP3XP_4CB5:
  418. ir_codes = RC_MAP_EZTV;
  419. mask_keycode = 0x00017c;
  420. mask_keyup = 0x000002;
  421. polling = 50; // ms
  422. break;
  423. case SAA7134_BOARD_KWORLD_XPERT:
  424. case SAA7134_BOARD_AVACSSMARTTV:
  425. ir_codes = RC_MAP_PIXELVIEW;
  426. mask_keycode = 0x00001F;
  427. mask_keyup = 0x000020;
  428. polling = 50; // ms
  429. break;
  430. case SAA7134_BOARD_MD2819:
  431. case SAA7134_BOARD_KWORLD_VSTREAM_XPERT:
  432. case SAA7134_BOARD_AVERMEDIA_305:
  433. case SAA7134_BOARD_AVERMEDIA_307:
  434. case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
  435. case SAA7134_BOARD_AVERMEDIA_STUDIO_505:
  436. case SAA7134_BOARD_AVERMEDIA_STUDIO_307:
  437. case SAA7134_BOARD_AVERMEDIA_STUDIO_507:
  438. case SAA7134_BOARD_AVERMEDIA_STUDIO_507UA:
  439. case SAA7134_BOARD_AVERMEDIA_GO_007_FM:
  440. case SAA7134_BOARD_AVERMEDIA_M102:
  441. case SAA7134_BOARD_AVERMEDIA_GO_007_FM_PLUS:
  442. ir_codes = RC_MAP_AVERMEDIA;
  443. mask_keycode = 0x0007C8;
  444. mask_keydown = 0x000010;
  445. polling = 50; // ms
  446. /* Set GPIO pin2 to high to enable the IR controller */
  447. saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
  448. saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
  449. break;
  450. case SAA7134_BOARD_AVERMEDIA_M135A:
  451. ir_codes = RC_MAP_AVERMEDIA_M135A;
  452. mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
  453. mask_keyup = 0x0040000;
  454. mask_keycode = 0xffff;
  455. raw_decode = true;
  456. break;
  457. case SAA7134_BOARD_AVERMEDIA_M733A:
  458. ir_codes = RC_MAP_AVERMEDIA_M733A_RM_K6;
  459. mask_keydown = 0x0040000;
  460. mask_keyup = 0x0040000;
  461. mask_keycode = 0xffff;
  462. raw_decode = true;
  463. break;
  464. case SAA7134_BOARD_AVERMEDIA_777:
  465. case SAA7134_BOARD_AVERMEDIA_A16AR:
  466. ir_codes = RC_MAP_AVERMEDIA;
  467. mask_keycode = 0x02F200;
  468. mask_keydown = 0x000400;
  469. polling = 50; // ms
  470. /* Without this we won't receive key up events */
  471. saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
  472. saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
  473. break;
  474. case SAA7134_BOARD_AVERMEDIA_A16D:
  475. ir_codes = RC_MAP_AVERMEDIA_A16D;
  476. mask_keycode = 0x02F200;
  477. mask_keydown = 0x000400;
  478. polling = 50; /* ms */
  479. /* Without this we won't receive key up events */
  480. saa_setb(SAA7134_GPIO_GPMODE1, 0x1);
  481. saa_setb(SAA7134_GPIO_GPSTATUS1, 0x1);
  482. break;
  483. case SAA7134_BOARD_KWORLD_TERMINATOR:
  484. ir_codes = RC_MAP_PIXELVIEW;
  485. mask_keycode = 0x00001f;
  486. mask_keyup = 0x000060;
  487. polling = 50; // ms
  488. break;
  489. case SAA7134_BOARD_MANLI_MTV001:
  490. case SAA7134_BOARD_MANLI_MTV002:
  491. ir_codes = RC_MAP_MANLI;
  492. mask_keycode = 0x001f00;
  493. mask_keyup = 0x004000;
  494. polling = 50; /* ms */
  495. break;
  496. case SAA7134_BOARD_BEHOLD_409FM:
  497. case SAA7134_BOARD_BEHOLD_401:
  498. case SAA7134_BOARD_BEHOLD_403:
  499. case SAA7134_BOARD_BEHOLD_403FM:
  500. case SAA7134_BOARD_BEHOLD_405:
  501. case SAA7134_BOARD_BEHOLD_405FM:
  502. case SAA7134_BOARD_BEHOLD_407:
  503. case SAA7134_BOARD_BEHOLD_407FM:
  504. case SAA7134_BOARD_BEHOLD_409:
  505. case SAA7134_BOARD_BEHOLD_505FM:
  506. case SAA7134_BOARD_BEHOLD_505RDS_MK5:
  507. case SAA7134_BOARD_BEHOLD_505RDS_MK3:
  508. case SAA7134_BOARD_BEHOLD_507_9FM:
  509. case SAA7134_BOARD_BEHOLD_507RDS_MK3:
  510. case SAA7134_BOARD_BEHOLD_507RDS_MK5:
  511. ir_codes = RC_MAP_MANLI;
  512. mask_keycode = 0x003f00;
  513. mask_keyup = 0x004000;
  514. polling = 50; /* ms */
  515. break;
  516. case SAA7134_BOARD_BEHOLD_COLUMBUS_TVFM:
  517. ir_codes = RC_MAP_BEHOLD_COLUMBUS;
  518. mask_keycode = 0x003f00;
  519. mask_keyup = 0x004000;
  520. polling = 50; // ms
  521. break;
  522. case SAA7134_BOARD_SEDNA_PC_TV_CARDBUS:
  523. ir_codes = RC_MAP_PCTV_SEDNA;
  524. mask_keycode = 0x001f00;
  525. mask_keyup = 0x004000;
  526. polling = 50; // ms
  527. break;
  528. case SAA7134_BOARD_GOTVIEW_7135:
  529. ir_codes = RC_MAP_GOTVIEW7135;
  530. mask_keycode = 0x0003CC;
  531. mask_keydown = 0x000010;
  532. polling = 5; /* ms */
  533. saa_setb(SAA7134_GPIO_GPMODE1, 0x80);
  534. break;
  535. case SAA7134_BOARD_VIDEOMATE_TV_PVR:
  536. case SAA7134_BOARD_VIDEOMATE_GOLD_PLUS:
  537. case SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII:
  538. ir_codes = RC_MAP_VIDEOMATE_TV_PVR;
  539. mask_keycode = 0x00003F;
  540. mask_keyup = 0x400000;
  541. polling = 50; // ms
  542. break;
  543. case SAA7134_BOARD_PROTEUS_2309:
  544. ir_codes = RC_MAP_PROTEUS_2309;
  545. mask_keycode = 0x00007F;
  546. mask_keyup = 0x000080;
  547. polling = 50; // ms
  548. break;
  549. case SAA7134_BOARD_VIDEOMATE_DVBT_300:
  550. case SAA7134_BOARD_VIDEOMATE_DVBT_200:
  551. ir_codes = RC_MAP_VIDEOMATE_TV_PVR;
  552. mask_keycode = 0x003F00;
  553. mask_keyup = 0x040000;
  554. break;
  555. case SAA7134_BOARD_FLYDVBS_LR300:
  556. case SAA7134_BOARD_FLYDVBT_LR301:
  557. case SAA7134_BOARD_FLYDVBTDUO:
  558. ir_codes = RC_MAP_FLYDVB;
  559. mask_keycode = 0x0001F00;
  560. mask_keydown = 0x0040000;
  561. break;
  562. case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
  563. case SAA7134_BOARD_ASUSTeK_P7131_HYBRID_LNA:
  564. case SAA7134_BOARD_ASUSTeK_P7131_ANALOG:
  565. ir_codes = RC_MAP_ASUS_PC39;
  566. mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
  567. mask_keyup = 0x0040000;
  568. mask_keycode = 0xffff;
  569. raw_decode = true;
  570. break;
  571. case SAA7134_BOARD_ENCORE_ENLTV:
  572. case SAA7134_BOARD_ENCORE_ENLTV_FM:
  573. ir_codes = RC_MAP_ENCORE_ENLTV;
  574. mask_keycode = 0x00007f;
  575. mask_keyup = 0x040000;
  576. polling = 50; // ms
  577. break;
  578. case SAA7134_BOARD_ENCORE_ENLTV_FM53:
  579. ir_codes = RC_MAP_ENCORE_ENLTV_FM53;
  580. mask_keydown = 0x0040000; /* Enable GPIO18 line on both edges */
  581. mask_keyup = 0x0040000;
  582. mask_keycode = 0xffff;
  583. raw_decode = true;
  584. break;
  585. case SAA7134_BOARD_10MOONSTVMASTER3:
  586. ir_codes = RC_MAP_ENCORE_ENLTV;
  587. mask_keycode = 0x5f80000;
  588. mask_keyup = 0x8000000;
  589. polling = 50; //ms
  590. break;
  591. case SAA7134_BOARD_GENIUS_TVGO_A11MCE:
  592. ir_codes = RC_MAP_GENIUS_TVGO_A11MCE;
  593. mask_keycode = 0xff;
  594. mask_keydown = 0xf00000;
  595. polling = 50; /* ms */
  596. break;
  597. case SAA7134_BOARD_REAL_ANGEL_220:
  598. ir_codes = RC_MAP_REAL_AUDIO_220_32_KEYS;
  599. mask_keycode = 0x3f00;
  600. mask_keyup = 0x4000;
  601. polling = 50; /* ms */
  602. break;
  603. case SAA7134_BOARD_KWORLD_PLUS_TV_ANALOG:
  604. ir_codes = RC_MAP_KWORLD_PLUS_TV_ANALOG;
  605. mask_keycode = 0x7f;
  606. polling = 40; /* ms */
  607. break;
  608. case SAA7134_BOARD_VIDEOMATE_S350:
  609. ir_codes = RC_MAP_VIDEOMATE_S350;
  610. mask_keycode = 0x003f00;
  611. mask_keydown = 0x040000;
  612. break;
  613. case SAA7134_BOARD_LEADTEK_WINFAST_DTV1000S:
  614. ir_codes = RC_MAP_WINFAST;
  615. mask_keycode = 0x5f00;
  616. mask_keyup = 0x020000;
  617. polling = 50; /* ms */
  618. break;
  619. }
  620. if (NULL == ir_codes) {
  621. printk("%s: Oops: IR config error [card=%d]\n",
  622. dev->name, dev->board);
  623. return -ENODEV;
  624. }
  625. ir = kzalloc(sizeof(*ir), GFP_KERNEL);
  626. rc = rc_allocate_device();
  627. if (!ir || !rc) {
  628. err = -ENOMEM;
  629. goto err_out_free;
  630. }
  631. ir->dev = rc;
  632. dev->remote = ir;
  633. /* init hardware-specific stuff */
  634. ir->mask_keycode = mask_keycode;
  635. ir->mask_keydown = mask_keydown;
  636. ir->mask_keyup = mask_keyup;
  637. ir->polling = polling;
  638. ir->raw_decode = raw_decode;
  639. /* init input device */
  640. snprintf(ir->name, sizeof(ir->name), "saa7134 IR (%s)",
  641. saa7134_boards[dev->board].name);
  642. snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
  643. pci_name(dev->pci));
  644. rc->priv = dev;
  645. rc->open = saa7134_ir_open;
  646. rc->close = saa7134_ir_close;
  647. if (raw_decode)
  648. rc->driver_type = RC_DRIVER_IR_RAW;
  649. rc->input_name = ir->name;
  650. rc->input_phys = ir->phys;
  651. rc->input_id.bustype = BUS_PCI;
  652. rc->input_id.version = 1;
  653. if (dev->pci->subsystem_vendor) {
  654. rc->input_id.vendor = dev->pci->subsystem_vendor;
  655. rc->input_id.product = dev->pci->subsystem_device;
  656. } else {
  657. rc->input_id.vendor = dev->pci->vendor;
  658. rc->input_id.product = dev->pci->device;
  659. }
  660. rc->dev.parent = &dev->pci->dev;
  661. rc->map_name = ir_codes;
  662. rc->driver_name = MODULE_NAME;
  663. err = rc_register_device(rc);
  664. if (err)
  665. goto err_out_free;
  666. return 0;
  667. err_out_free:
  668. rc_free_device(rc);
  669. dev->remote = NULL;
  670. kfree(ir);
  671. return err;
  672. }
  673. void saa7134_input_fini(struct saa7134_dev *dev)
  674. {
  675. if (NULL == dev->remote)
  676. return;
  677. saa7134_ir_stop(dev);
  678. rc_unregister_device(dev->remote->dev);
  679. kfree(dev->remote);
  680. dev->remote = NULL;
  681. }
  682. void saa7134_probe_i2c_ir(struct saa7134_dev *dev)
  683. {
  684. struct i2c_board_info info;
  685. struct i2c_msg msg_msi = {
  686. .addr = 0x50,
  687. .flags = I2C_M_RD,
  688. .len = 0,
  689. .buf = NULL,
  690. };
  691. int rc;
  692. if (disable_ir) {
  693. dprintk("IR has been disabled, not probing for i2c remote\n");
  694. return;
  695. }
  696. memset(&info, 0, sizeof(struct i2c_board_info));
  697. memset(&dev->init_data, 0, sizeof(dev->init_data));
  698. strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
  699. switch (dev->board) {
  700. case SAA7134_BOARD_PINNACLE_PCTV_110i:
  701. case SAA7134_BOARD_PINNACLE_PCTV_310i:
  702. dev->init_data.name = "Pinnacle PCTV";
  703. if (pinnacle_remote == 0) {
  704. dev->init_data.get_key = get_key_pinnacle_color;
  705. dev->init_data.ir_codes = RC_MAP_PINNACLE_COLOR;
  706. info.addr = 0x47;
  707. } else {
  708. dev->init_data.get_key = get_key_pinnacle_grey;
  709. dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
  710. info.addr = 0x47;
  711. }
  712. break;
  713. case SAA7134_BOARD_UPMOST_PURPLE_TV:
  714. dev->init_data.name = "Purple TV";
  715. dev->init_data.get_key = get_key_purpletv;
  716. dev->init_data.ir_codes = RC_MAP_PURPLETV;
  717. info.addr = 0x7a;
  718. break;
  719. case SAA7134_BOARD_MSI_TVATANYWHERE_PLUS:
  720. dev->init_data.name = "MSI TV@nywhere Plus";
  721. dev->init_data.get_key = get_key_msi_tvanywhere_plus;
  722. dev->init_data.ir_codes = RC_MAP_MSI_TVANYWHERE_PLUS;
  723. /*
  724. * MSI TV@nyware Plus requires more frequent polling
  725. * otherwise it will miss some keypresses
  726. */
  727. dev->init_data.polling_interval = 50;
  728. info.addr = 0x30;
  729. /* MSI TV@nywhere Plus controller doesn't seem to
  730. respond to probes unless we read something from
  731. an existing device. Weird...
  732. REVISIT: might no longer be needed */
  733. rc = i2c_transfer(&dev->i2c_adap, &msg_msi, 1);
  734. dprintk("probe 0x%02x @ %s: %s\n",
  735. msg_msi.addr, dev->i2c_adap.name,
  736. (1 == rc) ? "yes" : "no");
  737. break;
  738. case SAA7134_BOARD_HAUPPAUGE_HVR1110:
  739. dev->init_data.name = "HVR 1110";
  740. dev->init_data.get_key = get_key_hvr1110;
  741. dev->init_data.ir_codes = RC_MAP_HAUPPAUGE_NEW;
  742. info.addr = 0x71;
  743. break;
  744. case SAA7134_BOARD_BEHOLD_607FM_MK3:
  745. case SAA7134_BOARD_BEHOLD_607FM_MK5:
  746. case SAA7134_BOARD_BEHOLD_609FM_MK3:
  747. case SAA7134_BOARD_BEHOLD_609FM_MK5:
  748. case SAA7134_BOARD_BEHOLD_607RDS_MK3:
  749. case SAA7134_BOARD_BEHOLD_607RDS_MK5:
  750. case SAA7134_BOARD_BEHOLD_609RDS_MK3:
  751. case SAA7134_BOARD_BEHOLD_609RDS_MK5:
  752. case SAA7134_BOARD_BEHOLD_M6:
  753. case SAA7134_BOARD_BEHOLD_M63:
  754. case SAA7134_BOARD_BEHOLD_M6_EXTRA:
  755. case SAA7134_BOARD_BEHOLD_H6:
  756. case SAA7134_BOARD_BEHOLD_X7:
  757. case SAA7134_BOARD_BEHOLD_H7:
  758. case SAA7134_BOARD_BEHOLD_A7:
  759. dev->init_data.name = "BeholdTV";
  760. dev->init_data.get_key = get_key_beholdm6xx;
  761. dev->init_data.ir_codes = RC_MAP_BEHOLD;
  762. dev->init_data.type = RC_TYPE_NEC;
  763. info.addr = 0x2d;
  764. break;
  765. case SAA7134_BOARD_AVERMEDIA_CARDBUS_501:
  766. case SAA7134_BOARD_AVERMEDIA_CARDBUS_506:
  767. info.addr = 0x40;
  768. break;
  769. case SAA7134_BOARD_FLYDVB_TRIO:
  770. dev->init_data.name = "FlyDVB Trio";
  771. dev->init_data.get_key = get_key_flydvb_trio;
  772. dev->init_data.ir_codes = RC_MAP_FLYDVB;
  773. info.addr = 0x0b;
  774. break;
  775. default:
  776. dprintk("No I2C IR support for board %x\n", dev->board);
  777. return;
  778. }
  779. if (dev->init_data.name)
  780. info.platform_data = &dev->init_data;
  781. i2c_new_device(&dev->i2c_adap, &info);
  782. }
  783. static int saa7134_raw_decode_irq(struct saa7134_dev *dev)
  784. {
  785. struct saa7134_card_ir *ir = dev->remote;
  786. unsigned long timeout;
  787. int space;
  788. /* Generate initial event */
  789. saa_clearb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  790. saa_setb(SAA7134_GPIO_GPMODE3, SAA7134_GPIO_GPRESCAN);
  791. space = saa_readl(SAA7134_GPIO_GPSTATUS0 >> 2) & ir->mask_keydown;
  792. ir_raw_event_store_edge(dev->remote->dev, space ? IR_SPACE : IR_PULSE);
  793. /*
  794. * Wait 15 ms from the start of the first IR event before processing
  795. * the event. This time is enough for NEC protocol. May need adjustments
  796. * to work with other protocols.
  797. */
  798. if (!ir->active) {
  799. timeout = jiffies + jiffies_to_msecs(15);
  800. mod_timer(&ir->timer_end, timeout);
  801. ir->active = true;
  802. }
  803. return 1;
  804. }