python_code
stringlengths 0
1.8M
| repo_name
stringclasses 7
values | file_path
stringlengths 5
99
|
|---|---|---|
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc-delock-61959.c - Keytable for Delock
*
* Copyright (c) 2013 by Jakob Haufe <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keytable for remote provided with Delock 61959
*/
static struct rc_map_table delock_61959[] = {
{ 0x866b16, KEY_POWER2 }, /* Power */
{ 0x866b0c, KEY_POWER }, /* Shut Down */
{ 0x866b00, KEY_NUMERIC_1},
{ 0x866b01, KEY_NUMERIC_2},
{ 0x866b02, KEY_NUMERIC_3},
{ 0x866b03, KEY_NUMERIC_4},
{ 0x866b04, KEY_NUMERIC_5},
{ 0x866b05, KEY_NUMERIC_6},
{ 0x866b06, KEY_NUMERIC_7},
{ 0x866b07, KEY_NUMERIC_8},
{ 0x866b08, KEY_NUMERIC_9},
{ 0x866b14, KEY_NUMERIC_0},
{ 0x866b0a, KEY_ZOOM}, /* Full Screen */
{ 0x866b10, KEY_CAMERA}, /* Photo */
{ 0x866b0e, KEY_CHANNEL}, /* circular arrow / Recall */
{ 0x866b13, KEY_ESC}, /* Back */
{ 0x866b20, KEY_UP},
{ 0x866b21, KEY_DOWN},
{ 0x866b42, KEY_LEFT},
{ 0x866b43, KEY_RIGHT},
{ 0x866b0b, KEY_OK},
{ 0x866b11, KEY_CHANNELUP},
{ 0x866b1b, KEY_CHANNELDOWN},
{ 0x866b12, KEY_VOLUMEUP},
{ 0x866b48, KEY_VOLUMEDOWN},
{ 0x866b44, KEY_MUTE},
{ 0x866b1a, KEY_RECORD},
{ 0x866b41, KEY_PLAY},
{ 0x866b40, KEY_STOP},
{ 0x866b19, KEY_PAUSE},
{ 0x866b1c, KEY_FASTFORWARD}, /* >> / FWD */
{ 0x866b1e, KEY_REWIND}, /* << / REW */
};
static struct rc_map_list delock_61959_map = {
.map = {
.scan = delock_61959,
.size = ARRAY_SIZE(delock_61959),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_DELOCK_61959,
}
};
static int __init init_rc_map_delock_61959(void)
{
return rc_map_register(&delock_61959_map);
}
static void __exit exit_rc_map_delock_61959(void)
{
rc_map_unregister(&delock_61959_map);
}
module_init(init_rc_map_delock_61959)
module_exit(exit_rc_map_delock_61959)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jakob Haufe <[email protected]>");
MODULE_DESCRIPTION("Delock 61959 remote keytable");
| linux-master | drivers/media/rc/keymaps/rc-delock-61959.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc-rc6-mce.c - Keytable for Windows Media Center RC-6 remotes for use
* with the Media Center Edition eHome Infrared Transceiver.
*
* Copyright (c) 2010 by Jarod Wilson <[email protected]>
*
* See http://mediacenterguides.com/book/export/html/31 for details on
* key mappings.
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table rc6_mce[] = {
{ 0x800f0400, KEY_NUMERIC_0 },
{ 0x800f0401, KEY_NUMERIC_1 },
{ 0x800f0402, KEY_NUMERIC_2 },
{ 0x800f0403, KEY_NUMERIC_3 },
{ 0x800f0404, KEY_NUMERIC_4 },
{ 0x800f0405, KEY_NUMERIC_5 },
{ 0x800f0406, KEY_NUMERIC_6 },
{ 0x800f0407, KEY_NUMERIC_7 },
{ 0x800f0408, KEY_NUMERIC_8 },
{ 0x800f0409, KEY_NUMERIC_9 },
{ 0x800f040a, KEY_DELETE },
{ 0x800f040b, KEY_ENTER },
{ 0x800f040c, KEY_SLEEP }, /* Formerly PC Power */
{ 0x800f040d, KEY_MEDIA }, /* Windows MCE button */
{ 0x800f040e, KEY_MUTE },
{ 0x800f040f, KEY_INFO },
{ 0x800f0410, KEY_VOLUMEUP },
{ 0x800f0411, KEY_VOLUMEDOWN },
{ 0x800f0412, KEY_CHANNELUP },
{ 0x800f0413, KEY_CHANNELDOWN },
{ 0x800f0414, KEY_FASTFORWARD },
{ 0x800f0415, KEY_REWIND },
{ 0x800f0416, KEY_PLAY },
{ 0x800f0417, KEY_RECORD },
{ 0x800f0418, KEY_PAUSE },
{ 0x800f0419, KEY_STOP },
{ 0x800f041a, KEY_NEXT },
{ 0x800f041b, KEY_PREVIOUS },
{ 0x800f041c, KEY_NUMERIC_POUND },
{ 0x800f041d, KEY_NUMERIC_STAR },
{ 0x800f041e, KEY_UP },
{ 0x800f041f, KEY_DOWN },
{ 0x800f0420, KEY_LEFT },
{ 0x800f0421, KEY_RIGHT },
{ 0x800f0422, KEY_OK },
{ 0x800f0423, KEY_EXIT },
{ 0x800f0424, KEY_DVD },
{ 0x800f0425, KEY_TUNER }, /* LiveTV */
{ 0x800f0426, KEY_EPG }, /* Guide */
{ 0x800f0427, KEY_ZOOM }, /* Aspect */
{ 0x800f0432, KEY_MODE }, /* Visualization */
{ 0x800f0433, KEY_PRESENTATION }, /* Slide Show */
{ 0x800f0434, KEY_EJECTCD },
{ 0x800f043a, KEY_BRIGHTNESSUP },
{ 0x800f0446, KEY_TV },
{ 0x800f0447, KEY_AUDIO }, /* My Music */
{ 0x800f0448, KEY_PVR }, /* RecordedTV */
{ 0x800f0449, KEY_CAMERA },
{ 0x800f044a, KEY_VIDEO },
{ 0x800f044c, KEY_LANGUAGE },
{ 0x800f044d, KEY_TITLE },
{ 0x800f044e, KEY_PRINT }, /* Print - HP OEM version of remote */
{ 0x800f0450, KEY_RADIO },
{ 0x800f045a, KEY_SUBTITLE }, /* Caption/Teletext */
{ 0x800f045b, KEY_RED },
{ 0x800f045c, KEY_GREEN },
{ 0x800f045d, KEY_YELLOW },
{ 0x800f045e, KEY_BLUE },
{ 0x800f0465, KEY_POWER2 }, /* TV Power */
{ 0x800f0469, KEY_MESSENGER },
{ 0x800f046e, KEY_PLAYPAUSE },
{ 0x800f046f, KEY_PLAYER }, /* Start media application (NEW) */
{ 0x800f0480, KEY_BRIGHTNESSDOWN },
{ 0x800f0481, KEY_PLAYPAUSE },
};
static struct rc_map_list rc6_mce_map = {
.map = {
.scan = rc6_mce,
.size = ARRAY_SIZE(rc6_mce),
.rc_proto = RC_PROTO_RC6_MCE,
.name = RC_MAP_RC6_MCE,
}
};
static int __init init_rc_map_rc6_mce(void)
{
return rc_map_register(&rc6_mce_map);
}
static void __exit exit_rc_map_rc6_mce(void)
{
rc_map_unregister(&rc6_mce_map);
}
module_init(init_rc_map_rc6_mce)
module_exit(exit_rc_map_rc6_mce)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jarod Wilson <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-rc6-mce.c |
// SPDX-License-Identifier: GPL-2.0+
// eztv.h - Keytable for eztv Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Alfons Geser <[email protected]>
* updates from Job D. R. Borges <[email protected]> */
static struct rc_map_table eztv[] = {
{ 0x12, KEY_POWER },
{ 0x01, KEY_TV }, /* DVR */
{ 0x15, KEY_DVD }, /* DVD */
{ 0x17, KEY_AUDIO }, /* music */
/* DVR mode / DVD mode / music mode */
{ 0x1b, KEY_MUTE }, /* mute */
{ 0x02, KEY_LANGUAGE }, /* MTS/SAP / audio / autoseek */
{ 0x1e, KEY_SUBTITLE }, /* closed captioning / subtitle / seek */
{ 0x16, KEY_ZOOM }, /* full screen */
{ 0x1c, KEY_VIDEO }, /* video source / eject / delall */
{ 0x1d, KEY_RESTART }, /* playback / angle / del */
{ 0x2f, KEY_SEARCH }, /* scan / menu / playlist */
{ 0x30, KEY_CHANNEL }, /* CH surfing / bookmark / memo */
{ 0x31, KEY_HELP }, /* help */
{ 0x32, KEY_MODE }, /* num/memo */
{ 0x33, KEY_ESC }, /* cancel */
{ 0x0c, KEY_UP }, /* up */
{ 0x10, KEY_DOWN }, /* down */
{ 0x08, KEY_LEFT }, /* left */
{ 0x04, KEY_RIGHT }, /* right */
{ 0x03, KEY_SELECT }, /* select */
{ 0x1f, KEY_REWIND }, /* rewind */
{ 0x20, KEY_PLAYPAUSE },/* play/pause */
{ 0x29, KEY_FORWARD }, /* forward */
{ 0x14, KEY_AGAIN }, /* repeat */
{ 0x2b, KEY_RECORD }, /* recording */
{ 0x2c, KEY_STOP }, /* stop */
{ 0x2d, KEY_PLAY }, /* play */
{ 0x2e, KEY_CAMERA }, /* snapshot / shuffle */
{ 0x00, KEY_NUMERIC_0 },
{ 0x05, KEY_NUMERIC_1 },
{ 0x06, KEY_NUMERIC_2 },
{ 0x07, KEY_NUMERIC_3 },
{ 0x09, KEY_NUMERIC_4 },
{ 0x0a, KEY_NUMERIC_5 },
{ 0x0b, KEY_NUMERIC_6 },
{ 0x0d, KEY_NUMERIC_7 },
{ 0x0e, KEY_NUMERIC_8 },
{ 0x0f, KEY_NUMERIC_9 },
{ 0x2a, KEY_VOLUMEUP },
{ 0x11, KEY_VOLUMEDOWN },
{ 0x18, KEY_CHANNELUP },/* CH.tracking up */
{ 0x19, KEY_CHANNELDOWN },/* CH.tracking down */
{ 0x13, KEY_ENTER }, /* enter */
{ 0x21, KEY_DOT }, /* . (decimal dot) */
};
static struct rc_map_list eztv_map = {
.map = {
.scan = eztv,
.size = ARRAY_SIZE(eztv),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_EZTV,
}
};
static int __init init_rc_map_eztv(void)
{
return rc_map_register(&eztv_map);
}
static void __exit exit_rc_map_eztv(void)
{
rc_map_unregister(&eztv_map);
}
module_init(init_rc_map_eztv)
module_exit(exit_rc_map_eztv)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-eztv.c |
// SPDX-License-Identifier: GPL-2.0+
// asus-pc39.h - Keytable for asus_pc39 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Marc Fargas <[email protected]>
* this is the remote control that comes with the asus p7131
* which has a label saying is "Model PC-39"
*/
static struct rc_map_table asus_pc39[] = {
/* Keys 0 to 9 */
{ 0x082a, KEY_NUMERIC_0 },
{ 0x0816, KEY_NUMERIC_1 },
{ 0x0812, KEY_NUMERIC_2 },
{ 0x0814, KEY_NUMERIC_3 },
{ 0x0836, KEY_NUMERIC_4 },
{ 0x0832, KEY_NUMERIC_5 },
{ 0x0834, KEY_NUMERIC_6 },
{ 0x080e, KEY_NUMERIC_7 },
{ 0x080a, KEY_NUMERIC_8 },
{ 0x080c, KEY_NUMERIC_9 },
{ 0x0801, KEY_RADIO }, /* radio */
{ 0x083c, KEY_MENU }, /* dvd/menu */
{ 0x0815, KEY_VOLUMEUP },
{ 0x0826, KEY_VOLUMEDOWN },
{ 0x0808, KEY_UP },
{ 0x0804, KEY_DOWN },
{ 0x0818, KEY_LEFT },
{ 0x0810, KEY_RIGHT },
{ 0x081a, KEY_VIDEO }, /* video */
{ 0x0806, KEY_AUDIO }, /* music */
{ 0x081e, KEY_TV }, /* tv */
{ 0x0822, KEY_EXIT }, /* back */
{ 0x0835, KEY_CHANNELUP }, /* channel / program + */
{ 0x0824, KEY_CHANNELDOWN }, /* channel / program - */
{ 0x0825, KEY_ENTER }, /* enter */
{ 0x0839, KEY_PAUSE }, /* play/pause */
{ 0x0821, KEY_PREVIOUS }, /* rew */
{ 0x0819, KEY_NEXT }, /* forward */
{ 0x0831, KEY_REWIND }, /* backward << */
{ 0x0805, KEY_FASTFORWARD }, /* forward >> */
{ 0x0809, KEY_STOP },
{ 0x0811, KEY_RECORD }, /* recording */
{ 0x0829, KEY_POWER }, /* the button that reads "close" */
{ 0x082e, KEY_ZOOM }, /* full screen */
{ 0x082c, KEY_MACRO }, /* recall */
{ 0x081c, KEY_HOME }, /* home */
{ 0x083a, KEY_PVR }, /* picture */
{ 0x0802, KEY_MUTE }, /* mute */
{ 0x083e, KEY_DVD }, /* dvd */
};
static struct rc_map_list asus_pc39_map = {
.map = {
.scan = asus_pc39,
.size = ARRAY_SIZE(asus_pc39),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_ASUS_PC39,
}
};
static int __init init_rc_map_asus_pc39(void)
{
return rc_map_register(&asus_pc39_map);
}
static void __exit exit_rc_map_asus_pc39(void)
{
rc_map_unregister(&asus_pc39_map);
}
module_init(init_rc_map_asus_pc39)
module_exit(exit_rc_map_asus_pc39)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-asus-pc39.c |
// SPDX-License-Identifier: GPL-2.0+
// pinnacle-grey.h - Keytable for pinnacle_grey Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table pinnacle_grey[] = {
{ 0x3a, KEY_NUMERIC_0 },
{ 0x31, KEY_NUMERIC_1 },
{ 0x32, KEY_NUMERIC_2 },
{ 0x33, KEY_NUMERIC_3 },
{ 0x34, KEY_NUMERIC_4 },
{ 0x35, KEY_NUMERIC_5 },
{ 0x36, KEY_NUMERIC_6 },
{ 0x37, KEY_NUMERIC_7 },
{ 0x38, KEY_NUMERIC_8 },
{ 0x39, KEY_NUMERIC_9 },
{ 0x2f, KEY_POWER },
{ 0x2e, KEY_P },
{ 0x1f, KEY_L },
{ 0x2b, KEY_I },
{ 0x2d, KEY_SCREEN },
{ 0x1e, KEY_ZOOM },
{ 0x1b, KEY_VOLUMEUP },
{ 0x0f, KEY_VOLUMEDOWN },
{ 0x17, KEY_CHANNELUP },
{ 0x1c, KEY_CHANNELDOWN },
{ 0x25, KEY_INFO },
{ 0x3c, KEY_MUTE },
{ 0x3d, KEY_LEFT },
{ 0x3b, KEY_RIGHT },
{ 0x3f, KEY_UP },
{ 0x3e, KEY_DOWN },
{ 0x1a, KEY_ENTER },
{ 0x1d, KEY_MENU },
{ 0x19, KEY_AGAIN },
{ 0x16, KEY_PREVIOUSSONG },
{ 0x13, KEY_NEXTSONG },
{ 0x15, KEY_PAUSE },
{ 0x0e, KEY_REWIND },
{ 0x0d, KEY_PLAY },
{ 0x0b, KEY_STOP },
{ 0x07, KEY_FORWARD },
{ 0x27, KEY_RECORD },
{ 0x26, KEY_TUNER },
{ 0x29, KEY_TEXT },
{ 0x2a, KEY_MEDIA },
{ 0x18, KEY_EPG },
};
static struct rc_map_list pinnacle_grey_map = {
.map = {
.scan = pinnacle_grey,
.size = ARRAY_SIZE(pinnacle_grey),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_PINNACLE_GREY,
}
};
static int __init init_rc_map_pinnacle_grey(void)
{
return rc_map_register(&pinnacle_grey_map);
}
static void __exit exit_rc_map_pinnacle_grey(void)
{
rc_map_unregister(&pinnacle_grey_map);
}
module_init(init_rc_map_pinnacle_grey)
module_exit(exit_rc_map_pinnacle_grey)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pinnacle-grey.c |
// SPDX-License-Identifier: GPL-2.0+
// genius-tvgo-a11mce.h - Keytable for genius_tvgo_a11mce Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Remote control for the Genius TVGO A11MCE
* Adrian Pardini <[email protected]>
*/
static struct rc_map_table genius_tvgo_a11mce[] = {
/* Keys 0 to 9 */
{ 0x48, KEY_NUMERIC_0 },
{ 0x09, KEY_NUMERIC_1 },
{ 0x1d, KEY_NUMERIC_2 },
{ 0x1f, KEY_NUMERIC_3 },
{ 0x19, KEY_NUMERIC_4 },
{ 0x1b, KEY_NUMERIC_5 },
{ 0x11, KEY_NUMERIC_6 },
{ 0x17, KEY_NUMERIC_7 },
{ 0x12, KEY_NUMERIC_8 },
{ 0x16, KEY_NUMERIC_9 },
{ 0x54, KEY_RECORD }, /* recording */
{ 0x06, KEY_MUTE }, /* mute */
{ 0x10, KEY_POWER },
{ 0x40, KEY_LAST }, /* recall */
{ 0x4c, KEY_CHANNELUP }, /* channel / program + */
{ 0x00, KEY_CHANNELDOWN }, /* channel / program - */
{ 0x0d, KEY_VOLUMEUP },
{ 0x15, KEY_VOLUMEDOWN },
{ 0x4d, KEY_OK }, /* also labeled as Pause */
{ 0x1c, KEY_ZOOM }, /* full screen and Stop*/
{ 0x02, KEY_MODE }, /* AV Source or Rewind*/
{ 0x04, KEY_LIST }, /* -/-- */
/* small arrows above numbers */
{ 0x1a, KEY_NEXT }, /* also Fast Forward */
{ 0x0e, KEY_PREVIOUS }, /* also Rewind */
/* these are in a rather non standard layout and have
an alternate name written */
{ 0x1e, KEY_UP }, /* Video Setting */
{ 0x0a, KEY_DOWN }, /* Video Default */
{ 0x05, KEY_CAMERA }, /* Snapshot */
{ 0x0c, KEY_RIGHT }, /* Hide Panel */
/* Four buttons without label */
{ 0x49, KEY_RED },
{ 0x0b, KEY_GREEN },
{ 0x13, KEY_YELLOW },
{ 0x50, KEY_BLUE },
};
static struct rc_map_list genius_tvgo_a11mce_map = {
.map = {
.scan = genius_tvgo_a11mce,
.size = ARRAY_SIZE(genius_tvgo_a11mce),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_GENIUS_TVGO_A11MCE,
}
};
static int __init init_rc_map_genius_tvgo_a11mce(void)
{
return rc_map_register(&genius_tvgo_a11mce_map);
}
static void __exit exit_rc_map_genius_tvgo_a11mce(void)
{
rc_map_unregister(&genius_tvgo_a11mce_map);
}
module_init(init_rc_map_genius_tvgo_a11mce)
module_exit(exit_rc_map_genius_tvgo_a11mce)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-genius-tvgo-a11mce.c |
// SPDX-License-Identifier: GPL-2.0+
// kaiomy.h - Keytable for kaiomy Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Kaiomy TVnPC U2
Mauro Carvalho Chehab <[email protected]>
*/
static struct rc_map_table kaiomy[] = {
{ 0x43, KEY_POWER2},
{ 0x01, KEY_LIST},
{ 0x0b, KEY_ZOOM},
{ 0x03, KEY_POWER},
{ 0x04, KEY_NUMERIC_1},
{ 0x08, KEY_NUMERIC_2},
{ 0x02, KEY_NUMERIC_3},
{ 0x0f, KEY_NUMERIC_4},
{ 0x05, KEY_NUMERIC_5},
{ 0x06, KEY_NUMERIC_6},
{ 0x0c, KEY_NUMERIC_7},
{ 0x0d, KEY_NUMERIC_8},
{ 0x0a, KEY_NUMERIC_9},
{ 0x11, KEY_NUMERIC_0},
{ 0x09, KEY_CHANNELUP},
{ 0x07, KEY_CHANNELDOWN},
{ 0x0e, KEY_VOLUMEUP},
{ 0x13, KEY_VOLUMEDOWN},
{ 0x10, KEY_HOME},
{ 0x12, KEY_ENTER},
{ 0x14, KEY_RECORD},
{ 0x15, KEY_STOP},
{ 0x16, KEY_PLAY},
{ 0x17, KEY_MUTE},
{ 0x18, KEY_UP},
{ 0x19, KEY_DOWN},
{ 0x1a, KEY_LEFT},
{ 0x1b, KEY_RIGHT},
{ 0x1c, KEY_RED},
{ 0x1d, KEY_GREEN},
{ 0x1e, KEY_YELLOW},
{ 0x1f, KEY_BLUE},
};
static struct rc_map_list kaiomy_map = {
.map = {
.scan = kaiomy,
.size = ARRAY_SIZE(kaiomy),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_KAIOMY,
}
};
static int __init init_rc_map_kaiomy(void)
{
return rc_map_register(&kaiomy_map);
}
static void __exit exit_rc_map_kaiomy(void)
{
rc_map_unregister(&kaiomy_map);
}
module_init(init_rc_map_kaiomy)
module_exit(exit_rc_map_kaiomy)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-kaiomy.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2019 Christian Hewitt <[email protected]>
*
*/
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keytable for the Beelink Mini MXIII remote control
*
*/
static struct rc_map_table beelink_mxiii[] = {
{ 0xb2dc, KEY_POWER },
{ 0xb288, KEY_MUTE },
{ 0xb282, KEY_HOME },
{ 0xb2ca, KEY_UP },
{ 0xb299, KEY_LEFT },
{ 0xb2ce, KEY_OK },
{ 0xb2c1, KEY_RIGHT },
{ 0xb2d2, KEY_DOWN },
{ 0xb2c5, KEY_MENU },
{ 0xb29a, KEY_BACK },
{ 0xb281, KEY_VOLUMEDOWN },
{ 0xb280, KEY_VOLUMEUP },
};
static struct rc_map_list beelink_mxiii_map = {
.map = {
.scan = beelink_mxiii,
.size = ARRAY_SIZE(beelink_mxiii),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_BEELINK_MXIII,
}
};
static int __init init_rc_map_beelink_mxiii(void)
{
return rc_map_register(&beelink_mxiii_map);
}
static void __exit exit_rc_map_beelink_mxiii(void)
{
rc_map_unregister(&beelink_mxiii_map);
}
module_init(init_rc_map_beelink_mxiii)
module_exit(exit_rc_map_beelink_mxiii)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]");
| linux-master | drivers/media/rc/keymaps/rc-beelink-mxiii.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2019 Christian Hewitt <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
//
// Keytable for the X96-max STB remote control
//
static struct rc_map_table x96max[] = {
{ 0x140, KEY_POWER },
// ** TV CONTROL **
// SET
// AV/TV
// POWER
// VOLUME UP
// VOLUME DOWN
{ 0x118, KEY_VOLUMEUP },
{ 0x110, KEY_VOLUMEDOWN },
{ 0x143, KEY_MUTE }, // config
{ 0x100, KEY_EPG }, // mouse
{ 0x119, KEY_BACK },
{ 0x116, KEY_UP },
{ 0x151, KEY_LEFT },
{ 0x150, KEY_RIGHT },
{ 0x11a, KEY_DOWN },
{ 0x113, KEY_OK },
{ 0x111, KEY_HOME },
{ 0x14c, KEY_CONTEXT_MENU },
{ 0x159, KEY_PREVIOUS },
{ 0x15a, KEY_PLAYPAUSE },
{ 0x158, KEY_NEXT },
{ 0x147, KEY_MENU }, // @ key
{ 0x101, KEY_NUMERIC_0 },
{ 0x142, KEY_BACKSPACE },
{ 0x14e, KEY_NUMERIC_1 },
{ 0x10d, KEY_NUMERIC_2 },
{ 0x10c, KEY_NUMERIC_3 },
{ 0x14a, KEY_NUMERIC_4 },
{ 0x109, KEY_NUMERIC_5 },
{ 0x108, KEY_NUMERIC_6 },
{ 0x146, KEY_NUMERIC_7 },
{ 0x105, KEY_NUMERIC_8 },
{ 0x104, KEY_NUMERIC_9 },
};
static struct rc_map_list x96max_map = {
.map = {
.scan = x96max,
.size = ARRAY_SIZE(x96max),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_X96MAX,
}
};
static int __init init_rc_map_x96max(void)
{
return rc_map_register(&x96max_map);
}
static void __exit exit_rc_map_x96max(void)
{
rc_map_unregister(&x96max_map);
}
module_init(init_rc_map_x96max)
module_exit(exit_rc_map_x96max)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]");
| linux-master | drivers/media/rc/keymaps/rc-x96max.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* keytable for Terratec Cinergy S2 HD Remote Controller
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table terratec_cinergy_s2_hd[] = {
{ 0x03, KEY_NEXT}, /* >| */
{ 0x07, KEY_RECORD},
{ 0x0b, KEY_PREVIOUS}, /* |< */
{ 0x10, KEY_FASTFORWARD}, /* >> */
{ 0x11, KEY_REWIND}, /* << */
{ 0x12, KEY_ESC}, /* Back */
{ 0x13, KEY_PLAY},
{ 0x14, KEY_IMAGES},
{ 0x15, KEY_AUDIO},
{ 0x16, KEY_MEDIA}, /* Video-Menu */
{ 0x17, KEY_STOP},
{ 0x18, KEY_DVD},
{ 0x19, KEY_TV},
{ 0x1a, KEY_DELETE},
{ 0x1b, KEY_TEXT},
{ 0x1c, KEY_SUBTITLE},
{ 0x1d, KEY_MENU}, /* DVD-Menu */
{ 0x1e, KEY_HOME},
{ 0x1f, KEY_PAUSE},
{ 0x20, KEY_CHANNELDOWN},
{ 0x21, KEY_VOLUMEDOWN},
{ 0x22, KEY_MUTE},
{ 0x23, KEY_VOLUMEUP},
{ 0x24, KEY_CHANNELUP},
{ 0x25, KEY_BLUE},
{ 0x26, KEY_YELLOW},
{ 0x27, KEY_GREEN},
{ 0x28, KEY_RED},
{ 0x29, KEY_INFO},
{ 0x2b, KEY_DOWN},
{ 0x2c, KEY_RIGHT},
{ 0x2d, KEY_OK},
{ 0x2e, KEY_LEFT},
{ 0x2f, KEY_UP},
{ 0x30, KEY_EPG},
{ 0x32, KEY_VIDEO}, /* A<=>B */
{ 0x33, KEY_NUMERIC_0},
{ 0x34, KEY_VCR}, /* AV */
{ 0x35, KEY_NUMERIC_9},
{ 0x36, KEY_NUMERIC_8},
{ 0x37, KEY_NUMERIC_7},
{ 0x38, KEY_NUMERIC_6},
{ 0x39, KEY_NUMERIC_5},
{ 0x3a, KEY_NUMERIC_4},
{ 0x3b, KEY_NUMERIC_3},
{ 0x3c, KEY_NUMERIC_2},
{ 0x3d, KEY_NUMERIC_1},
{ 0x3e, KEY_POWER},
};
static struct rc_map_list terratec_cinergy_s2_hd_map = {
.map = {
.scan = terratec_cinergy_s2_hd,
.size = ARRAY_SIZE(terratec_cinergy_s2_hd),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_TERRATEC_CINERGY_S2_HD,
}
};
static int __init init_rc_map_terratec_cinergy_s2_hd(void)
{
return rc_map_register(&terratec_cinergy_s2_hd_map);
}
static void __exit exit_rc_map_terratec_cinergy_s2_hd(void)
{
rc_map_unregister(&terratec_cinergy_s2_hd_map);
}
module_init(init_rc_map_terratec_cinergy_s2_hd);
module_exit(exit_rc_map_terratec_cinergy_s2_hd);
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-terratec-cinergy-s2-hd.c |
// SPDX-License-Identifier: GPL-2.0+
// npgtech.h - Keytable for npgtech Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table npgtech[] = {
{ 0x1d, KEY_SWITCHVIDEOMODE }, /* switch inputs */
{ 0x2a, KEY_FRONT },
{ 0x3e, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x06, KEY_NUMERIC_3 },
{ 0x0a, KEY_NUMERIC_4 },
{ 0x0e, KEY_NUMERIC_5 },
{ 0x12, KEY_NUMERIC_6 },
{ 0x16, KEY_NUMERIC_7 },
{ 0x1a, KEY_NUMERIC_8 },
{ 0x1e, KEY_NUMERIC_9 },
{ 0x3a, KEY_NUMERIC_0 },
{ 0x22, KEY_NUMLOCK }, /* -/-- */
{ 0x20, KEY_REFRESH },
{ 0x03, KEY_BRIGHTNESSDOWN },
{ 0x28, KEY_AUDIO },
{ 0x3c, KEY_CHANNELUP },
{ 0x3f, KEY_VOLUMEDOWN },
{ 0x2e, KEY_MUTE },
{ 0x3b, KEY_VOLUMEUP },
{ 0x00, KEY_CHANNELDOWN },
{ 0x07, KEY_BRIGHTNESSUP },
{ 0x2c, KEY_TEXT },
{ 0x37, KEY_RECORD },
{ 0x17, KEY_PLAY },
{ 0x13, KEY_PAUSE },
{ 0x26, KEY_STOP },
{ 0x18, KEY_FASTFORWARD },
{ 0x14, KEY_REWIND },
{ 0x33, KEY_ZOOM },
{ 0x32, KEY_KEYBOARD },
{ 0x30, KEY_GOTO }, /* Pointing arrow */
{ 0x36, KEY_MACRO }, /* Maximize/Minimize (yellow) */
{ 0x0b, KEY_RADIO },
{ 0x10, KEY_POWER },
};
static struct rc_map_list npgtech_map = {
.map = {
.scan = npgtech,
.size = ARRAY_SIZE(npgtech),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_NPGTECH,
}
};
static int __init init_rc_map_npgtech(void)
{
return rc_map_register(&npgtech_map);
}
static void __exit exit_rc_map_npgtech(void)
{
rc_map_unregister(&npgtech_map);
}
module_init(init_rc_map_npgtech)
module_exit(exit_rc_map_npgtech)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-npgtech.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* TerraTec remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* TerraTec slim remote, 7 rows, 4 columns. */
/* Uses NEC extended 0x02bd. */
static struct rc_map_table terratec_slim[] = {
{ 0x02bd00, KEY_NUMERIC_1 },
{ 0x02bd01, KEY_NUMERIC_2 },
{ 0x02bd02, KEY_NUMERIC_3 },
{ 0x02bd03, KEY_NUMERIC_4 },
{ 0x02bd04, KEY_NUMERIC_5 },
{ 0x02bd05, KEY_NUMERIC_6 },
{ 0x02bd06, KEY_NUMERIC_7 },
{ 0x02bd07, KEY_NUMERIC_8 },
{ 0x02bd08, KEY_NUMERIC_9 },
{ 0x02bd09, KEY_NUMERIC_0 },
{ 0x02bd0a, KEY_MUTE },
{ 0x02bd0b, KEY_NEW }, /* symbol: PIP */
{ 0x02bd0e, KEY_VOLUMEDOWN },
{ 0x02bd0f, KEY_PLAYPAUSE },
{ 0x02bd10, KEY_RIGHT },
{ 0x02bd11, KEY_LEFT },
{ 0x02bd12, KEY_UP },
{ 0x02bd13, KEY_DOWN },
{ 0x02bd15, KEY_OK },
{ 0x02bd16, KEY_STOP },
{ 0x02bd17, KEY_CAMERA }, /* snapshot */
{ 0x02bd18, KEY_CHANNELUP },
{ 0x02bd19, KEY_RECORD },
{ 0x02bd1a, KEY_CHANNELDOWN },
{ 0x02bd1c, KEY_ESC },
{ 0x02bd1f, KEY_VOLUMEUP },
{ 0x02bd44, KEY_EPG },
{ 0x02bd45, KEY_POWER2 }, /* [red power button] */
};
static struct rc_map_list terratec_slim_map = {
.map = {
.scan = terratec_slim,
.size = ARRAY_SIZE(terratec_slim),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_TERRATEC_SLIM,
}
};
static int __init init_rc_map_terratec_slim(void)
{
return rc_map_register(&terratec_slim_map);
}
static void __exit exit_rc_map_terratec_slim(void)
{
rc_map_unregister(&terratec_slim_map);
}
module_init(init_rc_map_terratec_slim)
module_exit(exit_rc_map_terratec_slim)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-terratec-slim.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* ITE Generic remotes Version 2
*
* Copyright (C) 2012 Malcolm Priestley ([email protected])
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table it913x_v2_rc[] = {
/* Type 1 */
/* 9005 remote */
{ 0x807f12, KEY_POWER2 }, /* Power (RED POWER BUTTON)*/
{ 0x807f1a, KEY_VIDEO }, /* Source */
{ 0x807f1e, KEY_MUTE }, /* Mute */
{ 0x807f01, KEY_RECORD }, /* Record */
{ 0x807f02, KEY_CHANNELUP }, /* Channel+ */
{ 0x807f03, KEY_TIME }, /* TimeShift */
{ 0x807f04, KEY_VOLUMEUP }, /* Volume- */
{ 0x807f05, KEY_SCREEN }, /* FullScreen */
{ 0x807f06, KEY_VOLUMEDOWN }, /* Volume- */
{ 0x807f07, KEY_NUMERIC_0 }, /* 0 */
{ 0x807f08, KEY_CHANNELDOWN }, /* Channel- */
{ 0x807f09, KEY_PREVIOUS }, /* Recall */
{ 0x807f0a, KEY_NUMERIC_1 }, /* 1 */
{ 0x807f1b, KEY_NUMERIC_2 }, /* 2 */
{ 0x807f1f, KEY_NUMERIC_3 }, /* 3 */
{ 0x807f0c, KEY_NUMERIC_4 }, /* 4 */
{ 0x807f0d, KEY_NUMERIC_5 }, /* 5 */
{ 0x807f0e, KEY_NUMERIC_6 }, /* 6 */
{ 0x807f00, KEY_NUMERIC_7 }, /* 7 */
{ 0x807f0f, KEY_NUMERIC_8 }, /* 8 */
{ 0x807f19, KEY_NUMERIC_9 }, /* 9 */
/* Type 2 */
/* keys stereo, snapshot unassigned */
{ 0x866b00, KEY_NUMERIC_0 },
{ 0x866b01, KEY_NUMERIC_1 },
{ 0x866b02, KEY_NUMERIC_2 },
{ 0x866b03, KEY_NUMERIC_3 },
{ 0x866b04, KEY_NUMERIC_4 },
{ 0x866b05, KEY_NUMERIC_5 },
{ 0x866b06, KEY_NUMERIC_6 },
{ 0x866b07, KEY_NUMERIC_7 },
{ 0x866b08, KEY_NUMERIC_8 },
{ 0x866b09, KEY_NUMERIC_9 },
{ 0x866b12, KEY_POWER },
{ 0x866b13, KEY_MUTE },
{ 0x866b0a, KEY_PREVIOUS }, /* Recall */
{ 0x866b1e, KEY_PAUSE },
{ 0x866b0c, KEY_VOLUMEUP },
{ 0x866b18, KEY_VOLUMEDOWN },
{ 0x866b0b, KEY_CHANNELUP },
{ 0x866b18, KEY_CHANNELDOWN },
{ 0x866b10, KEY_ZOOM },
{ 0x866b1d, KEY_RECORD },
{ 0x866b0e, KEY_STOP },
{ 0x866b11, KEY_EPG},
{ 0x866b1a, KEY_FASTFORWARD },
{ 0x866b0f, KEY_REWIND },
{ 0x866b1c, KEY_TV },
{ 0x866b1b, KEY_TEXT },
};
static struct rc_map_list it913x_v2_map = {
.map = {
.scan = it913x_v2_rc,
.size = ARRAY_SIZE(it913x_v2_rc),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_IT913X_V2,
}
};
static int __init init_rc_it913x_v2_map(void)
{
return rc_map_register(&it913x_v2_map);
}
static void __exit exit_rc_it913x_v2_map(void)
{
rc_map_unregister(&it913x_v2_map);
}
module_init(init_rc_it913x_v2_map)
module_exit(exit_rc_it913x_v2_map)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Malcolm Priestley [email protected]");
| linux-master | drivers/media/rc/keymaps/rc-it913x-v2.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* A-Link DTU(m) remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* A-Link DTU(m) slim remote, 6 rows, 3 columns. */
static struct rc_map_table alink_dtu_m[] = {
{ 0x0800, KEY_VOLUMEUP },
{ 0x0801, KEY_NUMERIC_1 },
{ 0x0802, KEY_NUMERIC_3 },
{ 0x0803, KEY_NUMERIC_7 },
{ 0x0804, KEY_NUMERIC_9 },
{ 0x0805, KEY_NEW }, /* symbol: PIP */
{ 0x0806, KEY_NUMERIC_0 },
{ 0x0807, KEY_CHANNEL }, /* JUMP */
{ 0x080d, KEY_NUMERIC_5 },
{ 0x080f, KEY_NUMERIC_2 },
{ 0x0812, KEY_POWER2 },
{ 0x0814, KEY_CHANNELUP },
{ 0x0816, KEY_VOLUMEDOWN },
{ 0x0818, KEY_NUMERIC_6 },
{ 0x081a, KEY_MUTE },
{ 0x081b, KEY_NUMERIC_8 },
{ 0x081c, KEY_NUMERIC_4 },
{ 0x081d, KEY_CHANNELDOWN },
};
static struct rc_map_list alink_dtu_m_map = {
.map = {
.scan = alink_dtu_m,
.size = ARRAY_SIZE(alink_dtu_m),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_ALINK_DTU_M,
}
};
static int __init init_rc_map_alink_dtu_m(void)
{
return rc_map_register(&alink_dtu_m_map);
}
static void __exit exit_rc_map_alink_dtu_m(void)
{
rc_map_unregister(&alink_dtu_m_map);
}
module_init(init_rc_map_alink_dtu_m)
module_exit(exit_rc_map_alink_dtu_m)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-alink-dtu-m.c |
// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2018 Christian Hewitt
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keymap for the Tanix TX3 mini STB remote control
*/
static struct rc_map_table tanix_tx3mini[] = {
{ 0x8051, KEY_POWER },
{ 0x804d, KEY_MUTE },
{ 0x8009, KEY_RED },
{ 0x8011, KEY_GREEN },
{ 0x8054, KEY_YELLOW },
{ 0x804f, KEY_BLUE },
{ 0x8056, KEY_VOLUMEDOWN },
{ 0x80bd, KEY_PREVIOUS },
{ 0x80bb, KEY_NEXT },
{ 0x804e, KEY_VOLUMEUP },
{ 0x8053, KEY_HOME },
{ 0x801b, KEY_BACK },
{ 0x8026, KEY_UP },
{ 0x8028, KEY_DOWN },
{ 0x8025, KEY_LEFT },
{ 0x8027, KEY_RIGHT },
{ 0x800d, KEY_OK },
{ 0x8049, KEY_MENU },
{ 0x8052, KEY_EPG }, // mouse
{ 0x8031, KEY_1 },
{ 0x8032, KEY_2 },
{ 0x8033, KEY_3 },
{ 0x8034, KEY_4 },
{ 0x8035, KEY_5 },
{ 0x8036, KEY_6 },
{ 0x8037, KEY_7 },
{ 0x8038, KEY_8 },
{ 0x8039, KEY_9 },
{ 0x8058, KEY_SUBTITLE }, // 1/a
{ 0x8030, KEY_0 },
{ 0x8044, KEY_DELETE },
};
static struct rc_map_list tanix_tx3mini_map = {
.map = {
.scan = tanix_tx3mini,
.size = ARRAY_SIZE(tanix_tx3mini),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_TANIX_TX3MINI,
}
};
static int __init init_rc_map_tanix_tx3mini(void)
{
return rc_map_register(&tanix_tx3mini_map);
}
static void __exit exit_rc_map_tanix_tx3mini(void)
{
rc_map_unregister(&tanix_tx3mini_map);
}
module_init(init_rc_map_tanix_tx3mini)
module_exit(exit_rc_map_tanix_tx3mini)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-tanix-tx3mini.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* videomate-k100.h - Keytable for videomate_k100 Remote Controller
*
* keymap imported from ir-keymaps.c
*
* Copyright (c) 2010 by Pavel Osnova <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table videomate_k100[] = {
{ 0x01, KEY_POWER },
{ 0x31, KEY_TUNER },
{ 0x33, KEY_VIDEO },
{ 0x2f, KEY_RADIO },
{ 0x30, KEY_CAMERA },
{ 0x2d, KEY_NEW }, /* TV record button */
{ 0x17, KEY_CYCLEWINDOWS },
{ 0x2c, KEY_ANGLE },
{ 0x2b, KEY_LANGUAGE },
{ 0x32, KEY_SEARCH }, /* '...' button */
{ 0x11, KEY_UP },
{ 0x13, KEY_LEFT },
{ 0x15, KEY_OK },
{ 0x14, KEY_RIGHT },
{ 0x12, KEY_DOWN },
{ 0x16, KEY_BACKSPACE },
{ 0x02, KEY_ZOOM }, /* WIN key */
{ 0x04, KEY_INFO },
{ 0x05, KEY_VOLUMEUP },
{ 0x03, KEY_MUTE },
{ 0x07, KEY_CHANNELUP },
{ 0x06, KEY_VOLUMEDOWN },
{ 0x08, KEY_CHANNELDOWN },
{ 0x0c, KEY_RECORD },
{ 0x0e, KEY_STOP },
{ 0x0a, KEY_BACK },
{ 0x0b, KEY_PLAY },
{ 0x09, KEY_FORWARD },
{ 0x10, KEY_PREVIOUS },
{ 0x0d, KEY_PAUSE },
{ 0x0f, KEY_NEXT },
{ 0x1e, KEY_NUMERIC_1 },
{ 0x1f, KEY_NUMERIC_2 },
{ 0x20, KEY_NUMERIC_3 },
{ 0x21, KEY_NUMERIC_4 },
{ 0x22, KEY_NUMERIC_5 },
{ 0x23, KEY_NUMERIC_6 },
{ 0x24, KEY_NUMERIC_7 },
{ 0x25, KEY_NUMERIC_8 },
{ 0x26, KEY_NUMERIC_9 },
{ 0x2a, KEY_NUMERIC_STAR }, /* * key */
{ 0x1d, KEY_NUMERIC_0 },
{ 0x29, KEY_SUBTITLE }, /* # key */
{ 0x27, KEY_CLEAR },
{ 0x34, KEY_SCREEN },
{ 0x28, KEY_ENTER },
{ 0x19, KEY_RED },
{ 0x1a, KEY_GREEN },
{ 0x1b, KEY_YELLOW },
{ 0x1c, KEY_BLUE },
{ 0x18, KEY_TEXT },
};
static struct rc_map_list videomate_k100_map = {
.map = {
.scan = videomate_k100,
.size = ARRAY_SIZE(videomate_k100),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_VIDEOMATE_K100,
}
};
static int __init init_rc_map_videomate_k100(void)
{
return rc_map_register(&videomate_k100_map);
}
static void __exit exit_rc_map_videomate_k100(void)
{
rc_map_unregister(&videomate_k100_map);
}
module_init(init_rc_map_videomate_k100)
module_exit(exit_rc_map_videomate_k100)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Pavel Osnova <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-videomate-m1f.c |
// SPDX-License-Identifier: GPL-2.0+
// avermedia-m135a.c - Keytable for Avermedia M135A Remote Controllers
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
// Copyright (c) 2010 by Herton Ronaldo Krzesinski <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Avermedia M135A with RM-JX and RM-K6 remote controls
*
* On Avermedia M135A with IR model RM-JX, the same codes exist on both
* Positivo (BR) and original IR, initial version and remote control codes
* added by Mauro Carvalho Chehab <[email protected]>
*
* Positivo also ships Avermedia M135A with model RM-K6, extra control
* codes added by Herton Ronaldo Krzesinski <[email protected]>
*/
static struct rc_map_table avermedia_m135a[] = {
/* RM-JX */
{ 0x0200, KEY_POWER2 },
{ 0x022e, KEY_DOT }, /* '.' */
{ 0x0201, KEY_MODE }, /* TV/FM or SOURCE */
{ 0x0205, KEY_NUMERIC_1 },
{ 0x0206, KEY_NUMERIC_2 },
{ 0x0207, KEY_NUMERIC_3 },
{ 0x0209, KEY_NUMERIC_4 },
{ 0x020a, KEY_NUMERIC_5 },
{ 0x020b, KEY_NUMERIC_6 },
{ 0x020d, KEY_NUMERIC_7 },
{ 0x020e, KEY_NUMERIC_8 },
{ 0x020f, KEY_NUMERIC_9 },
{ 0x0211, KEY_NUMERIC_0 },
{ 0x0213, KEY_RIGHT }, /* -> or L */
{ 0x0212, KEY_LEFT }, /* <- or R */
{ 0x0215, KEY_MENU },
{ 0x0217, KEY_CAMERA }, /* Capturar Imagem or Snapshot */
{ 0x0210, KEY_SHUFFLE }, /* Amostra or 16 chan prev */
{ 0x0303, KEY_CHANNELUP },
{ 0x0302, KEY_CHANNELDOWN },
{ 0x021f, KEY_VOLUMEUP },
{ 0x021e, KEY_VOLUMEDOWN },
{ 0x020c, KEY_ENTER }, /* Full Screen */
{ 0x0214, KEY_MUTE },
{ 0x0208, KEY_AUDIO },
{ 0x0203, KEY_TEXT }, /* Teletext */
{ 0x0204, KEY_EPG },
{ 0x022b, KEY_TV2 }, /* TV2 or PIP */
{ 0x021d, KEY_RED },
{ 0x021c, KEY_YELLOW },
{ 0x0301, KEY_GREEN },
{ 0x0300, KEY_BLUE },
{ 0x021a, KEY_PLAYPAUSE },
{ 0x0219, KEY_RECORD },
{ 0x0218, KEY_PLAY },
{ 0x021b, KEY_STOP },
/* RM-K6 */
{ 0x0401, KEY_POWER2 },
{ 0x0406, KEY_MUTE },
{ 0x0408, KEY_MODE }, /* TV/FM */
{ 0x0409, KEY_NUMERIC_1 },
{ 0x040a, KEY_NUMERIC_2 },
{ 0x040b, KEY_NUMERIC_3 },
{ 0x040c, KEY_NUMERIC_4 },
{ 0x040d, KEY_NUMERIC_5 },
{ 0x040e, KEY_NUMERIC_6 },
{ 0x040f, KEY_NUMERIC_7 },
{ 0x0410, KEY_NUMERIC_8 },
{ 0x0411, KEY_NUMERIC_9 },
{ 0x044c, KEY_DOT }, /* '.' */
{ 0x0412, KEY_NUMERIC_0 },
{ 0x0407, KEY_REFRESH }, /* Refresh/Reload */
{ 0x0413, KEY_AUDIO },
{ 0x0440, KEY_SCREEN }, /* Full Screen toggle */
{ 0x0441, KEY_HOME },
{ 0x0442, KEY_BACK },
{ 0x0447, KEY_UP },
{ 0x0448, KEY_DOWN },
{ 0x0449, KEY_LEFT },
{ 0x044a, KEY_RIGHT },
{ 0x044b, KEY_OK },
{ 0x0404, KEY_VOLUMEUP },
{ 0x0405, KEY_VOLUMEDOWN },
{ 0x0402, KEY_CHANNELUP },
{ 0x0403, KEY_CHANNELDOWN },
{ 0x0443, KEY_RED },
{ 0x0444, KEY_GREEN },
{ 0x0445, KEY_YELLOW },
{ 0x0446, KEY_BLUE },
{ 0x0414, KEY_TEXT },
{ 0x0415, KEY_EPG },
{ 0x041a, KEY_TV2 }, /* PIP */
{ 0x041b, KEY_CAMERA }, /* Snapshot */
{ 0x0417, KEY_RECORD },
{ 0x0416, KEY_PLAYPAUSE },
{ 0x0418, KEY_STOP },
{ 0x0419, KEY_PAUSE },
{ 0x041f, KEY_PREVIOUS },
{ 0x041c, KEY_REWIND },
{ 0x041d, KEY_FORWARD },
{ 0x041e, KEY_NEXT },
};
static struct rc_map_list avermedia_m135a_map = {
.map = {
.scan = avermedia_m135a,
.size = ARRAY_SIZE(avermedia_m135a),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_AVERMEDIA_M135A,
}
};
static int __init init_rc_map_avermedia_m135a(void)
{
return rc_map_register(&avermedia_m135a_map);
}
static void __exit exit_rc_map_avermedia_m135a(void)
{
rc_map_unregister(&avermedia_m135a_map);
}
module_init(init_rc_map_avermedia_m135a)
module_exit(exit_rc_map_avermedia_m135a)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-avermedia-m135a.c |
// SPDX-License-Identifier: GPL-2.0+
// videomate-s350.h - Keytable for videomate_s350 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table videomate_s350[] = {
{ 0x00, KEY_TV},
{ 0x01, KEY_DVD},
{ 0x04, KEY_RECORD},
{ 0x05, KEY_VIDEO}, /* TV/Video */
{ 0x07, KEY_STOP},
{ 0x08, KEY_PLAYPAUSE},
{ 0x0a, KEY_REWIND},
{ 0x0f, KEY_FASTFORWARD},
{ 0x10, KEY_CHANNELUP},
{ 0x12, KEY_VOLUMEUP},
{ 0x13, KEY_CHANNELDOWN},
{ 0x14, KEY_MUTE},
{ 0x15, KEY_VOLUMEDOWN},
{ 0x16, KEY_NUMERIC_1},
{ 0x17, KEY_NUMERIC_2},
{ 0x18, KEY_NUMERIC_3},
{ 0x19, KEY_NUMERIC_4},
{ 0x1a, KEY_NUMERIC_5},
{ 0x1b, KEY_NUMERIC_6},
{ 0x1c, KEY_NUMERIC_7},
{ 0x1d, KEY_NUMERIC_8},
{ 0x1e, KEY_NUMERIC_9},
{ 0x1f, KEY_NUMERIC_0},
{ 0x21, KEY_SLEEP},
{ 0x24, KEY_ZOOM},
{ 0x25, KEY_LAST}, /* Recall */
{ 0x26, KEY_SUBTITLE}, /* CC */
{ 0x27, KEY_LANGUAGE}, /* MTS */
{ 0x29, KEY_CHANNEL}, /* SURF */
{ 0x2b, KEY_A},
{ 0x2c, KEY_B},
{ 0x2f, KEY_CAMERA}, /* Snapshot */
{ 0x23, KEY_RADIO},
{ 0x02, KEY_PREVIOUSSONG},
{ 0x06, KEY_NEXTSONG},
{ 0x03, KEY_EPG},
{ 0x09, KEY_SETUP},
{ 0x22, KEY_BACKSPACE},
{ 0x0c, KEY_UP},
{ 0x0e, KEY_DOWN},
{ 0x0b, KEY_LEFT},
{ 0x0d, KEY_RIGHT},
{ 0x11, KEY_ENTER},
{ 0x20, KEY_TEXT},
};
static struct rc_map_list videomate_s350_map = {
.map = {
.scan = videomate_s350,
.size = ARRAY_SIZE(videomate_s350),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_VIDEOMATE_S350,
}
};
static int __init init_rc_map_videomate_s350(void)
{
return rc_map_register(&videomate_s350_map);
}
static void __exit exit_rc_map_videomate_s350(void)
{
rc_map_unregister(&videomate_s350_map);
}
module_init(init_rc_map_videomate_s350)
module_exit(exit_rc_map_videomate_s350)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-videomate-s350.c |
// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2020 Christian Hewitt
#include <media/rc-map.h>
#include <linux/module.h>
/*
* KHAMSIN is an IR/Bluetooth RCU supplied with the SmartLabs
* SML-5442TW DVB-S/VOD box. The RCU has separate IR (TV) and
* BT (STB) modes. This keymap suppors the IR controls.
*/
static struct rc_map_table khamsin[] = {
{ 0x70702, KEY_POWER},
{ 0x70701, KEY_VIDEO}, // source
{ 0x7076c, KEY_RED},
{ 0x70714, KEY_GREEN},
{ 0x70715, KEY_YELLOW},
{ 0x70716, KEY_BLUE},
{ 0x7071a, KEY_MENU},
{ 0x7074f, KEY_EPG},
{ 0x70760, KEY_UP },
{ 0x70761, KEY_DOWN },
{ 0x70765, KEY_LEFT },
{ 0x70762, KEY_RIGHT },
{ 0x70768, KEY_ENTER },
{ 0x7072d, KEY_ESC }, // back
{ 0x70707, KEY_VOLUMEUP },
{ 0x7070b, KEY_VOLUMEDOWN },
{ 0x7070f, KEY_MUTE },
{ 0x70712, KEY_CHANNELUP },
{ 0x70710, KEY_CHANNELDOWN },
{ 0x70704, KEY_1 },
{ 0x70705, KEY_2 },
{ 0x70706, KEY_3 },
{ 0x70708, KEY_4 },
{ 0x70709, KEY_5 },
{ 0x7070a, KEY_6 },
{ 0x7070c, KEY_7 },
{ 0x7070d, KEY_8 },
{ 0x7070e, KEY_9 },
{ 0x70711, KEY_0 },
};
static struct rc_map_list khamsin_map = {
.map = {
.scan = khamsin,
.size = ARRAY_SIZE(khamsin),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_KHAMSIN,
}
};
static int __init init_rc_map_khamsin(void)
{
return rc_map_register(&khamsin_map);
}
static void __exit exit_rc_map_khamsin(void)
{
rc_map_unregister(&khamsin_map);
}
module_init(init_rc_map_khamsin)
module_exit(exit_rc_map_khamsin)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-khamsin.c |
// SPDX-License-Identifier: GPL-2.0+
// avermedia-dvbt.h - Keytable for avermedia_dvbt Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Matt Jesson <[email protected] */
static struct rc_map_table avermedia_dvbt[] = {
{ 0x28, KEY_NUMERIC_0 }, /* '0' / 'enter' */
{ 0x22, KEY_NUMERIC_1 }, /* '1' */
{ 0x12, KEY_NUMERIC_2 }, /* '2' / 'up arrow' */
{ 0x32, KEY_NUMERIC_3 }, /* '3' */
{ 0x24, KEY_NUMERIC_4 }, /* '4' / 'left arrow' */
{ 0x14, KEY_NUMERIC_5 }, /* '5' */
{ 0x34, KEY_NUMERIC_6 }, /* '6' / 'right arrow' */
{ 0x26, KEY_NUMERIC_7 }, /* '7' */
{ 0x16, KEY_NUMERIC_8 }, /* '8' / 'down arrow' */
{ 0x36, KEY_NUMERIC_9 }, /* '9' */
{ 0x20, KEY_VIDEO }, /* 'source' */
{ 0x10, KEY_TEXT }, /* 'teletext' */
{ 0x00, KEY_POWER }, /* 'power' */
{ 0x04, KEY_AUDIO }, /* 'audio' */
{ 0x06, KEY_ZOOM }, /* 'full screen' */
{ 0x18, KEY_SWITCHVIDEOMODE }, /* 'display' */
{ 0x38, KEY_SEARCH }, /* 'loop' */
{ 0x08, KEY_INFO }, /* 'preview' */
{ 0x2a, KEY_REWIND }, /* 'backward <<' */
{ 0x1a, KEY_FASTFORWARD }, /* 'forward >>' */
{ 0x3a, KEY_RECORD }, /* 'capture' */
{ 0x0a, KEY_MUTE }, /* 'mute' */
{ 0x2c, KEY_RECORD }, /* 'record' */
{ 0x1c, KEY_PAUSE }, /* 'pause' */
{ 0x3c, KEY_STOP }, /* 'stop' */
{ 0x0c, KEY_PLAY }, /* 'play' */
{ 0x2e, KEY_RED }, /* 'red' */
{ 0x01, KEY_BLUE }, /* 'blue' / 'cancel' */
{ 0x0e, KEY_YELLOW }, /* 'yellow' / 'ok' */
{ 0x21, KEY_GREEN }, /* 'green' */
{ 0x11, KEY_CHANNELDOWN }, /* 'channel -' */
{ 0x31, KEY_CHANNELUP }, /* 'channel +' */
{ 0x1e, KEY_VOLUMEDOWN }, /* 'volume -' */
{ 0x3e, KEY_VOLUMEUP }, /* 'volume +' */
};
static struct rc_map_list avermedia_dvbt_map = {
.map = {
.scan = avermedia_dvbt,
.size = ARRAY_SIZE(avermedia_dvbt),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_AVERMEDIA_DVBT,
}
};
static int __init init_rc_map_avermedia_dvbt(void)
{
return rc_map_register(&avermedia_dvbt_map);
}
static void __exit exit_rc_map_avermedia_dvbt(void)
{
rc_map_unregister(&avermedia_dvbt_map);
}
module_init(init_rc_map_avermedia_dvbt)
module_exit(exit_rc_map_avermedia_dvbt)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-avermedia-dvbt.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* TerraTec remote controller keytable
*
* Copyright (C) 2011 Martin Groszhauser <[email protected]>
* Copyright (C) 2011 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/*
* TerraTec slim remote, 6 rows, 3 columns.
* Keytable from Martin Groszhauser <[email protected]>
*/
static struct rc_map_table terratec_slim_2[] = {
{ 0x8001, KEY_MUTE }, /* MUTE */
{ 0x8002, KEY_VOLUMEDOWN },
{ 0x8003, KEY_CHANNELDOWN },
{ 0x8004, KEY_NUMERIC_1 },
{ 0x8005, KEY_NUMERIC_2 },
{ 0x8006, KEY_NUMERIC_3 },
{ 0x8007, KEY_NUMERIC_4 },
{ 0x8008, KEY_NUMERIC_5 },
{ 0x8009, KEY_NUMERIC_6 },
{ 0x800a, KEY_NUMERIC_7 },
{ 0x800c, KEY_ZOOM }, /* [fullscreen] */
{ 0x800d, KEY_NUMERIC_0 },
{ 0x800e, KEY_AGAIN }, /* [two arrows forming a circle] */
{ 0x8012, KEY_POWER2 }, /* [red power button] */
{ 0x801a, KEY_VOLUMEUP },
{ 0x801b, KEY_NUMERIC_8 },
{ 0x801e, KEY_CHANNELUP },
{ 0x801f, KEY_NUMERIC_9 },
};
static struct rc_map_list terratec_slim_2_map = {
.map = {
.scan = terratec_slim_2,
.size = ARRAY_SIZE(terratec_slim_2),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_TERRATEC_SLIM_2,
}
};
static int __init init_rc_map_terratec_slim_2(void)
{
return rc_map_register(&terratec_slim_2_map);
}
static void __exit exit_rc_map_terratec_slim_2(void)
{
rc_map_unregister(&terratec_slim_2_map);
}
module_init(init_rc_map_terratec_slim_2)
module_exit(exit_rc_map_terratec_slim_2)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-terratec-slim-2.c |
// SPDX-License-Identifier: GPL-2.0-only
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table twinhan_vp1027[] = {
{ 0x16, KEY_POWER2 },
{ 0x17, KEY_FAVORITES },
{ 0x0f, KEY_TEXT },
{ 0x48, KEY_INFO},
{ 0x1c, KEY_EPG },
{ 0x04, KEY_LIST },
{ 0x03, KEY_NUMERIC_1 },
{ 0x01, KEY_NUMERIC_2 },
{ 0x06, KEY_NUMERIC_3 },
{ 0x09, KEY_NUMERIC_4 },
{ 0x1d, KEY_NUMERIC_5 },
{ 0x1f, KEY_NUMERIC_6 },
{ 0x0d, KEY_NUMERIC_7 },
{ 0x19, KEY_NUMERIC_8 },
{ 0x1b, KEY_NUMERIC_9 },
{ 0x15, KEY_NUMERIC_0 },
{ 0x0c, KEY_CANCEL },
{ 0x4a, KEY_CLEAR },
{ 0x13, KEY_BACKSPACE },
{ 0x00, KEY_TAB },
{ 0x4b, KEY_UP },
{ 0x51, KEY_DOWN },
{ 0x4e, KEY_LEFT },
{ 0x52, KEY_RIGHT },
{ 0x4f, KEY_ENTER },
{ 0x1e, KEY_VOLUMEUP },
{ 0x0a, KEY_VOLUMEDOWN },
{ 0x02, KEY_CHANNELDOWN },
{ 0x05, KEY_CHANNELUP },
{ 0x11, KEY_RECORD },
{ 0x14, KEY_PLAY },
{ 0x4c, KEY_PAUSE },
{ 0x1a, KEY_STOP },
{ 0x40, KEY_REWIND },
{ 0x12, KEY_FASTFORWARD },
{ 0x41, KEY_PREVIOUSSONG },
{ 0x42, KEY_NEXTSONG },
{ 0x54, KEY_SAVE },
{ 0x50, KEY_LANGUAGE },
{ 0x47, KEY_MEDIA },
{ 0x4d, KEY_SCREEN },
{ 0x43, KEY_SUBTITLE },
{ 0x10, KEY_MUTE },
{ 0x49, KEY_AUDIO },
{ 0x07, KEY_SLEEP },
{ 0x08, KEY_VIDEO },
{ 0x0e, KEY_AGAIN },
{ 0x45, KEY_EQUAL },
{ 0x46, KEY_MINUS },
{ 0x18, KEY_RED },
{ 0x53, KEY_GREEN },
{ 0x5e, KEY_YELLOW },
{ 0x5f, KEY_BLUE },
};
static struct rc_map_list twinhan_vp1027_map = {
.map = {
.scan = twinhan_vp1027,
.size = ARRAY_SIZE(twinhan_vp1027),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_TWINHAN_VP1027_DVBS,
}
};
static int __init init_rc_map_twinhan_vp1027(void)
{
return rc_map_register(&twinhan_vp1027_map);
}
static void __exit exit_rc_map_twinhan_vp1027(void)
{
rc_map_unregister(&twinhan_vp1027_map);
}
module_init(init_rc_map_twinhan_vp1027)
module_exit(exit_rc_map_twinhan_vp1027)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Sergey Ivanov <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-twinhan1027.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* TwinHan AzureWave AD-TU700(704J) remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table azurewave_ad_tu700[] = {
{ 0x0000, KEY_TAB }, /* Tab */
{ 0x0001, KEY_NUMERIC_2 },
{ 0x0002, KEY_CHANNELDOWN },
{ 0x0003, KEY_NUMERIC_1 },
{ 0x0004, KEY_MENU }, /* Record List */
{ 0x0005, KEY_CHANNELUP },
{ 0x0006, KEY_NUMERIC_3 },
{ 0x0007, KEY_SLEEP }, /* Hibernate */
{ 0x0008, KEY_VIDEO }, /* A/V */
{ 0x0009, KEY_NUMERIC_4 },
{ 0x000a, KEY_VOLUMEDOWN },
{ 0x000c, KEY_CANCEL }, /* Cancel */
{ 0x000d, KEY_NUMERIC_7 },
{ 0x000e, KEY_AGAIN }, /* Recall */
{ 0x000f, KEY_TEXT }, /* Teletext */
{ 0x0010, KEY_MUTE },
{ 0x0011, KEY_RECORD },
{ 0x0012, KEY_FASTFORWARD }, /* FF >> */
{ 0x0013, KEY_BACK }, /* Back */
{ 0x0014, KEY_PLAY },
{ 0x0015, KEY_NUMERIC_0 },
{ 0x0016, KEY_POWER2 }, /* [red power button] */
{ 0x0017, KEY_FAVORITES }, /* Favorite List */
{ 0x0018, KEY_RED },
{ 0x0019, KEY_NUMERIC_8 },
{ 0x001a, KEY_STOP },
{ 0x001b, KEY_NUMERIC_9 },
{ 0x001c, KEY_EPG }, /* Info/EPG */
{ 0x001d, KEY_NUMERIC_5 },
{ 0x001e, KEY_VOLUMEUP },
{ 0x001f, KEY_NUMERIC_6 },
{ 0x0040, KEY_REWIND }, /* FR << */
{ 0x0041, KEY_PREVIOUS }, /* Replay */
{ 0x0042, KEY_NEXT }, /* Skip */
{ 0x0043, KEY_SUBTITLE }, /* Subtitle / CC */
{ 0x0045, KEY_KPPLUS }, /* Zoom+ */
{ 0x0046, KEY_KPMINUS }, /* Zoom- */
{ 0x0047, KEY_NEW }, /* PIP */
{ 0x0048, KEY_INFO }, /* Preview */
{ 0x0049, KEY_MODE }, /* L/R */
{ 0x004a, KEY_CLEAR }, /* Clear */
{ 0x004b, KEY_UP }, /* up arrow */
{ 0x004c, KEY_PAUSE },
{ 0x004d, KEY_ZOOM }, /* Full Screen */
{ 0x004e, KEY_LEFT }, /* left arrow */
{ 0x004f, KEY_OK }, /* Enter / ok */
{ 0x0050, KEY_LANGUAGE }, /* SAP */
{ 0x0051, KEY_DOWN }, /* down arrow */
{ 0x0052, KEY_RIGHT }, /* right arrow */
{ 0x0053, KEY_GREEN },
{ 0x0054, KEY_CAMERA }, /* Capture */
{ 0x005e, KEY_YELLOW },
{ 0x005f, KEY_BLUE },
};
static struct rc_map_list azurewave_ad_tu700_map = {
.map = {
.scan = azurewave_ad_tu700,
.size = ARRAY_SIZE(azurewave_ad_tu700),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_AZUREWAVE_AD_TU700,
}
};
static int __init init_rc_map_azurewave_ad_tu700(void)
{
return rc_map_register(&azurewave_ad_tu700_map);
}
static void __exit exit_rc_map_azurewave_ad_tu700(void)
{
rc_map_unregister(&azurewave_ad_tu700_map);
}
module_init(init_rc_map_azurewave_ad_tu700)
module_exit(exit_rc_map_azurewave_ad_tu700)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-azurewave-ad-tu700.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Keytable for remote controller of HiSilicon tv demo board.
*
* Copyright (c) 2017 HiSilicon Technologies Co., Ltd.
*/
#include <linux/module.h>
#include <media/rc-map.h>
static struct rc_map_table hisi_tv_demo_keymap[] = {
{ 0x00000092, KEY_NUMERIC_1},
{ 0x00000093, KEY_NUMERIC_2},
{ 0x000000cc, KEY_NUMERIC_3},
{ 0x0000009f, KEY_NUMERIC_4},
{ 0x0000008e, KEY_NUMERIC_5},
{ 0x0000008f, KEY_NUMERIC_6},
{ 0x000000c8, KEY_NUMERIC_7},
{ 0x00000094, KEY_NUMERIC_8},
{ 0x0000008a, KEY_NUMERIC_9},
{ 0x0000008b, KEY_NUMERIC_0},
{ 0x000000ce, KEY_ENTER},
{ 0x000000ca, KEY_UP},
{ 0x00000099, KEY_LEFT},
{ 0x00000084, KEY_PAGEUP},
{ 0x000000c1, KEY_RIGHT},
{ 0x000000d2, KEY_DOWN},
{ 0x00000089, KEY_PAGEDOWN},
{ 0x000000d1, KEY_MUTE},
{ 0x00000098, KEY_VOLUMEDOWN},
{ 0x00000090, KEY_VOLUMEUP},
{ 0x0000009c, KEY_POWER},
{ 0x000000d6, KEY_STOP},
{ 0x00000097, KEY_MENU},
{ 0x000000cb, KEY_BACK},
{ 0x000000da, KEY_PLAYPAUSE},
{ 0x00000080, KEY_INFO},
{ 0x000000c3, KEY_REWIND},
{ 0x00000087, KEY_HOMEPAGE},
{ 0x000000d0, KEY_FASTFORWARD},
{ 0x000000c4, KEY_SOUND},
{ 0x00000082, BTN_1},
{ 0x000000c7, BTN_2},
{ 0x00000086, KEY_PROGRAM},
{ 0x000000d9, KEY_SUBTITLE},
{ 0x00000085, KEY_ZOOM},
{ 0x0000009b, KEY_RED},
{ 0x0000009a, KEY_GREEN},
{ 0x000000c0, KEY_YELLOW},
{ 0x000000c2, KEY_BLUE},
{ 0x0000009d, KEY_CHANNELDOWN},
{ 0x000000cf, KEY_CHANNELUP},
};
static struct rc_map_list hisi_tv_demo_map = {
.map = {
.scan = hisi_tv_demo_keymap,
.size = ARRAY_SIZE(hisi_tv_demo_keymap),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_HISI_TV_DEMO,
}
};
static int __init init_rc_map_hisi_tv_demo(void)
{
return rc_map_register(&hisi_tv_demo_map);
}
static void __exit exit_rc_map_hisi_tv_demo(void)
{
rc_map_unregister(&hisi_tv_demo_map);
}
module_init(init_rc_map_hisi_tv_demo)
module_exit(exit_rc_map_hisi_tv_demo)
MODULE_LICENSE("GPL v2");
| linux-master | drivers/media/rc/keymaps/rc-hisi-tv-demo.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* AverMedia RM-KS remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* Initial keytable is from Jose Alberto Reguero <[email protected]>
and Felipe Morales Moreno <[email protected]> */
/* Keytable fixed by Philippe Valembois <[email protected]> */
static struct rc_map_table avermedia_rm_ks[] = {
{ 0x0501, KEY_POWER2 }, /* Power (RED POWER BUTTON) */
{ 0x0502, KEY_CHANNELUP }, /* Channel+ */
{ 0x0503, KEY_CHANNELDOWN }, /* Channel- */
{ 0x0504, KEY_VOLUMEUP }, /* Volume+ */
{ 0x0505, KEY_VOLUMEDOWN }, /* Volume- */
{ 0x0506, KEY_MUTE }, /* Mute */
{ 0x0507, KEY_AGAIN }, /* Recall */
{ 0x0508, KEY_VIDEO }, /* Source */
{ 0x0509, KEY_NUMERIC_1 }, /* 1 */
{ 0x050a, KEY_NUMERIC_2 }, /* 2 */
{ 0x050b, KEY_NUMERIC_3 }, /* 3 */
{ 0x050c, KEY_NUMERIC_4 }, /* 4 */
{ 0x050d, KEY_NUMERIC_5 }, /* 5 */
{ 0x050e, KEY_NUMERIC_6 }, /* 6 */
{ 0x050f, KEY_NUMERIC_7 }, /* 7 */
{ 0x0510, KEY_NUMERIC_8 }, /* 8 */
{ 0x0511, KEY_NUMERIC_9 }, /* 9 */
{ 0x0512, KEY_NUMERIC_0 }, /* 0 */
{ 0x0513, KEY_AUDIO }, /* Audio */
{ 0x0515, KEY_EPG }, /* EPG */
{ 0x0516, KEY_PLAYPAUSE }, /* Play/Pause */
{ 0x0517, KEY_RECORD }, /* Record */
{ 0x0518, KEY_STOP }, /* Stop */
{ 0x051c, KEY_BACK }, /* << */
{ 0x051d, KEY_FORWARD }, /* >> */
{ 0x054d, KEY_INFO }, /* Display information */
{ 0x0556, KEY_ZOOM }, /* Fullscreen */
};
static struct rc_map_list avermedia_rm_ks_map = {
.map = {
.scan = avermedia_rm_ks,
.size = ARRAY_SIZE(avermedia_rm_ks),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_AVERMEDIA_RM_KS,
}
};
static int __init init_rc_map_avermedia_rm_ks(void)
{
return rc_map_register(&avermedia_rm_ks_map);
}
static void __exit exit_rc_map_avermedia_rm_ks(void)
{
rc_map_unregister(&avermedia_rm_ks_map);
}
module_init(init_rc_map_avermedia_rm_ks)
module_exit(exit_rc_map_avermedia_rm_ks)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-avermedia-rm-ks.c |
// SPDX-License-Identifier: GPL-2.0+
// dm1105-nec.h - Keytable for dm1105_nec Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* DVBWorld remotes
Igor M. Liplianin <[email protected]>
*/
static struct rc_map_table dm1105_nec[] = {
{ 0x0a, KEY_POWER2}, /* power */
{ 0x0c, KEY_MUTE}, /* mute */
{ 0x11, KEY_NUMERIC_1},
{ 0x12, KEY_NUMERIC_2},
{ 0x13, KEY_NUMERIC_3},
{ 0x14, KEY_NUMERIC_4},
{ 0x15, KEY_NUMERIC_5},
{ 0x16, KEY_NUMERIC_6},
{ 0x17, KEY_NUMERIC_7},
{ 0x18, KEY_NUMERIC_8},
{ 0x19, KEY_NUMERIC_9},
{ 0x10, KEY_NUMERIC_0},
{ 0x1c, KEY_CHANNELUP}, /* ch+ */
{ 0x0f, KEY_CHANNELDOWN}, /* ch- */
{ 0x1a, KEY_VOLUMEUP}, /* vol+ */
{ 0x0e, KEY_VOLUMEDOWN}, /* vol- */
{ 0x04, KEY_RECORD}, /* rec */
{ 0x09, KEY_CHANNEL}, /* fav */
{ 0x08, KEY_BACKSPACE}, /* rewind */
{ 0x07, KEY_FASTFORWARD}, /* fast */
{ 0x0b, KEY_PAUSE}, /* pause */
{ 0x02, KEY_ESC}, /* cancel */
{ 0x03, KEY_TAB}, /* tab */
{ 0x00, KEY_UP}, /* up */
{ 0x1f, KEY_ENTER}, /* ok */
{ 0x01, KEY_DOWN}, /* down */
{ 0x05, KEY_RECORD}, /* cap */
{ 0x06, KEY_STOP}, /* stop */
{ 0x40, KEY_ZOOM}, /* full */
{ 0x1e, KEY_TV}, /* tvmode */
{ 0x1b, KEY_B}, /* recall */
};
static struct rc_map_list dm1105_nec_map = {
.map = {
.scan = dm1105_nec,
.size = ARRAY_SIZE(dm1105_nec),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_DM1105_NEC,
}
};
static int __init init_rc_map_dm1105_nec(void)
{
return rc_map_register(&dm1105_nec_map);
}
static void __exit exit_rc_map_dm1105_nec(void)
{
rc_map_unregister(&dm1105_nec_map);
}
module_init(init_rc_map_dm1105_nec)
module_exit(exit_rc_map_dm1105_nec)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-dm1105-nec.c |
// SPDX-License-Identifier: GPL-2.0+
// norwood.h - Keytable for norwood Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Norwood Micro (non-Pro) TV Tuner
By Peter Naulls <[email protected]>
Key comments are the functions given in the manual */
static struct rc_map_table norwood[] = {
/* Keys 0 to 9 */
{ 0x20, KEY_NUMERIC_0 },
{ 0x21, KEY_NUMERIC_1 },
{ 0x22, KEY_NUMERIC_2 },
{ 0x23, KEY_NUMERIC_3 },
{ 0x24, KEY_NUMERIC_4 },
{ 0x25, KEY_NUMERIC_5 },
{ 0x26, KEY_NUMERIC_6 },
{ 0x27, KEY_NUMERIC_7 },
{ 0x28, KEY_NUMERIC_8 },
{ 0x29, KEY_NUMERIC_9 },
{ 0x78, KEY_VIDEO }, /* Video Source */
{ 0x2c, KEY_EXIT }, /* Open/Close software */
{ 0x2a, KEY_SELECT }, /* 2 Digit Select */
{ 0x69, KEY_AGAIN }, /* Recall */
{ 0x32, KEY_BRIGHTNESSUP }, /* Brightness increase */
{ 0x33, KEY_BRIGHTNESSDOWN }, /* Brightness decrease */
{ 0x6b, KEY_KPPLUS }, /* (not named >>>>>) */
{ 0x6c, KEY_KPMINUS }, /* (not named <<<<<) */
{ 0x2d, KEY_MUTE }, /* Mute */
{ 0x30, KEY_VOLUMEUP }, /* Volume up */
{ 0x31, KEY_VOLUMEDOWN }, /* Volume down */
{ 0x60, KEY_CHANNELUP }, /* Channel up */
{ 0x61, KEY_CHANNELDOWN }, /* Channel down */
{ 0x3f, KEY_RECORD }, /* Record */
{ 0x37, KEY_PLAY }, /* Play */
{ 0x36, KEY_PAUSE }, /* Pause */
{ 0x2b, KEY_STOP }, /* Stop */
{ 0x67, KEY_FASTFORWARD }, /* Forward */
{ 0x66, KEY_REWIND }, /* Rewind */
{ 0x3e, KEY_SEARCH }, /* Auto Scan */
{ 0x2e, KEY_CAMERA }, /* Capture Video */
{ 0x6d, KEY_MENU }, /* Show/Hide Control */
{ 0x2f, KEY_ZOOM }, /* Full Screen */
{ 0x34, KEY_RADIO }, /* FM */
{ 0x65, KEY_POWER }, /* Computer power */
};
static struct rc_map_list norwood_map = {
.map = {
.scan = norwood,
.size = ARRAY_SIZE(norwood),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_NORWOOD,
}
};
static int __init init_rc_map_norwood(void)
{
return rc_map_register(&norwood_map);
}
static void __exit exit_rc_map_norwood(void)
{
rc_map_unregister(&norwood_map);
}
module_init(init_rc_map_norwood)
module_exit(exit_rc_map_norwood)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-norwood.c |
// SPDX-License-Identifier: GPL-2.0+
// avermedia-cardbus.h - Keytable for avermedia_cardbus Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Oldrich Jedlicka <[email protected]> */
static struct rc_map_table avermedia_cardbus[] = {
{ 0x00, KEY_POWER },
{ 0x01, KEY_TUNER }, /* TV/FM */
{ 0x03, KEY_TEXT }, /* Teletext */
{ 0x04, KEY_EPG },
{ 0x05, KEY_NUMERIC_1 },
{ 0x06, KEY_NUMERIC_2 },
{ 0x07, KEY_NUMERIC_3 },
{ 0x08, KEY_AUDIO },
{ 0x09, KEY_NUMERIC_4 },
{ 0x0a, KEY_NUMERIC_5 },
{ 0x0b, KEY_NUMERIC_6 },
{ 0x0c, KEY_ZOOM }, /* Full screen */
{ 0x0d, KEY_NUMERIC_7 },
{ 0x0e, KEY_NUMERIC_8 },
{ 0x0f, KEY_NUMERIC_9 },
{ 0x10, KEY_PAGEUP }, /* 16-CH PREV */
{ 0x11, KEY_NUMERIC_0 },
{ 0x12, KEY_INFO },
{ 0x13, KEY_AGAIN }, /* CH RTN - channel return */
{ 0x14, KEY_MUTE },
{ 0x15, KEY_EDIT }, /* Autoscan */
{ 0x17, KEY_SAVE }, /* Screenshot */
{ 0x18, KEY_PLAYPAUSE },
{ 0x19, KEY_RECORD },
{ 0x1a, KEY_PLAY },
{ 0x1b, KEY_STOP },
{ 0x1c, KEY_FASTFORWARD },
{ 0x1d, KEY_REWIND },
{ 0x1e, KEY_VOLUMEDOWN },
{ 0x1f, KEY_VOLUMEUP },
{ 0x22, KEY_SLEEP }, /* Sleep */
{ 0x23, KEY_ZOOM }, /* Aspect */
{ 0x26, KEY_SCREEN }, /* Pos */
{ 0x27, KEY_ANGLE }, /* Size */
{ 0x28, KEY_SELECT }, /* Select */
{ 0x29, KEY_BLUE }, /* Blue/Picture */
{ 0x2a, KEY_BACKSPACE }, /* Back */
{ 0x2b, KEY_VIDEO }, /* PIP (Picture-in-picture) */
{ 0x2c, KEY_DOWN },
{ 0x2e, KEY_DOT },
{ 0x2f, KEY_TV }, /* Live TV */
{ 0x32, KEY_LEFT },
{ 0x33, KEY_CLEAR }, /* Clear */
{ 0x35, KEY_RED }, /* Red/TV */
{ 0x36, KEY_UP },
{ 0x37, KEY_HOME }, /* Home */
{ 0x39, KEY_GREEN }, /* Green/Video */
{ 0x3d, KEY_YELLOW }, /* Yellow/Music */
{ 0x3e, KEY_OK }, /* Ok */
{ 0x3f, KEY_RIGHT },
{ 0x40, KEY_NEXT }, /* Next */
{ 0x41, KEY_PREVIOUS }, /* Previous */
{ 0x42, KEY_CHANNELDOWN }, /* Channel down */
{ 0x43, KEY_CHANNELUP }, /* Channel up */
};
static struct rc_map_list avermedia_cardbus_map = {
.map = {
.scan = avermedia_cardbus,
.size = ARRAY_SIZE(avermedia_cardbus),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_AVERMEDIA_CARDBUS,
}
};
static int __init init_rc_map_avermedia_cardbus(void)
{
return rc_map_register(&avermedia_cardbus_map);
}
static void __exit exit_rc_map_avermedia_cardbus(void)
{
rc_map_unregister(&avermedia_cardbus_map);
}
module_init(init_rc_map_avermedia_cardbus)
module_exit(exit_rc_map_avermedia_cardbus)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-avermedia-cardbus.c |
// SPDX-License-Identifier: GPL-2.0+
// winfast.h - Keytable for winfast Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Table for Leadtek Winfast Remote Controls - used by both bttv and cx88 */
static struct rc_map_table winfast[] = {
/* Keys 0 to 9 */
{ 0x12, KEY_NUMERIC_0 },
{ 0x05, KEY_NUMERIC_1 },
{ 0x06, KEY_NUMERIC_2 },
{ 0x07, KEY_NUMERIC_3 },
{ 0x09, KEY_NUMERIC_4 },
{ 0x0a, KEY_NUMERIC_5 },
{ 0x0b, KEY_NUMERIC_6 },
{ 0x0d, KEY_NUMERIC_7 },
{ 0x0e, KEY_NUMERIC_8 },
{ 0x0f, KEY_NUMERIC_9 },
{ 0x00, KEY_POWER2 },
{ 0x1b, KEY_AUDIO }, /* Audio Source */
{ 0x02, KEY_TUNER }, /* TV/FM, not on Y0400052 */
{ 0x1e, KEY_VIDEO }, /* Video Source */
{ 0x16, KEY_INFO }, /* Display information */
{ 0x04, KEY_RIGHT },
{ 0x08, KEY_LEFT },
{ 0x0c, KEY_UP },
{ 0x10, KEY_DOWN },
{ 0x03, KEY_ZOOM }, /* fullscreen */
{ 0x1f, KEY_TEXT }, /* closed caption/teletext */
{ 0x20, KEY_SLEEP },
{ 0x29, KEY_CLEAR }, /* boss key */
{ 0x14, KEY_MUTE },
{ 0x2b, KEY_RED },
{ 0x2c, KEY_GREEN },
{ 0x2d, KEY_YELLOW },
{ 0x2e, KEY_BLUE },
{ 0x18, KEY_KPPLUS }, /* fine tune + , not on Y040052 */
{ 0x19, KEY_KPMINUS }, /* fine tune - , not on Y040052 */
{ 0x2a, KEY_TV2 }, /* PIP (Picture in picture */
{ 0x21, KEY_DOT },
{ 0x13, KEY_ENTER },
{ 0x11, KEY_LAST }, /* Recall (last channel */
{ 0x22, KEY_PREVIOUS },
{ 0x23, KEY_PLAYPAUSE },
{ 0x24, KEY_NEXT },
{ 0x25, KEY_TIME }, /* Time Shifting */
{ 0x26, KEY_STOP },
{ 0x27, KEY_RECORD },
{ 0x28, KEY_CAMERA }, /* Screenshot */
{ 0x2f, KEY_MENU },
{ 0x30, KEY_CANCEL },
{ 0x31, KEY_CHANNEL }, /* Channel Surf */
{ 0x32, KEY_SUBTITLE },
{ 0x33, KEY_LANGUAGE },
{ 0x34, KEY_REWIND },
{ 0x35, KEY_FASTFORWARD },
{ 0x36, KEY_TV },
{ 0x37, KEY_RADIO }, /* FM */
{ 0x38, KEY_DVD },
{ 0x1a, KEY_MODE}, /* change to MCE mode on Y04G0051 */
{ 0x3e, KEY_VOLUMEUP }, /* MCE +VOL, on Y04G0033 */
{ 0x3a, KEY_VOLUMEDOWN }, /* MCE -VOL, on Y04G0033 */
{ 0x3b, KEY_CHANNELUP }, /* MCE +CH, on Y04G0033 */
{ 0x3f, KEY_CHANNELDOWN } /* MCE -CH, on Y04G0033 */
};
static struct rc_map_list winfast_map = {
.map = {
.scan = winfast,
.size = ARRAY_SIZE(winfast),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_WINFAST,
}
};
static int __init init_rc_map_winfast(void)
{
return rc_map_register(&winfast_map);
}
static void __exit exit_rc_map_winfast(void)
{
rc_map_unregister(&winfast_map);
}
module_init(init_rc_map_winfast)
module_exit(exit_rc_map_winfast)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-winfast.c |
// SPDX-License-Identifier: GPL-2.0+
// pinnacle-color.h - Keytable for pinnacle_color Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table pinnacle_color[] = {
{ 0x59, KEY_MUTE },
{ 0x4a, KEY_POWER },
{ 0x18, KEY_TEXT },
{ 0x26, KEY_TV },
{ 0x3d, KEY_PRINT },
{ 0x48, KEY_RED },
{ 0x04, KEY_GREEN },
{ 0x11, KEY_YELLOW },
{ 0x00, KEY_BLUE },
{ 0x2d, KEY_VOLUMEUP },
{ 0x1e, KEY_VOLUMEDOWN },
{ 0x49, KEY_MENU },
{ 0x16, KEY_CHANNELUP },
{ 0x17, KEY_CHANNELDOWN },
{ 0x20, KEY_UP },
{ 0x21, KEY_DOWN },
{ 0x22, KEY_LEFT },
{ 0x23, KEY_RIGHT },
{ 0x0d, KEY_SELECT },
{ 0x08, KEY_BACK },
{ 0x07, KEY_REFRESH },
{ 0x2f, KEY_ZOOM },
{ 0x29, KEY_RECORD },
{ 0x4b, KEY_PAUSE },
{ 0x4d, KEY_REWIND },
{ 0x2e, KEY_PLAY },
{ 0x4e, KEY_FORWARD },
{ 0x53, KEY_PREVIOUS },
{ 0x4c, KEY_STOP },
{ 0x54, KEY_NEXT },
{ 0x69, KEY_NUMERIC_0 },
{ 0x6a, KEY_NUMERIC_1 },
{ 0x6b, KEY_NUMERIC_2 },
{ 0x6c, KEY_NUMERIC_3 },
{ 0x6d, KEY_NUMERIC_4 },
{ 0x6e, KEY_NUMERIC_5 },
{ 0x6f, KEY_NUMERIC_6 },
{ 0x70, KEY_NUMERIC_7 },
{ 0x71, KEY_NUMERIC_8 },
{ 0x72, KEY_NUMERIC_9 },
{ 0x74, KEY_CHANNEL },
{ 0x0a, KEY_BACKSPACE },
};
static struct rc_map_list pinnacle_color_map = {
.map = {
.scan = pinnacle_color,
.size = ARRAY_SIZE(pinnacle_color),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_PINNACLE_COLOR,
}
};
static int __init init_rc_map_pinnacle_color(void)
{
return rc_map_register(&pinnacle_color_map);
}
static void __exit exit_rc_map_pinnacle_color(void)
{
rc_map_unregister(&pinnacle_color_map);
}
module_init(init_rc_map_pinnacle_color)
module_exit(exit_rc_map_pinnacle_color)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pinnacle-color.c |
// SPDX-License-Identifier: GPL-2.0+
// tevii-nec.h - Keytable for tevii_nec Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table tevii_nec[] = {
{ 0x0a, KEY_POWER2},
{ 0x0c, KEY_MUTE},
{ 0x11, KEY_NUMERIC_1},
{ 0x12, KEY_NUMERIC_2},
{ 0x13, KEY_NUMERIC_3},
{ 0x14, KEY_NUMERIC_4},
{ 0x15, KEY_NUMERIC_5},
{ 0x16, KEY_NUMERIC_6},
{ 0x17, KEY_NUMERIC_7},
{ 0x18, KEY_NUMERIC_8},
{ 0x19, KEY_NUMERIC_9},
{ 0x10, KEY_NUMERIC_0},
{ 0x1c, KEY_MENU},
{ 0x0f, KEY_VOLUMEDOWN},
{ 0x1a, KEY_LAST},
{ 0x0e, KEY_OPEN},
{ 0x04, KEY_RECORD},
{ 0x09, KEY_VOLUMEUP},
{ 0x08, KEY_CHANNELUP},
{ 0x07, KEY_PVR},
{ 0x0b, KEY_TIME},
{ 0x02, KEY_RIGHT},
{ 0x03, KEY_LEFT},
{ 0x00, KEY_UP},
{ 0x1f, KEY_OK},
{ 0x01, KEY_DOWN},
{ 0x05, KEY_TUNER},
{ 0x06, KEY_CHANNELDOWN},
{ 0x40, KEY_PLAYPAUSE},
{ 0x1e, KEY_REWIND},
{ 0x1b, KEY_FAVORITES},
{ 0x1d, KEY_BACK},
{ 0x4d, KEY_FASTFORWARD},
{ 0x44, KEY_EPG},
{ 0x4c, KEY_INFO},
{ 0x41, KEY_AB},
{ 0x43, KEY_AUDIO},
{ 0x45, KEY_SUBTITLE},
{ 0x4a, KEY_LIST},
{ 0x46, KEY_F1},
{ 0x47, KEY_F2},
{ 0x5e, KEY_F3},
{ 0x5c, KEY_F4},
{ 0x52, KEY_F5},
{ 0x5a, KEY_F6},
{ 0x56, KEY_MODE},
{ 0x58, KEY_SWITCHVIDEOMODE},
};
static struct rc_map_list tevii_nec_map = {
.map = {
.scan = tevii_nec,
.size = ARRAY_SIZE(tevii_nec),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_TEVII_NEC,
}
};
static int __init init_rc_map_tevii_nec(void)
{
return rc_map_register(&tevii_nec_map);
}
static void __exit exit_rc_map_tevii_nec(void)
{
rc_map_unregister(&tevii_nec_map);
}
module_init(init_rc_map_tevii_nec)
module_exit(exit_rc_map_tevii_nec)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-tevii-nec.c |
// SPDX-License-Identifier: GPL-2.0-only
/*
* keymap imported from cxusb.c
*
* Copyright (C) 2016 Sean Young
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table rc_map_dvico_portable_table[] = {
{ 0x0302, KEY_SETUP }, /* Profile */
{ 0x0343, KEY_POWER2 },
{ 0x0306, KEY_EPG },
{ 0x035a, KEY_BACK },
{ 0x0305, KEY_MENU },
{ 0x0347, KEY_INFO },
{ 0x0301, KEY_TAB },
{ 0x0342, KEY_PREVIOUSSONG },/* Replay */
{ 0x0349, KEY_VOLUMEUP },
{ 0x0309, KEY_VOLUMEDOWN },
{ 0x0354, KEY_CHANNELUP },
{ 0x030b, KEY_CHANNELDOWN },
{ 0x0316, KEY_CAMERA },
{ 0x0340, KEY_TUNER }, /* ATV/DTV */
{ 0x0345, KEY_OPEN },
{ 0x0319, KEY_NUMERIC_1 },
{ 0x0318, KEY_NUMERIC_2 },
{ 0x031b, KEY_NUMERIC_3 },
{ 0x031a, KEY_NUMERIC_4 },
{ 0x0358, KEY_NUMERIC_5 },
{ 0x0359, KEY_NUMERIC_6 },
{ 0x0315, KEY_NUMERIC_7 },
{ 0x0314, KEY_NUMERIC_8 },
{ 0x0317, KEY_NUMERIC_9 },
{ 0x0344, KEY_ANGLE }, /* Aspect */
{ 0x0355, KEY_NUMERIC_0 },
{ 0x0307, KEY_ZOOM },
{ 0x030a, KEY_REWIND },
{ 0x0308, KEY_PLAYPAUSE },
{ 0x034b, KEY_FASTFORWARD },
{ 0x035b, KEY_MUTE },
{ 0x0304, KEY_STOP },
{ 0x0356, KEY_RECORD },
{ 0x0357, KEY_POWER },
{ 0x0341, KEY_UNKNOWN }, /* INPUT */
{ 0x0300, KEY_UNKNOWN }, /* HD */
};
static struct rc_map_list dvico_portable_map = {
.map = {
.scan = rc_map_dvico_portable_table,
.size = ARRAY_SIZE(rc_map_dvico_portable_table),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_DVICO_PORTABLE,
}
};
static int __init init_rc_map_dvico_portable(void)
{
return rc_map_register(&dvico_portable_map);
}
static void __exit exit_rc_map_dvico_portable(void)
{
rc_map_unregister(&dvico_portable_map);
}
module_init(init_rc_map_dvico_portable)
module_exit(exit_rc_map_dvico_portable)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-dvico-portable.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* MSI DIGIVOX mini II remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table msi_digivox_ii[] = {
{ 0x0302, KEY_NUMERIC_2 },
{ 0x0303, KEY_UP }, /* up */
{ 0x0304, KEY_NUMERIC_3 },
{ 0x0305, KEY_CHANNELDOWN },
{ 0x0308, KEY_NUMERIC_5 },
{ 0x0309, KEY_NUMERIC_0 },
{ 0x030b, KEY_NUMERIC_8 },
{ 0x030d, KEY_DOWN }, /* down */
{ 0x0310, KEY_NUMERIC_9 },
{ 0x0311, KEY_NUMERIC_7 },
{ 0x0314, KEY_VOLUMEUP },
{ 0x0315, KEY_CHANNELUP },
{ 0x0316, KEY_OK },
{ 0x0317, KEY_POWER2 },
{ 0x031a, KEY_NUMERIC_1 },
{ 0x031c, KEY_NUMERIC_4 },
{ 0x031d, KEY_NUMERIC_6 },
{ 0x031f, KEY_VOLUMEDOWN },
};
static struct rc_map_list msi_digivox_ii_map = {
.map = {
.scan = msi_digivox_ii,
.size = ARRAY_SIZE(msi_digivox_ii),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_MSI_DIGIVOX_II,
}
};
static int __init init_rc_map_msi_digivox_ii(void)
{
return rc_map_register(&msi_digivox_ii_map);
}
static void __exit exit_rc_map_msi_digivox_ii(void)
{
rc_map_unregister(&msi_digivox_ii_map);
}
module_init(init_rc_map_msi_digivox_ii)
module_exit(exit_rc_map_msi_digivox_ii)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-msi-digivox-ii.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Total Media In Hand remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* Uses NEC extended 0x02bd */
static struct rc_map_table total_media_in_hand[] = {
{ 0x02bd00, KEY_NUMERIC_1 },
{ 0x02bd01, KEY_NUMERIC_2 },
{ 0x02bd02, KEY_NUMERIC_3 },
{ 0x02bd03, KEY_NUMERIC_4 },
{ 0x02bd04, KEY_NUMERIC_5 },
{ 0x02bd05, KEY_NUMERIC_6 },
{ 0x02bd06, KEY_NUMERIC_7 },
{ 0x02bd07, KEY_NUMERIC_8 },
{ 0x02bd08, KEY_NUMERIC_9 },
{ 0x02bd09, KEY_NUMERIC_0 },
{ 0x02bd0a, KEY_MUTE },
{ 0x02bd0b, KEY_CYCLEWINDOWS }, /* yellow, [min / max] */
{ 0x02bd0c, KEY_VIDEO }, /* TV / AV */
{ 0x02bd0e, KEY_VOLUMEDOWN },
{ 0x02bd0f, KEY_TIME }, /* TimeShift */
{ 0x02bd10, KEY_RIGHT }, /* right arrow */
{ 0x02bd11, KEY_LEFT }, /* left arrow */
{ 0x02bd12, KEY_UP }, /* up arrow */
{ 0x02bd13, KEY_DOWN }, /* down arrow */
{ 0x02bd14, KEY_POWER2 }, /* [red] */
{ 0x02bd15, KEY_OK }, /* OK */
{ 0x02bd16, KEY_STOP },
{ 0x02bd17, KEY_CAMERA }, /* Snapshot */
{ 0x02bd18, KEY_CHANNELUP },
{ 0x02bd19, KEY_RECORD },
{ 0x02bd1a, KEY_CHANNELDOWN },
{ 0x02bd1c, KEY_ESC }, /* Esc */
{ 0x02bd1e, KEY_PLAY },
{ 0x02bd1f, KEY_VOLUMEUP },
{ 0x02bd40, KEY_PAUSE },
{ 0x02bd41, KEY_FASTFORWARD }, /* FF >> */
{ 0x02bd42, KEY_REWIND }, /* FR << */
{ 0x02bd43, KEY_ZOOM }, /* [window + mouse pointer] */
{ 0x02bd44, KEY_SHUFFLE }, /* Shuffle */
{ 0x02bd45, KEY_INFO }, /* [red (I)] */
};
static struct rc_map_list total_media_in_hand_map = {
.map = {
.scan = total_media_in_hand,
.size = ARRAY_SIZE(total_media_in_hand),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_TOTAL_MEDIA_IN_HAND,
}
};
static int __init init_rc_map_total_media_in_hand(void)
{
return rc_map_register(&total_media_in_hand_map);
}
static void __exit exit_rc_map_total_media_in_hand(void)
{
rc_map_unregister(&total_media_in_hand_map);
}
module_init(init_rc_map_total_media_in_hand)
module_exit(exit_rc_map_total_media_in_hand)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-total-media-in-hand.c |
// SPDX-License-Identifier: GPL-2.0+
// nebula.h - Keytable for nebula Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table nebula[] = {
{ 0x0000, KEY_NUMERIC_0 },
{ 0x0001, KEY_NUMERIC_1 },
{ 0x0002, KEY_NUMERIC_2 },
{ 0x0003, KEY_NUMERIC_3 },
{ 0x0004, KEY_NUMERIC_4 },
{ 0x0005, KEY_NUMERIC_5 },
{ 0x0006, KEY_NUMERIC_6 },
{ 0x0007, KEY_NUMERIC_7 },
{ 0x0008, KEY_NUMERIC_8 },
{ 0x0009, KEY_NUMERIC_9 },
{ 0x000a, KEY_TV },
{ 0x000b, KEY_AUX },
{ 0x000c, KEY_DVD },
{ 0x000d, KEY_POWER },
{ 0x000e, KEY_CAMERA }, /* labelled 'Picture' */
{ 0x000f, KEY_AUDIO },
{ 0x0010, KEY_INFO },
{ 0x0011, KEY_F13 }, /* 16:9 */
{ 0x0012, KEY_F14 }, /* 14:9 */
{ 0x0013, KEY_EPG },
{ 0x0014, KEY_EXIT },
{ 0x0015, KEY_MENU },
{ 0x0016, KEY_UP },
{ 0x0017, KEY_DOWN },
{ 0x0018, KEY_LEFT },
{ 0x0019, KEY_RIGHT },
{ 0x001a, KEY_ENTER },
{ 0x001b, KEY_CHANNELUP },
{ 0x001c, KEY_CHANNELDOWN },
{ 0x001d, KEY_VOLUMEUP },
{ 0x001e, KEY_VOLUMEDOWN },
{ 0x001f, KEY_RED },
{ 0x0020, KEY_GREEN },
{ 0x0021, KEY_YELLOW },
{ 0x0022, KEY_BLUE },
{ 0x0023, KEY_SUBTITLE },
{ 0x0024, KEY_F15 }, /* AD */
{ 0x0025, KEY_TEXT },
{ 0x0026, KEY_MUTE },
{ 0x0027, KEY_REWIND },
{ 0x0028, KEY_STOP },
{ 0x0029, KEY_PLAY },
{ 0x002a, KEY_FASTFORWARD },
{ 0x002b, KEY_F16 }, /* chapter */
{ 0x002c, KEY_PAUSE },
{ 0x002d, KEY_PLAY },
{ 0x002e, KEY_RECORD },
{ 0x002f, KEY_F17 }, /* picture in picture */
{ 0x0030, KEY_KPPLUS }, /* zoom in */
{ 0x0031, KEY_KPMINUS }, /* zoom out */
{ 0x0032, KEY_F18 }, /* capture */
{ 0x0033, KEY_F19 }, /* web */
{ 0x0034, KEY_EMAIL },
{ 0x0035, KEY_PHONE },
{ 0x0036, KEY_PC },
};
static struct rc_map_list nebula_map = {
.map = {
.scan = nebula,
.size = ARRAY_SIZE(nebula),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_NEBULA,
}
};
static int __init init_rc_map_nebula(void)
{
return rc_map_register(&nebula_map);
}
static void __exit exit_rc_map_nebula(void)
{
rc_map_unregister(&nebula_map);
}
module_init(init_rc_map_nebula)
module_exit(exit_rc_map_nebula)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-nebula.c |
// SPDX-License-Identifier: GPL-2.0+
// flyvideo.h - Keytable for flyvideo Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table flyvideo[] = {
{ 0x0f, KEY_NUMERIC_0 },
{ 0x03, KEY_NUMERIC_1 },
{ 0x04, KEY_NUMERIC_2 },
{ 0x05, KEY_NUMERIC_3 },
{ 0x07, KEY_NUMERIC_4 },
{ 0x08, KEY_NUMERIC_5 },
{ 0x09, KEY_NUMERIC_6 },
{ 0x0b, KEY_NUMERIC_7 },
{ 0x0c, KEY_NUMERIC_8 },
{ 0x0d, KEY_NUMERIC_9 },
{ 0x0e, KEY_MODE }, /* Air/Cable */
{ 0x11, KEY_VIDEO }, /* Video */
{ 0x15, KEY_AUDIO }, /* Audio */
{ 0x00, KEY_POWER }, /* Power */
{ 0x18, KEY_TUNER }, /* AV Source */
{ 0x02, KEY_ZOOM }, /* Fullscreen */
{ 0x1a, KEY_LANGUAGE }, /* Stereo */
{ 0x1b, KEY_MUTE }, /* Mute */
{ 0x14, KEY_VOLUMEUP }, /* Volume + */
{ 0x17, KEY_VOLUMEDOWN },/* Volume - */
{ 0x12, KEY_CHANNELUP },/* Channel + */
{ 0x13, KEY_CHANNELDOWN },/* Channel - */
{ 0x06, KEY_AGAIN }, /* Recall */
{ 0x10, KEY_ENTER }, /* Enter */
{ 0x19, KEY_BACK }, /* Rewind ( <<< ) */
{ 0x1f, KEY_FORWARD }, /* Forward ( >>> ) */
{ 0x0a, KEY_ANGLE }, /* no label, may be used as the PAUSE button */
};
static struct rc_map_list flyvideo_map = {
.map = {
.scan = flyvideo,
.size = ARRAY_SIZE(flyvideo),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_FLYVIDEO,
}
};
static int __init init_rc_map_flyvideo(void)
{
return rc_map_register(&flyvideo_map);
}
static void __exit exit_rc_map_flyvideo(void)
{
rc_map_unregister(&flyvideo_map);
}
module_init(init_rc_map_flyvideo)
module_exit(exit_rc_map_flyvideo)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-flyvideo.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Medion X10 RF remote keytable (Digitainer variant)
*
* Copyright (C) 2012 Anssi Hannula <[email protected]>
*
* This keymap is for a variant that has a distinctive scrollwheel instead of
* up/down buttons (tested with P/N 40009936 / 20018268), reportedly
* originally shipped with Medion Digitainer but now sold separately simply as
* an "X10" remote.
*/
#include <linux/module.h>
#include <media/rc-map.h>
static struct rc_map_table medion_x10_digitainer[] = {
{ 0x02, KEY_POWER },
{ 0x2c, KEY_TV },
{ 0x2d, KEY_VIDEO },
{ 0x04, KEY_DVD }, /* CD/DVD */
{ 0x16, KEY_TEXT }, /* "teletext" icon, i.e. a screen with lines */
{ 0x06, KEY_AUDIO },
{ 0x2e, KEY_RADIO },
{ 0x31, KEY_EPG }, /* a screen with an open book */
{ 0x05, KEY_IMAGES }, /* Photo */
{ 0x2f, KEY_INFO },
{ 0x78, KEY_UP }, /* scrollwheel up 1 notch */
/* 0x79..0x7f: 2-8 notches, driver repeats 0x78 entry */
{ 0x70, KEY_DOWN }, /* scrollwheel down 1 notch */
/* 0x71..0x77: 2-8 notches, driver repeats 0x70 entry */
{ 0x19, KEY_MENU },
{ 0x1d, KEY_LEFT },
{ 0x1e, KEY_OK }, /* scrollwheel press */
{ 0x1f, KEY_RIGHT },
{ 0x20, KEY_BACK },
{ 0x09, KEY_VOLUMEUP },
{ 0x08, KEY_VOLUMEDOWN },
{ 0x00, KEY_MUTE },
{ 0x1b, KEY_SELECT }, /* also has "U" rotated 90 degrees CCW */
{ 0x0b, KEY_CHANNELUP },
{ 0x0c, KEY_CHANNELDOWN },
{ 0x1c, KEY_LAST },
{ 0x32, KEY_RED }, /* also Audio */
{ 0x33, KEY_GREEN }, /* also Subtitle */
{ 0x34, KEY_YELLOW }, /* also Angle */
{ 0x35, KEY_BLUE }, /* also Title */
{ 0x28, KEY_STOP },
{ 0x29, KEY_PAUSE },
{ 0x25, KEY_PLAY },
{ 0x21, KEY_PREVIOUS },
{ 0x18, KEY_CAMERA },
{ 0x23, KEY_NEXT },
{ 0x24, KEY_REWIND },
{ 0x27, KEY_RECORD },
{ 0x26, KEY_FORWARD },
{ 0x0d, KEY_NUMERIC_1 },
{ 0x0e, KEY_NUMERIC_2 },
{ 0x0f, KEY_NUMERIC_3 },
{ 0x10, KEY_NUMERIC_4 },
{ 0x11, KEY_NUMERIC_5 },
{ 0x12, KEY_NUMERIC_6 },
{ 0x13, KEY_NUMERIC_7 },
{ 0x14, KEY_NUMERIC_8 },
{ 0x15, KEY_NUMERIC_9 },
{ 0x17, KEY_NUMERIC_0 },
/* these do not actually exist on this remote, but these scancodes
* exist on all other Medion X10 remotes and adding them here allows
* such remotes to be adequately usable with this keymap in case
* this keymap is wrongly used with them (which is quite possible as
* there are lots of different Medion X10 remotes): */
{ 0x1a, KEY_UP },
{ 0x22, KEY_DOWN },
};
static struct rc_map_list medion_x10_digitainer_map = {
.map = {
.scan = medion_x10_digitainer,
.size = ARRAY_SIZE(medion_x10_digitainer),
.rc_proto = RC_PROTO_OTHER,
.name = RC_MAP_MEDION_X10_DIGITAINER,
}
};
static int __init init_rc_map_medion_x10_digitainer(void)
{
return rc_map_register(&medion_x10_digitainer_map);
}
static void __exit exit_rc_map_medion_x10_digitainer(void)
{
rc_map_unregister(&medion_x10_digitainer_map);
}
module_init(init_rc_map_medion_x10_digitainer)
module_exit(exit_rc_map_medion_x10_digitainer)
MODULE_DESCRIPTION("Medion X10 RF remote keytable (Digitainer variant)");
MODULE_AUTHOR("Anssi Hannula <[email protected]>");
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-medion-x10-digitainer.c |
// SPDX-License-Identifier: GPL-2.0+
// avertv-303.h - Keytable for avertv_303 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* AVERTV STUDIO 303 Remote */
static struct rc_map_table avertv_303[] = {
{ 0x2a, KEY_NUMERIC_1 },
{ 0x32, KEY_NUMERIC_2 },
{ 0x3a, KEY_NUMERIC_3 },
{ 0x4a, KEY_NUMERIC_4 },
{ 0x52, KEY_NUMERIC_5 },
{ 0x5a, KEY_NUMERIC_6 },
{ 0x6a, KEY_NUMERIC_7 },
{ 0x72, KEY_NUMERIC_8 },
{ 0x7a, KEY_NUMERIC_9 },
{ 0x0e, KEY_NUMERIC_0 },
{ 0x02, KEY_POWER },
{ 0x22, KEY_VIDEO },
{ 0x42, KEY_AUDIO },
{ 0x62, KEY_ZOOM },
{ 0x0a, KEY_TV },
{ 0x12, KEY_CD },
{ 0x1a, KEY_TEXT },
{ 0x16, KEY_SUBTITLE },
{ 0x1e, KEY_REWIND },
{ 0x06, KEY_PRINT },
{ 0x2e, KEY_SEARCH },
{ 0x36, KEY_SLEEP },
{ 0x3e, KEY_SHUFFLE },
{ 0x26, KEY_MUTE },
{ 0x4e, KEY_RECORD },
{ 0x56, KEY_PAUSE },
{ 0x5e, KEY_STOP },
{ 0x46, KEY_PLAY },
{ 0x6e, KEY_RED },
{ 0x0b, KEY_GREEN },
{ 0x66, KEY_YELLOW },
{ 0x03, KEY_BLUE },
{ 0x76, KEY_LEFT },
{ 0x7e, KEY_RIGHT },
{ 0x13, KEY_DOWN },
{ 0x1b, KEY_UP },
};
static struct rc_map_list avertv_303_map = {
.map = {
.scan = avertv_303,
.size = ARRAY_SIZE(avertv_303),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_AVERTV_303,
}
};
static int __init init_rc_map_avertv_303(void)
{
return rc_map_register(&avertv_303_map);
}
static void __exit exit_rc_map_avertv_303(void)
{
rc_map_unregister(&avertv_303_map);
}
module_init(init_rc_map_avertv_303)
module_exit(exit_rc_map_avertv_303)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-avertv-303.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc5-imon-pad.c - Keytable for SoundGraph iMON PAD and Antec Veris
* RM-200 Remote Control
*
* Copyright (c) 2010 by Jarod Wilson <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/*
* standard imon remote key table, which isn't really entirely
* "standard", as different receivers decode the same key on the
* same remote to different hex codes, and the silkscreened names
* vary a bit between the SoundGraph and Antec remotes... ugh.
*/
static struct rc_map_table imon_pad[] = {
/* keys sorted mostly by frequency of use to optimize lookups */
{ 0x2a8195b7, KEY_REWIND },
{ 0x298315b7, KEY_REWIND },
{ 0x2b8115b7, KEY_FASTFORWARD },
{ 0x2b8315b7, KEY_FASTFORWARD },
{ 0x2b9115b7, KEY_PREVIOUS },
{ 0x298195b7, KEY_NEXT },
{ 0x2a8115b7, KEY_PLAY },
{ 0x2a8315b7, KEY_PLAY },
{ 0x2a9115b7, KEY_PAUSE },
{ 0x2b9715b7, KEY_STOP },
{ 0x298115b7, KEY_RECORD },
{ 0x01008000, KEY_UP },
{ 0x01007f00, KEY_DOWN },
{ 0x01000080, KEY_LEFT },
{ 0x0100007f, KEY_RIGHT },
{ 0x2aa515b7, KEY_UP },
{ 0x289515b7, KEY_DOWN },
{ 0x29a515b7, KEY_LEFT },
{ 0x2ba515b7, KEY_RIGHT },
{ 0x0200002c, KEY_SPACE }, /* Select/Space */
{ 0x2a9315b7, KEY_SPACE }, /* Select/Space */
{ 0x02000028, KEY_ENTER },
{ 0x28a195b7, KEY_ENTER },
{ 0x288195b7, KEY_EXIT },
{ 0x02000029, KEY_ESC },
{ 0x2bb715b7, KEY_ESC },
{ 0x0200002a, KEY_BACKSPACE },
{ 0x28a115b7, KEY_BACKSPACE },
{ 0x2b9595b7, KEY_MUTE },
{ 0x28a395b7, KEY_VOLUMEUP },
{ 0x28a595b7, KEY_VOLUMEDOWN },
{ 0x289395b7, KEY_CHANNELUP },
{ 0x288795b7, KEY_CHANNELDOWN },
{ 0x0200001e, KEY_NUMERIC_1 },
{ 0x0200001f, KEY_NUMERIC_2 },
{ 0x02000020, KEY_NUMERIC_3 },
{ 0x02000021, KEY_NUMERIC_4 },
{ 0x02000022, KEY_NUMERIC_5 },
{ 0x02000023, KEY_NUMERIC_6 },
{ 0x02000024, KEY_NUMERIC_7 },
{ 0x02000025, KEY_NUMERIC_8 },
{ 0x02000026, KEY_NUMERIC_9 },
{ 0x02000027, KEY_NUMERIC_0 },
{ 0x28b595b7, KEY_NUMERIC_1 },
{ 0x2bb195b7, KEY_NUMERIC_2 },
{ 0x28b195b7, KEY_NUMERIC_3 },
{ 0x2a8595b7, KEY_NUMERIC_4 },
{ 0x299595b7, KEY_NUMERIC_5 },
{ 0x2aa595b7, KEY_NUMERIC_6 },
{ 0x2b9395b7, KEY_NUMERIC_7 },
{ 0x2a8515b7, KEY_NUMERIC_8 },
{ 0x2aa115b7, KEY_NUMERIC_9 },
{ 0x2ba595b7, KEY_NUMERIC_0 },
{ 0x02200025, KEY_NUMERIC_STAR },
{ 0x28b515b7, KEY_NUMERIC_STAR },
{ 0x02200020, KEY_NUMERIC_POUND },
{ 0x29a115b7, KEY_NUMERIC_POUND },
{ 0x2b8515b7, KEY_VIDEO },
{ 0x299195b7, KEY_AUDIO },
{ 0x2ba115b7, KEY_IMAGES },
{ 0x28a515b7, KEY_TV },
{ 0x29a395b7, KEY_DVD },
{ 0x29a295b7, KEY_DVD },
/* the Menu key between DVD and Subtitle on the RM-200... */
{ 0x2ba385b7, KEY_MENU },
{ 0x2ba395b7, KEY_MENU },
{ 0x288515b7, KEY_BOOKMARKS },
{ 0x2ab715b7, KEY_CAMERA }, /* Thumbnail */
{ 0x298595b7, KEY_SUBTITLE },
{ 0x2b8595b7, KEY_LANGUAGE },
{ 0x29a595b7, KEY_ZOOM },
{ 0x2aa395b7, KEY_SCREEN }, /* FullScreen */
{ 0x299115b7, KEY_KEYBOARD },
{ 0x299135b7, KEY_KEYBOARD },
{ 0x01010000, BTN_LEFT },
{ 0x01020000, BTN_RIGHT },
{ 0x01010080, BTN_LEFT },
{ 0x01020080, BTN_RIGHT },
{ 0x688301b7, BTN_LEFT },
{ 0x688481b7, BTN_RIGHT },
{ 0x2a9395b7, KEY_CYCLEWINDOWS }, /* TaskSwitcher */
{ 0x2b8395b7, KEY_TIME }, /* Timer */
{ 0x289115b7, KEY_POWER },
{ 0x29b195b7, KEY_EJECTCD }, /* the one next to play */
{ 0x299395b7, KEY_EJECTCLOSECD }, /* eject (by TaskSw) */
{ 0x02800000, KEY_CONTEXT_MENU }, /* Left Menu */
{ 0x2b8195b7, KEY_CONTEXT_MENU }, /* Left Menu*/
{ 0x02000065, KEY_COMPOSE }, /* RightMenu */
{ 0x28b715b7, KEY_COMPOSE }, /* RightMenu */
{ 0x2ab195b7, KEY_MEDIA }, /* Go or MultiMon */
{ 0x29b715b7, KEY_DASHBOARD }, /* AppLauncher */
};
static struct rc_map_list imon_pad_map = {
.map = {
.scan = imon_pad,
.size = ARRAY_SIZE(imon_pad),
.rc_proto = RC_PROTO_IMON,
.name = RC_MAP_IMON_PAD,
}
};
static int __init init_rc_map_imon_pad(void)
{
return rc_map_register(&imon_pad_map);
}
static void __exit exit_rc_map_imon_pad(void)
{
rc_map_unregister(&imon_pad_map);
}
module_init(init_rc_map_imon_pad)
module_exit(exit_rc_map_imon_pad)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jarod Wilson <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-imon-pad.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* TrekStor remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* TrekStor DVB-T USB Stick remote controller. */
/* Imported from af9015.h.
Initial keytable was from Marc Schneider <[email protected]> */
static struct rc_map_table trekstor[] = {
{ 0x0084, KEY_NUMERIC_0 },
{ 0x0085, KEY_MUTE }, /* Mute */
{ 0x0086, KEY_HOMEPAGE }, /* Home */
{ 0x0087, KEY_UP }, /* Up */
{ 0x0088, KEY_OK }, /* OK */
{ 0x0089, KEY_RIGHT }, /* Right */
{ 0x008a, KEY_FASTFORWARD }, /* Fast forward */
{ 0x008b, KEY_VOLUMEUP }, /* Volume + */
{ 0x008c, KEY_DOWN }, /* Down */
{ 0x008d, KEY_PLAY }, /* Play/Pause */
{ 0x008e, KEY_STOP }, /* Stop */
{ 0x008f, KEY_EPG }, /* Info/EPG */
{ 0x0090, KEY_NUMERIC_7 },
{ 0x0091, KEY_NUMERIC_4 },
{ 0x0092, KEY_NUMERIC_1 },
{ 0x0093, KEY_CHANNELDOWN }, /* Channel - */
{ 0x0094, KEY_NUMERIC_8 },
{ 0x0095, KEY_NUMERIC_5 },
{ 0x0096, KEY_NUMERIC_2 },
{ 0x0097, KEY_CHANNELUP }, /* Channel + */
{ 0x0098, KEY_NUMERIC_9 },
{ 0x0099, KEY_NUMERIC_6 },
{ 0x009a, KEY_NUMERIC_3 },
{ 0x009b, KEY_VOLUMEDOWN }, /* Volume - */
{ 0x009c, KEY_TV }, /* TV */
{ 0x009d, KEY_RECORD }, /* Record */
{ 0x009e, KEY_REWIND }, /* Rewind */
{ 0x009f, KEY_LEFT }, /* Left */
};
static struct rc_map_list trekstor_map = {
.map = {
.scan = trekstor,
.size = ARRAY_SIZE(trekstor),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_TREKSTOR,
}
};
static int __init init_rc_map_trekstor(void)
{
return rc_map_register(&trekstor_map);
}
static void __exit exit_rc_map_trekstor(void)
{
rc_map_unregister(&trekstor_map);
}
module_init(init_rc_map_trekstor)
module_exit(exit_rc_map_trekstor)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-trekstor.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* keytable for Terratec Cinergy C PCI Remote Controller
*
* Copyright (c) 2010 by Igor M. Liplianin <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table terratec_cinergy_c_pci[] = {
{ 0x3e, KEY_POWER},
{ 0x3d, KEY_NUMERIC_1},
{ 0x3c, KEY_NUMERIC_2},
{ 0x3b, KEY_NUMERIC_3},
{ 0x3a, KEY_NUMERIC_4},
{ 0x39, KEY_NUMERIC_5},
{ 0x38, KEY_NUMERIC_6},
{ 0x37, KEY_NUMERIC_7},
{ 0x36, KEY_NUMERIC_8},
{ 0x35, KEY_NUMERIC_9},
{ 0x34, KEY_VIDEO_NEXT}, /* AV */
{ 0x33, KEY_NUMERIC_0},
{ 0x32, KEY_REFRESH},
{ 0x30, KEY_EPG},
{ 0x2f, KEY_UP},
{ 0x2e, KEY_LEFT},
{ 0x2d, KEY_OK},
{ 0x2c, KEY_RIGHT},
{ 0x2b, KEY_DOWN},
{ 0x29, KEY_INFO},
{ 0x28, KEY_RED},
{ 0x27, KEY_GREEN},
{ 0x26, KEY_YELLOW},
{ 0x25, KEY_BLUE},
{ 0x24, KEY_CHANNELUP},
{ 0x23, KEY_VOLUMEUP},
{ 0x22, KEY_MUTE},
{ 0x21, KEY_VOLUMEDOWN},
{ 0x20, KEY_CHANNELDOWN},
{ 0x1f, KEY_PAUSE},
{ 0x1e, KEY_HOME},
{ 0x1d, KEY_MENU}, /* DVD Menu */
{ 0x1c, KEY_SUBTITLE},
{ 0x1b, KEY_TEXT}, /* Teletext */
{ 0x1a, KEY_DELETE},
{ 0x19, KEY_TV},
{ 0x18, KEY_DVD},
{ 0x17, KEY_STOP},
{ 0x16, KEY_VIDEO},
{ 0x15, KEY_AUDIO}, /* Music */
{ 0x14, KEY_SCREEN}, /* Pic */
{ 0x13, KEY_PLAY},
{ 0x12, KEY_BACK},
{ 0x11, KEY_REWIND},
{ 0x10, KEY_FASTFORWARD},
{ 0x0b, KEY_PREVIOUS},
{ 0x07, KEY_RECORD},
{ 0x03, KEY_NEXT},
};
static struct rc_map_list terratec_cinergy_c_pci_map = {
.map = {
.scan = terratec_cinergy_c_pci,
.size = ARRAY_SIZE(terratec_cinergy_c_pci),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_TERRATEC_CINERGY_C_PCI,
}
};
static int __init init_rc_map_terratec_cinergy_c_pci(void)
{
return rc_map_register(&terratec_cinergy_c_pci_map);
}
static void __exit exit_rc_map_terratec_cinergy_c_pci(void)
{
rc_map_unregister(&terratec_cinergy_c_pci_map);
}
module_init(init_rc_map_terratec_cinergy_c_pci);
module_exit(exit_rc_map_terratec_cinergy_c_pci);
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-terratec-cinergy-c-pci.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2018 Sean Young <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
//
// Note that this remote has a stick which its own IR protocol,
// with 16 directions. This is supported by the imon_rsc BPF decoder
// in v4l-utils.
//
static struct rc_map_table imon_rsc[] = {
{ 0x801010, KEY_EXIT },
{ 0x80102f, KEY_POWER },
{ 0x80104a, KEY_SCREENSAVER }, /* Screensaver */
{ 0x801049, KEY_TIME }, /* Timer */
{ 0x801054, KEY_NUMERIC_1 },
{ 0x801055, KEY_NUMERIC_2 },
{ 0x801056, KEY_NUMERIC_3 },
{ 0x801057, KEY_NUMERIC_4 },
{ 0x801058, KEY_NUMERIC_5 },
{ 0x801059, KEY_NUMERIC_6 },
{ 0x80105a, KEY_NUMERIC_7 },
{ 0x80105b, KEY_NUMERIC_8 },
{ 0x80105c, KEY_NUMERIC_9 },
{ 0x801081, KEY_SCREEN }, /* Desktop */
{ 0x80105d, KEY_NUMERIC_0 },
{ 0x801082, KEY_ZOOM }, /* Maximise */
{ 0x801048, KEY_ESC },
{ 0x80104b, KEY_MEDIA }, /* Windows key */
{ 0x801083, KEY_MENU },
{ 0x801045, KEY_APPSELECT }, /* app launcher */
{ 0x801084, KEY_STOP },
{ 0x801046, KEY_CYCLEWINDOWS },
{ 0x801085, KEY_BACKSPACE },
{ 0x801086, KEY_KEYBOARD },
{ 0x801087, KEY_SPACE },
{ 0x80101e, KEY_RESERVED }, /* shift tab */
{ 0x801098, BTN_0 },
{ 0x80101f, KEY_TAB },
{ 0x80101b, BTN_LEFT },
{ 0x80101d, BTN_RIGHT },
{ 0x801016, BTN_MIDDLE }, /* drag and drop */
{ 0x801088, KEY_MUTE },
{ 0x80105e, KEY_VOLUMEDOWN },
{ 0x80105f, KEY_VOLUMEUP },
{ 0x80104c, KEY_PLAY },
{ 0x80104d, KEY_PAUSE },
{ 0x80104f, KEY_EJECTCD },
{ 0x801050, KEY_PREVIOUS },
{ 0x801051, KEY_NEXT },
{ 0x80104e, KEY_STOP },
{ 0x801052, KEY_REWIND },
{ 0x801053, KEY_FASTFORWARD },
{ 0x801089, KEY_FULL_SCREEN } /* full screen */
};
static struct rc_map_list imon_rsc_map = {
.map = {
.scan = imon_rsc,
.size = ARRAY_SIZE(imon_rsc),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_IMON_RSC,
}
};
static int __init init_rc_map_imon_rsc(void)
{
return rc_map_register(&imon_rsc_map);
}
static void __exit exit_rc_map_imon_rsc(void)
{
rc_map_unregister(&imon_rsc_map);
}
module_init(init_rc_map_imon_rsc)
module_exit(exit_rc_map_imon_rsc)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Sean Young <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-imon-rsc.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2019 Christian Hewitt <[email protected]>
/*
* Keytable for the Khadas VIM/EDGE SBC remote control
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table khadas[] = {
{ 0x14, KEY_POWER },
{ 0x03, KEY_UP },
{ 0x02, KEY_DOWN },
{ 0x0e, KEY_LEFT },
{ 0x1a, KEY_RIGHT },
{ 0x07, KEY_OK },
{ 0x01, KEY_BACK },
{ 0x5b, KEY_MUTE }, // mouse
{ 0x13, KEY_MENU },
{ 0x58, KEY_VOLUMEDOWN },
{ 0x0b, KEY_VOLUMEUP },
{ 0x48, KEY_HOME },
};
static struct rc_map_list khadas_map = {
.map = {
.scan = khadas,
.size = ARRAY_SIZE(khadas),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_KHADAS,
}
};
static int __init init_rc_map_khadas(void)
{
return rc_map_register(&khadas_map);
}
static void __exit exit_rc_map_khadas(void)
{
rc_map_unregister(&khadas_map);
}
module_init(init_rc_map_khadas)
module_exit(exit_rc_map_khadas)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-khadas.c |
/* rc-technisat-usb2.c - Keytable for SkyStar HD USB
*
* Copyright (C) 2010 Patrick Boettcher,
* Kernel Labs Inc. PO Box 745, St James, NY 11780
*
* Development was sponsored by Technisat Digital UK Limited, whose
* registered office is Witan Gate House 500 - 600 Witan Gate West,
* Milton Keynes, MK9 1SH
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
*
* THIS PROGRAM IS PROVIDED "AS IS" AND BOTH THE COPYRIGHT HOLDER AND
* TECHNISAT DIGITAL UK LTD DISCLAIM ALL WARRANTIES WITH REGARD TO
* THIS PROGRAM INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY OR
* FITNESS FOR A PARTICULAR PURPOSE. NEITHER THE COPYRIGHT HOLDER
* NOR TECHNISAT DIGITAL UK LIMITED SHALL BE LIABLE FOR ANY SPECIAL,
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS PROGRAM. See the
* GNU General Public License for more details.
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table technisat_usb2[] = {
{0x0a0c, KEY_POWER},
{0x0a01, KEY_NUMERIC_1},
{0x0a02, KEY_NUMERIC_2},
{0x0a03, KEY_NUMERIC_3},
{0x0a0d, KEY_MUTE},
{0x0a04, KEY_NUMERIC_4},
{0x0a05, KEY_NUMERIC_5},
{0x0a06, KEY_NUMERIC_6},
{0x0a38, KEY_VIDEO}, /* EXT */
{0x0a07, KEY_NUMERIC_7},
{0x0a08, KEY_NUMERIC_8},
{0x0a09, KEY_NUMERIC_9},
{0x0a00, KEY_NUMERIC_0},
{0x0a4f, KEY_INFO},
{0x0a20, KEY_CHANNELUP},
{0x0a52, KEY_MENU},
{0x0a11, KEY_VOLUMEUP},
{0x0a57, KEY_OK},
{0x0a10, KEY_VOLUMEDOWN},
{0x0a2f, KEY_EPG},
{0x0a21, KEY_CHANNELDOWN},
{0x0a22, KEY_REFRESH},
{0x0a3c, KEY_TEXT},
{0x0a76, KEY_ENTER}, /* HOOK */
{0x0a0f, KEY_HELP},
{0x0a6b, KEY_RED},
{0x0a6c, KEY_GREEN},
{0x0a6d, KEY_YELLOW},
{0x0a6e, KEY_BLUE},
{0x0a29, KEY_STOP},
{0x0a23, KEY_LANGUAGE},
{0x0a53, KEY_TV},
{0x0a0a, KEY_PROGRAM},
};
static struct rc_map_list technisat_usb2_map = {
.map = {
.scan = technisat_usb2,
.size = ARRAY_SIZE(technisat_usb2),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_TECHNISAT_USB2,
}
};
static int __init init_rc_map(void)
{
return rc_map_register(&technisat_usb2_map);
}
static void __exit exit_rc_map(void)
{
rc_map_unregister(&technisat_usb2_map);
}
module_init(init_rc_map)
module_exit(exit_rc_map)
MODULE_AUTHOR("Patrick Boettcher <[email protected]>");
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-technisat-usb2.c |
// SPDX-License-Identifier: GPL-2.0+
// cinergy.h - Keytable for cinergy Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table cinergy[] = {
{ 0x00, KEY_NUMERIC_0 },
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x0a, KEY_POWER },
{ 0x0b, KEY_MEDIA }, /* app */
{ 0x0c, KEY_ZOOM }, /* zoom/fullscreen */
{ 0x0d, KEY_CHANNELUP }, /* channel */
{ 0x0e, KEY_CHANNELDOWN }, /* channel- */
{ 0x0f, KEY_VOLUMEUP },
{ 0x10, KEY_VOLUMEDOWN },
{ 0x11, KEY_TUNER }, /* AV */
{ 0x12, KEY_NUMLOCK }, /* -/-- */
{ 0x13, KEY_AUDIO }, /* audio */
{ 0x14, KEY_MUTE },
{ 0x15, KEY_UP },
{ 0x16, KEY_DOWN },
{ 0x17, KEY_LEFT },
{ 0x18, KEY_RIGHT },
{ 0x19, BTN_LEFT, },
{ 0x1a, BTN_RIGHT, },
{ 0x1b, KEY_WWW }, /* text */
{ 0x1c, KEY_REWIND },
{ 0x1d, KEY_FORWARD },
{ 0x1e, KEY_RECORD },
{ 0x1f, KEY_PLAY },
{ 0x20, KEY_PREVIOUSSONG },
{ 0x21, KEY_NEXTSONG },
{ 0x22, KEY_PAUSE },
{ 0x23, KEY_STOP },
};
static struct rc_map_list cinergy_map = {
.map = {
.scan = cinergy,
.size = ARRAY_SIZE(cinergy),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_CINERGY,
}
};
static int __init init_rc_map_cinergy(void)
{
return rc_map_register(&cinergy_map);
}
static void __exit exit_rc_map_cinergy(void)
{
rc_map_unregister(&cinergy_map);
}
module_init(init_rc_map_cinergy)
module_exit(exit_rc_map_cinergy)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-cinergy.c |
// SPDX-License-Identifier: GPL-2.0+
// dntv-live-dvbt-pro.h - Keytable for dntv_live_dvbt_pro Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* DigitalNow DNTV Live! DVB-T Pro Remote */
static struct rc_map_table dntv_live_dvbt_pro[] = {
{ 0x16, KEY_POWER },
{ 0x5b, KEY_HOME },
{ 0x55, KEY_TV }, /* live tv */
{ 0x58, KEY_TUNER }, /* digital Radio */
{ 0x5a, KEY_RADIO }, /* FM radio */
{ 0x59, KEY_DVD }, /* dvd menu */
{ 0x03, KEY_NUMERIC_1 },
{ 0x01, KEY_NUMERIC_2 },
{ 0x06, KEY_NUMERIC_3 },
{ 0x09, KEY_NUMERIC_4 },
{ 0x1d, KEY_NUMERIC_5 },
{ 0x1f, KEY_NUMERIC_6 },
{ 0x0d, KEY_NUMERIC_7 },
{ 0x19, KEY_NUMERIC_8 },
{ 0x1b, KEY_NUMERIC_9 },
{ 0x0c, KEY_CANCEL },
{ 0x15, KEY_NUMERIC_0 },
{ 0x4a, KEY_CLEAR },
{ 0x13, KEY_BACK },
{ 0x00, KEY_TAB },
{ 0x4b, KEY_UP },
{ 0x4e, KEY_LEFT },
{ 0x4f, KEY_OK },
{ 0x52, KEY_RIGHT },
{ 0x51, KEY_DOWN },
{ 0x1e, KEY_VOLUMEUP },
{ 0x0a, KEY_VOLUMEDOWN },
{ 0x02, KEY_CHANNELDOWN },
{ 0x05, KEY_CHANNELUP },
{ 0x11, KEY_RECORD },
{ 0x14, KEY_PLAY },
{ 0x4c, KEY_PAUSE },
{ 0x1a, KEY_STOP },
{ 0x40, KEY_REWIND },
{ 0x12, KEY_FASTFORWARD },
{ 0x41, KEY_PREVIOUSSONG }, /* replay |< */
{ 0x42, KEY_NEXTSONG }, /* skip >| */
{ 0x54, KEY_CAMERA }, /* capture */
{ 0x50, KEY_LANGUAGE }, /* sap */
{ 0x47, KEY_TV2 }, /* pip */
{ 0x4d, KEY_SCREEN },
{ 0x43, KEY_SUBTITLE },
{ 0x10, KEY_MUTE },
{ 0x49, KEY_AUDIO }, /* l/r */
{ 0x07, KEY_SLEEP },
{ 0x08, KEY_VIDEO }, /* a/v */
{ 0x0e, KEY_PREVIOUS }, /* recall */
{ 0x45, KEY_ZOOM }, /* zoom + */
{ 0x46, KEY_ANGLE }, /* zoom - */
{ 0x56, KEY_RED },
{ 0x57, KEY_GREEN },
{ 0x5c, KEY_YELLOW },
{ 0x5d, KEY_BLUE },
};
static struct rc_map_list dntv_live_dvbt_pro_map = {
.map = {
.scan = dntv_live_dvbt_pro,
.size = ARRAY_SIZE(dntv_live_dvbt_pro),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_DNTV_LIVE_DVBT_PRO,
}
};
static int __init init_rc_map_dntv_live_dvbt_pro(void)
{
return rc_map_register(&dntv_live_dvbt_pro_map);
}
static void __exit exit_rc_map_dntv_live_dvbt_pro(void)
{
rc_map_unregister(&dntv_live_dvbt_pro_map);
}
module_init(init_rc_map_dntv_live_dvbt_pro)
module_exit(exit_rc_map_dntv_live_dvbt_pro)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-dntv-live-dvbt-pro.c |
// SPDX-License-Identifier: GPL-2.0+
// iodata-bctv7e.h - Keytable for iodata_bctv7e Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* IO-DATA BCTV7E Remote */
static struct rc_map_table iodata_bctv7e[] = {
{ 0x40, KEY_TV },
{ 0x20, KEY_RADIO }, /* FM */
{ 0x60, KEY_EPG },
{ 0x00, KEY_POWER },
/* Keys 0 to 9 */
{ 0x44, KEY_NUMERIC_0 }, /* 10 */
{ 0x50, KEY_NUMERIC_1 },
{ 0x30, KEY_NUMERIC_2 },
{ 0x70, KEY_NUMERIC_3 },
{ 0x48, KEY_NUMERIC_4 },
{ 0x28, KEY_NUMERIC_5 },
{ 0x68, KEY_NUMERIC_6 },
{ 0x58, KEY_NUMERIC_7 },
{ 0x38, KEY_NUMERIC_8 },
{ 0x78, KEY_NUMERIC_9 },
{ 0x10, KEY_L }, /* Live */
{ 0x08, KEY_TIME }, /* Time Shift */
{ 0x18, KEY_PLAYPAUSE }, /* Play */
{ 0x24, KEY_ENTER }, /* 11 */
{ 0x64, KEY_ESC }, /* 12 */
{ 0x04, KEY_M }, /* Multi */
{ 0x54, KEY_VIDEO },
{ 0x34, KEY_CHANNELUP },
{ 0x74, KEY_VOLUMEUP },
{ 0x14, KEY_MUTE },
{ 0x4c, KEY_VCR }, /* SVIDEO */
{ 0x2c, KEY_CHANNELDOWN },
{ 0x6c, KEY_VOLUMEDOWN },
{ 0x0c, KEY_ZOOM },
{ 0x5c, KEY_PAUSE },
{ 0x3c, KEY_RED }, /* || (red) */
{ 0x7c, KEY_RECORD }, /* recording */
{ 0x1c, KEY_STOP },
{ 0x41, KEY_REWIND }, /* backward << */
{ 0x21, KEY_PLAY },
{ 0x61, KEY_FASTFORWARD }, /* forward >> */
{ 0x01, KEY_NEXT }, /* skip >| */
};
static struct rc_map_list iodata_bctv7e_map = {
.map = {
.scan = iodata_bctv7e,
.size = ARRAY_SIZE(iodata_bctv7e),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_IODATA_BCTV7E,
}
};
static int __init init_rc_map_iodata_bctv7e(void)
{
return rc_map_register(&iodata_bctv7e_map);
}
static void __exit exit_rc_map_iodata_bctv7e(void)
{
rc_map_unregister(&iodata_bctv7e_map);
}
module_init(init_rc_map_iodata_bctv7e)
module_exit(exit_rc_map_iodata_bctv7e)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-iodata-bctv7e.c |
// SPDX-License-Identifier: GPL-2.0+
// tt-1500.h - Keytable for tt_1500 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* for the Technotrend 1500 bundled remotes (grey and black): */
static struct rc_map_table tt_1500[] = {
{ 0x1501, KEY_POWER },
{ 0x1502, KEY_SHUFFLE }, /* ? double-arrow key */
{ 0x1503, KEY_NUMERIC_1 },
{ 0x1504, KEY_NUMERIC_2 },
{ 0x1505, KEY_NUMERIC_3 },
{ 0x1506, KEY_NUMERIC_4 },
{ 0x1507, KEY_NUMERIC_5 },
{ 0x1508, KEY_NUMERIC_6 },
{ 0x1509, KEY_NUMERIC_7 },
{ 0x150a, KEY_NUMERIC_8 },
{ 0x150b, KEY_NUMERIC_9 },
{ 0x150c, KEY_NUMERIC_0 },
{ 0x150d, KEY_UP },
{ 0x150e, KEY_LEFT },
{ 0x150f, KEY_OK },
{ 0x1510, KEY_RIGHT },
{ 0x1511, KEY_DOWN },
{ 0x1512, KEY_INFO },
{ 0x1513, KEY_EXIT },
{ 0x1514, KEY_RED },
{ 0x1515, KEY_GREEN },
{ 0x1516, KEY_YELLOW },
{ 0x1517, KEY_BLUE },
{ 0x1518, KEY_MUTE },
{ 0x1519, KEY_TEXT },
{ 0x151a, KEY_MODE }, /* ? TV/Radio */
{ 0x1521, KEY_OPTION },
{ 0x1522, KEY_EPG },
{ 0x1523, KEY_CHANNELUP },
{ 0x1524, KEY_CHANNELDOWN },
{ 0x1525, KEY_VOLUMEUP },
{ 0x1526, KEY_VOLUMEDOWN },
{ 0x1527, KEY_SETUP },
{ 0x153a, KEY_RECORD }, /* these keys are only in the black remote */
{ 0x153b, KEY_PLAY },
{ 0x153c, KEY_STOP },
{ 0x153d, KEY_REWIND },
{ 0x153e, KEY_PAUSE },
{ 0x153f, KEY_FORWARD },
};
static struct rc_map_list tt_1500_map = {
.map = {
.scan = tt_1500,
.size = ARRAY_SIZE(tt_1500),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_TT_1500,
}
};
static int __init init_rc_map_tt_1500(void)
{
return rc_map_register(&tt_1500_map);
}
static void __exit exit_rc_map_tt_1500(void)
{
rc_map_unregister(&tt_1500_map);
}
module_init(init_rc_map_tt_1500)
module_exit(exit_rc_map_tt_1500)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-tt-1500.c |
// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2019 Clément Péron
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keymap for the Beelink GS1 remote control
*/
static struct rc_map_table beelink_gs1_table[] = {
/*
* TV Keys (Power, Learn and Volume)
* { 0x40400d, KEY_TV },
* { 0x80f1, KEY_TV },
* { 0x80f3, KEY_TV },
* { 0x80f4, KEY_TV },
*/
{ 0x8051, KEY_POWER },
{ 0x804d, KEY_MUTE },
{ 0x8040, KEY_CONFIG },
{ 0x8026, KEY_UP },
{ 0x8028, KEY_DOWN },
{ 0x8025, KEY_LEFT },
{ 0x8027, KEY_RIGHT },
{ 0x800d, KEY_OK },
{ 0x8053, KEY_HOME },
{ 0x80bc, KEY_MEDIA },
{ 0x801b, KEY_BACK },
{ 0x8049, KEY_MENU },
{ 0x804e, KEY_VOLUMEUP },
{ 0x8056, KEY_VOLUMEDOWN },
{ 0x8054, KEY_SUBTITLE }, /* Web */
{ 0x8052, KEY_EPG }, /* Media */
{ 0x8041, KEY_CHANNELUP },
{ 0x8042, KEY_CHANNELDOWN },
{ 0x8031, KEY_1 },
{ 0x8032, KEY_2 },
{ 0x8033, KEY_3 },
{ 0x8034, KEY_4 },
{ 0x8035, KEY_5 },
{ 0x8036, KEY_6 },
{ 0x8037, KEY_7 },
{ 0x8038, KEY_8 },
{ 0x8039, KEY_9 },
{ 0x8044, KEY_DELETE },
{ 0x8030, KEY_0 },
{ 0x8058, KEY_MODE }, /* # Input Method */
};
static struct rc_map_list beelink_gs1_map = {
.map = {
.scan = beelink_gs1_table,
.size = ARRAY_SIZE(beelink_gs1_table),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_BEELINK_GS1,
}
};
static int __init init_rc_map_beelink_gs1(void)
{
return rc_map_register(&beelink_gs1_map);
}
static void __exit exit_rc_map_beelink_gs1(void)
{
rc_map_unregister(&beelink_gs1_map);
}
module_init(init_rc_map_beelink_gs1)
module_exit(exit_rc_map_beelink_gs1)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Clément Péron <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-beelink-gs1.c |
// SPDX-License-Identifier: GPL-2.0+
// budget-ci-old.h - Keytable for budget_ci_old Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/*
* From reading the following remotes:
* Zenith Universal 7 / TV Mode 807 / VCR Mode 837
* Hauppauge (from NOVA-CI-s box product)
* This is a "middle of the road" approach, differences are noted
*/
static struct rc_map_table budget_ci_old[] = {
{ 0x00, KEY_NUMERIC_0 },
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x0a, KEY_ENTER },
{ 0x0b, KEY_RED },
{ 0x0c, KEY_POWER }, /* RADIO on Hauppauge */
{ 0x0d, KEY_MUTE },
{ 0x0f, KEY_A }, /* TV on Hauppauge */
{ 0x10, KEY_VOLUMEUP },
{ 0x11, KEY_VOLUMEDOWN },
{ 0x14, KEY_B },
{ 0x1c, KEY_UP },
{ 0x1d, KEY_DOWN },
{ 0x1e, KEY_OPTION }, /* RESERVED on Hauppauge */
{ 0x1f, KEY_BREAK },
{ 0x20, KEY_CHANNELUP },
{ 0x21, KEY_CHANNELDOWN },
{ 0x22, KEY_PREVIOUS }, /* Prev Ch on Zenith, SOURCE on Hauppauge */
{ 0x24, KEY_RESTART },
{ 0x25, KEY_OK },
{ 0x26, KEY_CYCLEWINDOWS }, /* MINIMIZE on Hauppauge */
{ 0x28, KEY_ENTER }, /* VCR mode on Zenith */
{ 0x29, KEY_PAUSE },
{ 0x2b, KEY_RIGHT },
{ 0x2c, KEY_LEFT },
{ 0x2e, KEY_MENU }, /* FULL SCREEN on Hauppauge */
{ 0x30, KEY_SLOW },
{ 0x31, KEY_PREVIOUS }, /* VCR mode on Zenith */
{ 0x32, KEY_REWIND },
{ 0x34, KEY_FASTFORWARD },
{ 0x35, KEY_PLAY },
{ 0x36, KEY_STOP },
{ 0x37, KEY_RECORD },
{ 0x38, KEY_TUNER }, /* TV/VCR on Zenith */
{ 0x3a, KEY_C },
{ 0x3c, KEY_EXIT },
{ 0x3d, KEY_POWER2 },
{ 0x3e, KEY_TUNER },
};
static struct rc_map_list budget_ci_old_map = {
.map = {
.scan = budget_ci_old,
.size = ARRAY_SIZE(budget_ci_old),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_BUDGET_CI_OLD,
}
};
static int __init init_rc_map_budget_ci_old(void)
{
return rc_map_register(&budget_ci_old_map);
}
static void __exit exit_rc_map_budget_ci_old(void)
{
rc_map_unregister(&budget_ci_old_map);
}
module_init(init_rc_map_budget_ci_old)
module_exit(exit_rc_map_budget_ci_old)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-budget-ci-old.c |
// SPDX-License-Identifier: GPL-2.0-only
/*
* Keytable for the Astrometa T2hybrid remote controller
*
* Copyright (C) 2017 Oleh Kravchenko <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table t2hybrid[] = {
{ 0x4d, KEY_POWER2 },
{ 0x54, KEY_VIDEO }, /* Source */
{ 0x16, KEY_MUTE },
{ 0x4c, KEY_RECORD },
{ 0x05, KEY_CHANNELUP },
{ 0x0c, KEY_TIME}, /* Timeshift */
{ 0x0a, KEY_VOLUMEDOWN },
{ 0x40, KEY_ZOOM }, /* Fullscreen */
{ 0x1e, KEY_VOLUMEUP },
{ 0x12, KEY_NUMERIC_0 },
{ 0x02, KEY_CHANNELDOWN },
{ 0x1c, KEY_AGAIN }, /* Recall */
{ 0x09, KEY_NUMERIC_1 },
{ 0x1d, KEY_NUMERIC_2 },
{ 0x1f, KEY_NUMERIC_3 },
{ 0x0d, KEY_NUMERIC_4 },
{ 0x19, KEY_NUMERIC_5 },
{ 0x1b, KEY_NUMERIC_6 },
{ 0x11, KEY_NUMERIC_7 },
{ 0x15, KEY_NUMERIC_8 },
{ 0x17, KEY_NUMERIC_9 },
};
static struct rc_map_list t2hybrid_map = {
.map = {
.scan = t2hybrid,
.size = ARRAY_SIZE(t2hybrid),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_ASTROMETA_T2HYBRID,
}
};
static int __init init_rc_map_t2hybrid(void)
{
return rc_map_register(&t2hybrid_map);
}
static void __exit exit_rc_map_t2hybrid(void)
{
rc_map_unregister(&t2hybrid_map);
}
module_init(init_rc_map_t2hybrid)
module_exit(exit_rc_map_t2hybrid)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Oleh Kravchenko <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-astrometa-t2hybrid.c |
// SPDX-License-Identifier: GPL-2.0+
// encore-enltv-fm53.h - Keytable for encore_enltv_fm53 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Encore ENLTV-FM v5.3
Mauro Carvalho Chehab <[email protected]>
*/
static struct rc_map_table encore_enltv_fm53[] = {
{ 0x10, KEY_POWER2},
{ 0x06, KEY_MUTE},
{ 0x09, KEY_NUMERIC_1},
{ 0x1d, KEY_NUMERIC_2},
{ 0x1f, KEY_NUMERIC_3},
{ 0x19, KEY_NUMERIC_4},
{ 0x1b, KEY_NUMERIC_5},
{ 0x11, KEY_NUMERIC_6},
{ 0x17, KEY_NUMERIC_7},
{ 0x12, KEY_NUMERIC_8},
{ 0x16, KEY_NUMERIC_9},
{ 0x48, KEY_NUMERIC_0},
{ 0x04, KEY_LIST}, /* -/-- */
{ 0x40, KEY_LAST}, /* recall */
{ 0x02, KEY_MODE}, /* TV/AV */
{ 0x05, KEY_CAMERA}, /* SNAPSHOT */
{ 0x4c, KEY_CHANNELUP}, /* UP */
{ 0x00, KEY_CHANNELDOWN}, /* DOWN */
{ 0x0d, KEY_VOLUMEUP}, /* RIGHT */
{ 0x15, KEY_VOLUMEDOWN}, /* LEFT */
{ 0x49, KEY_ENTER}, /* OK */
{ 0x54, KEY_RECORD},
{ 0x4d, KEY_PLAY}, /* pause */
{ 0x1e, KEY_MENU}, /* video setting */
{ 0x0e, KEY_RIGHT}, /* <- */
{ 0x1a, KEY_LEFT}, /* -> */
{ 0x0a, KEY_CLEAR}, /* video default */
{ 0x0c, KEY_ZOOM}, /* hide pannel */
{ 0x47, KEY_SLEEP}, /* shutdown */
};
static struct rc_map_list encore_enltv_fm53_map = {
.map = {
.scan = encore_enltv_fm53,
.size = ARRAY_SIZE(encore_enltv_fm53),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_ENCORE_ENLTV_FM53,
}
};
static int __init init_rc_map_encore_enltv_fm53(void)
{
return rc_map_register(&encore_enltv_fm53_map);
}
static void __exit exit_rc_map_encore_enltv_fm53(void)
{
rc_map_unregister(&encore_enltv_fm53_map);
}
module_init(init_rc_map_encore_enltv_fm53)
module_exit(exit_rc_map_encore_enltv_fm53)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-encore-enltv-fm53.c |
// SPDX-License-Identifier: GPL-2.0+
// avermedia.h - Keytable for avermedia Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Alex Hermann <[email protected]> */
static struct rc_map_table avermedia[] = {
{ 0x28, KEY_NUMERIC_1 },
{ 0x18, KEY_NUMERIC_2 },
{ 0x38, KEY_NUMERIC_3 },
{ 0x24, KEY_NUMERIC_4 },
{ 0x14, KEY_NUMERIC_5 },
{ 0x34, KEY_NUMERIC_6 },
{ 0x2c, KEY_NUMERIC_7 },
{ 0x1c, KEY_NUMERIC_8 },
{ 0x3c, KEY_NUMERIC_9 },
{ 0x22, KEY_NUMERIC_0 },
{ 0x20, KEY_TV }, /* TV/FM */
{ 0x10, KEY_CD }, /* CD */
{ 0x30, KEY_TEXT }, /* TELETEXT */
{ 0x00, KEY_POWER }, /* POWER */
{ 0x08, KEY_VIDEO }, /* VIDEO */
{ 0x04, KEY_AUDIO }, /* AUDIO */
{ 0x0c, KEY_ZOOM }, /* FULL SCREEN */
{ 0x12, KEY_SUBTITLE }, /* DISPLAY */
{ 0x32, KEY_REWIND }, /* LOOP */
{ 0x02, KEY_PRINT }, /* PREVIEW */
{ 0x2a, KEY_SEARCH }, /* AUTOSCAN */
{ 0x1a, KEY_SLEEP }, /* FREEZE */
{ 0x3a, KEY_CAMERA }, /* SNAPSHOT */
{ 0x0a, KEY_MUTE }, /* MUTE */
{ 0x26, KEY_RECORD }, /* RECORD */
{ 0x16, KEY_PAUSE }, /* PAUSE */
{ 0x36, KEY_STOP }, /* STOP */
{ 0x06, KEY_PLAY }, /* PLAY */
{ 0x2e, KEY_RED }, /* RED */
{ 0x21, KEY_GREEN }, /* GREEN */
{ 0x0e, KEY_YELLOW }, /* YELLOW */
{ 0x01, KEY_BLUE }, /* BLUE */
{ 0x1e, KEY_VOLUMEDOWN }, /* VOLUME- */
{ 0x3e, KEY_VOLUMEUP }, /* VOLUME+ */
{ 0x11, KEY_CHANNELDOWN }, /* CHANNEL/PAGE- */
{ 0x31, KEY_CHANNELUP } /* CHANNEL/PAGE+ */
};
static struct rc_map_list avermedia_map = {
.map = {
.scan = avermedia,
.size = ARRAY_SIZE(avermedia),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_AVERMEDIA,
}
};
static int __init init_rc_map_avermedia(void)
{
return rc_map_register(&avermedia_map);
}
static void __exit exit_rc_map_avermedia(void)
{
rc_map_unregister(&avermedia_map);
}
module_init(init_rc_map_avermedia)
module_exit(exit_rc_map_avermedia)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-avermedia.c |
// SPDX-License-Identifier: GPL-2.0+
// kworld-315u.h - Keytable for kworld_315u Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Kworld 315U
*/
static struct rc_map_table kworld_315u[] = {
{ 0x6143, KEY_POWER },
{ 0x6101, KEY_VIDEO }, /* source */
{ 0x610b, KEY_ZOOM },
{ 0x6103, KEY_POWER2 }, /* shutdown */
{ 0x6104, KEY_NUMERIC_1 },
{ 0x6108, KEY_NUMERIC_2 },
{ 0x6102, KEY_NUMERIC_3 },
{ 0x6109, KEY_CHANNELUP },
{ 0x610f, KEY_NUMERIC_4 },
{ 0x6105, KEY_NUMERIC_5 },
{ 0x6106, KEY_NUMERIC_6 },
{ 0x6107, KEY_CHANNELDOWN },
{ 0x610c, KEY_NUMERIC_7 },
{ 0x610d, KEY_NUMERIC_8 },
{ 0x610a, KEY_NUMERIC_9 },
{ 0x610e, KEY_VOLUMEUP },
{ 0x6110, KEY_LAST },
{ 0x6111, KEY_NUMERIC_0 },
{ 0x6112, KEY_ENTER },
{ 0x6113, KEY_VOLUMEDOWN },
{ 0x6114, KEY_RECORD },
{ 0x6115, KEY_STOP },
{ 0x6116, KEY_PLAY },
{ 0x6117, KEY_MUTE },
{ 0x6118, KEY_UP },
{ 0x6119, KEY_DOWN },
{ 0x611a, KEY_LEFT },
{ 0x611b, KEY_RIGHT },
{ 0x611c, KEY_RED },
{ 0x611d, KEY_GREEN },
{ 0x611e, KEY_YELLOW },
{ 0x611f, KEY_BLUE },
};
static struct rc_map_list kworld_315u_map = {
.map = {
.scan = kworld_315u,
.size = ARRAY_SIZE(kworld_315u),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_KWORLD_315U,
}
};
static int __init init_rc_map_kworld_315u(void)
{
return rc_map_register(&kworld_315u_map);
}
static void __exit exit_rc_map_kworld_315u(void)
{
rc_map_unregister(&kworld_315u_map);
}
module_init(init_rc_map_kworld_315u)
module_exit(exit_rc_map_kworld_315u)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-kworld-315u.c |
// SPDX-License-Identifier: GPL-2.0+
// rc-dvb0700-big.c - Keytable for devices in dvb0700
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
//
// TODO: This table is a real mess, as it merges RC codes from several
// devices into a big table. It also has both RC-5 and NEC codes inside.
// It should be broken into small tables, and the protocols should properly
// be identificated.
//
// The table were imported from dib0700_devices.c.
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table dib0700_rc5_table[] = {
/* Key codes for the tiny Pinnacle remote*/
{ 0x0700, KEY_MUTE },
{ 0x0701, KEY_MENU }, /* Pinnacle logo */
{ 0x0739, KEY_POWER },
{ 0x0703, KEY_VOLUMEUP },
{ 0x0709, KEY_VOLUMEDOWN },
{ 0x0706, KEY_CHANNELUP },
{ 0x070c, KEY_CHANNELDOWN },
{ 0x070f, KEY_NUMERIC_1 },
{ 0x0715, KEY_NUMERIC_2 },
{ 0x0710, KEY_NUMERIC_3 },
{ 0x0718, KEY_NUMERIC_4 },
{ 0x071b, KEY_NUMERIC_5 },
{ 0x071e, KEY_NUMERIC_6 },
{ 0x0711, KEY_NUMERIC_7 },
{ 0x0721, KEY_NUMERIC_8 },
{ 0x0712, KEY_NUMERIC_9 },
{ 0x0727, KEY_NUMERIC_0 },
{ 0x0724, KEY_SCREEN }, /* 'Square' key */
{ 0x072a, KEY_TEXT }, /* 'T' key */
{ 0x072d, KEY_REWIND },
{ 0x0730, KEY_PLAY },
{ 0x0733, KEY_FASTFORWARD },
{ 0x0736, KEY_RECORD },
{ 0x073c, KEY_STOP },
{ 0x073f, KEY_CANCEL }, /* '?' key */
/* Key codes for the Terratec Cinergy DT XS Diversity, similar to cinergyT2.c */
{ 0xeb01, KEY_POWER },
{ 0xeb02, KEY_NUMERIC_1 },
{ 0xeb03, KEY_NUMERIC_2 },
{ 0xeb04, KEY_NUMERIC_3 },
{ 0xeb05, KEY_NUMERIC_4 },
{ 0xeb06, KEY_NUMERIC_5 },
{ 0xeb07, KEY_NUMERIC_6 },
{ 0xeb08, KEY_NUMERIC_7 },
{ 0xeb09, KEY_NUMERIC_8 },
{ 0xeb0a, KEY_NUMERIC_9 },
{ 0xeb0b, KEY_VIDEO },
{ 0xeb0c, KEY_NUMERIC_0 },
{ 0xeb0d, KEY_REFRESH },
{ 0xeb0f, KEY_EPG },
{ 0xeb10, KEY_UP },
{ 0xeb11, KEY_LEFT },
{ 0xeb12, KEY_OK },
{ 0xeb13, KEY_RIGHT },
{ 0xeb14, KEY_DOWN },
{ 0xeb16, KEY_INFO },
{ 0xeb17, KEY_RED },
{ 0xeb18, KEY_GREEN },
{ 0xeb19, KEY_YELLOW },
{ 0xeb1a, KEY_BLUE },
{ 0xeb1b, KEY_CHANNELUP },
{ 0xeb1c, KEY_VOLUMEUP },
{ 0xeb1d, KEY_MUTE },
{ 0xeb1e, KEY_VOLUMEDOWN },
{ 0xeb1f, KEY_CHANNELDOWN },
{ 0xeb40, KEY_PAUSE },
{ 0xeb41, KEY_HOME },
{ 0xeb42, KEY_MENU }, /* DVD Menu */
{ 0xeb43, KEY_SUBTITLE },
{ 0xeb44, KEY_TEXT }, /* Teletext */
{ 0xeb45, KEY_DELETE },
{ 0xeb46, KEY_TV },
{ 0xeb47, KEY_DVD },
{ 0xeb48, KEY_STOP },
{ 0xeb49, KEY_VIDEO },
{ 0xeb4a, KEY_AUDIO }, /* Music */
{ 0xeb4b, KEY_SCREEN }, /* Pic */
{ 0xeb4c, KEY_PLAY },
{ 0xeb4d, KEY_BACK },
{ 0xeb4e, KEY_REWIND },
{ 0xeb4f, KEY_FASTFORWARD },
{ 0xeb54, KEY_PREVIOUS },
{ 0xeb58, KEY_RECORD },
{ 0xeb5c, KEY_NEXT },
/* Key codes for the Haupauge WinTV Nova-TD, copied from nova-t-usb2.c (Nova-T USB2) */
{ 0x1e00, KEY_NUMERIC_0 },
{ 0x1e01, KEY_NUMERIC_1 },
{ 0x1e02, KEY_NUMERIC_2 },
{ 0x1e03, KEY_NUMERIC_3 },
{ 0x1e04, KEY_NUMERIC_4 },
{ 0x1e05, KEY_NUMERIC_5 },
{ 0x1e06, KEY_NUMERIC_6 },
{ 0x1e07, KEY_NUMERIC_7 },
{ 0x1e08, KEY_NUMERIC_8 },
{ 0x1e09, KEY_NUMERIC_9 },
{ 0x1e0a, KEY_KPASTERISK },
{ 0x1e0b, KEY_RED },
{ 0x1e0c, KEY_RADIO },
{ 0x1e0d, KEY_MENU },
{ 0x1e0e, KEY_GRAVE }, /* # */
{ 0x1e0f, KEY_MUTE },
{ 0x1e10, KEY_VOLUMEUP },
{ 0x1e11, KEY_VOLUMEDOWN },
{ 0x1e12, KEY_CHANNEL },
{ 0x1e14, KEY_UP },
{ 0x1e15, KEY_DOWN },
{ 0x1e16, KEY_LEFT },
{ 0x1e17, KEY_RIGHT },
{ 0x1e18, KEY_VIDEO },
{ 0x1e19, KEY_AUDIO },
{ 0x1e1a, KEY_MEDIA },
{ 0x1e1b, KEY_EPG },
{ 0x1e1c, KEY_TV },
{ 0x1e1e, KEY_NEXT },
{ 0x1e1f, KEY_BACK },
{ 0x1e20, KEY_CHANNELUP },
{ 0x1e21, KEY_CHANNELDOWN },
{ 0x1e24, KEY_LAST }, /* Skip backwards */
{ 0x1e25, KEY_OK },
{ 0x1e29, KEY_BLUE},
{ 0x1e2e, KEY_GREEN },
{ 0x1e30, KEY_PAUSE },
{ 0x1e32, KEY_REWIND },
{ 0x1e34, KEY_FASTFORWARD },
{ 0x1e35, KEY_PLAY },
{ 0x1e36, KEY_STOP },
{ 0x1e37, KEY_RECORD },
{ 0x1e38, KEY_YELLOW },
{ 0x1e3b, KEY_GOTO },
{ 0x1e3d, KEY_POWER },
/* Key codes for the Leadtek Winfast DTV Dongle */
{ 0x0042, KEY_POWER },
{ 0x077c, KEY_TUNER },
{ 0x0f4e, KEY_PRINT }, /* PREVIEW */
{ 0x0840, KEY_SCREEN }, /* full screen toggle*/
{ 0x0f71, KEY_DOT }, /* frequency */
{ 0x0743, KEY_NUMERIC_0 },
{ 0x0c41, KEY_NUMERIC_1 },
{ 0x0443, KEY_NUMERIC_2 },
{ 0x0b7f, KEY_NUMERIC_3 },
{ 0x0e41, KEY_NUMERIC_4 },
{ 0x0643, KEY_NUMERIC_5 },
{ 0x097f, KEY_NUMERIC_6 },
{ 0x0d7e, KEY_NUMERIC_7 },
{ 0x057c, KEY_NUMERIC_8 },
{ 0x0a40, KEY_NUMERIC_9 },
{ 0x0e4e, KEY_CLEAR },
{ 0x047c, KEY_CHANNEL }, /* show channel number */
{ 0x0f41, KEY_LAST }, /* recall */
{ 0x0342, KEY_MUTE },
{ 0x064c, KEY_RESERVED }, /* PIP button*/
{ 0x0172, KEY_SHUFFLE }, /* SNAPSHOT */
{ 0x0c4e, KEY_PLAYPAUSE }, /* TIMESHIFT */
{ 0x0b70, KEY_RECORD },
{ 0x037d, KEY_VOLUMEUP },
{ 0x017d, KEY_VOLUMEDOWN },
{ 0x0242, KEY_CHANNELUP },
{ 0x007d, KEY_CHANNELDOWN },
/* Key codes for Nova-TD "credit card" remote control. */
{ 0x1d00, KEY_NUMERIC_0 },
{ 0x1d01, KEY_NUMERIC_1 },
{ 0x1d02, KEY_NUMERIC_2 },
{ 0x1d03, KEY_NUMERIC_3 },
{ 0x1d04, KEY_NUMERIC_4 },
{ 0x1d05, KEY_NUMERIC_5 },
{ 0x1d06, KEY_NUMERIC_6 },
{ 0x1d07, KEY_NUMERIC_7 },
{ 0x1d08, KEY_NUMERIC_8 },
{ 0x1d09, KEY_NUMERIC_9 },
{ 0x1d0a, KEY_TEXT },
{ 0x1d0d, KEY_MENU },
{ 0x1d0f, KEY_MUTE },
{ 0x1d10, KEY_VOLUMEUP },
{ 0x1d11, KEY_VOLUMEDOWN },
{ 0x1d12, KEY_CHANNEL },
{ 0x1d14, KEY_UP },
{ 0x1d15, KEY_DOWN },
{ 0x1d16, KEY_LEFT },
{ 0x1d17, KEY_RIGHT },
{ 0x1d1c, KEY_TV },
{ 0x1d1e, KEY_NEXT },
{ 0x1d1f, KEY_BACK },
{ 0x1d20, KEY_CHANNELUP },
{ 0x1d21, KEY_CHANNELDOWN },
{ 0x1d24, KEY_LAST },
{ 0x1d25, KEY_OK },
{ 0x1d30, KEY_PAUSE },
{ 0x1d32, KEY_REWIND },
{ 0x1d34, KEY_FASTFORWARD },
{ 0x1d35, KEY_PLAY },
{ 0x1d36, KEY_STOP },
{ 0x1d37, KEY_RECORD },
{ 0x1d3b, KEY_GOTO },
{ 0x1d3d, KEY_POWER },
};
static struct rc_map_list dib0700_rc5_map = {
.map = {
.scan = dib0700_rc5_table,
.size = ARRAY_SIZE(dib0700_rc5_table),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_DIB0700_RC5_TABLE,
}
};
static int __init init_rc_map(void)
{
return rc_map_register(&dib0700_rc5_map);
}
static void __exit exit_rc_map(void)
{
rc_map_unregister(&dib0700_rc5_map);
}
module_init(init_rc_map)
module_exit(exit_rc_map)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-dib0700-rc5.c |
// SPDX-License-Identifier: GPL-2.0+
// apac-viewcomp.h - Keytable for apac_viewcomp Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Attila Kondoros <[email protected]> */
static struct rc_map_table apac_viewcomp[] = {
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x00, KEY_NUMERIC_0 },
{ 0x17, KEY_LAST }, /* +100 */
{ 0x0a, KEY_LIST }, /* recall */
{ 0x1c, KEY_TUNER }, /* TV/FM */
{ 0x15, KEY_SEARCH }, /* scan */
{ 0x12, KEY_POWER }, /* power */
{ 0x1f, KEY_VOLUMEDOWN }, /* vol up */
{ 0x1b, KEY_VOLUMEUP }, /* vol down */
{ 0x1e, KEY_CHANNELDOWN }, /* chn up */
{ 0x1a, KEY_CHANNELUP }, /* chn down */
{ 0x11, KEY_VIDEO }, /* video */
{ 0x0f, KEY_ZOOM }, /* full screen */
{ 0x13, KEY_MUTE }, /* mute/unmute */
{ 0x10, KEY_TEXT }, /* min */
{ 0x0d, KEY_STOP }, /* freeze */
{ 0x0e, KEY_RECORD }, /* record */
{ 0x1d, KEY_PLAYPAUSE }, /* stop */
{ 0x19, KEY_PLAY }, /* play */
{ 0x16, KEY_GOTO }, /* osd */
{ 0x14, KEY_REFRESH }, /* default */
{ 0x0c, KEY_KPPLUS }, /* fine tune >>>> */
{ 0x18, KEY_KPMINUS }, /* fine tune <<<< */
};
static struct rc_map_list apac_viewcomp_map = {
.map = {
.scan = apac_viewcomp,
.size = ARRAY_SIZE(apac_viewcomp),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_APAC_VIEWCOMP,
}
};
static int __init init_rc_map_apac_viewcomp(void)
{
return rc_map_register(&apac_viewcomp_map);
}
static void __exit exit_rc_map_apac_viewcomp(void)
{
rc_map_unregister(&apac_viewcomp_map);
}
module_init(init_rc_map_apac_viewcomp)
module_exit(exit_rc_map_apac_viewcomp)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-apac-viewcomp.c |
// SPDX-License-Identifier: GPL-2.0+
// manli.h - Keytable for manli Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Michael Tokarev <[email protected]>
keytable is used by MANLI MTV00[0x0c] and BeholdTV 40[13] at
least, and probably other cards too.
The "ascii-art picture" below (in comments, first row
is the keycode in hex, and subsequent row(s) shows
the button labels (several variants when appropriate)
helps to decide which keycodes to assign to the buttons.
*/
static struct rc_map_table manli[] = {
/* 0x1c 0x12 *
* FUNCTION POWER *
* FM (|) *
* */
{ 0x1c, KEY_RADIO }, /*XXX*/
{ 0x12, KEY_POWER },
/* 0x01 0x02 0x03 *
* 1 2 3 *
* *
* 0x04 0x05 0x06 *
* 4 5 6 *
* *
* 0x07 0x08 0x09 *
* 7 8 9 *
* */
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
/* 0x0a 0x00 0x17 *
* RECALL 0 +100 *
* PLUS *
* */
{ 0x0a, KEY_AGAIN }, /*XXX KEY_REWIND? */
{ 0x00, KEY_NUMERIC_0 },
{ 0x17, KEY_DIGITS }, /*XXX*/
/* 0x14 0x10 *
* MENU INFO *
* OSD */
{ 0x14, KEY_MENU },
{ 0x10, KEY_INFO },
/* 0x0b *
* Up *
* *
* 0x18 0x16 0x0c *
* Left Ok Right *
* *
* 0x015 *
* Down *
* */
{ 0x0b, KEY_UP },
{ 0x18, KEY_LEFT },
{ 0x16, KEY_OK }, /*XXX KEY_SELECT? KEY_ENTER? */
{ 0x0c, KEY_RIGHT },
{ 0x15, KEY_DOWN },
/* 0x11 0x0d *
* TV/AV MODE *
* SOURCE STEREO *
* */
{ 0x11, KEY_TV }, /*XXX*/
{ 0x0d, KEY_MODE }, /*XXX there's no KEY_STEREO */
/* 0x0f 0x1b 0x1a *
* AUDIO Vol+ Chan+ *
* TIMESHIFT??? *
* *
* 0x0e 0x1f 0x1e *
* SLEEP Vol- Chan- *
* */
{ 0x0f, KEY_AUDIO },
{ 0x1b, KEY_VOLUMEUP },
{ 0x1a, KEY_CHANNELUP },
{ 0x0e, KEY_TIME },
{ 0x1f, KEY_VOLUMEDOWN },
{ 0x1e, KEY_CHANNELDOWN },
/* 0x13 0x19 *
* MUTE SNAPSHOT*
* */
{ 0x13, KEY_MUTE },
{ 0x19, KEY_CAMERA },
/* 0x1d unused ? */
};
static struct rc_map_list manli_map = {
.map = {
.scan = manli,
.size = ARRAY_SIZE(manli),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_MANLI,
}
};
static int __init init_rc_map_manli(void)
{
return rc_map_register(&manli_map);
}
static void __exit exit_rc_map_manli(void)
{
rc_map_unregister(&manli_map);
}
module_init(init_rc_map_manli)
module_exit(exit_rc_map_manli)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-manli.c |
// SPDX-License-Identifier: GPL-2.0+
// encore-enltv.h - Keytable for encore_enltv Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Encore ENLTV-FM - black plastic, white front cover with white glowing buttons
Juan Pablo Sormani <[email protected]> */
static struct rc_map_table encore_enltv[] = {
/* Power button does nothing, neither in Windows app,
although it sends data (used for BIOS wakeup?) */
{ 0x0d, KEY_MUTE },
{ 0x1e, KEY_TV },
{ 0x00, KEY_VIDEO },
{ 0x01, KEY_AUDIO }, /* music */
{ 0x02, KEY_CAMERA }, /* picture */
{ 0x1f, KEY_NUMERIC_1 },
{ 0x03, KEY_NUMERIC_2 },
{ 0x04, KEY_NUMERIC_3 },
{ 0x05, KEY_NUMERIC_4 },
{ 0x1c, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x1d, KEY_NUMERIC_9 },
{ 0x0a, KEY_NUMERIC_0 },
{ 0x09, KEY_LIST }, /* -/-- */
{ 0x0b, KEY_LAST }, /* recall */
{ 0x14, KEY_HOME }, /* win start menu */
{ 0x15, KEY_EXIT }, /* exit */
{ 0x16, KEY_CHANNELUP }, /* UP */
{ 0x12, KEY_CHANNELDOWN }, /* DOWN */
{ 0x0c, KEY_VOLUMEUP }, /* RIGHT */
{ 0x17, KEY_VOLUMEDOWN }, /* LEFT */
{ 0x18, KEY_ENTER }, /* OK */
{ 0x0e, KEY_ESC },
{ 0x13, KEY_CYCLEWINDOWS }, /* desktop */
{ 0x11, KEY_TAB },
{ 0x19, KEY_SWITCHVIDEOMODE }, /* switch */
{ 0x1a, KEY_MENU },
{ 0x1b, KEY_ZOOM }, /* fullscreen */
{ 0x44, KEY_TIME }, /* time shift */
{ 0x40, KEY_MODE }, /* source */
{ 0x5a, KEY_RECORD },
{ 0x42, KEY_PLAY }, /* play/pause */
{ 0x45, KEY_STOP },
{ 0x43, KEY_CAMERA }, /* camera icon */
{ 0x48, KEY_REWIND },
{ 0x4a, KEY_FASTFORWARD },
{ 0x49, KEY_PREVIOUS },
{ 0x4b, KEY_NEXT },
{ 0x4c, KEY_FAVORITES }, /* tv wall */
{ 0x4d, KEY_SOUND }, /* DVD sound */
{ 0x4e, KEY_LANGUAGE }, /* DVD lang */
{ 0x4f, KEY_TEXT }, /* DVD text */
{ 0x50, KEY_SLEEP }, /* shutdown */
{ 0x51, KEY_MODE }, /* stereo > main */
{ 0x52, KEY_SELECT }, /* stereo > sap */
{ 0x53, KEY_TEXT }, /* teletext */
{ 0x59, KEY_RED }, /* AP1 */
{ 0x41, KEY_GREEN }, /* AP2 */
{ 0x47, KEY_YELLOW }, /* AP3 */
{ 0x57, KEY_BLUE }, /* AP4 */
};
static struct rc_map_list encore_enltv_map = {
.map = {
.scan = encore_enltv,
.size = ARRAY_SIZE(encore_enltv),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_ENCORE_ENLTV,
}
};
static int __init init_rc_map_encore_enltv(void)
{
return rc_map_register(&encore_enltv_map);
}
static void __exit exit_rc_map_encore_enltv(void)
{
rc_map_unregister(&encore_enltv_map);
}
module_init(init_rc_map_encore_enltv)
module_exit(exit_rc_map_encore_enltv)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-encore-enltv.c |
// SPDX-License-Identifier: GPL-2.0+
// encore-enltv2.h - Keytable for encore_enltv2 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Encore ENLTV2-FM - silver plastic - "Wand Media" written at the botton
Mauro Carvalho Chehab <[email protected]> */
static struct rc_map_table encore_enltv2[] = {
{ 0x4c, KEY_POWER2 },
{ 0x4a, KEY_TUNER },
{ 0x40, KEY_NUMERIC_1 },
{ 0x60, KEY_NUMERIC_2 },
{ 0x50, KEY_NUMERIC_3 },
{ 0x70, KEY_NUMERIC_4 },
{ 0x48, KEY_NUMERIC_5 },
{ 0x68, KEY_NUMERIC_6 },
{ 0x58, KEY_NUMERIC_7 },
{ 0x78, KEY_NUMERIC_8 },
{ 0x44, KEY_NUMERIC_9 },
{ 0x54, KEY_NUMERIC_0 },
{ 0x64, KEY_LAST }, /* +100 */
{ 0x4e, KEY_AGAIN }, /* Recall */
{ 0x6c, KEY_VIDEO }, /* Video Source */
{ 0x5e, KEY_MENU },
{ 0x56, KEY_SCREEN },
{ 0x7a, KEY_SETUP },
{ 0x46, KEY_MUTE },
{ 0x5c, KEY_MODE }, /* Stereo */
{ 0x74, KEY_INFO },
{ 0x7c, KEY_CLEAR },
{ 0x55, KEY_UP },
{ 0x49, KEY_DOWN },
{ 0x7e, KEY_LEFT },
{ 0x59, KEY_RIGHT },
{ 0x6a, KEY_ENTER },
{ 0x42, KEY_VOLUMEUP },
{ 0x62, KEY_VOLUMEDOWN },
{ 0x52, KEY_CHANNELUP },
{ 0x72, KEY_CHANNELDOWN },
{ 0x41, KEY_RECORD },
{ 0x51, KEY_CAMERA }, /* Snapshot */
{ 0x75, KEY_TIME }, /* Timeshift */
{ 0x71, KEY_TV2 }, /* PIP */
{ 0x45, KEY_REWIND },
{ 0x6f, KEY_PAUSE },
{ 0x7d, KEY_FORWARD },
{ 0x79, KEY_STOP },
};
static struct rc_map_list encore_enltv2_map = {
.map = {
.scan = encore_enltv2,
.size = ARRAY_SIZE(encore_enltv2),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_ENCORE_ENLTV2,
}
};
static int __init init_rc_map_encore_enltv2(void)
{
return rc_map_register(&encore_enltv2_map);
}
static void __exit exit_rc_map_encore_enltv2(void)
{
rc_map_unregister(&encore_enltv2_map);
}
module_init(init_rc_map_encore_enltv2)
module_exit(exit_rc_map_encore_enltv2)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-encore-enltv2.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* keytable for Twinhan DTV CAB CI Remote Controller
*
* Copyright (c) 2010 by Igor M. Liplianin <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table twinhan_dtv_cab_ci[] = {
{ 0x29, KEY_POWER},
{ 0x28, KEY_FAVORITES},
{ 0x30, KEY_TEXT},
{ 0x17, KEY_INFO}, /* Preview */
{ 0x23, KEY_EPG},
{ 0x3b, KEY_F22}, /* Record List */
{ 0x3c, KEY_NUMERIC_1},
{ 0x3e, KEY_NUMERIC_2},
{ 0x39, KEY_NUMERIC_3},
{ 0x36, KEY_NUMERIC_4},
{ 0x22, KEY_NUMERIC_5},
{ 0x20, KEY_NUMERIC_6},
{ 0x32, KEY_NUMERIC_7},
{ 0x26, KEY_NUMERIC_8},
{ 0x24, KEY_NUMERIC_9},
{ 0x2a, KEY_NUMERIC_0},
{ 0x33, KEY_CANCEL},
{ 0x2c, KEY_BACK},
{ 0x15, KEY_CLEAR},
{ 0x3f, KEY_TAB},
{ 0x10, KEY_ENTER},
{ 0x14, KEY_UP},
{ 0x0d, KEY_RIGHT},
{ 0x0e, KEY_DOWN},
{ 0x11, KEY_LEFT},
{ 0x21, KEY_VOLUMEUP},
{ 0x35, KEY_VOLUMEDOWN},
{ 0x3d, KEY_CHANNELDOWN},
{ 0x3a, KEY_CHANNELUP},
{ 0x2e, KEY_RECORD},
{ 0x2b, KEY_PLAY},
{ 0x13, KEY_PAUSE},
{ 0x25, KEY_STOP},
{ 0x1f, KEY_REWIND},
{ 0x2d, KEY_FASTFORWARD},
{ 0x1e, KEY_PREVIOUS}, /* Replay |< */
{ 0x1d, KEY_NEXT}, /* Skip >| */
{ 0x0b, KEY_CAMERA}, /* Capture */
{ 0x0f, KEY_LANGUAGE}, /* SAP */
{ 0x18, KEY_MODE}, /* PIP */
{ 0x12, KEY_ZOOM}, /* Full screen */
{ 0x1c, KEY_SUBTITLE},
{ 0x2f, KEY_MUTE},
{ 0x16, KEY_F20}, /* L/R */
{ 0x38, KEY_F21}, /* Hibernate */
{ 0x37, KEY_SWITCHVIDEOMODE}, /* A/V */
{ 0x31, KEY_AGAIN}, /* Recall */
{ 0x1a, KEY_KPPLUS}, /* Zoom+ */
{ 0x19, KEY_KPMINUS}, /* Zoom- */
{ 0x27, KEY_RED},
{ 0x0C, KEY_GREEN},
{ 0x01, KEY_YELLOW},
{ 0x00, KEY_BLUE},
};
static struct rc_map_list twinhan_dtv_cab_ci_map = {
.map = {
.scan = twinhan_dtv_cab_ci,
.size = ARRAY_SIZE(twinhan_dtv_cab_ci),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_TWINHAN_DTV_CAB_CI,
}
};
static int __init init_rc_map_twinhan_dtv_cab_ci(void)
{
return rc_map_register(&twinhan_dtv_cab_ci_map);
}
static void __exit exit_rc_map_twinhan_dtv_cab_ci(void)
{
rc_map_unregister(&twinhan_dtv_cab_ci_map);
}
module_init(init_rc_map_twinhan_dtv_cab_ci);
module_exit(exit_rc_map_twinhan_dtv_cab_ci);
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-twinhan-dtv-cab-ci.c |
// SPDX-License-Identifier: GPL-2.0+
// avermedia-a16d.h - Keytable for avermedia_a16d Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table avermedia_a16d[] = {
{ 0x20, KEY_LIST},
{ 0x00, KEY_POWER},
{ 0x28, KEY_NUMERIC_1},
{ 0x18, KEY_NUMERIC_2},
{ 0x38, KEY_NUMERIC_3},
{ 0x24, KEY_NUMERIC_4},
{ 0x14, KEY_NUMERIC_5},
{ 0x34, KEY_NUMERIC_6},
{ 0x2c, KEY_NUMERIC_7},
{ 0x1c, KEY_NUMERIC_8},
{ 0x3c, KEY_NUMERIC_9},
{ 0x12, KEY_SUBTITLE},
{ 0x22, KEY_NUMERIC_0},
{ 0x32, KEY_REWIND},
{ 0x3a, KEY_SHUFFLE},
{ 0x02, KEY_PRINT},
{ 0x11, KEY_CHANNELDOWN},
{ 0x31, KEY_CHANNELUP},
{ 0x0c, KEY_ZOOM},
{ 0x1e, KEY_VOLUMEDOWN},
{ 0x3e, KEY_VOLUMEUP},
{ 0x0a, KEY_MUTE},
{ 0x04, KEY_AUDIO},
{ 0x26, KEY_RECORD},
{ 0x06, KEY_PLAY},
{ 0x36, KEY_STOP},
{ 0x16, KEY_PAUSE},
{ 0x2e, KEY_REWIND},
{ 0x0e, KEY_FASTFORWARD},
{ 0x30, KEY_TEXT},
{ 0x21, KEY_GREEN},
{ 0x01, KEY_BLUE},
{ 0x08, KEY_EPG},
{ 0x2a, KEY_MENU},
};
static struct rc_map_list avermedia_a16d_map = {
.map = {
.scan = avermedia_a16d,
.size = ARRAY_SIZE(avermedia_a16d),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_AVERMEDIA_A16D,
}
};
static int __init init_rc_map_avermedia_a16d(void)
{
return rc_map_register(&avermedia_a16d_map);
}
static void __exit exit_rc_map_avermedia_a16d(void)
{
rc_map_unregister(&avermedia_a16d_map);
}
module_init(init_rc_map_avermedia_a16d)
module_exit(exit_rc_map_avermedia_a16d)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-avermedia-a16d.c |
// SPDX-License-Identifier: GPL-2.0-only
/*
* Keytable for the GeekBox remote controller
*
* Copyright (C) 2017 Martin Blumenstingl <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table geekbox[] = {
{ 0x01, KEY_BACK },
{ 0x02, KEY_DOWN },
{ 0x03, KEY_UP },
{ 0x07, KEY_OK },
{ 0x0b, KEY_VOLUMEUP },
{ 0x0e, KEY_LEFT },
{ 0x13, KEY_MENU },
{ 0x14, KEY_POWER },
{ 0x1a, KEY_RIGHT },
{ 0x48, KEY_HOME },
{ 0x58, KEY_VOLUMEDOWN },
{ 0x5c, KEY_SCREEN },
};
static struct rc_map_list geekbox_map = {
.map = {
.scan = geekbox,
.size = ARRAY_SIZE(geekbox),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_GEEKBOX,
}
};
static int __init init_rc_map_geekbox(void)
{
return rc_map_register(&geekbox_map);
}
static void __exit exit_rc_map_geekbox(void)
{
rc_map_unregister(&geekbox_map);
}
module_init(init_rc_map_geekbox)
module_exit(exit_rc_map_geekbox)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Martin Blumenstingl <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-geekbox.c |
// SPDX-License-Identifier: GPL-2.0+
// adstech-dvb-t-pci.h - Keytable for adstech_dvb_t_pci Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* ADS Tech Instant TV DVB-T PCI Remote */
static struct rc_map_table adstech_dvb_t_pci[] = {
/* Keys 0 to 9 */
{ 0x4d, KEY_NUMERIC_0 },
{ 0x57, KEY_NUMERIC_1 },
{ 0x4f, KEY_NUMERIC_2 },
{ 0x53, KEY_NUMERIC_3 },
{ 0x56, KEY_NUMERIC_4 },
{ 0x4e, KEY_NUMERIC_5 },
{ 0x5e, KEY_NUMERIC_6 },
{ 0x54, KEY_NUMERIC_7 },
{ 0x4c, KEY_NUMERIC_8 },
{ 0x5c, KEY_NUMERIC_9 },
{ 0x5b, KEY_POWER },
{ 0x5f, KEY_MUTE },
{ 0x55, KEY_GOTO },
{ 0x5d, KEY_SEARCH },
{ 0x17, KEY_EPG }, /* Guide */
{ 0x1f, KEY_MENU },
{ 0x0f, KEY_UP },
{ 0x46, KEY_DOWN },
{ 0x16, KEY_LEFT },
{ 0x1e, KEY_RIGHT },
{ 0x0e, KEY_SELECT }, /* Enter */
{ 0x5a, KEY_INFO },
{ 0x52, KEY_EXIT },
{ 0x59, KEY_PREVIOUS },
{ 0x51, KEY_NEXT },
{ 0x58, KEY_REWIND },
{ 0x50, KEY_FORWARD },
{ 0x44, KEY_PLAYPAUSE },
{ 0x07, KEY_STOP },
{ 0x1b, KEY_RECORD },
{ 0x13, KEY_TUNER }, /* Live */
{ 0x0a, KEY_A },
{ 0x12, KEY_B },
{ 0x03, KEY_RED }, /* 1 */
{ 0x01, KEY_GREEN }, /* 2 */
{ 0x00, KEY_YELLOW }, /* 3 */
{ 0x06, KEY_DVD },
{ 0x48, KEY_AUX }, /* Photo */
{ 0x40, KEY_VIDEO },
{ 0x19, KEY_AUDIO }, /* Music */
{ 0x0b, KEY_CHANNELUP },
{ 0x08, KEY_CHANNELDOWN },
{ 0x15, KEY_VOLUMEUP },
{ 0x1c, KEY_VOLUMEDOWN },
};
static struct rc_map_list adstech_dvb_t_pci_map = {
.map = {
.scan = adstech_dvb_t_pci,
.size = ARRAY_SIZE(adstech_dvb_t_pci),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_ADSTECH_DVB_T_PCI,
}
};
static int __init init_rc_map_adstech_dvb_t_pci(void)
{
return rc_map_register(&adstech_dvb_t_pci_map);
}
static void __exit exit_rc_map_adstech_dvb_t_pci(void)
{
rc_map_unregister(&adstech_dvb_t_pci_map);
}
module_init(init_rc_map_adstech_dvb_t_pci)
module_exit(exit_rc_map_adstech_dvb_t_pci)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-adstech-dvb-t-pci.c |
// SPDX-License-Identifier: GPL-2.0+
// pv951.h - Keytable for pv951 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Mark Phalan <[email protected]> */
static struct rc_map_table pv951[] = {
{ 0x00, KEY_NUMERIC_0 },
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x12, KEY_POWER },
{ 0x10, KEY_MUTE },
{ 0x1f, KEY_VOLUMEDOWN },
{ 0x1b, KEY_VOLUMEUP },
{ 0x1a, KEY_CHANNELUP },
{ 0x1e, KEY_CHANNELDOWN },
{ 0x0e, KEY_PAGEUP },
{ 0x1d, KEY_PAGEDOWN },
{ 0x13, KEY_SOUND },
{ 0x18, KEY_KPPLUSMINUS }, /* CH +/- */
{ 0x16, KEY_SUBTITLE }, /* CC */
{ 0x0d, KEY_TEXT }, /* TTX */
{ 0x0b, KEY_TV }, /* AIR/CBL */
{ 0x11, KEY_PC }, /* PC/TV */
{ 0x17, KEY_OK }, /* CH RTN */
{ 0x19, KEY_MODE }, /* FUNC */
{ 0x0c, KEY_SEARCH }, /* AUTOSCAN */
/* Not sure what to do with these ones! */
{ 0x0f, KEY_VIDEO }, /* SOURCE */
{ 0x0a, KEY_KPPLUS }, /* +100 */
{ 0x14, KEY_EQUAL }, /* SYNC */
{ 0x1c, KEY_TV }, /* PC/TV */
};
static struct rc_map_list pv951_map = {
.map = {
.scan = pv951,
.size = ARRAY_SIZE(pv951),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_PV951,
}
};
static int __init init_rc_map_pv951(void)
{
return rc_map_register(&pv951_map);
}
static void __exit exit_rc_map_pv951(void)
{
rc_map_unregister(&pv951_map);
}
module_init(init_rc_map_pv951)
module_exit(exit_rc_map_pv951)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pv951.c |
// SPDX-License-Identifier: GPL-2.0+
// rc-pixelview-mk12.h - Keytable for pixelview Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keytable for MK-F12 IR remote provided together with Pixelview
* Ultra Pro Remote Controller. Uses NEC extended format.
*/
static struct rc_map_table pixelview_mk12[] = {
{ 0x866b03, KEY_TUNER }, /* Timeshift */
{ 0x866b1e, KEY_POWER2 }, /* power */
{ 0x866b01, KEY_NUMERIC_1 },
{ 0x866b0b, KEY_NUMERIC_2 },
{ 0x866b1b, KEY_NUMERIC_3 },
{ 0x866b05, KEY_NUMERIC_4 },
{ 0x866b09, KEY_NUMERIC_5 },
{ 0x866b15, KEY_NUMERIC_6 },
{ 0x866b06, KEY_NUMERIC_7 },
{ 0x866b0a, KEY_NUMERIC_8 },
{ 0x866b12, KEY_NUMERIC_9 },
{ 0x866b02, KEY_NUMERIC_0 },
{ 0x866b13, KEY_AGAIN }, /* loop */
{ 0x866b10, KEY_DIGITS }, /* +100 */
{ 0x866b00, KEY_VIDEO }, /* source */
{ 0x866b18, KEY_MUTE }, /* mute */
{ 0x866b19, KEY_CAMERA }, /* snapshot */
{ 0x866b1a, KEY_SEARCH }, /* scan */
{ 0x866b16, KEY_CHANNELUP }, /* chn + */
{ 0x866b14, KEY_CHANNELDOWN }, /* chn - */
{ 0x866b1f, KEY_VOLUMEUP }, /* vol + */
{ 0x866b17, KEY_VOLUMEDOWN }, /* vol - */
{ 0x866b1c, KEY_ZOOM }, /* zoom */
{ 0x866b04, KEY_REWIND },
{ 0x866b0e, KEY_RECORD },
{ 0x866b0c, KEY_FORWARD },
{ 0x866b1d, KEY_STOP },
{ 0x866b08, KEY_PLAY },
{ 0x866b0f, KEY_PAUSE },
{ 0x866b0d, KEY_TV },
{ 0x866b07, KEY_RADIO }, /* FM */
};
static struct rc_map_list pixelview_map = {
.map = {
.scan = pixelview_mk12,
.size = ARRAY_SIZE(pixelview_mk12),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_PIXELVIEW_MK12,
}
};
static int __init init_rc_map_pixelview(void)
{
return rc_map_register(&pixelview_map);
}
static void __exit exit_rc_map_pixelview(void)
{
rc_map_unregister(&pixelview_map);
}
module_init(init_rc_map_pixelview)
module_exit(exit_rc_map_pixelview)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pixelview-mk12.c |
// SPDX-License-Identifier: GPL-2.0+
// rc-hauppauge.c - Keytable for Hauppauge Remote Controllers
//
// keymap imported from ir-keymaps.c
//
// This map currently contains the code for four different RCs:
// - New Hauppauge Gray;
// - Old Hauppauge Gray (with a golden screen for media keys);
// - Hauppauge Black;
// - DSR-0112 remote bundled with Haupauge MiniStick.
//
// Copyright (c) 2010-2011 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Hauppauge:the newer, gray remotes (seems there are multiple
* slightly different versions), shipped with cx88+ivtv cards.
*
* This table contains the complete RC5 code, instead of just the data part
*/
static struct rc_map_table rc5_hauppauge_new[] = {
/*
* Remote Controller Hauppauge Gray found on modern devices
* Keycodes start with address = 0x1e
*/
{ 0x1e3b, KEY_SELECT }, /* GO / house symbol */
{ 0x1e3d, KEY_POWER2 }, /* system power (green button) */
{ 0x1e1c, KEY_TV },
{ 0x1e18, KEY_VIDEO }, /* Videos */
{ 0x1e19, KEY_AUDIO }, /* Music */
{ 0x1e1a, KEY_CAMERA }, /* Pictures */
{ 0x1e1b, KEY_EPG }, /* Guide */
{ 0x1e0c, KEY_RADIO },
{ 0x1e14, KEY_UP },
{ 0x1e15, KEY_DOWN },
{ 0x1e16, KEY_LEFT },
{ 0x1e17, KEY_RIGHT },
{ 0x1e25, KEY_OK }, /* OK */
{ 0x1e1f, KEY_EXIT }, /* back/exit */
{ 0x1e0d, KEY_MENU },
{ 0x1e10, KEY_VOLUMEUP },
{ 0x1e11, KEY_VOLUMEDOWN },
{ 0x1e12, KEY_PREVIOUS }, /* previous channel */
{ 0x1e0f, KEY_MUTE },
{ 0x1e20, KEY_CHANNELUP }, /* channel / program + */
{ 0x1e21, KEY_CHANNELDOWN }, /* channel / program - */
{ 0x1e37, KEY_RECORD }, /* recording */
{ 0x1e36, KEY_STOP },
{ 0x1e32, KEY_REWIND }, /* backward << */
{ 0x1e35, KEY_PLAY },
{ 0x1e34, KEY_FASTFORWARD }, /* forward >> */
{ 0x1e24, KEY_PREVIOUSSONG }, /* replay |< */
{ 0x1e30, KEY_PAUSE }, /* pause */
{ 0x1e1e, KEY_NEXTSONG }, /* skip >| */
{ 0x1e01, KEY_NUMERIC_1 },
{ 0x1e02, KEY_NUMERIC_2 },
{ 0x1e03, KEY_NUMERIC_3 },
{ 0x1e04, KEY_NUMERIC_4 },
{ 0x1e05, KEY_NUMERIC_5 },
{ 0x1e06, KEY_NUMERIC_6 },
{ 0x1e07, KEY_NUMERIC_7 },
{ 0x1e08, KEY_NUMERIC_8 },
{ 0x1e09, KEY_NUMERIC_9 },
{ 0x1e0a, KEY_TEXT }, /* keypad asterisk as well */
{ 0x1e00, KEY_NUMERIC_0 },
{ 0x1e0e, KEY_SUBTITLE }, /* also the Pound key (#) */
{ 0x1e0b, KEY_RED }, /* red button */
{ 0x1e2e, KEY_GREEN }, /* green button */
{ 0x1e38, KEY_YELLOW }, /* yellow key */
{ 0x1e29, KEY_BLUE }, /* blue key */
/*
* Old Remote Controller Hauppauge Gray with a golden screen
* Keycodes start with address = 0x1f
*/
{ 0x1f3d, KEY_POWER2 }, /* system power (green button) */
{ 0x1f3b, KEY_SELECT }, /* GO */
/* Keys 0 to 9 */
{ 0x1f00, KEY_NUMERIC_0 },
{ 0x1f01, KEY_NUMERIC_1 },
{ 0x1f02, KEY_NUMERIC_2 },
{ 0x1f03, KEY_NUMERIC_3 },
{ 0x1f04, KEY_NUMERIC_4 },
{ 0x1f05, KEY_NUMERIC_5 },
{ 0x1f06, KEY_NUMERIC_6 },
{ 0x1f07, KEY_NUMERIC_7 },
{ 0x1f08, KEY_NUMERIC_8 },
{ 0x1f09, KEY_NUMERIC_9 },
{ 0x1f1f, KEY_EXIT }, /* back/exit */
{ 0x1f0d, KEY_MENU },
{ 0x1f10, KEY_VOLUMEUP },
{ 0x1f11, KEY_VOLUMEDOWN },
{ 0x1f20, KEY_CHANNELUP }, /* channel / program + */
{ 0x1f21, KEY_CHANNELDOWN }, /* channel / program - */
{ 0x1f25, KEY_ENTER }, /* OK */
{ 0x1f0b, KEY_RED }, /* red button */
{ 0x1f2e, KEY_GREEN }, /* green button */
{ 0x1f38, KEY_YELLOW }, /* yellow key */
{ 0x1f29, KEY_BLUE }, /* blue key */
{ 0x1f0f, KEY_MUTE },
{ 0x1f0c, KEY_RADIO }, /* There's no indicator on this key */
{ 0x1f3c, KEY_ZOOM }, /* full */
{ 0x1f32, KEY_REWIND }, /* backward << */
{ 0x1f35, KEY_PLAY },
{ 0x1f34, KEY_FASTFORWARD }, /* forward >> */
{ 0x1f37, KEY_RECORD }, /* recording */
{ 0x1f36, KEY_STOP },
{ 0x1f30, KEY_PAUSE }, /* pause */
{ 0x1f24, KEY_PREVIOUSSONG }, /* replay |< */
{ 0x1f1e, KEY_NEXTSONG }, /* skip >| */
/*
* Keycodes for DSR-0112 remote bundled with Haupauge MiniStick
* Keycodes start with address = 0x1d
*/
{ 0x1d00, KEY_NUMERIC_0 },
{ 0x1d01, KEY_NUMERIC_1 },
{ 0x1d02, KEY_NUMERIC_2 },
{ 0x1d03, KEY_NUMERIC_3 },
{ 0x1d04, KEY_NUMERIC_4 },
{ 0x1d05, KEY_NUMERIC_5 },
{ 0x1d06, KEY_NUMERIC_6 },
{ 0x1d07, KEY_NUMERIC_7 },
{ 0x1d08, KEY_NUMERIC_8 },
{ 0x1d09, KEY_NUMERIC_9 },
{ 0x1d0a, KEY_TEXT },
{ 0x1d0d, KEY_MENU },
{ 0x1d0f, KEY_MUTE },
{ 0x1d10, KEY_VOLUMEUP },
{ 0x1d11, KEY_VOLUMEDOWN },
{ 0x1d12, KEY_PREVIOUS }, /* Prev.Ch .. ??? */
{ 0x1d14, KEY_UP },
{ 0x1d15, KEY_DOWN },
{ 0x1d16, KEY_LEFT },
{ 0x1d17, KEY_RIGHT },
{ 0x1d1c, KEY_TV },
{ 0x1d1e, KEY_NEXT }, /* >| */
{ 0x1d1f, KEY_EXIT },
{ 0x1d20, KEY_CHANNELUP },
{ 0x1d21, KEY_CHANNELDOWN },
{ 0x1d24, KEY_LAST }, /* <| */
{ 0x1d25, KEY_OK },
{ 0x1d30, KEY_PAUSE },
{ 0x1d32, KEY_REWIND },
{ 0x1d34, KEY_FASTFORWARD },
{ 0x1d35, KEY_PLAY },
{ 0x1d36, KEY_STOP },
{ 0x1d37, KEY_RECORD },
{ 0x1d3b, KEY_GOTO },
{ 0x1d3d, KEY_POWER },
{ 0x1d3f, KEY_HOME },
/*
* Keycodes for PT# R-005 remote bundled with Haupauge HVR-930C
* Keycodes start with address = 0x1c
*/
{ 0x1c3b, KEY_GOTO },
{ 0x1c3d, KEY_POWER },
{ 0x1c14, KEY_UP },
{ 0x1c15, KEY_DOWN },
{ 0x1c16, KEY_LEFT },
{ 0x1c17, KEY_RIGHT },
{ 0x1c25, KEY_OK },
{ 0x1c00, KEY_NUMERIC_0 },
{ 0x1c01, KEY_NUMERIC_1 },
{ 0x1c02, KEY_NUMERIC_2 },
{ 0x1c03, KEY_NUMERIC_3 },
{ 0x1c04, KEY_NUMERIC_4 },
{ 0x1c05, KEY_NUMERIC_5 },
{ 0x1c06, KEY_NUMERIC_6 },
{ 0x1c07, KEY_NUMERIC_7 },
{ 0x1c08, KEY_NUMERIC_8 },
{ 0x1c09, KEY_NUMERIC_9 },
{ 0x1c1f, KEY_EXIT }, /* BACK */
{ 0x1c0d, KEY_MENU },
{ 0x1c1c, KEY_TV },
{ 0x1c10, KEY_VOLUMEUP },
{ 0x1c11, KEY_VOLUMEDOWN },
{ 0x1c20, KEY_CHANNELUP },
{ 0x1c21, KEY_CHANNELDOWN },
{ 0x1c0f, KEY_MUTE },
{ 0x1c12, KEY_PREVIOUS }, /* Prev */
{ 0x1c36, KEY_STOP },
{ 0x1c37, KEY_RECORD },
{ 0x1c24, KEY_LAST }, /* <| */
{ 0x1c1e, KEY_NEXT }, /* >| */
{ 0x1c0a, KEY_TEXT },
{ 0x1c0e, KEY_SUBTITLE }, /* CC */
{ 0x1c32, KEY_REWIND },
{ 0x1c30, KEY_PAUSE },
{ 0x1c35, KEY_PLAY },
{ 0x1c34, KEY_FASTFORWARD },
/*
* Keycodes for the old Black Remote Controller
* This one also uses RC-5 protocol
* Keycodes start with address = 0x00
*/
{ 0x000f, KEY_TV },
{ 0x001f, KEY_TV },
{ 0x0020, KEY_CHANNELUP },
{ 0x000c, KEY_RADIO },
{ 0x0011, KEY_VOLUMEDOWN },
{ 0x002e, KEY_ZOOM }, /* full screen */
{ 0x0010, KEY_VOLUMEUP },
{ 0x000d, KEY_MUTE },
{ 0x0021, KEY_CHANNELDOWN },
{ 0x0022, KEY_VIDEO }, /* source */
{ 0x0001, KEY_NUMERIC_1 },
{ 0x0002, KEY_NUMERIC_2 },
{ 0x0003, KEY_NUMERIC_3 },
{ 0x0004, KEY_NUMERIC_4 },
{ 0x0005, KEY_NUMERIC_5 },
{ 0x0006, KEY_NUMERIC_6 },
{ 0x0007, KEY_NUMERIC_7 },
{ 0x0008, KEY_NUMERIC_8 },
{ 0x0009, KEY_NUMERIC_9 },
{ 0x001e, KEY_RED }, /* Reserved */
{ 0x0000, KEY_NUMERIC_0 },
{ 0x0026, KEY_SLEEP }, /* Minimize */
};
static struct rc_map_list rc5_hauppauge_new_map = {
.map = {
.scan = rc5_hauppauge_new,
.size = ARRAY_SIZE(rc5_hauppauge_new),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_HAUPPAUGE,
}
};
static int __init init_rc_map_rc5_hauppauge_new(void)
{
return rc_map_register(&rc5_hauppauge_new_map);
}
static void __exit exit_rc_map_rc5_hauppauge_new(void)
{
rc_map_unregister(&rc5_hauppauge_new_map);
}
module_init(init_rc_map_rc5_hauppauge_new)
module_exit(exit_rc_map_rc5_hauppauge_new)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-hauppauge.c |
// SPDX-License-Identifier: GPL-2.0+
// behold-columbus.h - Keytable for behold_columbus Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Beholder Intl. Ltd. 2008
* Dmitry Belimov [email protected]
* Keytable is used by BeholdTV Columbus
* The "ascii-art picture" below (in comments, first row
* is the keycode in hex, and subsequent row(s) shows
* the button labels (several variants when appropriate)
* helps to decide which keycodes to assign to the buttons.
*/
static struct rc_map_table behold_columbus[] = {
/* 0x13 0x11 0x1C 0x12 *
* Mute Source TV/FM Power *
* */
{ 0x13, KEY_MUTE },
{ 0x11, KEY_VIDEO },
{ 0x1C, KEY_TUNER }, /* KEY_TV/KEY_RADIO */
{ 0x12, KEY_POWER },
/* 0x01 0x02 0x03 0x0D *
* 1 2 3 Stereo *
* *
* 0x04 0x05 0x06 0x19 *
* 4 5 6 Snapshot *
* *
* 0x07 0x08 0x09 0x10 *
* 7 8 9 Zoom *
* */
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x0D, KEY_SETUP }, /* Setup key */
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x19, KEY_CAMERA }, /* Snapshot key */
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x10, KEY_ZOOM },
/* 0x0A 0x00 0x0B 0x0C *
* RECALL 0 ChannelUp VolumeUp *
* */
{ 0x0A, KEY_AGAIN },
{ 0x00, KEY_NUMERIC_0 },
{ 0x0B, KEY_CHANNELUP },
{ 0x0C, KEY_VOLUMEUP },
/* 0x1B 0x1D 0x15 0x18 *
* Timeshift Record ChannelDown VolumeDown *
* */
{ 0x1B, KEY_TIME },
{ 0x1D, KEY_RECORD },
{ 0x15, KEY_CHANNELDOWN },
{ 0x18, KEY_VOLUMEDOWN },
/* 0x0E 0x1E 0x0F 0x1A *
* Stop Pause Previous Next *
* */
{ 0x0E, KEY_STOP },
{ 0x1E, KEY_PAUSE },
{ 0x0F, KEY_PREVIOUS },
{ 0x1A, KEY_NEXT },
};
static struct rc_map_list behold_columbus_map = {
.map = {
.scan = behold_columbus,
.size = ARRAY_SIZE(behold_columbus),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_BEHOLD_COLUMBUS,
}
};
static int __init init_rc_map_behold_columbus(void)
{
return rc_map_register(&behold_columbus_map);
}
static void __exit exit_rc_map_behold_columbus(void)
{
rc_map_unregister(&behold_columbus_map);
}
module_init(init_rc_map_behold_columbus)
module_exit(exit_rc_map_behold_columbus)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-behold-columbus.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* DigitalNow TinyTwin remote controller keytable
*
* Copyright (C) 2010 Antti Palosaari <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table digitalnow_tinytwin[] = {
{ 0x0000, KEY_MUTE }, /* [symbol speaker] */
{ 0x0001, KEY_VOLUMEUP },
{ 0x0002, KEY_POWER2 }, /* TV [power button] */
{ 0x0003, KEY_NUMERIC_2 },
{ 0x0004, KEY_NUMERIC_3 },
{ 0x0005, KEY_NUMERIC_4 },
{ 0x0006, KEY_NUMERIC_6 },
{ 0x0007, KEY_NUMERIC_7 },
{ 0x0008, KEY_NUMERIC_8 },
{ 0x0009, KEY_NUMERIC_STAR }, /* [*] */
{ 0x000a, KEY_NUMERIC_0 },
{ 0x000b, KEY_NUMERIC_POUND }, /* [#] */
{ 0x000c, KEY_RIGHT }, /* [right arrow] */
{ 0x000d, KEY_HOMEPAGE }, /* [symbol home] Start */
{ 0x000e, KEY_RED }, /* [red] Videos */
{ 0x0010, KEY_POWER }, /* PC [power button] */
{ 0x0011, KEY_YELLOW }, /* [yellow] Pictures */
{ 0x0012, KEY_DOWN }, /* [down arrow] */
{ 0x0013, KEY_GREEN }, /* [green] Music */
{ 0x0014, KEY_CYCLEWINDOWS }, /* BACK */
{ 0x0015, KEY_FAVORITES }, /* MORE */
{ 0x0016, KEY_UP }, /* [up arrow] */
{ 0x0017, KEY_LEFT }, /* [left arrow] */
{ 0x0018, KEY_OK }, /* OK */
{ 0x0019, KEY_BLUE }, /* [blue] MyTV */
{ 0x001a, KEY_REWIND }, /* REW [<<] */
{ 0x001b, KEY_PLAY }, /* PLAY */
{ 0x001c, KEY_NUMERIC_5 },
{ 0x001d, KEY_NUMERIC_9 },
{ 0x001e, KEY_VOLUMEDOWN },
{ 0x001f, KEY_NUMERIC_1 },
{ 0x0040, KEY_STOP }, /* STOP */
{ 0x0042, KEY_PAUSE }, /* PAUSE */
{ 0x0043, KEY_SCREEN }, /* Aspect */
{ 0x0044, KEY_FORWARD }, /* FWD [>>] */
{ 0x0045, KEY_NEXT }, /* SKIP */
{ 0x0048, KEY_RECORD }, /* RECORD */
{ 0x0049, KEY_VIDEO }, /* RTV */
{ 0x004a, KEY_EPG }, /* Guide */
{ 0x004b, KEY_CHANNELUP },
{ 0x004c, KEY_HELP }, /* Help */
{ 0x004d, KEY_RADIO }, /* Radio */
{ 0x004f, KEY_CHANNELDOWN },
{ 0x0050, KEY_DVD }, /* DVD */
{ 0x0051, KEY_AUDIO }, /* Audio */
{ 0x0052, KEY_TITLE }, /* Title */
{ 0x0053, KEY_NEW }, /* [symbol PIP?] */
{ 0x0057, KEY_MENU }, /* Mouse */
{ 0x005a, KEY_PREVIOUS }, /* REPLAY */
};
static struct rc_map_list digitalnow_tinytwin_map = {
.map = {
.scan = digitalnow_tinytwin,
.size = ARRAY_SIZE(digitalnow_tinytwin),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_DIGITALNOW_TINYTWIN,
}
};
static int __init init_rc_map_digitalnow_tinytwin(void)
{
return rc_map_register(&digitalnow_tinytwin_map);
}
static void __exit exit_rc_map_digitalnow_tinytwin(void)
{
rc_map_unregister(&digitalnow_tinytwin_map);
}
module_init(init_rc_map_digitalnow_tinytwin)
module_exit(exit_rc_map_digitalnow_tinytwin)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Antti Palosaari <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-digitalnow-tinytwin.c |
// SPDX-License-Identifier: GPL-2.0+
// Keytable for the Pine64 IR Remote Controller
// Copyright (c) 2017 Jonas Karlman
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table pine64[] = {
{ 0x40404d, KEY_POWER },
{ 0x40401f, KEY_WWW },
{ 0x40400a, KEY_MUTE },
{ 0x404017, KEY_VOLUMEDOWN },
{ 0x404018, KEY_VOLUMEUP },
{ 0x404010, KEY_LEFT },
{ 0x404011, KEY_RIGHT },
{ 0x40400b, KEY_UP },
{ 0x40400e, KEY_DOWN },
{ 0x40400d, KEY_OK },
{ 0x40401d, KEY_MENU },
{ 0x40401a, KEY_HOME },
{ 0x404045, KEY_BACK },
{ 0x404001, KEY_NUMERIC_1 },
{ 0x404002, KEY_NUMERIC_2 },
{ 0x404003, KEY_NUMERIC_3 },
{ 0x404004, KEY_NUMERIC_4 },
{ 0x404005, KEY_NUMERIC_5 },
{ 0x404006, KEY_NUMERIC_6 },
{ 0x404007, KEY_NUMERIC_7 },
{ 0x404008, KEY_NUMERIC_8 },
{ 0x404009, KEY_NUMERIC_9 },
{ 0x40400c, KEY_BACKSPACE },
{ 0x404000, KEY_NUMERIC_0 },
{ 0x404047, KEY_EPG }, // mouse
};
static struct rc_map_list pine64_map = {
.map = {
.scan = pine64,
.size = ARRAY_SIZE(pine64),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_PINE64,
}
};
static int __init init_rc_map_pine64(void)
{
return rc_map_register(&pine64_map);
}
static void __exit exit_rc_map_pine64(void)
{
rc_map_unregister(&pine64_map);
}
module_init(init_rc_map_pine64)
module_exit(exit_rc_map_pine64)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jonas Karlman");
| linux-master | drivers/media/rc/keymaps/rc-pine64.c |
// SPDX-License-Identifier: GPL-2.0+
// Keytable for Xbox 360 Universal Media remote
// Copyright (c) 2021 Bastien Nocera <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Manual for remote available at:
* http://download.microsoft.com/download/b/c/e/bce76f3f-db51-4c98-b79d-b3d21e90ccc1/universalmediaremote_na_0609.pdf
*/
static struct rc_map_table xbox_360[] = {
{KEY_EJECTCD, 0x800f7428},
{KEY_HOMEPAGE, 0x800f7464},
{KEY_POWER, 0x800f740c},
{KEY_STOP, 0x800f7419},
{KEY_PAUSE, 0x800f7418},
{KEY_REWIND, 0x800f7415},
{KEY_FASTFORWARD, 0x800f7414},
{KEY_PREVIOUS, 0x800f741b},
{KEY_NEXT, 0x800f741a},
{KEY_PLAY, 0x800f7416},
{KEY_PROPS, 0x800f744f}, /* "Display" */
{KEY_BACK, 0x800f7423},
{KEY_MEDIA_TOP_MENU, 0x800f7424}, /* "DVD Menu" */
{KEY_ROOT_MENU, 0x800f7451}, /* "Title" */
{KEY_INFO, 0x800f740f},
{KEY_UP, 0x800f741e},
{KEY_LEFT, 0x800f7420},
{KEY_RIGHT, 0x800f7421},
{KEY_DOWN, 0x800f741f},
{KEY_OK, 0x800f7422},
{KEY_YELLOW, 0x800f7426},
{KEY_BLUE, 0x800f7468},
{KEY_GREEN, 0x800f7466},
{KEY_RED, 0x800f7425},
{KEY_VOLUMEUP, 0x800f7410},
{KEY_VOLUMEDOWN, 0x800f7411},
/* TV key doesn't light the IR LED */
{KEY_MUTE, 0x800f740e},
{KEY_CHANNELUP, 0x800f746c},
{KEY_CHANNELDOWN, 0x800f746d},
{KEY_LEFTMETA, 0x800f740d},
{KEY_ENTER, 0x800f740b},
{KEY_RECORD, 0x800f7417},
{KEY_CLEAR, 0x800f740a},
{KEY_NUMERIC_1, 0x800f7401},
{KEY_NUMERIC_2, 0x800f7402},
{KEY_NUMERIC_3, 0x800f7403},
{KEY_NUMERIC_4, 0x800f7404},
{KEY_NUMERIC_5, 0x800f7405},
{KEY_NUMERIC_6, 0x800f7406},
{KEY_NUMERIC_7, 0x800f7407},
{KEY_NUMERIC_8, 0x800f7408},
{KEY_NUMERIC_9, 0x800f7409},
{KEY_NUMERIC_0, 0x800f7400},
{KEY_102ND, 0x800f741d}, /* "100" */
{KEY_CANCEL, 0x800f741c},
};
static struct rc_map_list xbox_360_map = {
.map = {
.scan = xbox_360,
.size = ARRAY_SIZE(xbox_360),
.rc_proto = RC_PROTO_RC6_MCE,
.name = RC_MAP_XBOX_360,
}
};
static int __init init_rc_map(void)
{
return rc_map_register(&xbox_360_map);
}
static void __exit exit_rc_map(void)
{
rc_map_unregister(&xbox_360_map);
}
module_init(init_rc_map)
module_exit(exit_rc_map)
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-xbox-360.c |
// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2018 Christian Hewitt
#include <media/rc-map.h>
#include <linux/module.h>
/*
* This keymap is used with the WeTek Hub STB.
*/
static struct rc_map_table wetek_hub[] = {
{ 0x77f1, KEY_POWER },
{ 0x77f2, KEY_HOME },
{ 0x77f3, KEY_MUTE }, // mouse
{ 0x77f4, KEY_UP },
{ 0x77f5, KEY_DOWN },
{ 0x77f6, KEY_LEFT },
{ 0x77f7, KEY_RIGHT },
{ 0x77f8, KEY_OK },
{ 0x77f9, KEY_BACK },
{ 0x77fa, KEY_MENU },
{ 0x77fb, KEY_VOLUMEUP },
{ 0x77fc, KEY_VOLUMEDOWN },
};
static struct rc_map_list wetek_hub_map = {
.map = {
.scan = wetek_hub,
.size = ARRAY_SIZE(wetek_hub),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_WETEK_HUB,
}
};
static int __init init_rc_map_wetek_hub(void)
{
return rc_map_register(&wetek_hub_map);
}
static void __exit exit_rc_map_wetek_hub(void)
{
rc_map_unregister(&wetek_hub_map);
}
module_init(init_rc_map_wetek_hub)
module_exit(exit_rc_map_wetek_hub)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-wetek-hub.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Medion X10 OR22/OR24 RF remote keytable
*
* Copyright (C) 2012 Anssi Hannula <[email protected]>
*
* This keymap is for several Medion X10 remotes that have the Windows MCE
* button. This has been tested with a "RF VISTA Remote Control", OR24V,
* P/N 20035335, but should work with other variants that have the same
* buttons, such as OR22V and OR24E.
*/
#include <linux/module.h>
#include <media/rc-map.h>
static struct rc_map_table medion_x10_or2x[] = {
{ 0x02, KEY_POWER },
{ 0x16, KEY_TEXT }, /* "T" in a box, for teletext */
{ 0x09, KEY_VOLUMEUP },
{ 0x08, KEY_VOLUMEDOWN },
{ 0x00, KEY_MUTE },
{ 0x0b, KEY_CHANNELUP },
{ 0x0c, KEY_CHANNELDOWN },
{ 0x32, KEY_RED },
{ 0x33, KEY_GREEN },
{ 0x34, KEY_YELLOW },
{ 0x35, KEY_BLUE },
{ 0x18, KEY_PVR }, /* record symbol inside a tv symbol */
{ 0x04, KEY_DVD }, /* disc symbol */
{ 0x31, KEY_EPG }, /* a tv schedule symbol */
{ 0x1c, KEY_TV }, /* play symbol inside a tv symbol */
{ 0x20, KEY_BACK },
{ 0x2f, KEY_INFO },
{ 0x1a, KEY_UP },
{ 0x22, KEY_DOWN },
{ 0x1d, KEY_LEFT },
{ 0x1f, KEY_RIGHT },
{ 0x1e, KEY_OK },
{ 0x1b, KEY_MEDIA }, /* Windows MCE button */
{ 0x21, KEY_PREVIOUS },
{ 0x23, KEY_NEXT },
{ 0x24, KEY_REWIND },
{ 0x26, KEY_FORWARD },
{ 0x25, KEY_PLAY },
{ 0x28, KEY_STOP },
{ 0x29, KEY_PAUSE },
{ 0x27, KEY_RECORD },
{ 0x0d, KEY_NUMERIC_1 },
{ 0x0e, KEY_NUMERIC_2 },
{ 0x0f, KEY_NUMERIC_3 },
{ 0x10, KEY_NUMERIC_4 },
{ 0x11, KEY_NUMERIC_5 },
{ 0x12, KEY_NUMERIC_6 },
{ 0x13, KEY_NUMERIC_7 },
{ 0x14, KEY_NUMERIC_8 },
{ 0x15, KEY_NUMERIC_9 },
{ 0x17, KEY_NUMERIC_0 },
{ 0x30, KEY_CLEAR },
{ 0x36, KEY_ENTER },
{ 0x37, KEY_NUMERIC_STAR },
{ 0x38, KEY_NUMERIC_POUND },
};
static struct rc_map_list medion_x10_or2x_map = {
.map = {
.scan = medion_x10_or2x,
.size = ARRAY_SIZE(medion_x10_or2x),
.rc_proto = RC_PROTO_OTHER,
.name = RC_MAP_MEDION_X10_OR2X,
}
};
static int __init init_rc_map_medion_x10_or2x(void)
{
return rc_map_register(&medion_x10_or2x_map);
}
static void __exit exit_rc_map_medion_x10_or2x(void)
{
rc_map_unregister(&medion_x10_or2x_map);
}
module_init(init_rc_map_medion_x10_or2x)
module_exit(exit_rc_map_medion_x10_or2x)
MODULE_DESCRIPTION("Medion X10 OR22/OR24 RF remote keytable");
MODULE_AUTHOR("Anssi Hannula <[email protected]>");
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-medion-x10-or2x.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* SnapStream Firefly X10 RF remote keytable
*
* Copyright (C) 2011 Anssi Hannula <anssi.hannula@?ki.fi>
*/
#include <linux/module.h>
#include <media/rc-map.h>
static struct rc_map_table snapstream_firefly[] = {
{ 0x2c, KEY_ZOOM }, /* Maximize */
{ 0x02, KEY_CLOSE },
{ 0x0d, KEY_NUMERIC_1 },
{ 0x0e, KEY_NUMERIC_2 },
{ 0x0f, KEY_NUMERIC_3 },
{ 0x10, KEY_NUMERIC_4 },
{ 0x11, KEY_NUMERIC_5 },
{ 0x12, KEY_NUMERIC_6 },
{ 0x13, KEY_NUMERIC_7 },
{ 0x14, KEY_NUMERIC_8 },
{ 0x15, KEY_NUMERIC_9 },
{ 0x17, KEY_NUMERIC_0 },
{ 0x16, KEY_BACK },
{ 0x18, KEY_KPENTER }, /* ent */
{ 0x09, KEY_VOLUMEUP },
{ 0x08, KEY_VOLUMEDOWN },
{ 0x0a, KEY_MUTE },
{ 0x0b, KEY_CHANNELUP },
{ 0x0c, KEY_CHANNELDOWN },
{ 0x00, KEY_VENDOR }, /* firefly */
{ 0x2e, KEY_INFO },
{ 0x2f, KEY_OPTION },
{ 0x1d, KEY_LEFT },
{ 0x1f, KEY_RIGHT },
{ 0x22, KEY_DOWN },
{ 0x1a, KEY_UP },
{ 0x1e, KEY_OK },
{ 0x1c, KEY_MENU },
{ 0x20, KEY_EXIT },
{ 0x27, KEY_RECORD },
{ 0x25, KEY_PLAY },
{ 0x28, KEY_STOP },
{ 0x24, KEY_REWIND },
{ 0x26, KEY_FORWARD },
{ 0x29, KEY_PAUSE },
{ 0x2b, KEY_PREVIOUS },
{ 0x2a, KEY_NEXT },
{ 0x06, KEY_AUDIO }, /* Music */
{ 0x05, KEY_IMAGES }, /* Photos */
{ 0x04, KEY_DVD },
{ 0x03, KEY_TV },
{ 0x07, KEY_VIDEO },
{ 0x01, KEY_HELP },
{ 0x2d, KEY_MODE }, /* Mouse */
{ 0x19, KEY_A },
{ 0x1b, KEY_B },
{ 0x21, KEY_C },
{ 0x23, KEY_D },
};
static struct rc_map_list snapstream_firefly_map = {
.map = {
.scan = snapstream_firefly,
.size = ARRAY_SIZE(snapstream_firefly),
.rc_proto = RC_PROTO_OTHER,
.name = RC_MAP_SNAPSTREAM_FIREFLY,
}
};
static int __init init_rc_map_snapstream_firefly(void)
{
return rc_map_register(&snapstream_firefly_map);
}
static void __exit exit_rc_map_snapstream_firefly(void)
{
rc_map_unregister(&snapstream_firefly_map);
}
module_init(init_rc_map_snapstream_firefly)
module_exit(exit_rc_map_snapstream_firefly)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anssi Hannula <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-snapstream-firefly.c |
// SPDX-License-Identifier: GPL-2.0+
// gotview7135.h - Keytable for gotview7135 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Mike Baikov <[email protected]> */
static struct rc_map_table gotview7135[] = {
{ 0x11, KEY_POWER },
{ 0x35, KEY_TV },
{ 0x1b, KEY_NUMERIC_0 },
{ 0x29, KEY_NUMERIC_1 },
{ 0x19, KEY_NUMERIC_2 },
{ 0x39, KEY_NUMERIC_3 },
{ 0x1f, KEY_NUMERIC_4 },
{ 0x2c, KEY_NUMERIC_5 },
{ 0x21, KEY_NUMERIC_6 },
{ 0x24, KEY_NUMERIC_7 },
{ 0x18, KEY_NUMERIC_8 },
{ 0x2b, KEY_NUMERIC_9 },
{ 0x3b, KEY_AGAIN }, /* LOOP */
{ 0x06, KEY_AUDIO },
{ 0x31, KEY_PRINT }, /* PREVIEW */
{ 0x3e, KEY_VIDEO },
{ 0x10, KEY_CHANNELUP },
{ 0x20, KEY_CHANNELDOWN },
{ 0x0c, KEY_VOLUMEDOWN },
{ 0x28, KEY_VOLUMEUP },
{ 0x08, KEY_MUTE },
{ 0x26, KEY_SEARCH }, /* SCAN */
{ 0x3f, KEY_CAMERA }, /* SNAPSHOT */
{ 0x12, KEY_RECORD },
{ 0x32, KEY_STOP },
{ 0x3c, KEY_PLAY },
{ 0x1d, KEY_REWIND },
{ 0x2d, KEY_PAUSE },
{ 0x0d, KEY_FORWARD },
{ 0x05, KEY_ZOOM }, /*FULL*/
{ 0x2a, KEY_F21 }, /* LIVE TIMESHIFT */
{ 0x0e, KEY_F22 }, /* MIN TIMESHIFT */
{ 0x1e, KEY_TIME }, /* TIMESHIFT */
{ 0x38, KEY_F24 }, /* NORMAL TIMESHIFT */
};
static struct rc_map_list gotview7135_map = {
.map = {
.scan = gotview7135,
.size = ARRAY_SIZE(gotview7135),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_GOTVIEW7135,
}
};
static int __init init_rc_map_gotview7135(void)
{
return rc_map_register(&gotview7135_map);
}
static void __exit exit_rc_map_gotview7135(void)
{
rc_map_unregister(&gotview7135_map);
}
module_init(init_rc_map_gotview7135)
module_exit(exit_rc_map_gotview7135)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-gotview7135.c |
// SPDX-License-Identifier: GPL-2.0+
// videomate-tv-pvr.h - Keytable for videomate_tv_pvr Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table videomate_tv_pvr[] = {
{ 0x14, KEY_MUTE },
{ 0x24, KEY_ZOOM },
{ 0x01, KEY_DVD },
{ 0x23, KEY_RADIO },
{ 0x00, KEY_TV },
{ 0x0a, KEY_REWIND },
{ 0x08, KEY_PLAYPAUSE },
{ 0x0f, KEY_FORWARD },
{ 0x02, KEY_PREVIOUS },
{ 0x07, KEY_STOP },
{ 0x06, KEY_NEXT },
{ 0x0c, KEY_UP },
{ 0x0e, KEY_DOWN },
{ 0x0b, KEY_LEFT },
{ 0x0d, KEY_RIGHT },
{ 0x11, KEY_OK },
{ 0x03, KEY_MENU },
{ 0x09, KEY_SETUP },
{ 0x05, KEY_VIDEO },
{ 0x22, KEY_CHANNEL },
{ 0x12, KEY_VOLUMEUP },
{ 0x15, KEY_VOLUMEDOWN },
{ 0x10, KEY_CHANNELUP },
{ 0x13, KEY_CHANNELDOWN },
{ 0x04, KEY_RECORD },
{ 0x16, KEY_NUMERIC_1 },
{ 0x17, KEY_NUMERIC_2 },
{ 0x18, KEY_NUMERIC_3 },
{ 0x19, KEY_NUMERIC_4 },
{ 0x1a, KEY_NUMERIC_5 },
{ 0x1b, KEY_NUMERIC_6 },
{ 0x1c, KEY_NUMERIC_7 },
{ 0x1d, KEY_NUMERIC_8 },
{ 0x1e, KEY_NUMERIC_9 },
{ 0x1f, KEY_NUMERIC_0 },
{ 0x20, KEY_LANGUAGE },
{ 0x21, KEY_SLEEP },
};
static struct rc_map_list videomate_tv_pvr_map = {
.map = {
.scan = videomate_tv_pvr,
.size = ARRAY_SIZE(videomate_tv_pvr),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_VIDEOMATE_TV_PVR,
}
};
static int __init init_rc_map_videomate_tv_pvr(void)
{
return rc_map_register(&videomate_tv_pvr_map);
}
static void __exit exit_rc_map_videomate_tv_pvr(void)
{
rc_map_unregister(&videomate_tv_pvr_map);
}
module_init(init_rc_map_videomate_tv_pvr)
module_exit(exit_rc_map_videomate_tv_pvr)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-videomate-tv-pvr.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc-tivo.c - Keytable for TiVo remotes
*
* Copyright (c) 2011 by Jarod Wilson <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Initial mapping is for the TiVo remote included in the Nero LiquidTV bundle,
* which also ships with a TiVo-branded IR transceiver, supported by the mceusb
* driver. Note that the remote uses an NEC-ish protocol, but instead of having
* a command/not_command pair, it has a vendor ID of 0x3085, but some keys, the
* NEC extended checksums do pass, so the table presently has the intended
* values and the checksum-passed versions for those keys.
*/
static struct rc_map_table tivo[] = {
{ 0x3085f009, KEY_MEDIA }, /* TiVo Button */
{ 0x3085e010, KEY_POWER2 }, /* TV Power */
{ 0x3085e011, KEY_TV }, /* Live TV/Swap */
{ 0x3085c034, KEY_VIDEO_NEXT }, /* TV Input */
{ 0x3085e013, KEY_INFO },
{ 0x3085a05f, KEY_CYCLEWINDOWS }, /* Window */
{ 0x0085305f, KEY_CYCLEWINDOWS },
{ 0x3085c036, KEY_EPG }, /* Guide */
{ 0x3085e014, KEY_UP },
{ 0x3085e016, KEY_DOWN },
{ 0x3085e017, KEY_LEFT },
{ 0x3085e015, KEY_RIGHT },
{ 0x3085e018, KEY_SCROLLDOWN }, /* Red Thumbs Down */
{ 0x3085e019, KEY_SELECT },
{ 0x3085e01a, KEY_SCROLLUP }, /* Green Thumbs Up */
{ 0x3085e01c, KEY_VOLUMEUP },
{ 0x3085e01d, KEY_VOLUMEDOWN },
{ 0x3085e01b, KEY_MUTE },
{ 0x3085d020, KEY_RECORD },
{ 0x3085e01e, KEY_CHANNELUP },
{ 0x3085e01f, KEY_CHANNELDOWN },
{ 0x0085301f, KEY_CHANNELDOWN },
{ 0x3085d021, KEY_PLAY },
{ 0x3085d023, KEY_PAUSE },
{ 0x3085d025, KEY_SLOW },
{ 0x3085d022, KEY_REWIND },
{ 0x3085d024, KEY_FASTFORWARD },
{ 0x3085d026, KEY_PREVIOUS },
{ 0x3085d027, KEY_NEXT }, /* ->| */
{ 0x3085b044, KEY_ZOOM }, /* Aspect */
{ 0x3085b048, KEY_STOP },
{ 0x3085b04a, KEY_DVD }, /* DVD Menu */
{ 0x3085d028, KEY_NUMERIC_1 },
{ 0x3085d029, KEY_NUMERIC_2 },
{ 0x3085d02a, KEY_NUMERIC_3 },
{ 0x3085d02b, KEY_NUMERIC_4 },
{ 0x3085d02c, KEY_NUMERIC_5 },
{ 0x3085d02d, KEY_NUMERIC_6 },
{ 0x3085d02e, KEY_NUMERIC_7 },
{ 0x3085d02f, KEY_NUMERIC_8 },
{ 0x0085302f, KEY_NUMERIC_8 },
{ 0x3085c030, KEY_NUMERIC_9 },
{ 0x3085c031, KEY_NUMERIC_0 },
{ 0x3085c033, KEY_ENTER },
{ 0x3085c032, KEY_CLEAR },
};
static struct rc_map_list tivo_map = {
.map = {
.scan = tivo,
.size = ARRAY_SIZE(tivo),
.rc_proto = RC_PROTO_NEC32,
.name = RC_MAP_TIVO,
}
};
static int __init init_rc_map_tivo(void)
{
return rc_map_register(&tivo_map);
}
static void __exit exit_rc_map_tivo(void)
{
rc_map_unregister(&tivo_map);
}
module_init(init_rc_map_tivo)
module_exit(exit_rc_map_tivo)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jarod Wilson <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-tivo.c |
// SPDX-License-Identifier: GPL-2.0-only
/*
* keymap imported from cxusb.c
*
* Copyright (C) 2016 Sean Young
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table rc_map_dvico_mce_table[] = {
{ 0x0102, KEY_TV },
{ 0x010e, KEY_MP3 },
{ 0x011a, KEY_DVD },
{ 0x011e, KEY_FAVORITES },
{ 0x0116, KEY_SETUP },
{ 0x0146, KEY_POWER2 },
{ 0x010a, KEY_EPG },
{ 0x0149, KEY_BACK },
{ 0x014d, KEY_MENU },
{ 0x0151, KEY_UP },
{ 0x015b, KEY_LEFT },
{ 0x015f, KEY_RIGHT },
{ 0x0153, KEY_DOWN },
{ 0x015e, KEY_OK },
{ 0x0159, KEY_INFO },
{ 0x0155, KEY_TAB },
{ 0x010f, KEY_PREVIOUSSONG },/* Replay */
{ 0x0112, KEY_NEXTSONG }, /* Skip */
{ 0x0142, KEY_ENTER }, /* Windows/Start */
{ 0x0115, KEY_VOLUMEUP },
{ 0x0105, KEY_VOLUMEDOWN },
{ 0x0111, KEY_CHANNELUP },
{ 0x0109, KEY_CHANNELDOWN },
{ 0x0152, KEY_CAMERA },
{ 0x015a, KEY_TUNER }, /* Live */
{ 0x0119, KEY_OPEN },
{ 0x010b, KEY_NUMERIC_1 },
{ 0x0117, KEY_NUMERIC_2 },
{ 0x011b, KEY_NUMERIC_3 },
{ 0x0107, KEY_NUMERIC_4 },
{ 0x0150, KEY_NUMERIC_5 },
{ 0x0154, KEY_NUMERIC_6 },
{ 0x0148, KEY_NUMERIC_7 },
{ 0x014c, KEY_NUMERIC_8 },
{ 0x0158, KEY_NUMERIC_9 },
{ 0x0113, KEY_ANGLE }, /* Aspect */
{ 0x0103, KEY_NUMERIC_0 },
{ 0x011f, KEY_ZOOM },
{ 0x0143, KEY_REWIND },
{ 0x0147, KEY_PLAYPAUSE },
{ 0x014f, KEY_FASTFORWARD },
{ 0x0157, KEY_MUTE },
{ 0x010d, KEY_STOP },
{ 0x0101, KEY_RECORD },
{ 0x014e, KEY_POWER },
};
static struct rc_map_list dvico_mce_map = {
.map = {
.scan = rc_map_dvico_mce_table,
.size = ARRAY_SIZE(rc_map_dvico_mce_table),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_DVICO_MCE,
}
};
static int __init init_rc_map_dvico_mce(void)
{
return rc_map_register(&dvico_mce_map);
}
static void __exit exit_rc_map_dvico_mce(void)
{
rc_map_unregister(&dvico_mce_map);
}
module_init(init_rc_map_dvico_mce)
module_exit(exit_rc_map_dvico_mce)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-dvico-mce.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2019 Christian Hewitt <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
//
// Keytable for the WeTek Play 2 STB remote control
//
static struct rc_map_table wetek_play2[] = {
{ 0x5e5f02, KEY_POWER },
{ 0x5e5f46, KEY_SLEEP }, // tv
{ 0x5e5f10, KEY_MUTE },
{ 0x5e5f22, KEY_1 },
{ 0x5e5f23, KEY_2 },
{ 0x5e5f24, KEY_3 },
{ 0x5e5f25, KEY_4 },
{ 0x5e5f26, KEY_5 },
{ 0x5e5f27, KEY_6 },
{ 0x5e5f28, KEY_7 },
{ 0x5e5f29, KEY_8 },
{ 0x5e5f30, KEY_9 },
{ 0x5e5f71, KEY_BACK },
{ 0x5e5f21, KEY_0 },
{ 0x5e5f72, KEY_CAPSLOCK },
// outer ring clockwide from top
{ 0x5e5f03, KEY_HOME },
{ 0x5e5f61, KEY_BACK },
{ 0x5e5f77, KEY_CONFIG }, // mouse
{ 0x5e5f83, KEY_EPG },
{ 0x5e5f84, KEY_SCREEN }, // square
{ 0x5e5f48, KEY_MENU },
// inner ring
{ 0x5e5f50, KEY_UP },
{ 0x5e5f4b, KEY_DOWN },
{ 0x5e5f4c, KEY_LEFT },
{ 0x5e5f4d, KEY_RIGHT },
{ 0x5e5f47, KEY_OK },
{ 0x5e5f44, KEY_VOLUMEUP },
{ 0x5e5f43, KEY_VOLUMEDOWN },
{ 0x5e5f4f, KEY_FAVORITES },
{ 0x5e5f82, KEY_SUBTITLE }, // txt
{ 0x5e5f41, KEY_PAGEUP },
{ 0x5e5f42, KEY_PAGEDOWN },
{ 0x5e5f73, KEY_RED },
{ 0x5e5f74, KEY_GREEN },
{ 0x5e5f75, KEY_YELLOW },
{ 0x5e5f76, KEY_BLUE },
{ 0x5e5f67, KEY_PREVIOUSSONG },
{ 0x5e5f79, KEY_REWIND },
{ 0x5e5f80, KEY_FASTFORWARD },
{ 0x5e5f81, KEY_NEXTSONG },
{ 0x5e5f04, KEY_RECORD },
{ 0x5e5f2c, KEY_PLAYPAUSE },
{ 0x5e5f2b, KEY_STOP },
};
static struct rc_map_list wetek_play2_map = {
.map = {
.scan = wetek_play2,
.size = ARRAY_SIZE(wetek_play2),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_WETEK_PLAY2,
}
};
static int __init init_rc_map_wetek_play2(void)
{
return rc_map_register(&wetek_play2_map);
}
static void __exit exit_rc_map_wetek_play2(void)
{
rc_map_unregister(&wetek_play2_map);
}
module_init(init_rc_map_wetek_play2)
module_exit(exit_rc_map_wetek_play2)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]");
| linux-master | drivers/media/rc/keymaps/rc-wetek-play2.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Toshiba CT-90405 remote controller keytable
*
* Copyright (C) 2021 Alexander Voronov <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table ct_90405[] = {
{ 0x4014, KEY_SWITCHVIDEOMODE },
{ 0x4012, KEY_POWER },
{ 0x4044, KEY_TV },
{ 0x40be43, KEY_3D_MODE },
{ 0x400c, KEY_SUBTITLE },
{ 0x4001, KEY_NUMERIC_1 },
{ 0x4002, KEY_NUMERIC_2 },
{ 0x4003, KEY_NUMERIC_3 },
{ 0x4004, KEY_NUMERIC_4 },
{ 0x4005, KEY_NUMERIC_5 },
{ 0x4006, KEY_NUMERIC_6 },
{ 0x4007, KEY_NUMERIC_7 },
{ 0x4008, KEY_NUMERIC_8 },
{ 0x4009, KEY_NUMERIC_9 },
{ 0x4062, KEY_AUDIO_DESC },
{ 0x4000, KEY_NUMERIC_0 },
{ 0x401a, KEY_VOLUMEUP },
{ 0x401e, KEY_VOLUMEDOWN },
{ 0x4016, KEY_INFO },
{ 0x4010, KEY_MUTE },
{ 0x401b, KEY_CHANNELUP },
{ 0x401f, KEY_CHANNELDOWN },
{ 0x40da, KEY_VENDOR },
{ 0x4066, KEY_PLAYER },
{ 0x4017, KEY_TEXT },
{ 0x4047, KEY_LIST },
{ 0x4073, KEY_PAGEUP },
{ 0x4045, KEY_PROGRAM },
{ 0x4043, KEY_EXIT },
{ 0x4074, KEY_PAGEDOWN },
{ 0x4064, KEY_BACK },
{ 0x405b, KEY_MENU },
{ 0x4019, KEY_UP },
{ 0x4040, KEY_RIGHT },
{ 0x401d, KEY_DOWN },
{ 0x4042, KEY_LEFT },
{ 0x4021, KEY_OK },
{ 0x4053, KEY_REWIND },
{ 0x4067, KEY_PLAY },
{ 0x400d, KEY_FASTFORWARD },
{ 0x4054, KEY_PREVIOUS },
{ 0x4068, KEY_STOP },
{ 0x406a, KEY_PAUSE },
{ 0x4015, KEY_NEXT },
{ 0x4048, KEY_RED },
{ 0x4049, KEY_GREEN },
{ 0x404a, KEY_YELLOW },
{ 0x404b, KEY_BLUE },
{ 0x406f, KEY_RECORD }
};
static struct rc_map_list ct_90405_map = {
.map = {
.scan = ct_90405,
.size = ARRAY_SIZE(ct_90405),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_CT_90405,
}
};
static int __init init_rc_map_ct_90405(void)
{
return rc_map_register(&ct_90405_map);
}
static void __exit exit_rc_map_ct_90405(void)
{
rc_map_unregister(&ct_90405_map);
}
module_init(init_rc_map_ct_90405)
module_exit(exit_rc_map_ct_90405)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Alexander Voronov <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-ct-90405.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc5-imon-mce.c - Keytable for Windows Media Center RC-6 remotes for use
* with the SoundGraph iMON/Antec Veris hardware IR decoder
*
* Copyright (c) 2010 by Jarod Wilson <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* mce-mode imon mce remote key table */
static struct rc_map_table imon_mce[] = {
/* keys sorted mostly by frequency of use to optimize lookups */
{ 0x800ff415, KEY_REWIND },
{ 0x800ff414, KEY_FASTFORWARD },
{ 0x800ff41b, KEY_PREVIOUS },
{ 0x800ff41a, KEY_NEXT },
{ 0x800ff416, KEY_PLAY },
{ 0x800ff418, KEY_PAUSE },
{ 0x800ff419, KEY_STOP },
{ 0x800ff417, KEY_RECORD },
{ 0x02000052, KEY_UP },
{ 0x02000051, KEY_DOWN },
{ 0x02000050, KEY_LEFT },
{ 0x0200004f, KEY_RIGHT },
{ 0x800ff41e, KEY_UP },
{ 0x800ff41f, KEY_DOWN },
{ 0x800ff420, KEY_LEFT },
{ 0x800ff421, KEY_RIGHT },
/* 0x800ff40b also KEY_NUMERIC_POUND on some receivers */
{ 0x800ff40b, KEY_ENTER },
{ 0x02000028, KEY_ENTER },
/* the OK and Enter buttons decode to the same value on some remotes
{ 0x02000028, KEY_OK }, */
{ 0x800ff422, KEY_OK },
{ 0x0200002a, KEY_EXIT },
{ 0x800ff423, KEY_EXIT },
{ 0x02000029, KEY_DELETE },
/* 0x800ff40a also KEY_NUMERIC_STAR on some receivers */
{ 0x800ff40a, KEY_DELETE },
{ 0x800ff40e, KEY_MUTE },
{ 0x800ff410, KEY_VOLUMEUP },
{ 0x800ff411, KEY_VOLUMEDOWN },
{ 0x800ff412, KEY_CHANNELUP },
{ 0x800ff413, KEY_CHANNELDOWN },
{ 0x0200001e, KEY_NUMERIC_1 },
{ 0x0200001f, KEY_NUMERIC_2 },
{ 0x02000020, KEY_NUMERIC_3 },
{ 0x02000021, KEY_NUMERIC_4 },
{ 0x02000022, KEY_NUMERIC_5 },
{ 0x02000023, KEY_NUMERIC_6 },
{ 0x02000024, KEY_NUMERIC_7 },
{ 0x02000025, KEY_NUMERIC_8 },
{ 0x02000026, KEY_NUMERIC_9 },
{ 0x02000027, KEY_NUMERIC_0 },
{ 0x800ff401, KEY_NUMERIC_1 },
{ 0x800ff402, KEY_NUMERIC_2 },
{ 0x800ff403, KEY_NUMERIC_3 },
{ 0x800ff404, KEY_NUMERIC_4 },
{ 0x800ff405, KEY_NUMERIC_5 },
{ 0x800ff406, KEY_NUMERIC_6 },
{ 0x800ff407, KEY_NUMERIC_7 },
{ 0x800ff408, KEY_NUMERIC_8 },
{ 0x800ff409, KEY_NUMERIC_9 },
{ 0x800ff400, KEY_NUMERIC_0 },
{ 0x02200025, KEY_NUMERIC_STAR },
{ 0x02200020, KEY_NUMERIC_POUND },
/* 0x800ff41d also KEY_BLUE on some receivers */
{ 0x800ff41d, KEY_NUMERIC_STAR },
/* 0x800ff41c also KEY_PREVIOUS on some receivers */
{ 0x800ff41c, KEY_NUMERIC_POUND },
{ 0x800ff446, KEY_TV },
{ 0x800ff447, KEY_AUDIO }, /* My Music */
{ 0x800ff448, KEY_PVR }, /* RecordedTV */
{ 0x800ff449, KEY_CAMERA },
{ 0x800ff44a, KEY_VIDEO },
/* 0x800ff424 also KEY_MENU on some receivers */
{ 0x800ff424, KEY_DVD },
/* 0x800ff425 also KEY_GREEN on some receivers */
{ 0x800ff425, KEY_TUNER }, /* LiveTV */
{ 0x800ff450, KEY_RADIO },
{ 0x800ff44c, KEY_LANGUAGE },
{ 0x800ff427, KEY_ZOOM }, /* Aspect */
{ 0x800ff45b, KEY_RED },
{ 0x800ff45c, KEY_GREEN },
{ 0x800ff45d, KEY_YELLOW },
{ 0x800ff45e, KEY_BLUE },
{ 0x800ff466, KEY_RED },
/* { 0x800ff425, KEY_GREEN }, */
{ 0x800ff468, KEY_YELLOW },
/* { 0x800ff41d, KEY_BLUE }, */
{ 0x800ff40f, KEY_INFO },
{ 0x800ff426, KEY_EPG }, /* Guide */
{ 0x800ff45a, KEY_SUBTITLE }, /* Caption/Teletext */
{ 0x800ff44d, KEY_TITLE },
{ 0x800ff40c, KEY_POWER },
{ 0x800ff40d, KEY_MEDIA }, /* Windows MCE button */
};
static struct rc_map_list imon_mce_map = {
.map = {
.scan = imon_mce,
.size = ARRAY_SIZE(imon_mce),
/* its RC6, but w/a hardware decoder */
.rc_proto = RC_PROTO_RC6_MCE,
.name = RC_MAP_IMON_MCE,
}
};
static int __init init_rc_map_imon_mce(void)
{
return rc_map_register(&imon_mce_map);
}
static void __exit exit_rc_map_imon_mce(void)
{
rc_map_unregister(&imon_mce_map);
}
module_init(init_rc_map_imon_mce)
module_exit(exit_rc_map_imon_mce)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jarod Wilson <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-imon-mce.c |
// SPDX-License-Identifier: GPL-2.0+
// ati-tv-wonder-hd-600.h - Keytable for ati_tv_wonder_hd_600 Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* ATI TV Wonder HD 600 USB
Devin Heitmueller <[email protected]>
*/
static struct rc_map_table ati_tv_wonder_hd_600[] = {
{ 0x00, KEY_RECORD}, /* Row 1 */
{ 0x01, KEY_PLAYPAUSE},
{ 0x02, KEY_STOP},
{ 0x03, KEY_POWER},
{ 0x04, KEY_PREVIOUS}, /* Row 2 */
{ 0x05, KEY_REWIND},
{ 0x06, KEY_FORWARD},
{ 0x07, KEY_NEXT},
{ 0x08, KEY_EPG}, /* Row 3 */
{ 0x09, KEY_HOME},
{ 0x0a, KEY_MENU},
{ 0x0b, KEY_CHANNELUP},
{ 0x0c, KEY_BACK}, /* Row 4 */
{ 0x0d, KEY_UP},
{ 0x0e, KEY_INFO},
{ 0x0f, KEY_CHANNELDOWN},
{ 0x10, KEY_LEFT}, /* Row 5 */
{ 0x11, KEY_SELECT},
{ 0x12, KEY_RIGHT},
{ 0x13, KEY_VOLUMEUP},
{ 0x14, KEY_LAST}, /* Row 6 */
{ 0x15, KEY_DOWN},
{ 0x16, KEY_MUTE},
{ 0x17, KEY_VOLUMEDOWN},
};
static struct rc_map_list ati_tv_wonder_hd_600_map = {
.map = {
.scan = ati_tv_wonder_hd_600,
.size = ARRAY_SIZE(ati_tv_wonder_hd_600),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_ATI_TV_WONDER_HD_600,
}
};
static int __init init_rc_map_ati_tv_wonder_hd_600(void)
{
return rc_map_register(&ati_tv_wonder_hd_600_map);
}
static void __exit exit_rc_map_ati_tv_wonder_hd_600(void)
{
rc_map_unregister(&ati_tv_wonder_hd_600_map);
}
module_init(init_rc_map_ati_tv_wonder_hd_600)
module_exit(exit_rc_map_ati_tv_wonder_hd_600)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-ati-tv-wonder-hd-600.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc-streamzap.c - Keytable for Streamzap PC Remote, for use
* with the Streamzap PC Remote IR Receiver.
*
* Copyright (c) 2010 by Jarod Wilson <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table streamzap[] = {
/*
* The Streamzap remote is almost, but not quite, RC-5, as it has an extra
* bit in it.
*/
{ 0x28c0, KEY_NUMERIC_0 },
{ 0x28c1, KEY_NUMERIC_1 },
{ 0x28c2, KEY_NUMERIC_2 },
{ 0x28c3, KEY_NUMERIC_3 },
{ 0x28c4, KEY_NUMERIC_4 },
{ 0x28c5, KEY_NUMERIC_5 },
{ 0x28c6, KEY_NUMERIC_6 },
{ 0x28c7, KEY_NUMERIC_7 },
{ 0x28c8, KEY_NUMERIC_8 },
{ 0x28c9, KEY_NUMERIC_9 },
{ 0x28ca, KEY_POWER },
{ 0x28cb, KEY_MUTE },
{ 0x28cc, KEY_CHANNELUP },
{ 0x28cd, KEY_VOLUMEUP },
{ 0x28ce, KEY_CHANNELDOWN },
{ 0x28cf, KEY_VOLUMEDOWN },
{ 0x28d0, KEY_UP },
{ 0x28d1, KEY_LEFT },
{ 0x28d2, KEY_OK },
{ 0x28d3, KEY_RIGHT },
{ 0x28d4, KEY_DOWN },
{ 0x28d5, KEY_MENU },
{ 0x28d6, KEY_EXIT },
{ 0x28d7, KEY_PLAY },
{ 0x28d8, KEY_PAUSE },
{ 0x28d9, KEY_STOP },
{ 0x28da, KEY_BACK },
{ 0x28db, KEY_FORWARD },
{ 0x28dc, KEY_RECORD },
{ 0x28dd, KEY_REWIND },
{ 0x28de, KEY_FASTFORWARD },
{ 0x28e0, KEY_RED },
{ 0x28e1, KEY_GREEN },
{ 0x28e2, KEY_YELLOW },
{ 0x28e3, KEY_BLUE },
};
static struct rc_map_list streamzap_map = {
.map = {
.scan = streamzap,
.size = ARRAY_SIZE(streamzap),
.rc_proto = RC_PROTO_RC5_SZ,
.name = RC_MAP_STREAMZAP,
}
};
static int __init init_rc_map_streamzap(void)
{
return rc_map_register(&streamzap_map);
}
static void __exit exit_rc_map_streamzap(void)
{
rc_map_unregister(&streamzap_map);
}
module_init(init_rc_map_streamzap)
module_exit(exit_rc_map_streamzap)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jarod Wilson <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-streamzap.c |
// SPDX-License-Identifier: GPL-2.0+
// pixelview.h - Keytable for pixelview Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table pixelview[] = {
{ 0x1e, KEY_POWER }, /* power */
{ 0x07, KEY_VIDEO }, /* source */
{ 0x1c, KEY_SEARCH }, /* scan */
{ 0x03, KEY_TUNER }, /* TV/FM */
{ 0x00, KEY_RECORD },
{ 0x08, KEY_STOP },
{ 0x11, KEY_PLAY },
{ 0x1a, KEY_PLAYPAUSE }, /* freeze */
{ 0x19, KEY_ZOOM }, /* zoom */
{ 0x0f, KEY_TEXT }, /* min */
{ 0x01, KEY_NUMERIC_1 },
{ 0x0b, KEY_NUMERIC_2 },
{ 0x1b, KEY_NUMERIC_3 },
{ 0x05, KEY_NUMERIC_4 },
{ 0x09, KEY_NUMERIC_5 },
{ 0x15, KEY_NUMERIC_6 },
{ 0x06, KEY_NUMERIC_7 },
{ 0x0a, KEY_NUMERIC_8 },
{ 0x12, KEY_NUMERIC_9 },
{ 0x02, KEY_NUMERIC_0 },
{ 0x10, KEY_LAST }, /* +100 */
{ 0x13, KEY_LIST }, /* recall */
{ 0x1f, KEY_CHANNELUP }, /* chn down */
{ 0x17, KEY_CHANNELDOWN }, /* chn up */
{ 0x16, KEY_VOLUMEUP }, /* vol down */
{ 0x14, KEY_VOLUMEDOWN }, /* vol up */
{ 0x04, KEY_KPMINUS }, /* <<< */
{ 0x0e, KEY_SETUP }, /* function */
{ 0x0c, KEY_KPPLUS }, /* >>> */
{ 0x0d, KEY_GOTO }, /* mts */
{ 0x1d, KEY_REFRESH }, /* reset */
{ 0x18, KEY_MUTE }, /* mute/unmute */
};
static struct rc_map_list pixelview_map = {
.map = {
.scan = pixelview,
.size = ARRAY_SIZE(pixelview),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_PIXELVIEW,
}
};
static int __init init_rc_map_pixelview(void)
{
return rc_map_register(&pixelview_map);
}
static void __exit exit_rc_map_pixelview(void)
{
rc_map_unregister(&pixelview_map);
}
module_init(init_rc_map_pixelview)
module_exit(exit_rc_map_pixelview)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pixelview.c |
// SPDX-License-Identifier: GPL-2.0+
// nec-terratec-cinergy-xs.h - Keytable for nec_terratec_cinergy_xs Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Terratec Cinergy Hybrid T USB XS FM
Mauro Carvalho Chehab
*/
static struct rc_map_table nec_terratec_cinergy_xs[] = {
/* Terratec Grey IR, with most keys in orange */
{ 0x1441, KEY_HOME},
{ 0x1401, KEY_POWER2},
{ 0x1442, KEY_MENU}, /* DVD menu */
{ 0x1443, KEY_SUBTITLE},
{ 0x1444, KEY_TEXT}, /* Teletext */
{ 0x1445, KEY_DELETE},
{ 0x1402, KEY_NUMERIC_1},
{ 0x1403, KEY_NUMERIC_2},
{ 0x1404, KEY_NUMERIC_3},
{ 0x1405, KEY_NUMERIC_4},
{ 0x1406, KEY_NUMERIC_5},
{ 0x1407, KEY_NUMERIC_6},
{ 0x1408, KEY_NUMERIC_7},
{ 0x1409, KEY_NUMERIC_8},
{ 0x140a, KEY_NUMERIC_9},
{ 0x140c, KEY_NUMERIC_0},
{ 0x140b, KEY_TUNER}, /* AV */
{ 0x140d, KEY_MODE}, /* A.B */
{ 0x1446, KEY_TV},
{ 0x1447, KEY_DVD},
{ 0x1449, KEY_VIDEO},
{ 0x144a, KEY_RADIO}, /* Music */
{ 0x144b, KEY_CAMERA}, /* PIC */
{ 0x1410, KEY_UP},
{ 0x1411, KEY_LEFT},
{ 0x1412, KEY_OK},
{ 0x1413, KEY_RIGHT},
{ 0x1414, KEY_DOWN},
{ 0x140f, KEY_EPG},
{ 0x1416, KEY_INFO},
{ 0x144d, KEY_BACKSPACE},
{ 0x141c, KEY_VOLUMEUP},
{ 0x141e, KEY_VOLUMEDOWN},
{ 0x144c, KEY_PLAY},
{ 0x141d, KEY_MUTE},
{ 0x141b, KEY_CHANNELUP},
{ 0x141f, KEY_CHANNELDOWN},
{ 0x1417, KEY_RED},
{ 0x1418, KEY_GREEN},
{ 0x1419, KEY_YELLOW},
{ 0x141a, KEY_BLUE},
{ 0x1458, KEY_RECORD},
{ 0x1448, KEY_STOP},
{ 0x1440, KEY_PAUSE},
{ 0x1454, KEY_LAST},
{ 0x144e, KEY_REWIND},
{ 0x144f, KEY_FASTFORWARD},
{ 0x145c, KEY_NEXT},
/* Terratec Black IR, with most keys in black */
{ 0x04eb01, KEY_POWER2},
{ 0x04eb02, KEY_NUMERIC_1},
{ 0x04eb03, KEY_NUMERIC_2},
{ 0x04eb04, KEY_NUMERIC_3},
{ 0x04eb05, KEY_NUMERIC_4},
{ 0x04eb06, KEY_NUMERIC_5},
{ 0x04eb07, KEY_NUMERIC_6},
{ 0x04eb08, KEY_NUMERIC_7},
{ 0x04eb09, KEY_NUMERIC_8},
{ 0x04eb0a, KEY_NUMERIC_9},
{ 0x04eb0c, KEY_NUMERIC_0},
{ 0x04eb0b, KEY_TEXT}, /* TXT */
{ 0x04eb0d, KEY_REFRESH}, /* Refresh */
{ 0x04eb0e, KEY_HOME},
{ 0x04eb0f, KEY_EPG},
{ 0x04eb10, KEY_UP},
{ 0x04eb11, KEY_LEFT},
{ 0x04eb12, KEY_OK},
{ 0x04eb13, KEY_RIGHT},
{ 0x04eb14, KEY_DOWN},
{ 0x04eb15, KEY_BACKSPACE},
{ 0x04eb16, KEY_INFO},
{ 0x04eb17, KEY_RED},
{ 0x04eb18, KEY_GREEN},
{ 0x04eb19, KEY_YELLOW},
{ 0x04eb1a, KEY_BLUE},
{ 0x04eb1c, KEY_VOLUMEUP},
{ 0x04eb1e, KEY_VOLUMEDOWN},
{ 0x04eb1d, KEY_MUTE},
{ 0x04eb1b, KEY_CHANNELUP},
{ 0x04eb1f, KEY_CHANNELDOWN},
{ 0x04eb40, KEY_RECORD},
{ 0x04eb4c, KEY_PLAY},
{ 0x04eb58, KEY_PAUSE},
{ 0x04eb54, KEY_REWIND},
{ 0x04eb48, KEY_STOP},
{ 0x04eb5c, KEY_NEXT},
};
static struct rc_map_list nec_terratec_cinergy_xs_map = {
.map = {
.scan = nec_terratec_cinergy_xs,
.size = ARRAY_SIZE(nec_terratec_cinergy_xs),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_NEC_TERRATEC_CINERGY_XS,
}
};
static int __init init_rc_map_nec_terratec_cinergy_xs(void)
{
return rc_map_register(&nec_terratec_cinergy_xs_map);
}
static void __exit exit_rc_map_nec_terratec_cinergy_xs(void)
{
rc_map_unregister(&nec_terratec_cinergy_xs_map);
}
module_init(init_rc_map_nec_terratec_cinergy_xs)
module_exit(exit_rc_map_nec_terratec_cinergy_xs)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-nec-terratec-cinergy-xs.c |
// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2018 Christian Hewitt
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keymap for the Tanix TX5 max STB remote control
*/
static struct rc_map_table tanix_tx5max[] = {
{ 0x40404d, KEY_POWER },
{ 0x404043, KEY_MUTE },
{ 0x404017, KEY_VOLUMEDOWN },
{ 0x404018, KEY_VOLUMEUP },
{ 0x40400b, KEY_UP },
{ 0x404010, KEY_LEFT },
{ 0x404011, KEY_RIGHT },
{ 0x40400e, KEY_DOWN },
{ 0x40400d, KEY_OK },
{ 0x40401a, KEY_HOME },
{ 0x404045, KEY_MENU },
{ 0x404042, KEY_BACK },
{ 0x404001, KEY_1 },
{ 0x404002, KEY_2 },
{ 0x404003, KEY_3 },
{ 0x404004, KEY_4 },
{ 0x404005, KEY_5 },
{ 0x404006, KEY_6 },
{ 0x404007, KEY_7 },
{ 0x404008, KEY_8 },
{ 0x404009, KEY_9 },
{ 0x404047, KEY_SUBTITLE }, // mouse
{ 0x404000, KEY_0 },
{ 0x40400c, KEY_DELETE },
};
static struct rc_map_list tanix_tx5max_map = {
.map = {
.scan = tanix_tx5max,
.size = ARRAY_SIZE(tanix_tx5max),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_TANIX_TX5MAX,
}
};
static int __init init_rc_map_tanix_tx5max(void)
{
return rc_map_register(&tanix_tx5max_map);
}
static void __exit exit_rc_map_tanix_tx5max(void)
{
rc_map_unregister(&tanix_tx5max_map);
}
module_init(init_rc_map_tanix_tx5max)
module_exit(exit_rc_map_tanix_tx5max)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-tanix-tx5max.c |
// SPDX-License-Identifier: GPL-2.0-only
/*
* keymap imported from cxusb.c
*
* Copyright (C) 2016 Sean Young
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table rc_map_d680_dmb_table[] = {
{ 0x0038, KEY_SWITCHVIDEOMODE }, /* TV/AV */
{ 0x080c, KEY_ZOOM },
{ 0x0800, KEY_NUMERIC_0 },
{ 0x0001, KEY_NUMERIC_1 },
{ 0x0802, KEY_NUMERIC_2 },
{ 0x0003, KEY_NUMERIC_3 },
{ 0x0804, KEY_NUMERIC_4 },
{ 0x0005, KEY_NUMERIC_5 },
{ 0x0806, KEY_NUMERIC_6 },
{ 0x0007, KEY_NUMERIC_7 },
{ 0x0808, KEY_NUMERIC_8 },
{ 0x0009, KEY_NUMERIC_9 },
{ 0x000a, KEY_MUTE },
{ 0x0829, KEY_BACK },
{ 0x0012, KEY_CHANNELUP },
{ 0x0813, KEY_CHANNELDOWN },
{ 0x002b, KEY_VOLUMEUP },
{ 0x082c, KEY_VOLUMEDOWN },
{ 0x0020, KEY_UP },
{ 0x0821, KEY_DOWN },
{ 0x0011, KEY_LEFT },
{ 0x0810, KEY_RIGHT },
{ 0x000d, KEY_OK },
{ 0x081f, KEY_RECORD },
{ 0x0017, KEY_PLAYPAUSE },
{ 0x0816, KEY_PLAYPAUSE },
{ 0x000b, KEY_STOP },
{ 0x0827, KEY_FASTFORWARD },
{ 0x0026, KEY_REWIND },
{ 0x081e, KEY_UNKNOWN }, /* Time Shift */
{ 0x000e, KEY_UNKNOWN }, /* Snapshot */
{ 0x082d, KEY_UNKNOWN }, /* Mouse Cursor */
{ 0x000f, KEY_UNKNOWN }, /* Minimize/Maximize */
{ 0x0814, KEY_SHUFFLE }, /* Shuffle */
{ 0x0025, KEY_POWER },
};
static struct rc_map_list d680_dmb_map = {
.map = {
.scan = rc_map_d680_dmb_table,
.size = ARRAY_SIZE(rc_map_d680_dmb_table),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_D680_DMB,
}
};
static int __init init_rc_map_d680_dmb(void)
{
return rc_map_register(&d680_dmb_map);
}
static void __exit exit_rc_map_d680_dmb(void)
{
rc_map_unregister(&d680_dmb_map);
}
module_init(init_rc_map_d680_dmb)
module_exit(exit_rc_map_d680_dmb)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-d680-dmb.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* Keytable for Wideview WT-220U.
*
* Copyright (c) 2016 Jonathan McDowell <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
/* key list for the tiny remote control (Yakumo, don't know about the others) */
static struct rc_map_table dtt200u_table[] = {
{ 0x8001, KEY_MUTE },
{ 0x8002, KEY_CHANNELDOWN },
{ 0x8003, KEY_VOLUMEDOWN },
{ 0x8004, KEY_NUMERIC_1 },
{ 0x8005, KEY_NUMERIC_2 },
{ 0x8006, KEY_NUMERIC_3 },
{ 0x8007, KEY_NUMERIC_4 },
{ 0x8008, KEY_NUMERIC_5 },
{ 0x8009, KEY_NUMERIC_6 },
{ 0x800a, KEY_NUMERIC_7 },
{ 0x800c, KEY_ZOOM },
{ 0x800d, KEY_NUMERIC_0 },
{ 0x800e, KEY_SELECT },
{ 0x8012, KEY_POWER },
{ 0x801a, KEY_CHANNELUP },
{ 0x801b, KEY_NUMERIC_8 },
{ 0x801e, KEY_VOLUMEUP },
{ 0x801f, KEY_NUMERIC_9 },
};
static struct rc_map_list dtt200u_map = {
.map = {
.scan = dtt200u_table,
.size = ARRAY_SIZE(dtt200u_table),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_DTT200U,
}
};
static int __init init_rc_map_dtt200u(void)
{
return rc_map_register(&dtt200u_map);
}
static void __exit exit_rc_map_dtt200u(void)
{
rc_map_unregister(&dtt200u_map);
}
module_init(init_rc_map_dtt200u)
module_exit(exit_rc_map_dtt200u)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jonathan McDowell <[email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-dtt200u.c |
// SPDX-License-Identifier: GPL-2.0+
// evga-indtube.h - Keytable for evga_indtube Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* EVGA inDtube
Devin Heitmueller <[email protected]>
*/
static struct rc_map_table evga_indtube[] = {
{ 0x12, KEY_POWER},
{ 0x02, KEY_MODE}, /* TV */
{ 0x14, KEY_MUTE},
{ 0x1a, KEY_CHANNELUP},
{ 0x16, KEY_TV2}, /* PIP */
{ 0x1d, KEY_VOLUMEUP},
{ 0x05, KEY_CHANNELDOWN},
{ 0x0f, KEY_PLAYPAUSE},
{ 0x19, KEY_VOLUMEDOWN},
{ 0x1c, KEY_REWIND},
{ 0x0d, KEY_RECORD},
{ 0x18, KEY_FORWARD},
{ 0x1e, KEY_PREVIOUS},
{ 0x1b, KEY_STOP},
{ 0x1f, KEY_NEXT},
{ 0x13, KEY_CAMERA},
};
static struct rc_map_list evga_indtube_map = {
.map = {
.scan = evga_indtube,
.size = ARRAY_SIZE(evga_indtube),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_EVGA_INDTUBE,
}
};
static int __init init_rc_map_evga_indtube(void)
{
return rc_map_register(&evga_indtube_map);
}
static void __exit exit_rc_map_evga_indtube(void)
{
rc_map_unregister(&evga_indtube_map);
}
module_init(init_rc_map_evga_indtube)
module_exit(exit_rc_map_evga_indtube)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-evga-indtube.c |
// SPDX-License-Identifier: GPL-2.0+
// em-terratec.h - Keytable for em_terratec Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table em_terratec[] = {
{ 0x01, KEY_CHANNEL },
{ 0x02, KEY_SELECT },
{ 0x03, KEY_MUTE },
{ 0x04, KEY_POWER },
{ 0x05, KEY_NUMERIC_1 },
{ 0x06, KEY_NUMERIC_2 },
{ 0x07, KEY_NUMERIC_3 },
{ 0x08, KEY_CHANNELUP },
{ 0x09, KEY_NUMERIC_4 },
{ 0x0a, KEY_NUMERIC_5 },
{ 0x0b, KEY_NUMERIC_6 },
{ 0x0c, KEY_CHANNELDOWN },
{ 0x0d, KEY_NUMERIC_7 },
{ 0x0e, KEY_NUMERIC_8 },
{ 0x0f, KEY_NUMERIC_9 },
{ 0x10, KEY_VOLUMEUP },
{ 0x11, KEY_NUMERIC_0 },
{ 0x12, KEY_MENU },
{ 0x13, KEY_PRINT },
{ 0x14, KEY_VOLUMEDOWN },
{ 0x16, KEY_PAUSE },
{ 0x18, KEY_RECORD },
{ 0x19, KEY_REWIND },
{ 0x1a, KEY_PLAY },
{ 0x1b, KEY_FORWARD },
{ 0x1c, KEY_BACKSPACE },
{ 0x1e, KEY_STOP },
{ 0x40, KEY_ZOOM },
};
static struct rc_map_list em_terratec_map = {
.map = {
.scan = em_terratec,
.size = ARRAY_SIZE(em_terratec),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_EM_TERRATEC,
}
};
static int __init init_rc_map_em_terratec(void)
{
return rc_map_register(&em_terratec_map);
}
static void __exit exit_rc_map_em_terratec(void)
{
rc_map_unregister(&em_terratec_map);
}
module_init(init_rc_map_em_terratec)
module_exit(exit_rc_map_em_terratec)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-em-terratec.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2021 Christian Hewitt <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
//
// Keytable for the Minix NEO remote control
//
static struct rc_map_table minix_neo[] = {
{ 0x118, KEY_POWER },
{ 0x146, KEY_UP },
{ 0x116, KEY_DOWN },
{ 0x147, KEY_LEFT },
{ 0x115, KEY_RIGHT },
{ 0x155, KEY_ENTER },
{ 0x110, KEY_VOLUMEDOWN },
{ 0x140, KEY_BACK },
{ 0x114, KEY_VOLUMEUP },
{ 0x10d, KEY_HOME },
{ 0x104, KEY_MENU },
{ 0x112, KEY_CONFIG },
};
static struct rc_map_list minix_neo_map = {
.map = {
.scan = minix_neo,
.size = ARRAY_SIZE(minix_neo),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_MINIX_NEO,
}
};
static int __init init_rc_map_minix_neo(void)
{
return rc_map_register(&minix_neo_map);
}
static void __exit exit_rc_map_minix_neo(void)
{
rc_map_unregister(&minix_neo_map);
}
module_init(init_rc_map_minix_neo)
module_exit(exit_rc_map_minix_neo)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]");
| linux-master | drivers/media/rc/keymaps/rc-minix-neo.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc-technisat-ts35.c - Keytable for TechniSat TS35 remote
*
* Copyright (c) 2013 by Jan Klötzke <[email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table technisat_ts35[] = {
{0x32, KEY_MUTE},
{0x07, KEY_MEDIA},
{0x1c, KEY_AB},
{0x33, KEY_POWER},
{0x3e, KEY_NUMERIC_1},
{0x3d, KEY_NUMERIC_2},
{0x3c, KEY_NUMERIC_3},
{0x3b, KEY_NUMERIC_4},
{0x3a, KEY_NUMERIC_5},
{0x39, KEY_NUMERIC_6},
{0x38, KEY_NUMERIC_7},
{0x37, KEY_NUMERIC_8},
{0x36, KEY_NUMERIC_9},
{0x3f, KEY_NUMERIC_0},
{0x35, KEY_DIGITS},
{0x2c, KEY_TV},
{0x20, KEY_INFO},
{0x2d, KEY_MENU},
{0x1f, KEY_UP},
{0x1e, KEY_DOWN},
{0x2e, KEY_LEFT},
{0x2f, KEY_RIGHT},
{0x28, KEY_OK},
{0x10, KEY_EPG},
{0x1d, KEY_BACK},
{0x14, KEY_RED},
{0x13, KEY_GREEN},
{0x12, KEY_YELLOW},
{0x11, KEY_BLUE},
{0x09, KEY_SELECT},
{0x03, KEY_TEXT},
{0x16, KEY_STOP},
{0x30, KEY_HELP},
};
static struct rc_map_list technisat_ts35_map = {
.map = {
.scan = technisat_ts35,
.size = ARRAY_SIZE(technisat_ts35),
.rc_proto = RC_PROTO_UNKNOWN,
.name = RC_MAP_TECHNISAT_TS35,
}
};
static int __init init_rc_map(void)
{
return rc_map_register(&technisat_ts35_map);
}
static void __exit exit_rc_map(void)
{
rc_map_unregister(&technisat_ts35_map);
}
module_init(init_rc_map)
module_exit(exit_rc_map)
MODULE_LICENSE("GPL");
| linux-master | drivers/media/rc/keymaps/rc-technisat-ts35.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2021 Christian Hewitt <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
//
// Keytable for the Mecool Kiii Pro remote control
//
static struct rc_map_table mecool_kiii_pro[] = {
{ 0x59, KEY_POWER },
{ 0x52, KEY_1 },
{ 0x50, KEY_2 },
{ 0x10, KEY_3 },
{ 0x56, KEY_4 },
{ 0x54, KEY_5 },
{ 0x14, KEY_6 },
{ 0x4e, KEY_7 },
{ 0x4c, KEY_8 },
{ 0x0c, KEY_9 },
{ 0x02, KEY_INFO },
{ 0x0f, KEY_0 },
{ 0x51, KEY_DELETE },
{ 0x1f, KEY_FAVORITES},
{ 0x09, KEY_SUBTITLE },
{ 0x01, KEY_LANGUAGE }, // AUDIO
{ 0x42, KEY_RED },
{ 0x40, KEY_GREEN },
{ 0x00, KEY_YELLOW},
{ 0x03, KEY_BLUE }, // RADIO
{ 0x0d, KEY_HOME },
{ 0x4d, KEY_EPG },
{ 0x45, KEY_MENU },
{ 0x05, KEY_EXIT },
{ 0x5a, KEY_LEFT },
{ 0x1b, KEY_RIGHT },
{ 0x06, KEY_UP },
{ 0x16, KEY_DOWN },
{ 0x1a, KEY_OK },
{ 0x13, KEY_VOLUMEUP },
{ 0x17, KEY_VOLUMEDOWN },
{ 0x19, KEY_MUTE },
{ 0x12, KEY_CONTEXT_MENU }, // MOUSE
{ 0x55, KEY_CHANNELUP }, // PAGE_UP
{ 0x15, KEY_CHANNELDOWN }, // PAGE_DOWN
{ 0x4a, KEY_REWIND },
{ 0x48, KEY_FORWARD },
{ 0x46, KEY_PLAYPAUSE },
{ 0x44, KEY_STOP },
{ 0x08, KEY_PREVIOUSSONG},
{ 0x0b, KEY_NEXTSONG},
{ 0x04, KEY_PVR },
{ 0x64, KEY_RECORD },
};
static struct rc_map_list mecool_kiii_pro_map = {
.map = {
.scan = mecool_kiii_pro,
.size = ARRAY_SIZE(mecool_kiii_pro),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_MECOOL_KIII_PRO,
}
};
static int __init init_rc_map_mecool_kiii_pro(void)
{
return rc_map_register(&mecool_kiii_pro_map);
}
static void __exit exit_rc_map_mecool_kiii_pro(void)
{
rc_map_unregister(&mecool_kiii_pro_map);
}
module_init(init_rc_map_mecool_kiii_pro)
module_exit(exit_rc_map_mecool_kiii_pro)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]");
| linux-master | drivers/media/rc/keymaps/rc-mecool-kiii-pro.c |
// SPDX-License-Identifier: GPL-2.0+
// pinnacle-pctv-hd.h - Keytable for pinnacle_pctv_hd Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Pinnacle PCTV HD 800i mini remote */
static struct rc_map_table pinnacle_pctv_hd[] = {
/* Key codes for the tiny Pinnacle remote*/
{ 0x0700, KEY_MUTE },
{ 0x0701, KEY_MENU }, /* Pinnacle logo */
{ 0x0739, KEY_POWER },
{ 0x0703, KEY_VOLUMEUP },
{ 0x0705, KEY_OK },
{ 0x0709, KEY_VOLUMEDOWN },
{ 0x0706, KEY_CHANNELUP },
{ 0x070c, KEY_CHANNELDOWN },
{ 0x070f, KEY_NUMERIC_1 },
{ 0x0715, KEY_NUMERIC_2 },
{ 0x0710, KEY_NUMERIC_3 },
{ 0x0718, KEY_NUMERIC_4 },
{ 0x071b, KEY_NUMERIC_5 },
{ 0x071e, KEY_NUMERIC_6 },
{ 0x0711, KEY_NUMERIC_7 },
{ 0x0721, KEY_NUMERIC_8 },
{ 0x0712, KEY_NUMERIC_9 },
{ 0x0727, KEY_NUMERIC_0 },
{ 0x0724, KEY_ZOOM }, /* 'Square' key */
{ 0x072a, KEY_SUBTITLE }, /* 'T' key */
{ 0x072d, KEY_REWIND },
{ 0x0730, KEY_PLAYPAUSE },
{ 0x0733, KEY_FASTFORWARD },
{ 0x0736, KEY_RECORD },
{ 0x073c, KEY_STOP },
{ 0x073f, KEY_HELP }, /* '?' key */
};
static struct rc_map_list pinnacle_pctv_hd_map = {
.map = {
.scan = pinnacle_pctv_hd,
.size = ARRAY_SIZE(pinnacle_pctv_hd),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_PINNACLE_PCTV_HD,
}
};
static int __init init_rc_map_pinnacle_pctv_hd(void)
{
return rc_map_register(&pinnacle_pctv_hd_map);
}
static void __exit exit_rc_map_pinnacle_pctv_hd(void)
{
rc_map_unregister(&pinnacle_pctv_hd_map);
}
module_init(init_rc_map_pinnacle_pctv_hd)
module_exit(exit_rc_map_pinnacle_pctv_hd)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pinnacle-pctv-hd.c |
// SPDX-License-Identifier: GPL-2.0+
// kworld-plus-tv-analog.h - Keytable for kworld_plus_tv_analog Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Kworld Plus TV Analog Lite PCI IR
Mauro Carvalho Chehab <[email protected]>
*/
static struct rc_map_table kworld_plus_tv_analog[] = {
{ 0x0c, KEY_MEDIA }, /* Kworld key */
{ 0x16, KEY_CLOSECD }, /* -> ) */
{ 0x1d, KEY_POWER2 },
{ 0x00, KEY_NUMERIC_1 },
{ 0x01, KEY_NUMERIC_2 },
/* Two keys have the same code: 3 and left */
{ 0x02, KEY_NUMERIC_3 },
/* Two keys have the same code: 4 and right */
{ 0x03, KEY_NUMERIC_4 },
{ 0x04, KEY_NUMERIC_5 },
{ 0x05, KEY_NUMERIC_6 },
{ 0x06, KEY_NUMERIC_7 },
{ 0x07, KEY_NUMERIC_8 },
{ 0x08, KEY_NUMERIC_9 },
{ 0x0a, KEY_NUMERIC_0 },
{ 0x09, KEY_AGAIN },
{ 0x14, KEY_MUTE },
{ 0x20, KEY_UP },
{ 0x21, KEY_DOWN },
{ 0x0b, KEY_ENTER },
{ 0x10, KEY_CHANNELUP },
{ 0x11, KEY_CHANNELDOWN },
/* Couldn't map key left/key right since those
conflict with '3' and '4' scancodes
I dunno what the original driver does
*/
{ 0x13, KEY_VOLUMEUP },
{ 0x12, KEY_VOLUMEDOWN },
/* The lower part of the IR
There are several duplicated keycodes there.
Most of them conflict with digits.
Add mappings just to the unused scancodes.
Somehow, the original driver has a way to know,
but this doesn't seem to be on some GPIO.
Also, it is not related to the time between keyup
and keydown.
*/
{ 0x19, KEY_TIME}, /* Timeshift */
{ 0x1a, KEY_STOP},
{ 0x1b, KEY_RECORD},
{ 0x22, KEY_TEXT},
{ 0x15, KEY_AUDIO}, /* ((*)) */
{ 0x0f, KEY_ZOOM},
{ 0x1c, KEY_CAMERA}, /* snapshot */
{ 0x18, KEY_RED}, /* B */
{ 0x23, KEY_GREEN}, /* C */
};
static struct rc_map_list kworld_plus_tv_analog_map = {
.map = {
.scan = kworld_plus_tv_analog,
.size = ARRAY_SIZE(kworld_plus_tv_analog),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_KWORLD_PLUS_TV_ANALOG,
}
};
static int __init init_rc_map_kworld_plus_tv_analog(void)
{
return rc_map_register(&kworld_plus_tv_analog_map);
}
static void __exit exit_rc_map_kworld_plus_tv_analog(void)
{
rc_map_unregister(&kworld_plus_tv_analog_map);
}
module_init(init_rc_map_kworld_plus_tv_analog)
module_exit(exit_rc_map_kworld_plus_tv_analog)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-kworld-plus-tv-analog.c |
// SPDX-License-Identifier: GPL-2.0+
// fusionhdtv-mce.h - Keytable for fusionhdtv_mce Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* DViCO FUSION HDTV MCE remote */
static struct rc_map_table fusionhdtv_mce[] = {
{ 0x0b, KEY_NUMERIC_1 },
{ 0x17, KEY_NUMERIC_2 },
{ 0x1b, KEY_NUMERIC_3 },
{ 0x07, KEY_NUMERIC_4 },
{ 0x50, KEY_NUMERIC_5 },
{ 0x54, KEY_NUMERIC_6 },
{ 0x48, KEY_NUMERIC_7 },
{ 0x4c, KEY_NUMERIC_8 },
{ 0x58, KEY_NUMERIC_9 },
{ 0x03, KEY_NUMERIC_0 },
{ 0x5e, KEY_OK },
{ 0x51, KEY_UP },
{ 0x53, KEY_DOWN },
{ 0x5b, KEY_LEFT },
{ 0x5f, KEY_RIGHT },
{ 0x02, KEY_TV }, /* Labeled DTV on remote */
{ 0x0e, KEY_MP3 },
{ 0x1a, KEY_DVD },
{ 0x1e, KEY_FAVORITES }, /* Labeled CPF on remote */
{ 0x16, KEY_SETUP },
{ 0x46, KEY_POWER2 }, /* TV On/Off button on remote */
{ 0x0a, KEY_EPG }, /* Labeled Guide on remote */
{ 0x49, KEY_BACK },
{ 0x59, KEY_INFO }, /* Labeled MORE on remote */
{ 0x4d, KEY_MENU }, /* Labeled DVDMENU on remote */
{ 0x55, KEY_CYCLEWINDOWS }, /* Labeled ALT-TAB on remote */
{ 0x0f, KEY_PREVIOUSSONG }, /* Labeled |<< REPLAY on remote */
{ 0x12, KEY_NEXTSONG }, /* Labeled >>| SKIP on remote */
{ 0x42, KEY_ENTER }, /* Labeled START with a green
MS windows logo on remote */
{ 0x15, KEY_VOLUMEUP },
{ 0x05, KEY_VOLUMEDOWN },
{ 0x11, KEY_CHANNELUP },
{ 0x09, KEY_CHANNELDOWN },
{ 0x52, KEY_CAMERA },
{ 0x5a, KEY_TUNER },
{ 0x19, KEY_OPEN },
{ 0x13, KEY_MODE }, /* 4:3 16:9 select */
{ 0x1f, KEY_ZOOM },
{ 0x43, KEY_REWIND },
{ 0x47, KEY_PLAYPAUSE },
{ 0x4f, KEY_FASTFORWARD },
{ 0x57, KEY_MUTE },
{ 0x0d, KEY_STOP },
{ 0x01, KEY_RECORD },
{ 0x4e, KEY_POWER },
};
static struct rc_map_list fusionhdtv_mce_map = {
.map = {
.scan = fusionhdtv_mce,
.size = ARRAY_SIZE(fusionhdtv_mce),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_FUSIONHDTV_MCE,
}
};
static int __init init_rc_map_fusionhdtv_mce(void)
{
return rc_map_register(&fusionhdtv_mce_map);
}
static void __exit exit_rc_map_fusionhdtv_mce(void)
{
rc_map_unregister(&fusionhdtv_mce_map);
}
module_init(init_rc_map_fusionhdtv_mce)
module_exit(exit_rc_map_fusionhdtv_mce)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-fusionhdtv-mce.c |
// SPDX-License-Identifier: GPL-2.0+
// rc-pixelview-mk12.h - Keytable for pixelview Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/*
* Keytable for 002-T IR remote provided together with Pixelview
* SBTVD Hybrid Remote Controller. Uses NEC extended format.
*/
static struct rc_map_table pixelview_002t[] = {
{ 0x866b13, KEY_MUTE },
{ 0x866b12, KEY_POWER2 }, /* power */
{ 0x866b01, KEY_NUMERIC_1 },
{ 0x866b02, KEY_NUMERIC_2 },
{ 0x866b03, KEY_NUMERIC_3 },
{ 0x866b04, KEY_NUMERIC_4 },
{ 0x866b05, KEY_NUMERIC_5 },
{ 0x866b06, KEY_NUMERIC_6 },
{ 0x866b07, KEY_NUMERIC_7 },
{ 0x866b08, KEY_NUMERIC_8 },
{ 0x866b09, KEY_NUMERIC_9 },
{ 0x866b00, KEY_NUMERIC_0 },
{ 0x866b0d, KEY_CHANNELUP },
{ 0x866b19, KEY_CHANNELDOWN },
{ 0x866b10, KEY_VOLUMEUP }, /* vol + */
{ 0x866b0c, KEY_VOLUMEDOWN }, /* vol - */
{ 0x866b0a, KEY_CAMERA }, /* snapshot */
{ 0x866b0b, KEY_ZOOM }, /* zoom */
{ 0x866b1b, KEY_BACKSPACE },
{ 0x866b15, KEY_ENTER },
{ 0x866b1d, KEY_UP },
{ 0x866b1e, KEY_DOWN },
{ 0x866b0e, KEY_LEFT },
{ 0x866b0f, KEY_RIGHT },
{ 0x866b18, KEY_RECORD },
{ 0x866b1a, KEY_STOP },
};
static struct rc_map_list pixelview_map = {
.map = {
.scan = pixelview_002t,
.size = ARRAY_SIZE(pixelview_002t),
.rc_proto = RC_PROTO_NECX,
.name = RC_MAP_PIXELVIEW_002T,
}
};
static int __init init_rc_map_pixelview(void)
{
return rc_map_register(&pixelview_map);
}
static void __exit exit_rc_map_pixelview(void)
{
rc_map_unregister(&pixelview_map);
}
module_init(init_rc_map_pixelview)
module_exit(exit_rc_map_pixelview)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-pixelview-002t.c |
// SPDX-License-Identifier: GPL-2.0+
// msi-tvanywhere.h - Keytable for msi_tvanywhere Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* MSI TV@nywhere MASTER remote */
static struct rc_map_table msi_tvanywhere[] = {
/* Keys 0 to 9 */
{ 0x00, KEY_NUMERIC_0 },
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x0c, KEY_MUTE },
{ 0x0f, KEY_SCREEN }, /* Full Screen */
{ 0x10, KEY_FN }, /* Function */
{ 0x11, KEY_TIME }, /* Time shift */
{ 0x12, KEY_POWER },
{ 0x13, KEY_MEDIA }, /* MTS */
{ 0x14, KEY_SLOW },
{ 0x16, KEY_REWIND }, /* backward << */
{ 0x17, KEY_ENTER }, /* Return */
{ 0x18, KEY_FASTFORWARD }, /* forward >> */
{ 0x1a, KEY_CHANNELUP },
{ 0x1b, KEY_VOLUMEUP },
{ 0x1e, KEY_CHANNELDOWN },
{ 0x1f, KEY_VOLUMEDOWN },
};
static struct rc_map_list msi_tvanywhere_map = {
.map = {
.scan = msi_tvanywhere,
.size = ARRAY_SIZE(msi_tvanywhere),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_MSI_TVANYWHERE,
}
};
static int __init init_rc_map_msi_tvanywhere(void)
{
return rc_map_register(&msi_tvanywhere_map);
}
static void __exit exit_rc_map_msi_tvanywhere(void)
{
rc_map_unregister(&msi_tvanywhere_map);
}
module_init(init_rc_map_msi_tvanywhere)
module_exit(exit_rc_map_msi_tvanywhere)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-msi-tvanywhere.c |
// SPDX-License-Identifier: GPL-2.0+
// terratec-cinergy-xs.h - Keytable for terratec_cinergy_xs Remote Controller
//
// keymap imported from ir-keymaps.c
//
// Copyright (c) 2010 by Mauro Carvalho Chehab
#include <media/rc-map.h>
#include <linux/module.h>
/* Terratec Cinergy Hybrid T USB XS
Devin Heitmueller <[email protected]>
*/
static struct rc_map_table terratec_cinergy_xs[] = {
{ 0x41, KEY_HOME},
{ 0x01, KEY_POWER},
{ 0x42, KEY_MENU},
{ 0x02, KEY_NUMERIC_1},
{ 0x03, KEY_NUMERIC_2},
{ 0x04, KEY_NUMERIC_3},
{ 0x43, KEY_SUBTITLE},
{ 0x05, KEY_NUMERIC_4},
{ 0x06, KEY_NUMERIC_5},
{ 0x07, KEY_NUMERIC_6},
{ 0x44, KEY_TEXT},
{ 0x08, KEY_NUMERIC_7},
{ 0x09, KEY_NUMERIC_8},
{ 0x0a, KEY_NUMERIC_9},
{ 0x45, KEY_DELETE},
{ 0x0b, KEY_TUNER},
{ 0x0c, KEY_NUMERIC_0},
{ 0x0d, KEY_MODE},
{ 0x46, KEY_TV},
{ 0x47, KEY_DVD},
{ 0x49, KEY_VIDEO},
{ 0x4b, KEY_AUX},
{ 0x10, KEY_UP},
{ 0x11, KEY_LEFT},
{ 0x12, KEY_OK},
{ 0x13, KEY_RIGHT},
{ 0x14, KEY_DOWN},
{ 0x0f, KEY_EPG},
{ 0x16, KEY_INFO},
{ 0x4d, KEY_BACKSPACE},
{ 0x1c, KEY_VOLUMEUP},
{ 0x4c, KEY_PLAY},
{ 0x1b, KEY_CHANNELUP},
{ 0x1e, KEY_VOLUMEDOWN},
{ 0x1d, KEY_MUTE},
{ 0x1f, KEY_CHANNELDOWN},
{ 0x17, KEY_RED},
{ 0x18, KEY_GREEN},
{ 0x19, KEY_YELLOW},
{ 0x1a, KEY_BLUE},
{ 0x58, KEY_RECORD},
{ 0x48, KEY_STOP},
{ 0x40, KEY_PAUSE},
{ 0x54, KEY_LAST},
{ 0x4e, KEY_REWIND},
{ 0x4f, KEY_FASTFORWARD},
{ 0x5c, KEY_NEXT},
};
static struct rc_map_list terratec_cinergy_xs_map = {
.map = {
.scan = terratec_cinergy_xs,
.size = ARRAY_SIZE(terratec_cinergy_xs),
.rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
.name = RC_MAP_TERRATEC_CINERGY_XS,
}
};
static int __init init_rc_map_terratec_cinergy_xs(void)
{
return rc_map_register(&terratec_cinergy_xs_map);
}
static void __exit exit_rc_map_terratec_cinergy_xs(void)
{
rc_map_unregister(&terratec_cinergy_xs_map);
}
module_init(init_rc_map_terratec_cinergy_xs)
module_exit(exit_rc_map_terratec_cinergy_xs)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mauro Carvalho Chehab");
| linux-master | drivers/media/rc/keymaps/rc-terratec-cinergy-xs.c |
// SPDX-License-Identifier: GPL-2.0+
//
// Copyright (C) 2021 Christian Hewitt <[email protected]>
#include <media/rc-map.h>
#include <linux/module.h>
//
// Keytable for the Mecool Kii Pro remote control
//
static struct rc_map_table mecool_kii_pro[] = {
{ 0x59, KEY_POWER },
{ 0x19, KEY_MUTE },
{ 0x42, KEY_RED },
{ 0x40, KEY_GREEN },
{ 0x00, KEY_YELLOW},
{ 0x03, KEY_BLUE },
{ 0x4a, KEY_REWIND },
{ 0x48, KEY_FORWARD },
{ 0x08, KEY_PREVIOUSSONG},
{ 0x0b, KEY_NEXTSONG},
{ 0x46, KEY_PLAYPAUSE },
{ 0x44, KEY_STOP },
{ 0x1f, KEY_FAVORITES},
{ 0x04, KEY_PVR },
{ 0x4d, KEY_EPG },
{ 0x02, KEY_INFO },
{ 0x09, KEY_SUBTITLE },
{ 0x01, KEY_LANGUAGE }, // AUDIO
{ 0x0d, KEY_HOME },
{ 0x11, KEY_TV },
{ 0x45, KEY_MENU },
{ 0x05, KEY_EXIT },
{ 0x5a, KEY_LEFT },
{ 0x1b, KEY_RIGHT },
{ 0x06, KEY_UP },
{ 0x16, KEY_DOWN },
{ 0x1a, KEY_OK },
{ 0x13, KEY_VOLUMEUP },
{ 0x17, KEY_VOLUMEDOWN },
{ 0x58, KEY_APPSELECT }, // APPS
{ 0x12, KEY_CONTEXT_MENU }, // MOUSE
{ 0x55, KEY_CHANNELUP }, // PAGE_UP
{ 0x15, KEY_CHANNELDOWN }, // PAGE_DOWN
{ 0x52, KEY_1 },
{ 0x50, KEY_2 },
{ 0x10, KEY_3 },
{ 0x56, KEY_4 },
{ 0x54, KEY_5 },
{ 0x14, KEY_6 },
{ 0x4e, KEY_7 },
{ 0x4c, KEY_8 },
{ 0x0c, KEY_9 },
{ 0x18, KEY_WWW },
{ 0x0f, KEY_0 },
{ 0x51, KEY_DELETE },
};
static struct rc_map_list mecool_kii_pro_map = {
.map = {
.scan = mecool_kii_pro,
.size = ARRAY_SIZE(mecool_kii_pro),
.rc_proto = RC_PROTO_NEC,
.name = RC_MAP_MECOOL_KII_PRO,
}
};
static int __init init_rc_map_mecool_kii_pro(void)
{
return rc_map_register(&mecool_kii_pro_map);
}
static void __exit exit_rc_map_mecool_kii_pro(void)
{
rc_map_unregister(&mecool_kii_pro_map);
}
module_init(init_rc_map_mecool_kii_pro)
module_exit(exit_rc_map_mecool_kii_pro)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Christian Hewitt <[email protected]");
| linux-master | drivers/media/rc/keymaps/rc-mecool-kii-pro.c |
// SPDX-License-Identifier: GPL-2.0-or-later
/* rc-su3000.h - Keytable for Geniatech HDStar Remote Controller
*
* Copyright (c) 2013 by Evgeny Plehov <Evgeny [email protected]>
*/
#include <media/rc-map.h>
#include <linux/module.h>
static struct rc_map_table su3000[] = {
{ 0x25, KEY_POWER }, /* right-bottom Red */
{ 0x0a, KEY_MUTE }, /* -/-- */
{ 0x01, KEY_NUMERIC_1 },
{ 0x02, KEY_NUMERIC_2 },
{ 0x03, KEY_NUMERIC_3 },
{ 0x04, KEY_NUMERIC_4 },
{ 0x05, KEY_NUMERIC_5 },
{ 0x06, KEY_NUMERIC_6 },
{ 0x07, KEY_NUMERIC_7 },
{ 0x08, KEY_NUMERIC_8 },
{ 0x09, KEY_NUMERIC_9 },
{ 0x00, KEY_NUMERIC_0 },
{ 0x20, KEY_UP }, /* CH+ */
{ 0x21, KEY_DOWN }, /* CH+ */
{ 0x12, KEY_VOLUMEUP }, /* Brightness Up */
{ 0x13, KEY_VOLUMEDOWN },/* Brightness Down */
{ 0x1f, KEY_RECORD },
{ 0x17, KEY_PLAY },
{ 0x16, KEY_PAUSE },
{ 0x0b, KEY_STOP },
{ 0x27, KEY_FASTFORWARD },/* >> */
{ 0x26, KEY_REWIND }, /* << */
{ 0x0d, KEY_OK }, /* Mute */
{ 0x11, KEY_LEFT }, /* VOL- */
{ 0x10, KEY_RIGHT }, /* VOL+ */
{ 0x29, KEY_BACK }, /* button under 9 */
{ 0x2c, KEY_MENU }, /* TTX */
{ 0x2b, KEY_EPG }, /* EPG */
{ 0x1e, KEY_RED }, /* OSD */
{ 0x0e, KEY_GREEN }, /* Window */
{ 0x2d, KEY_YELLOW }, /* button under << */
{ 0x0f, KEY_BLUE }, /* bottom yellow button */
{ 0x14, KEY_AUDIO }, /* Snapshot */
{ 0x38, KEY_TV }, /* TV/Radio */
{ 0x0c, KEY_ESC } /* upper Red button */
};
static struct rc_map_list su3000_map = {
.map = {
.scan = su3000,
.size = ARRAY_SIZE(su3000),
.rc_proto = RC_PROTO_RC5,
.name = RC_MAP_SU3000,
}
};
static int __init init_rc_map_su3000(void)
{
return rc_map_register(&su3000_map);
}
static void __exit exit_rc_map_su3000(void)
{
rc_map_unregister(&su3000_map);
}
module_init(init_rc_map_su3000)
module_exit(exit_rc_map_su3000)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Evgeny Plehov <Evgeny [email protected]>");
| linux-master | drivers/media/rc/keymaps/rc-su3000.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.