Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

[media] rc: use rc_map_ prefix for all rc map tables

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

+280 -280
+4 -4
drivers/media/dvb/mantis/mantis_input.c
··· 95 95 { 0x00, KEY_BLUE }, 96 96 }; 97 97 98 - static struct rc_keymap ir_mantis_map = { 98 + static struct rc_map_list ir_mantis_map = { 99 99 .map = { 100 100 .scan = mantis_ir_table, 101 101 .size = ARRAY_SIZE(mantis_ir_table), ··· 109 109 struct rc_dev *dev; 110 110 int err; 111 111 112 - err = ir_register_map(&ir_mantis_map); 112 + err = rc_map_register(&ir_mantis_map); 113 113 if (err) 114 114 goto out; 115 115 ··· 145 145 out_dev: 146 146 rc_free_device(dev); 147 147 out_map: 148 - ir_unregister_map(&ir_mantis_map); 148 + rc_map_unregister(&ir_mantis_map); 149 149 out: 150 150 return err; 151 151 } ··· 153 153 int mantis_exit(struct mantis_pci *mantis) 154 154 { 155 155 rc_unregister_device(mantis->rc); 156 - ir_unregister_map(&ir_mantis_map); 156 + rc_map_unregister(&ir_mantis_map); 157 157 return 0; 158 158 } 159 159
+3 -3
drivers/media/rc/keymaps/rc-adstech-dvb-t-pci.c
··· 63 63 { 0x1c, KEY_VOLUMEDOWN }, 64 64 }; 65 65 66 - static struct rc_keymap adstech_dvb_t_pci_map = { 66 + static struct rc_map_list adstech_dvb_t_pci_map = { 67 67 .map = { 68 68 .scan = adstech_dvb_t_pci, 69 69 .size = ARRAY_SIZE(adstech_dvb_t_pci), ··· 74 74 75 75 static int __init init_rc_map_adstech_dvb_t_pci(void) 76 76 { 77 - return ir_register_map(&adstech_dvb_t_pci_map); 77 + return rc_map_register(&adstech_dvb_t_pci_map); 78 78 } 79 79 80 80 static void __exit exit_rc_map_adstech_dvb_t_pci(void) 81 81 { 82 - ir_unregister_map(&adstech_dvb_t_pci_map); 82 + rc_map_unregister(&adstech_dvb_t_pci_map); 83 83 } 84 84 85 85 module_init(init_rc_map_adstech_dvb_t_pci)
+3 -3
drivers/media/rc/keymaps/rc-anysee.c
··· 67 67 { 0x0851, KEY_PAUSE }, 68 68 }; 69 69 70 - static struct rc_keymap anysee_map = { 70 + static struct rc_map_list anysee_map = { 71 71 .map = { 72 72 .scan = anysee, 73 73 .size = ARRAY_SIZE(anysee), ··· 78 78 79 79 static int __init init_rc_map_anysee(void) 80 80 { 81 - return ir_register_map(&anysee_map); 81 + return rc_map_register(&anysee_map); 82 82 } 83 83 84 84 static void __exit exit_rc_map_anysee(void) 85 85 { 86 - ir_unregister_map(&anysee_map); 86 + rc_map_unregister(&anysee_map); 87 87 } 88 88 89 89 module_init(init_rc_map_anysee)
+3 -3
drivers/media/rc/keymaps/rc-apac-viewcomp.c
··· 54 54 { 0x18, KEY_KPMINUS }, /* fine tune <<<< */ 55 55 }; 56 56 57 - static struct rc_keymap apac_viewcomp_map = { 57 + static struct rc_map_list apac_viewcomp_map = { 58 58 .map = { 59 59 .scan = apac_viewcomp, 60 60 .size = ARRAY_SIZE(apac_viewcomp), ··· 65 65 66 66 static int __init init_rc_map_apac_viewcomp(void) 67 67 { 68 - return ir_register_map(&apac_viewcomp_map); 68 + return rc_map_register(&apac_viewcomp_map); 69 69 } 70 70 71 71 static void __exit exit_rc_map_apac_viewcomp(void) 72 72 { 73 - ir_unregister_map(&apac_viewcomp_map); 73 + rc_map_unregister(&apac_viewcomp_map); 74 74 } 75 75 76 76 module_init(init_rc_map_apac_viewcomp)
+3 -3
drivers/media/rc/keymaps/rc-asus-pc39.c
··· 65 65 { 0x083e, KEY_DVD }, /* dvd */ 66 66 }; 67 67 68 - static struct rc_keymap asus_pc39_map = { 68 + static struct rc_map_list asus_pc39_map = { 69 69 .map = { 70 70 .scan = asus_pc39, 71 71 .size = ARRAY_SIZE(asus_pc39), ··· 76 76 77 77 static int __init init_rc_map_asus_pc39(void) 78 78 { 79 - return ir_register_map(&asus_pc39_map); 79 + return rc_map_register(&asus_pc39_map); 80 80 } 81 81 82 82 static void __exit exit_rc_map_asus_pc39(void) 83 83 { 84 - ir_unregister_map(&asus_pc39_map); 84 + rc_map_unregister(&asus_pc39_map); 85 85 } 86 86 87 87 module_init(init_rc_map_asus_pc39)
+3 -3
drivers/media/rc/keymaps/rc-ati-tv-wonder-hd-600.c
··· 43 43 { 0x17, KEY_VOLUMEDOWN}, 44 44 }; 45 45 46 - static struct rc_keymap ati_tv_wonder_hd_600_map = { 46 + static struct rc_map_list ati_tv_wonder_hd_600_map = { 47 47 .map = { 48 48 .scan = ati_tv_wonder_hd_600, 49 49 .size = ARRAY_SIZE(ati_tv_wonder_hd_600), ··· 54 54 55 55 static int __init init_rc_map_ati_tv_wonder_hd_600(void) 56 56 { 57 - return ir_register_map(&ati_tv_wonder_hd_600_map); 57 + return rc_map_register(&ati_tv_wonder_hd_600_map); 58 58 } 59 59 60 60 static void __exit exit_rc_map_ati_tv_wonder_hd_600(void) 61 61 { 62 - ir_unregister_map(&ati_tv_wonder_hd_600_map); 62 + rc_map_unregister(&ati_tv_wonder_hd_600_map); 63 63 } 64 64 65 65 module_init(init_rc_map_ati_tv_wonder_hd_600)
+3 -3
drivers/media/rc/keymaps/rc-avermedia-a16d.c
··· 49 49 { 0x2a, KEY_MENU}, 50 50 }; 51 51 52 - static struct rc_keymap avermedia_a16d_map = { 52 + static struct rc_map_list avermedia_a16d_map = { 53 53 .map = { 54 54 .scan = avermedia_a16d, 55 55 .size = ARRAY_SIZE(avermedia_a16d), ··· 60 60 61 61 static int __init init_rc_map_avermedia_a16d(void) 62 62 { 63 - return ir_register_map(&avermedia_a16d_map); 63 + return rc_map_register(&avermedia_a16d_map); 64 64 } 65 65 66 66 static void __exit exit_rc_map_avermedia_a16d(void) 67 67 { 68 - ir_unregister_map(&avermedia_a16d_map); 68 + rc_map_unregister(&avermedia_a16d_map); 69 69 } 70 70 71 71 module_init(init_rc_map_avermedia_a16d)
+3 -3
drivers/media/rc/keymaps/rc-avermedia-cardbus.c
··· 71 71 { 0x43, KEY_CHANNELUP }, /* Channel up */ 72 72 }; 73 73 74 - static struct rc_keymap avermedia_cardbus_map = { 74 + static struct rc_map_list avermedia_cardbus_map = { 75 75 .map = { 76 76 .scan = avermedia_cardbus, 77 77 .size = ARRAY_SIZE(avermedia_cardbus), ··· 82 82 83 83 static int __init init_rc_map_avermedia_cardbus(void) 84 84 { 85 - return ir_register_map(&avermedia_cardbus_map); 85 + return rc_map_register(&avermedia_cardbus_map); 86 86 } 87 87 88 88 static void __exit exit_rc_map_avermedia_cardbus(void) 89 89 { 90 - ir_unregister_map(&avermedia_cardbus_map); 90 + rc_map_unregister(&avermedia_cardbus_map); 91 91 } 92 92 93 93 module_init(init_rc_map_avermedia_cardbus)
+3 -3
drivers/media/rc/keymaps/rc-avermedia-dvbt.c
··· 52 52 { 0x3e, KEY_VOLUMEUP }, /* 'volume +' */ 53 53 }; 54 54 55 - static struct rc_keymap avermedia_dvbt_map = { 55 + static struct rc_map_list avermedia_dvbt_map = { 56 56 .map = { 57 57 .scan = avermedia_dvbt, 58 58 .size = ARRAY_SIZE(avermedia_dvbt), ··· 63 63 64 64 static int __init init_rc_map_avermedia_dvbt(void) 65 65 { 66 - return ir_register_map(&avermedia_dvbt_map); 66 + return rc_map_register(&avermedia_dvbt_map); 67 67 } 68 68 69 69 static void __exit exit_rc_map_avermedia_dvbt(void) 70 70 { 71 - ir_unregister_map(&avermedia_dvbt_map); 71 + rc_map_unregister(&avermedia_dvbt_map); 72 72 } 73 73 74 74 module_init(init_rc_map_avermedia_dvbt)
+3 -3
drivers/media/rc/keymaps/rc-avermedia-m135a.c
··· 121 121 { 0x041e, KEY_NEXT }, 122 122 }; 123 123 124 - static struct rc_keymap avermedia_m135a_map = { 124 + static struct rc_map_list avermedia_m135a_map = { 125 125 .map = { 126 126 .scan = avermedia_m135a, 127 127 .size = ARRAY_SIZE(avermedia_m135a), ··· 132 132 133 133 static int __init init_rc_map_avermedia_m135a(void) 134 134 { 135 - return ir_register_map(&avermedia_m135a_map); 135 + return rc_map_register(&avermedia_m135a_map); 136 136 } 137 137 138 138 static void __exit exit_rc_map_avermedia_m135a(void) 139 139 { 140 - ir_unregister_map(&avermedia_m135a_map); 140 + rc_map_unregister(&avermedia_m135a_map); 141 141 } 142 142 143 143 module_init(init_rc_map_avermedia_m135a)
+3 -3
drivers/media/rc/keymaps/rc-avermedia-m733a-rm-k6.c
··· 69 69 { 0x041e, KEY_NEXT }, 70 70 }; 71 71 72 - static struct rc_keymap avermedia_m733a_rm_k6_map = { 72 + static struct rc_map_list avermedia_m733a_rm_k6_map = { 73 73 .map = { 74 74 .scan = avermedia_m733a_rm_k6, 75 75 .size = ARRAY_SIZE(avermedia_m733a_rm_k6), ··· 80 80 81 81 static int __init init_rc_map_avermedia_m733a_rm_k6(void) 82 82 { 83 - return ir_register_map(&avermedia_m733a_rm_k6_map); 83 + return rc_map_register(&avermedia_m733a_rm_k6_map); 84 84 } 85 85 86 86 static void __exit exit_rc_map_avermedia_m733a_rm_k6(void) 87 87 { 88 - ir_unregister_map(&avermedia_m733a_rm_k6_map); 88 + rc_map_unregister(&avermedia_m733a_rm_k6_map); 89 89 } 90 90 91 91 module_init(init_rc_map_avermedia_m733a_rm_k6)
+3 -3
drivers/media/rc/keymaps/rc-avermedia-rm-ks.c
··· 53 53 { 0x0556, KEY_ZOOM }, 54 54 }; 55 55 56 - static struct rc_keymap avermedia_rm_ks_map = { 56 + static struct rc_map_list avermedia_rm_ks_map = { 57 57 .map = { 58 58 .scan = avermedia_rm_ks, 59 59 .size = ARRAY_SIZE(avermedia_rm_ks), ··· 64 64 65 65 static int __init init_rc_map_avermedia_rm_ks(void) 66 66 { 67 - return ir_register_map(&avermedia_rm_ks_map); 67 + return rc_map_register(&avermedia_rm_ks_map); 68 68 } 69 69 70 70 static void __exit exit_rc_map_avermedia_rm_ks(void) 71 71 { 72 - ir_unregister_map(&avermedia_rm_ks_map); 72 + rc_map_unregister(&avermedia_rm_ks_map); 73 73 } 74 74 75 75 module_init(init_rc_map_avermedia_rm_ks)
+3 -3
drivers/media/rc/keymaps/rc-avermedia.c
··· 60 60 { 0x31, KEY_CHANNELUP } /* CHANNEL/PAGE+ */ 61 61 }; 62 62 63 - static struct rc_keymap avermedia_map = { 63 + static struct rc_map_list avermedia_map = { 64 64 .map = { 65 65 .scan = avermedia, 66 66 .size = ARRAY_SIZE(avermedia), ··· 71 71 72 72 static int __init init_rc_map_avermedia(void) 73 73 { 74 - return ir_register_map(&avermedia_map); 74 + return rc_map_register(&avermedia_map); 75 75 } 76 76 77 77 static void __exit exit_rc_map_avermedia(void) 78 78 { 79 - ir_unregister_map(&avermedia_map); 79 + rc_map_unregister(&avermedia_map); 80 80 } 81 81 82 82 module_init(init_rc_map_avermedia)
+3 -3
drivers/media/rc/keymaps/rc-avertv-303.c
··· 59 59 { 0x1b, KEY_UP }, 60 60 }; 61 61 62 - static struct rc_keymap avertv_303_map = { 62 + static struct rc_map_list avertv_303_map = { 63 63 .map = { 64 64 .scan = avertv_303, 65 65 .size = ARRAY_SIZE(avertv_303), ··· 70 70 71 71 static int __init init_rc_map_avertv_303(void) 72 72 { 73 - return ir_register_map(&avertv_303_map); 73 + return rc_map_register(&avertv_303_map); 74 74 } 75 75 76 76 static void __exit exit_rc_map_avertv_303(void) 77 77 { 78 - ir_unregister_map(&avertv_303_map); 78 + rc_map_unregister(&avertv_303_map); 79 79 } 80 80 81 81 module_init(init_rc_map_avertv_303)
+3 -3
drivers/media/rc/keymaps/rc-azurewave-ad-tu700.c
··· 76 76 { 0x005f, KEY_BLUE }, 77 77 }; 78 78 79 - static struct rc_keymap azurewave_ad_tu700_map = { 79 + static struct rc_map_list azurewave_ad_tu700_map = { 80 80 .map = { 81 81 .scan = azurewave_ad_tu700, 82 82 .size = ARRAY_SIZE(azurewave_ad_tu700), ··· 87 87 88 88 static int __init init_rc_map_azurewave_ad_tu700(void) 89 89 { 90 - return ir_register_map(&azurewave_ad_tu700_map); 90 + return rc_map_register(&azurewave_ad_tu700_map); 91 91 } 92 92 93 93 static void __exit exit_rc_map_azurewave_ad_tu700(void) 94 94 { 95 - ir_unregister_map(&azurewave_ad_tu700_map); 95 + rc_map_unregister(&azurewave_ad_tu700_map); 96 96 } 97 97 98 98 module_init(init_rc_map_azurewave_ad_tu700)
+3 -3
drivers/media/rc/keymaps/rc-behold-columbus.c
··· 82 82 83 83 }; 84 84 85 - static struct rc_keymap behold_columbus_map = { 85 + static struct rc_map_list behold_columbus_map = { 86 86 .map = { 87 87 .scan = behold_columbus, 88 88 .size = ARRAY_SIZE(behold_columbus), ··· 93 93 94 94 static int __init init_rc_map_behold_columbus(void) 95 95 { 96 - return ir_register_map(&behold_columbus_map); 96 + return rc_map_register(&behold_columbus_map); 97 97 } 98 98 99 99 static void __exit exit_rc_map_behold_columbus(void) 100 100 { 101 - ir_unregister_map(&behold_columbus_map); 101 + rc_map_unregister(&behold_columbus_map); 102 102 } 103 103 104 104 module_init(init_rc_map_behold_columbus)
+3 -3
drivers/media/rc/keymaps/rc-behold.c
··· 115 115 116 116 }; 117 117 118 - static struct rc_keymap behold_map = { 118 + static struct rc_map_list behold_map = { 119 119 .map = { 120 120 .scan = behold, 121 121 .size = ARRAY_SIZE(behold), ··· 126 126 127 127 static int __init init_rc_map_behold(void) 128 128 { 129 - return ir_register_map(&behold_map); 129 + return rc_map_register(&behold_map); 130 130 } 131 131 132 132 static void __exit exit_rc_map_behold(void) 133 133 { 134 - ir_unregister_map(&behold_map); 134 + rc_map_unregister(&behold_map); 135 135 } 136 136 137 137 module_init(init_rc_map_behold)
+3 -3
drivers/media/rc/keymaps/rc-budget-ci-old.c
··· 66 66 { 0x3e, KEY_TUNER }, 67 67 }; 68 68 69 - static struct rc_keymap budget_ci_old_map = { 69 + static struct rc_map_list budget_ci_old_map = { 70 70 .map = { 71 71 .scan = budget_ci_old, 72 72 .size = ARRAY_SIZE(budget_ci_old), ··· 77 77 78 78 static int __init init_rc_map_budget_ci_old(void) 79 79 { 80 - return ir_register_map(&budget_ci_old_map); 80 + return rc_map_register(&budget_ci_old_map); 81 81 } 82 82 83 83 static void __exit exit_rc_map_budget_ci_old(void) 84 84 { 85 - ir_unregister_map(&budget_ci_old_map); 85 + rc_map_unregister(&budget_ci_old_map); 86 86 } 87 87 88 88 module_init(init_rc_map_budget_ci_old)
+3 -3
drivers/media/rc/keymaps/rc-cinergy-1400.c
··· 58 58 { 0x5c, KEY_NEXT }, 59 59 }; 60 60 61 - static struct rc_keymap cinergy_1400_map = { 61 + static struct rc_map_list cinergy_1400_map = { 62 62 .map = { 63 63 .scan = cinergy_1400, 64 64 .size = ARRAY_SIZE(cinergy_1400), ··· 69 69 70 70 static int __init init_rc_map_cinergy_1400(void) 71 71 { 72 - return ir_register_map(&cinergy_1400_map); 72 + return rc_map_register(&cinergy_1400_map); 73 73 } 74 74 75 75 static void __exit exit_rc_map_cinergy_1400(void) 76 76 { 77 - ir_unregister_map(&cinergy_1400_map); 77 + rc_map_unregister(&cinergy_1400_map); 78 78 } 79 79 80 80 module_init(init_rc_map_cinergy_1400)
+3 -3
drivers/media/rc/keymaps/rc-cinergy.c
··· 52 52 { 0x23, KEY_STOP }, 53 53 }; 54 54 55 - static struct rc_keymap cinergy_map = { 55 + static struct rc_map_list cinergy_map = { 56 56 .map = { 57 57 .scan = cinergy, 58 58 .size = ARRAY_SIZE(cinergy), ··· 63 63 64 64 static int __init init_rc_map_cinergy(void) 65 65 { 66 - return ir_register_map(&cinergy_map); 66 + return rc_map_register(&cinergy_map); 67 67 } 68 68 69 69 static void __exit exit_rc_map_cinergy(void) 70 70 { 71 - ir_unregister_map(&cinergy_map); 71 + rc_map_unregister(&cinergy_map); 72 72 } 73 73 74 74 module_init(init_rc_map_cinergy)
+3 -3
drivers/media/rc/keymaps/rc-dib0700-nec.c
··· 98 98 { 0x4542, KEY_SELECT }, /* Select video input, 'Select' for Teletext */ 99 99 }; 100 100 101 - static struct rc_keymap dib0700_nec_map = { 101 + static struct rc_map_list dib0700_nec_map = { 102 102 .map = { 103 103 .scan = dib0700_nec_table, 104 104 .size = ARRAY_SIZE(dib0700_nec_table), ··· 109 109 110 110 static int __init init_rc_map(void) 111 111 { 112 - return ir_register_map(&dib0700_nec_map); 112 + return rc_map_register(&dib0700_nec_map); 113 113 } 114 114 115 115 static void __exit exit_rc_map(void) 116 116 { 117 - ir_unregister_map(&dib0700_nec_map); 117 + rc_map_unregister(&dib0700_nec_map); 118 118 } 119 119 120 120 module_init(init_rc_map)
+3 -3
drivers/media/rc/keymaps/rc-dib0700-rc5.c
··· 209 209 { 0x1d3d, KEY_POWER }, 210 210 }; 211 211 212 - static struct rc_keymap dib0700_rc5_map = { 212 + static struct rc_map_list dib0700_rc5_map = { 213 213 .map = { 214 214 .scan = dib0700_rc5_table, 215 215 .size = ARRAY_SIZE(dib0700_rc5_table), ··· 220 220 221 221 static int __init init_rc_map(void) 222 222 { 223 - return ir_register_map(&dib0700_rc5_map); 223 + return rc_map_register(&dib0700_rc5_map); 224 224 } 225 225 226 226 static void __exit exit_rc_map(void) 227 227 { 228 - ir_unregister_map(&dib0700_rc5_map); 228 + rc_map_unregister(&dib0700_rc5_map); 229 229 } 230 230 231 231 module_init(init_rc_map)
+3 -3
drivers/media/rc/keymaps/rc-digitalnow-tinytwin.c
··· 72 72 { 0x005a, KEY_PREVIOUS }, /* REPLAY */ 73 73 }; 74 74 75 - static struct rc_keymap digitalnow_tinytwin_map = { 75 + static struct rc_map_list digitalnow_tinytwin_map = { 76 76 .map = { 77 77 .scan = digitalnow_tinytwin, 78 78 .size = ARRAY_SIZE(digitalnow_tinytwin), ··· 83 83 84 84 static int __init init_rc_map_digitalnow_tinytwin(void) 85 85 { 86 - return ir_register_map(&digitalnow_tinytwin_map); 86 + return rc_map_register(&digitalnow_tinytwin_map); 87 87 } 88 88 89 89 static void __exit exit_rc_map_digitalnow_tinytwin(void) 90 90 { 91 - ir_unregister_map(&digitalnow_tinytwin_map); 91 + rc_map_unregister(&digitalnow_tinytwin_map); 92 92 } 93 93 94 94 module_init(init_rc_map_digitalnow_tinytwin)
+3 -3
drivers/media/rc/keymaps/rc-digittrade.c
··· 56 56 { 0x0054, KEY_0 }, 57 57 }; 58 58 59 - static struct rc_keymap digittrade_map = { 59 + static struct rc_map_list digittrade_map = { 60 60 .map = { 61 61 .scan = digittrade, 62 62 .size = ARRAY_SIZE(digittrade), ··· 67 67 68 68 static int __init init_rc_map_digittrade(void) 69 69 { 70 - return ir_register_map(&digittrade_map); 70 + return rc_map_register(&digittrade_map); 71 71 } 72 72 73 73 static void __exit exit_rc_map_digittrade(void) 74 74 { 75 - ir_unregister_map(&digittrade_map); 75 + rc_map_unregister(&digittrade_map); 76 76 } 77 77 78 78 module_init(init_rc_map_digittrade)
+3 -3
drivers/media/rc/keymaps/rc-dm1105-nec.c
··· 50 50 { 0x1b, KEY_B}, /* recall */ 51 51 }; 52 52 53 - static struct rc_keymap dm1105_nec_map = { 53 + static struct rc_map_list dm1105_nec_map = { 54 54 .map = { 55 55 .scan = dm1105_nec, 56 56 .size = ARRAY_SIZE(dm1105_nec), ··· 61 61 62 62 static int __init init_rc_map_dm1105_nec(void) 63 63 { 64 - return ir_register_map(&dm1105_nec_map); 64 + return rc_map_register(&dm1105_nec_map); 65 65 } 66 66 67 67 static void __exit exit_rc_map_dm1105_nec(void) 68 68 { 69 - ir_unregister_map(&dm1105_nec_map); 69 + rc_map_unregister(&dm1105_nec_map); 70 70 } 71 71 72 72 module_init(init_rc_map_dm1105_nec)
+3 -3
drivers/media/rc/keymaps/rc-dntv-live-dvb-t.c
··· 52 52 { 0x1f, KEY_VOLUMEDOWN }, 53 53 }; 54 54 55 - static struct rc_keymap dntv_live_dvb_t_map = { 55 + static struct rc_map_list dntv_live_dvb_t_map = { 56 56 .map = { 57 57 .scan = dntv_live_dvb_t, 58 58 .size = ARRAY_SIZE(dntv_live_dvb_t), ··· 63 63 64 64 static int __init init_rc_map_dntv_live_dvb_t(void) 65 65 { 66 - return ir_register_map(&dntv_live_dvb_t_map); 66 + return rc_map_register(&dntv_live_dvb_t_map); 67 67 } 68 68 69 69 static void __exit exit_rc_map_dntv_live_dvb_t(void) 70 70 { 71 - ir_unregister_map(&dntv_live_dvb_t_map); 71 + rc_map_unregister(&dntv_live_dvb_t_map); 72 72 } 73 73 74 74 module_init(init_rc_map_dntv_live_dvb_t)
+3 -3
drivers/media/rc/keymaps/rc-dntv-live-dvbt-pro.c
··· 71 71 { 0x5d, KEY_BLUE }, 72 72 }; 73 73 74 - static struct rc_keymap dntv_live_dvbt_pro_map = { 74 + static struct rc_map_list dntv_live_dvbt_pro_map = { 75 75 .map = { 76 76 .scan = dntv_live_dvbt_pro, 77 77 .size = ARRAY_SIZE(dntv_live_dvbt_pro), ··· 82 82 83 83 static int __init init_rc_map_dntv_live_dvbt_pro(void) 84 84 { 85 - return ir_register_map(&dntv_live_dvbt_pro_map); 85 + return rc_map_register(&dntv_live_dvbt_pro_map); 86 86 } 87 87 88 88 static void __exit exit_rc_map_dntv_live_dvbt_pro(void) 89 89 { 90 - ir_unregister_map(&dntv_live_dvbt_pro_map); 90 + rc_map_unregister(&dntv_live_dvbt_pro_map); 91 91 } 92 92 93 93 module_init(init_rc_map_dntv_live_dvbt_pro)
+3 -3
drivers/media/rc/keymaps/rc-em-terratec.c
··· 43 43 { 0x40, KEY_ZOOM }, 44 44 }; 45 45 46 - static struct rc_keymap em_terratec_map = { 46 + static struct rc_map_list em_terratec_map = { 47 47 .map = { 48 48 .scan = em_terratec, 49 49 .size = ARRAY_SIZE(em_terratec), ··· 54 54 55 55 static int __init init_rc_map_em_terratec(void) 56 56 { 57 - return ir_register_map(&em_terratec_map); 57 + return rc_map_register(&em_terratec_map); 58 58 } 59 59 60 60 static void __exit exit_rc_map_em_terratec(void) 61 61 { 62 - ir_unregister_map(&em_terratec_map); 62 + rc_map_unregister(&em_terratec_map); 63 63 } 64 64 65 65 module_init(init_rc_map_em_terratec)
+3 -3
drivers/media/rc/keymaps/rc-encore-enltv-fm53.c
··· 55 55 { 0x47, KEY_SLEEP}, /* shutdown */ 56 56 }; 57 57 58 - static struct rc_keymap encore_enltv_fm53_map = { 58 + static struct rc_map_list encore_enltv_fm53_map = { 59 59 .map = { 60 60 .scan = encore_enltv_fm53, 61 61 .size = ARRAY_SIZE(encore_enltv_fm53), ··· 66 66 67 67 static int __init init_rc_map_encore_enltv_fm53(void) 68 68 { 69 - return ir_register_map(&encore_enltv_fm53_map); 69 + return rc_map_register(&encore_enltv_fm53_map); 70 70 } 71 71 72 72 static void __exit exit_rc_map_encore_enltv_fm53(void) 73 73 { 74 - ir_unregister_map(&encore_enltv_fm53_map); 74 + rc_map_unregister(&encore_enltv_fm53_map); 75 75 } 76 76 77 77 module_init(init_rc_map_encore_enltv_fm53)
+3 -3
drivers/media/rc/keymaps/rc-encore-enltv.c
··· 86 86 { 0x57, KEY_BLUE }, /* AP4 */ 87 87 }; 88 88 89 - static struct rc_keymap encore_enltv_map = { 89 + static struct rc_map_list encore_enltv_map = { 90 90 .map = { 91 91 .scan = encore_enltv, 92 92 .size = ARRAY_SIZE(encore_enltv), ··· 97 97 98 98 static int __init init_rc_map_encore_enltv(void) 99 99 { 100 - return ir_register_map(&encore_enltv_map); 100 + return rc_map_register(&encore_enltv_map); 101 101 } 102 102 103 103 static void __exit exit_rc_map_encore_enltv(void) 104 104 { 105 - ir_unregister_map(&encore_enltv_map); 105 + rc_map_unregister(&encore_enltv_map); 106 106 } 107 107 108 108 module_init(init_rc_map_encore_enltv)
+3 -3
drivers/media/rc/keymaps/rc-encore-enltv2.c
··· 64 64 { 0x79, KEY_STOP }, 65 65 }; 66 66 67 - static struct rc_keymap encore_enltv2_map = { 67 + static struct rc_map_list encore_enltv2_map = { 68 68 .map = { 69 69 .scan = encore_enltv2, 70 70 .size = ARRAY_SIZE(encore_enltv2), ··· 75 75 76 76 static int __init init_rc_map_encore_enltv2(void) 77 77 { 78 - return ir_register_map(&encore_enltv2_map); 78 + return rc_map_register(&encore_enltv2_map); 79 79 } 80 80 81 81 static void __exit exit_rc_map_encore_enltv2(void) 82 82 { 83 - ir_unregister_map(&encore_enltv2_map); 83 + rc_map_unregister(&encore_enltv2_map); 84 84 } 85 85 86 86 module_init(init_rc_map_encore_enltv2)
+3 -3
drivers/media/rc/keymaps/rc-evga-indtube.c
··· 35 35 { 0x13, KEY_CAMERA}, 36 36 }; 37 37 38 - static struct rc_keymap evga_indtube_map = { 38 + static struct rc_map_list evga_indtube_map = { 39 39 .map = { 40 40 .scan = evga_indtube, 41 41 .size = ARRAY_SIZE(evga_indtube), ··· 46 46 47 47 static int __init init_rc_map_evga_indtube(void) 48 48 { 49 - return ir_register_map(&evga_indtube_map); 49 + return rc_map_register(&evga_indtube_map); 50 50 } 51 51 52 52 static void __exit exit_rc_map_evga_indtube(void) 53 53 { 54 - ir_unregister_map(&evga_indtube_map); 54 + rc_map_unregister(&evga_indtube_map); 55 55 } 56 56 57 57 module_init(init_rc_map_evga_indtube)
+3 -3
drivers/media/rc/keymaps/rc-eztv.c
··· 70 70 { 0x21, KEY_DOT }, /* . (decimal dot) */ 71 71 }; 72 72 73 - static struct rc_keymap eztv_map = { 73 + static struct rc_map_list eztv_map = { 74 74 .map = { 75 75 .scan = eztv, 76 76 .size = ARRAY_SIZE(eztv), ··· 81 81 82 82 static int __init init_rc_map_eztv(void) 83 83 { 84 - return ir_register_map(&eztv_map); 84 + return rc_map_register(&eztv_map); 85 85 } 86 86 87 87 static void __exit exit_rc_map_eztv(void) 88 88 { 89 - ir_unregister_map(&eztv_map); 89 + rc_map_unregister(&eztv_map); 90 90 } 91 91 92 92 module_init(init_rc_map_eztv)
+3 -3
drivers/media/rc/keymaps/rc-flydvb.c
··· 51 51 { 0x0e, KEY_NEXT }, /* End >>| */ 52 52 }; 53 53 54 - static struct rc_keymap flydvb_map = { 54 + static struct rc_map_list flydvb_map = { 55 55 .map = { 56 56 .scan = flydvb, 57 57 .size = ARRAY_SIZE(flydvb), ··· 62 62 63 63 static int __init init_rc_map_flydvb(void) 64 64 { 65 - return ir_register_map(&flydvb_map); 65 + return rc_map_register(&flydvb_map); 66 66 } 67 67 68 68 static void __exit exit_rc_map_flydvb(void) 69 69 { 70 - ir_unregister_map(&flydvb_map); 70 + rc_map_unregister(&flydvb_map); 71 71 } 72 72 73 73 module_init(init_rc_map_flydvb)
+3 -3
drivers/media/rc/keymaps/rc-flyvideo.c
··· 44 44 { 0x0a, KEY_ANGLE }, /* no label, may be used as the PAUSE button */ 45 45 }; 46 46 47 - static struct rc_keymap flyvideo_map = { 47 + static struct rc_map_list flyvideo_map = { 48 48 .map = { 49 49 .scan = flyvideo, 50 50 .size = ARRAY_SIZE(flyvideo), ··· 55 55 56 56 static int __init init_rc_map_flyvideo(void) 57 57 { 58 - return ir_register_map(&flyvideo_map); 58 + return rc_map_register(&flyvideo_map); 59 59 } 60 60 61 61 static void __exit exit_rc_map_flyvideo(void) 62 62 { 63 - ir_unregister_map(&flyvideo_map); 63 + rc_map_unregister(&flyvideo_map); 64 64 } 65 65 66 66 module_init(init_rc_map_flyvideo)
+3 -3
drivers/media/rc/keymaps/rc-fusionhdtv-mce.c
··· 72 72 { 0x4e, KEY_POWER }, 73 73 }; 74 74 75 - static struct rc_keymap fusionhdtv_mce_map = { 75 + static struct rc_map_list fusionhdtv_mce_map = { 76 76 .map = { 77 77 .scan = fusionhdtv_mce, 78 78 .size = ARRAY_SIZE(fusionhdtv_mce), ··· 83 83 84 84 static int __init init_rc_map_fusionhdtv_mce(void) 85 85 { 86 - return ir_register_map(&fusionhdtv_mce_map); 86 + return rc_map_register(&fusionhdtv_mce_map); 87 87 } 88 88 89 89 static void __exit exit_rc_map_fusionhdtv_mce(void) 90 90 { 91 - ir_unregister_map(&fusionhdtv_mce_map); 91 + rc_map_unregister(&fusionhdtv_mce_map); 92 92 } 93 93 94 94 module_init(init_rc_map_fusionhdtv_mce)
+3 -3
drivers/media/rc/keymaps/rc-gadmei-rm008z.c
··· 55 55 { 0x15, KEY_ENTER}, /* OK */ 56 56 }; 57 57 58 - static struct rc_keymap gadmei_rm008z_map = { 58 + static struct rc_map_list gadmei_rm008z_map = { 59 59 .map = { 60 60 .scan = gadmei_rm008z, 61 61 .size = ARRAY_SIZE(gadmei_rm008z), ··· 66 66 67 67 static int __init init_rc_map_gadmei_rm008z(void) 68 68 { 69 - return ir_register_map(&gadmei_rm008z_map); 69 + return rc_map_register(&gadmei_rm008z_map); 70 70 } 71 71 72 72 static void __exit exit_rc_map_gadmei_rm008z(void) 73 73 { 74 - ir_unregister_map(&gadmei_rm008z_map); 74 + rc_map_unregister(&gadmei_rm008z_map); 75 75 } 76 76 77 77 module_init(init_rc_map_gadmei_rm008z)
+3 -3
drivers/media/rc/keymaps/rc-genius-tvgo-a11mce.c
··· 58 58 { 0x50, KEY_BLUE }, 59 59 }; 60 60 61 - static struct rc_keymap genius_tvgo_a11mce_map = { 61 + static struct rc_map_list genius_tvgo_a11mce_map = { 62 62 .map = { 63 63 .scan = genius_tvgo_a11mce, 64 64 .size = ARRAY_SIZE(genius_tvgo_a11mce), ··· 69 69 70 70 static int __init init_rc_map_genius_tvgo_a11mce(void) 71 71 { 72 - return ir_register_map(&genius_tvgo_a11mce_map); 72 + return rc_map_register(&genius_tvgo_a11mce_map); 73 73 } 74 74 75 75 static void __exit exit_rc_map_genius_tvgo_a11mce(void) 76 76 { 77 - ir_unregister_map(&genius_tvgo_a11mce_map); 77 + rc_map_unregister(&genius_tvgo_a11mce_map); 78 78 } 79 79 80 80 module_init(init_rc_map_genius_tvgo_a11mce)
+3 -3
drivers/media/rc/keymaps/rc-gotview7135.c
··· 53 53 { 0x38, KEY_F24 }, /* NORMAL TIMESHIFT */ 54 54 }; 55 55 56 - static struct rc_keymap gotview7135_map = { 56 + static struct rc_map_list gotview7135_map = { 57 57 .map = { 58 58 .scan = gotview7135, 59 59 .size = ARRAY_SIZE(gotview7135), ··· 64 64 65 65 static int __init init_rc_map_gotview7135(void) 66 66 { 67 - return ir_register_map(&gotview7135_map); 67 + return rc_map_register(&gotview7135_map); 68 68 } 69 69 70 70 static void __exit exit_rc_map_gotview7135(void) 71 71 { 72 - ir_unregister_map(&gotview7135_map); 72 + rc_map_unregister(&gotview7135_map); 73 73 } 74 74 75 75 module_init(init_rc_map_gotview7135)
+3 -3
drivers/media/rc/keymaps/rc-hauppauge-new.c
··· 74 74 { 0x3d, KEY_POWER }, /* system power (green button) */ 75 75 }; 76 76 77 - static struct rc_keymap hauppauge_new_map = { 77 + static struct rc_map_list hauppauge_new_map = { 78 78 .map = { 79 79 .scan = hauppauge_new, 80 80 .size = ARRAY_SIZE(hauppauge_new), ··· 85 85 86 86 static int __init init_rc_map_hauppauge_new(void) 87 87 { 88 - return ir_register_map(&hauppauge_new_map); 88 + return rc_map_register(&hauppauge_new_map); 89 89 } 90 90 91 91 static void __exit exit_rc_map_hauppauge_new(void) 92 92 { 93 - ir_unregister_map(&hauppauge_new_map); 93 + rc_map_unregister(&hauppauge_new_map); 94 94 } 95 95 96 96 module_init(init_rc_map_hauppauge_new)
+3 -3
drivers/media/rc/keymaps/rc-imon-mce.c
··· 115 115 116 116 }; 117 117 118 - static struct rc_keymap imon_mce_map = { 118 + static struct rc_map_list imon_mce_map = { 119 119 .map = { 120 120 .scan = imon_mce, 121 121 .size = ARRAY_SIZE(imon_mce), ··· 127 127 128 128 static int __init init_rc_map_imon_mce(void) 129 129 { 130 - return ir_register_map(&imon_mce_map); 130 + return rc_map_register(&imon_mce_map); 131 131 } 132 132 133 133 static void __exit exit_rc_map_imon_mce(void) 134 134 { 135 - ir_unregister_map(&imon_mce_map); 135 + rc_map_unregister(&imon_mce_map); 136 136 } 137 137 138 138 module_init(init_rc_map_imon_mce)
+3 -3
drivers/media/rc/keymaps/rc-imon-pad.c
··· 129 129 { 0x29b715b7, KEY_DASHBOARD }, /* AppLauncher */ 130 130 }; 131 131 132 - static struct rc_keymap imon_pad_map = { 132 + static struct rc_map_list imon_pad_map = { 133 133 .map = { 134 134 .scan = imon_pad, 135 135 .size = ARRAY_SIZE(imon_pad), ··· 141 141 142 142 static int __init init_rc_map_imon_pad(void) 143 143 { 144 - return ir_register_map(&imon_pad_map); 144 + return rc_map_register(&imon_pad_map); 145 145 } 146 146 147 147 static void __exit exit_rc_map_imon_pad(void) 148 148 { 149 - ir_unregister_map(&imon_pad_map); 149 + rc_map_unregister(&imon_pad_map); 150 150 } 151 151 152 152 module_init(init_rc_map_imon_pad)
+3 -3
drivers/media/rc/keymaps/rc-iodata-bctv7e.c
··· 62 62 { 0x01, KEY_NEXT }, /* skip >| */ 63 63 }; 64 64 65 - static struct rc_keymap iodata_bctv7e_map = { 65 + static struct rc_map_list iodata_bctv7e_map = { 66 66 .map = { 67 67 .scan = iodata_bctv7e, 68 68 .size = ARRAY_SIZE(iodata_bctv7e), ··· 73 73 74 74 static int __init init_rc_map_iodata_bctv7e(void) 75 75 { 76 - return ir_register_map(&iodata_bctv7e_map); 76 + return rc_map_register(&iodata_bctv7e_map); 77 77 } 78 78 79 79 static void __exit exit_rc_map_iodata_bctv7e(void) 80 80 { 81 - ir_unregister_map(&iodata_bctv7e_map); 81 + rc_map_unregister(&iodata_bctv7e_map); 82 82 } 83 83 84 84 module_init(init_rc_map_iodata_bctv7e)
+3 -3
drivers/media/rc/keymaps/rc-kaiomy.c
··· 61 61 { 0x1f, KEY_BLUE}, 62 62 }; 63 63 64 - static struct rc_keymap kaiomy_map = { 64 + static struct rc_map_list kaiomy_map = { 65 65 .map = { 66 66 .scan = kaiomy, 67 67 .size = ARRAY_SIZE(kaiomy), ··· 72 72 73 73 static int __init init_rc_map_kaiomy(void) 74 74 { 75 - return ir_register_map(&kaiomy_map); 75 + return rc_map_register(&kaiomy_map); 76 76 } 77 77 78 78 static void __exit exit_rc_map_kaiomy(void) 79 79 { 80 - ir_unregister_map(&kaiomy_map); 80 + rc_map_unregister(&kaiomy_map); 81 81 } 82 82 83 83 module_init(init_rc_map_kaiomy)
+3 -3
drivers/media/rc/keymaps/rc-kworld-315u.c
··· 57 57 { 0x611f, KEY_BLUE }, 58 58 }; 59 59 60 - static struct rc_keymap kworld_315u_map = { 60 + static struct rc_map_list kworld_315u_map = { 61 61 .map = { 62 62 .scan = kworld_315u, 63 63 .size = ARRAY_SIZE(kworld_315u), ··· 68 68 69 69 static int __init init_rc_map_kworld_315u(void) 70 70 { 71 - return ir_register_map(&kworld_315u_map); 71 + return rc_map_register(&kworld_315u_map); 72 72 } 73 73 74 74 static void __exit exit_rc_map_kworld_315u(void) 75 75 { 76 - ir_unregister_map(&kworld_315u_map); 76 + rc_map_unregister(&kworld_315u_map); 77 77 } 78 78 79 79 module_init(init_rc_map_kworld_315u)
+3 -3
drivers/media/rc/keymaps/rc-kworld-plus-tv-analog.c
··· 73 73 { 0x23, KEY_GREEN}, /* C */ 74 74 }; 75 75 76 - static struct rc_keymap kworld_plus_tv_analog_map = { 76 + static struct rc_map_list kworld_plus_tv_analog_map = { 77 77 .map = { 78 78 .scan = kworld_plus_tv_analog, 79 79 .size = ARRAY_SIZE(kworld_plus_tv_analog), ··· 84 84 85 85 static int __init init_rc_map_kworld_plus_tv_analog(void) 86 86 { 87 - return ir_register_map(&kworld_plus_tv_analog_map); 87 + return rc_map_register(&kworld_plus_tv_analog_map); 88 88 } 89 89 90 90 static void __exit exit_rc_map_kworld_plus_tv_analog(void) 91 91 { 92 - ir_unregister_map(&kworld_plus_tv_analog_map); 92 + rc_map_unregister(&kworld_plus_tv_analog_map); 93 93 } 94 94 95 95 module_init(init_rc_map_kworld_plus_tv_analog)
+3 -3
drivers/media/rc/keymaps/rc-leadtek-y04g0051.c
··· 73 73 { 0x035f, KEY_CHANNELDOWN }, 74 74 }; 75 75 76 - static struct rc_keymap leadtek_y04g0051_map = { 76 + static struct rc_map_list leadtek_y04g0051_map = { 77 77 .map = { 78 78 .scan = leadtek_y04g0051, 79 79 .size = ARRAY_SIZE(leadtek_y04g0051), ··· 84 84 85 85 static int __init init_rc_map_leadtek_y04g0051(void) 86 86 { 87 - return ir_register_map(&leadtek_y04g0051_map); 87 + return rc_map_register(&leadtek_y04g0051_map); 88 88 } 89 89 90 90 static void __exit exit_rc_map_leadtek_y04g0051(void) 91 91 { 92 - ir_unregister_map(&leadtek_y04g0051_map); 92 + rc_map_unregister(&leadtek_y04g0051_map); 93 93 } 94 94 95 95 module_init(init_rc_map_leadtek_y04g0051)
+3 -3
drivers/media/rc/keymaps/rc-lirc.c
··· 15 15 { }, 16 16 }; 17 17 18 - static struct rc_keymap lirc_map = { 18 + static struct rc_map_list lirc_map = { 19 19 .map = { 20 20 .scan = lirc, 21 21 .size = ARRAY_SIZE(lirc), ··· 26 26 27 27 static int __init init_rc_map_lirc(void) 28 28 { 29 - return ir_register_map(&lirc_map); 29 + return rc_map_register(&lirc_map); 30 30 } 31 31 32 32 static void __exit exit_rc_map_lirc(void) 33 33 { 34 - ir_unregister_map(&lirc_map); 34 + rc_map_unregister(&lirc_map); 35 35 } 36 36 37 37 module_init(init_rc_map_lirc)
+3 -3
drivers/media/rc/keymaps/rc-lme2510.c
··· 42 42 43 43 }; 44 44 45 - static struct rc_keymap lme2510_map = { 45 + static struct rc_map_list lme2510_map = { 46 46 .map = { 47 47 .scan = lme2510_rc, 48 48 .size = ARRAY_SIZE(lme2510_rc), ··· 53 53 54 54 static int __init init_rc_lme2510_map(void) 55 55 { 56 - return ir_register_map(&lme2510_map); 56 + return rc_map_register(&lme2510_map); 57 57 } 58 58 59 59 static void __exit exit_rc_lme2510_map(void) 60 60 { 61 - ir_unregister_map(&lme2510_map); 61 + rc_map_unregister(&lme2510_map); 62 62 } 63 63 64 64 module_init(init_rc_lme2510_map)
+3 -3
drivers/media/rc/keymaps/rc-manli.c
··· 108 108 /* 0x1d unused ? */ 109 109 }; 110 110 111 - static struct rc_keymap manli_map = { 111 + static struct rc_map_list manli_map = { 112 112 .map = { 113 113 .scan = manli, 114 114 .size = ARRAY_SIZE(manli), ··· 119 119 120 120 static int __init init_rc_map_manli(void) 121 121 { 122 - return ir_register_map(&manli_map); 122 + return rc_map_register(&manli_map); 123 123 } 124 124 125 125 static void __exit exit_rc_map_manli(void) 126 126 { 127 - ir_unregister_map(&manli_map); 127 + rc_map_unregister(&manli_map); 128 128 } 129 129 130 130 module_init(init_rc_map_manli)
+3 -3
drivers/media/rc/keymaps/rc-msi-digivox-ii.c
··· 41 41 { 0x001f, KEY_VOLUMEDOWN }, 42 42 }; 43 43 44 - static struct rc_keymap msi_digivox_ii_map = { 44 + static struct rc_map_list msi_digivox_ii_map = { 45 45 .map = { 46 46 .scan = msi_digivox_ii, 47 47 .size = ARRAY_SIZE(msi_digivox_ii), ··· 52 52 53 53 static int __init init_rc_map_msi_digivox_ii(void) 54 54 { 55 - return ir_register_map(&msi_digivox_ii_map); 55 + return rc_map_register(&msi_digivox_ii_map); 56 56 } 57 57 58 58 static void __exit exit_rc_map_msi_digivox_ii(void) 59 59 { 60 - ir_unregister_map(&msi_digivox_ii_map); 60 + rc_map_unregister(&msi_digivox_ii_map); 61 61 } 62 62 63 63 module_init(init_rc_map_msi_digivox_ii)
+3 -3
drivers/media/rc/keymaps/rc-msi-digivox-iii.c
··· 59 59 { 0x61d643, KEY_POWER2 }, /* [red power button] */ 60 60 }; 61 61 62 - static struct rc_keymap msi_digivox_iii_map = { 62 + static struct rc_map_list msi_digivox_iii_map = { 63 63 .map = { 64 64 .scan = msi_digivox_iii, 65 65 .size = ARRAY_SIZE(msi_digivox_iii), ··· 70 70 71 71 static int __init init_rc_map_msi_digivox_iii(void) 72 72 { 73 - return ir_register_map(&msi_digivox_iii_map); 73 + return rc_map_register(&msi_digivox_iii_map); 74 74 } 75 75 76 76 static void __exit exit_rc_map_msi_digivox_iii(void) 77 77 { 78 - ir_unregister_map(&msi_digivox_iii_map); 78 + rc_map_unregister(&msi_digivox_iii_map); 79 79 } 80 80 81 81 module_init(init_rc_map_msi_digivox_iii)
+3 -3
drivers/media/rc/keymaps/rc-msi-tvanywhere-plus.c
··· 97 97 { 0x1d, KEY_RESTART }, /* Reset */ 98 98 }; 99 99 100 - static struct rc_keymap msi_tvanywhere_plus_map = { 100 + static struct rc_map_list msi_tvanywhere_plus_map = { 101 101 .map = { 102 102 .scan = msi_tvanywhere_plus, 103 103 .size = ARRAY_SIZE(msi_tvanywhere_plus), ··· 108 108 109 109 static int __init init_rc_map_msi_tvanywhere_plus(void) 110 110 { 111 - return ir_register_map(&msi_tvanywhere_plus_map); 111 + return rc_map_register(&msi_tvanywhere_plus_map); 112 112 } 113 113 114 114 static void __exit exit_rc_map_msi_tvanywhere_plus(void) 115 115 { 116 - ir_unregister_map(&msi_tvanywhere_plus_map); 116 + rc_map_unregister(&msi_tvanywhere_plus_map); 117 117 } 118 118 119 119 module_init(init_rc_map_msi_tvanywhere_plus)
+3 -3
drivers/media/rc/keymaps/rc-msi-tvanywhere.c
··· 43 43 { 0x1f, KEY_VOLUMEDOWN }, 44 44 }; 45 45 46 - static struct rc_keymap msi_tvanywhere_map = { 46 + static struct rc_map_list msi_tvanywhere_map = { 47 47 .map = { 48 48 .scan = msi_tvanywhere, 49 49 .size = ARRAY_SIZE(msi_tvanywhere), ··· 54 54 55 55 static int __init init_rc_map_msi_tvanywhere(void) 56 56 { 57 - return ir_register_map(&msi_tvanywhere_map); 57 + return rc_map_register(&msi_tvanywhere_map); 58 58 } 59 59 60 60 static void __exit exit_rc_map_msi_tvanywhere(void) 61 61 { 62 - ir_unregister_map(&msi_tvanywhere_map); 62 + rc_map_unregister(&msi_tvanywhere_map); 63 63 } 64 64 65 65 module_init(init_rc_map_msi_tvanywhere)
+3 -3
drivers/media/rc/keymaps/rc-nebula.c
··· 70 70 { 0x36, KEY_PC }, 71 71 }; 72 72 73 - static struct rc_keymap nebula_map = { 73 + static struct rc_map_list nebula_map = { 74 74 .map = { 75 75 .scan = nebula, 76 76 .size = ARRAY_SIZE(nebula), ··· 81 81 82 82 static int __init init_rc_map_nebula(void) 83 83 { 84 - return ir_register_map(&nebula_map); 84 + return rc_map_register(&nebula_map); 85 85 } 86 86 87 87 static void __exit exit_rc_map_nebula(void) 88 88 { 89 - ir_unregister_map(&nebula_map); 89 + rc_map_unregister(&nebula_map); 90 90 } 91 91 92 92 module_init(init_rc_map_nebula)
+3 -3
drivers/media/rc/keymaps/rc-nec-terratec-cinergy-xs.c
··· 79 79 { 0x145c, KEY_NEXT}, 80 80 }; 81 81 82 - static struct rc_keymap nec_terratec_cinergy_xs_map = { 82 + static struct rc_map_list nec_terratec_cinergy_xs_map = { 83 83 .map = { 84 84 .scan = nec_terratec_cinergy_xs, 85 85 .size = ARRAY_SIZE(nec_terratec_cinergy_xs), ··· 90 90 91 91 static int __init init_rc_map_nec_terratec_cinergy_xs(void) 92 92 { 93 - return ir_register_map(&nec_terratec_cinergy_xs_map); 93 + return rc_map_register(&nec_terratec_cinergy_xs_map); 94 94 } 95 95 96 96 static void __exit exit_rc_map_nec_terratec_cinergy_xs(void) 97 97 { 98 - ir_unregister_map(&nec_terratec_cinergy_xs_map); 98 + rc_map_unregister(&nec_terratec_cinergy_xs_map); 99 99 } 100 100 101 101 module_init(init_rc_map_nec_terratec_cinergy_xs)
+3 -3
drivers/media/rc/keymaps/rc-norwood.c
··· 59 59 { 0x65, KEY_POWER }, /* Computer power */ 60 60 }; 61 61 62 - static struct rc_keymap norwood_map = { 62 + static struct rc_map_list norwood_map = { 63 63 .map = { 64 64 .scan = norwood, 65 65 .size = ARRAY_SIZE(norwood), ··· 70 70 71 71 static int __init init_rc_map_norwood(void) 72 72 { 73 - return ir_register_map(&norwood_map); 73 + return rc_map_register(&norwood_map); 74 74 } 75 75 76 76 static void __exit exit_rc_map_norwood(void) 77 77 { 78 - ir_unregister_map(&norwood_map); 78 + rc_map_unregister(&norwood_map); 79 79 } 80 80 81 81 module_init(init_rc_map_norwood)
+3 -3
drivers/media/rc/keymaps/rc-npgtech.c
··· 54 54 55 55 }; 56 56 57 - static struct rc_keymap npgtech_map = { 57 + static struct rc_map_list npgtech_map = { 58 58 .map = { 59 59 .scan = npgtech, 60 60 .size = ARRAY_SIZE(npgtech), ··· 65 65 66 66 static int __init init_rc_map_npgtech(void) 67 67 { 68 - return ir_register_map(&npgtech_map); 68 + return rc_map_register(&npgtech_map); 69 69 } 70 70 71 71 static void __exit exit_rc_map_npgtech(void) 72 72 { 73 - ir_unregister_map(&npgtech_map); 73 + rc_map_unregister(&npgtech_map); 74 74 } 75 75 76 76 module_init(init_rc_map_npgtech)
+3 -3
drivers/media/rc/keymaps/rc-pctv-sedna.c
··· 54 54 { 0x1f, KEY_PLAY }, /* Play */ 55 55 }; 56 56 57 - static struct rc_keymap pctv_sedna_map = { 57 + static struct rc_map_list pctv_sedna_map = { 58 58 .map = { 59 59 .scan = pctv_sedna, 60 60 .size = ARRAY_SIZE(pctv_sedna), ··· 65 65 66 66 static int __init init_rc_map_pctv_sedna(void) 67 67 { 68 - return ir_register_map(&pctv_sedna_map); 68 + return rc_map_register(&pctv_sedna_map); 69 69 } 70 70 71 71 static void __exit exit_rc_map_pctv_sedna(void) 72 72 { 73 - ir_unregister_map(&pctv_sedna_map); 73 + rc_map_unregister(&pctv_sedna_map); 74 74 } 75 75 76 76 module_init(init_rc_map_pctv_sedna)
+3 -3
drivers/media/rc/keymaps/rc-pinnacle-color.c
··· 68 68 { 0x0a, KEY_BACKSPACE }, 69 69 }; 70 70 71 - static struct rc_keymap pinnacle_color_map = { 71 + static struct rc_map_list pinnacle_color_map = { 72 72 .map = { 73 73 .scan = pinnacle_color, 74 74 .size = ARRAY_SIZE(pinnacle_color), ··· 79 79 80 80 static int __init init_rc_map_pinnacle_color(void) 81 81 { 82 - return ir_register_map(&pinnacle_color_map); 82 + return rc_map_register(&pinnacle_color_map); 83 83 } 84 84 85 85 static void __exit exit_rc_map_pinnacle_color(void) 86 86 { 87 - ir_unregister_map(&pinnacle_color_map); 87 + rc_map_unregister(&pinnacle_color_map); 88 88 } 89 89 90 90 module_init(init_rc_map_pinnacle_color)
+3 -3
drivers/media/rc/keymaps/rc-pinnacle-grey.c
··· 63 63 { 0x18, KEY_EPG }, 64 64 }; 65 65 66 - static struct rc_keymap pinnacle_grey_map = { 66 + static struct rc_map_list pinnacle_grey_map = { 67 67 .map = { 68 68 .scan = pinnacle_grey, 69 69 .size = ARRAY_SIZE(pinnacle_grey), ··· 74 74 75 75 static int __init init_rc_map_pinnacle_grey(void) 76 76 { 77 - return ir_register_map(&pinnacle_grey_map); 77 + return rc_map_register(&pinnacle_grey_map); 78 78 } 79 79 80 80 static void __exit exit_rc_map_pinnacle_grey(void) 81 81 { 82 - ir_unregister_map(&pinnacle_grey_map); 82 + rc_map_unregister(&pinnacle_grey_map); 83 83 } 84 84 85 85 module_init(init_rc_map_pinnacle_grey)
+3 -3
drivers/media/rc/keymaps/rc-pinnacle-pctv-hd.c
··· 47 47 { 0x3f, KEY_EPG }, /* Labeled "?" */ 48 48 }; 49 49 50 - static struct rc_keymap pinnacle_pctv_hd_map = { 50 + static struct rc_map_list pinnacle_pctv_hd_map = { 51 51 .map = { 52 52 .scan = pinnacle_pctv_hd, 53 53 .size = ARRAY_SIZE(pinnacle_pctv_hd), ··· 58 58 59 59 static int __init init_rc_map_pinnacle_pctv_hd(void) 60 60 { 61 - return ir_register_map(&pinnacle_pctv_hd_map); 61 + return rc_map_register(&pinnacle_pctv_hd_map); 62 62 } 63 63 64 64 static void __exit exit_rc_map_pinnacle_pctv_hd(void) 65 65 { 66 - ir_unregister_map(&pinnacle_pctv_hd_map); 66 + rc_map_unregister(&pinnacle_pctv_hd_map); 67 67 } 68 68 69 69 module_init(init_rc_map_pinnacle_pctv_hd)
+3 -3
drivers/media/rc/keymaps/rc-pixelview-mk12.c
··· 57 57 { 0x866b07, KEY_RADIO }, /* FM */ 58 58 }; 59 59 60 - static struct rc_keymap pixelview_map = { 60 + static struct rc_map_list pixelview_map = { 61 61 .map = { 62 62 .scan = pixelview_mk12, 63 63 .size = ARRAY_SIZE(pixelview_mk12), ··· 68 68 69 69 static int __init init_rc_map_pixelview(void) 70 70 { 71 - return ir_register_map(&pixelview_map); 71 + return rc_map_register(&pixelview_map); 72 72 } 73 73 74 74 static void __exit exit_rc_map_pixelview(void) 75 75 { 76 - ir_unregister_map(&pixelview_map); 76 + rc_map_unregister(&pixelview_map); 77 77 } 78 78 79 79 module_init(init_rc_map_pixelview)
+3 -3
drivers/media/rc/keymaps/rc-pixelview-new.c
··· 57 57 { 0x34, KEY_RADIO }, 58 58 }; 59 59 60 - static struct rc_keymap pixelview_new_map = { 60 + static struct rc_map_list pixelview_new_map = { 61 61 .map = { 62 62 .scan = pixelview_new, 63 63 .size = ARRAY_SIZE(pixelview_new), ··· 68 68 69 69 static int __init init_rc_map_pixelview_new(void) 70 70 { 71 - return ir_register_map(&pixelview_new_map); 71 + return rc_map_register(&pixelview_new_map); 72 72 } 73 73 74 74 static void __exit exit_rc_map_pixelview_new(void) 75 75 { 76 - ir_unregister_map(&pixelview_new_map); 76 + rc_map_unregister(&pixelview_new_map); 77 77 } 78 78 79 79 module_init(init_rc_map_pixelview_new)
+3 -3
drivers/media/rc/keymaps/rc-pixelview.c
··· 56 56 { 0x18, KEY_MUTE }, /* mute/unmute */ 57 57 }; 58 58 59 - static struct rc_keymap pixelview_map = { 59 + static struct rc_map_list pixelview_map = { 60 60 .map = { 61 61 .scan = pixelview, 62 62 .size = ARRAY_SIZE(pixelview), ··· 67 67 68 68 static int __init init_rc_map_pixelview(void) 69 69 { 70 - return ir_register_map(&pixelview_map); 70 + return rc_map_register(&pixelview_map); 71 71 } 72 72 73 73 static void __exit exit_rc_map_pixelview(void) 74 74 { 75 - ir_unregister_map(&pixelview_map); 75 + rc_map_unregister(&pixelview_map); 76 76 } 77 77 78 78 module_init(init_rc_map_pixelview)
+3 -3
drivers/media/rc/keymaps/rc-powercolor-real-angel.c
··· 55 55 { 0x25, KEY_POWER }, /* power */ 56 56 }; 57 57 58 - static struct rc_keymap powercolor_real_angel_map = { 58 + static struct rc_map_list powercolor_real_angel_map = { 59 59 .map = { 60 60 .scan = powercolor_real_angel, 61 61 .size = ARRAY_SIZE(powercolor_real_angel), ··· 66 66 67 67 static int __init init_rc_map_powercolor_real_angel(void) 68 68 { 69 - return ir_register_map(&powercolor_real_angel_map); 69 + return rc_map_register(&powercolor_real_angel_map); 70 70 } 71 71 72 72 static void __exit exit_rc_map_powercolor_real_angel(void) 73 73 { 74 - ir_unregister_map(&powercolor_real_angel_map); 74 + rc_map_unregister(&powercolor_real_angel_map); 75 75 } 76 76 77 77 module_init(init_rc_map_powercolor_real_angel)
+3 -3
drivers/media/rc/keymaps/rc-proteus-2309.c
··· 43 43 { 0x14, KEY_F1 }, 44 44 }; 45 45 46 - static struct rc_keymap proteus_2309_map = { 46 + static struct rc_map_list proteus_2309_map = { 47 47 .map = { 48 48 .scan = proteus_2309, 49 49 .size = ARRAY_SIZE(proteus_2309), ··· 54 54 55 55 static int __init init_rc_map_proteus_2309(void) 56 56 { 57 - return ir_register_map(&proteus_2309_map); 57 + return rc_map_register(&proteus_2309_map); 58 58 } 59 59 60 60 static void __exit exit_rc_map_proteus_2309(void) 61 61 { 62 - ir_unregister_map(&proteus_2309_map); 62 + rc_map_unregister(&proteus_2309_map); 63 63 } 64 64 65 65 module_init(init_rc_map_proteus_2309)
+3 -3
drivers/media/rc/keymaps/rc-purpletv.c
··· 55 55 56 56 }; 57 57 58 - static struct rc_keymap purpletv_map = { 58 + static struct rc_map_list purpletv_map = { 59 59 .map = { 60 60 .scan = purpletv, 61 61 .size = ARRAY_SIZE(purpletv), ··· 66 66 67 67 static int __init init_rc_map_purpletv(void) 68 68 { 69 - return ir_register_map(&purpletv_map); 69 + return rc_map_register(&purpletv_map); 70 70 } 71 71 72 72 static void __exit exit_rc_map_purpletv(void) 73 73 { 74 - ir_unregister_map(&purpletv_map); 74 + rc_map_unregister(&purpletv_map); 75 75 } 76 76 77 77 module_init(init_rc_map_purpletv)
+3 -3
drivers/media/rc/keymaps/rc-pv951.c
··· 52 52 { 0x1c, KEY_MEDIA }, /* PC/TV */ 53 53 }; 54 54 55 - static struct rc_keymap pv951_map = { 55 + static struct rc_map_list pv951_map = { 56 56 .map = { 57 57 .scan = pv951, 58 58 .size = ARRAY_SIZE(pv951), ··· 63 63 64 64 static int __init init_rc_map_pv951(void) 65 65 { 66 - return ir_register_map(&pv951_map); 66 + return rc_map_register(&pv951_map); 67 67 } 68 68 69 69 static void __exit exit_rc_map_pv951(void) 70 70 { 71 - ir_unregister_map(&pv951_map); 71 + rc_map_unregister(&pv951_map); 72 72 } 73 73 74 74 module_init(init_rc_map_pv951)
+3 -3
drivers/media/rc/keymaps/rc-rc5-hauppauge-new.c
··· 77 77 { 0x1e3d, KEY_POWER }, /* system power (green button) */ 78 78 }; 79 79 80 - static struct rc_keymap rc5_hauppauge_new_map = { 80 + static struct rc_map_list rc5_hauppauge_new_map = { 81 81 .map = { 82 82 .scan = rc5_hauppauge_new, 83 83 .size = ARRAY_SIZE(rc5_hauppauge_new), ··· 88 88 89 89 static int __init init_rc_map_rc5_hauppauge_new(void) 90 90 { 91 - return ir_register_map(&rc5_hauppauge_new_map); 91 + return rc_map_register(&rc5_hauppauge_new_map); 92 92 } 93 93 94 94 static void __exit exit_rc_map_rc5_hauppauge_new(void) 95 95 { 96 - ir_unregister_map(&rc5_hauppauge_new_map); 96 + rc_map_unregister(&rc5_hauppauge_new_map); 97 97 } 98 98 99 99 module_init(init_rc_map_rc5_hauppauge_new)
+3 -3
drivers/media/rc/keymaps/rc-rc5-tv.c
··· 55 55 56 56 }; 57 57 58 - static struct rc_keymap rc5_tv_map = { 58 + static struct rc_map_list rc5_tv_map = { 59 59 .map = { 60 60 .scan = rc5_tv, 61 61 .size = ARRAY_SIZE(rc5_tv), ··· 66 66 67 67 static int __init init_rc_map_rc5_tv(void) 68 68 { 69 - return ir_register_map(&rc5_tv_map); 69 + return rc_map_register(&rc5_tv_map); 70 70 } 71 71 72 72 static void __exit exit_rc_map_rc5_tv(void) 73 73 { 74 - ir_unregister_map(&rc5_tv_map); 74 + rc_map_unregister(&rc5_tv_map); 75 75 } 76 76 77 77 module_init(init_rc_map_rc5_tv)
+3 -3
drivers/media/rc/keymaps/rc-rc6-mce.c
··· 87 87 { 0x800f0481, KEY_PLAYPAUSE }, 88 88 }; 89 89 90 - static struct rc_keymap rc6_mce_map = { 90 + static struct rc_map_list rc6_mce_map = { 91 91 .map = { 92 92 .scan = rc6_mce, 93 93 .size = ARRAY_SIZE(rc6_mce), ··· 98 98 99 99 static int __init init_rc_map_rc6_mce(void) 100 100 { 101 - return ir_register_map(&rc6_mce_map); 101 + return rc_map_register(&rc6_mce_map); 102 102 } 103 103 104 104 static void __exit exit_rc_map_rc6_mce(void) 105 105 { 106 - ir_unregister_map(&rc6_mce_map); 106 + rc_map_unregister(&rc6_mce_map); 107 107 } 108 108 109 109 module_init(init_rc_map_rc6_mce)
+3 -3
drivers/media/rc/keymaps/rc-real-audio-220-32-keys.c
··· 52 52 53 53 }; 54 54 55 - static struct rc_keymap real_audio_220_32_keys_map = { 55 + static struct rc_map_list real_audio_220_32_keys_map = { 56 56 .map = { 57 57 .scan = real_audio_220_32_keys, 58 58 .size = ARRAY_SIZE(real_audio_220_32_keys), ··· 63 63 64 64 static int __init init_rc_map_real_audio_220_32_keys(void) 65 65 { 66 - return ir_register_map(&real_audio_220_32_keys_map); 66 + return rc_map_register(&real_audio_220_32_keys_map); 67 67 } 68 68 69 69 static void __exit exit_rc_map_real_audio_220_32_keys(void) 70 70 { 71 - ir_unregister_map(&real_audio_220_32_keys_map); 71 + rc_map_unregister(&real_audio_220_32_keys_map); 72 72 } 73 73 74 74 module_init(init_rc_map_real_audio_220_32_keys)
+3 -3
drivers/media/rc/keymaps/rc-streamzap.c
··· 56 56 57 57 }; 58 58 59 - static struct rc_keymap streamzap_map = { 59 + static struct rc_map_list streamzap_map = { 60 60 .map = { 61 61 .scan = streamzap, 62 62 .size = ARRAY_SIZE(streamzap), ··· 67 67 68 68 static int __init init_rc_map_streamzap(void) 69 69 { 70 - return ir_register_map(&streamzap_map); 70 + return rc_map_register(&streamzap_map); 71 71 } 72 72 73 73 static void __exit exit_rc_map_streamzap(void) 74 74 { 75 - ir_unregister_map(&streamzap_map); 75 + rc_map_unregister(&streamzap_map); 76 76 } 77 77 78 78 module_init(init_rc_map_streamzap)
+3 -3
drivers/media/rc/keymaps/rc-tbs-nec.c
··· 47 47 { 0x1b, KEY_MODE}, 48 48 }; 49 49 50 - static struct rc_keymap tbs_nec_map = { 50 + static struct rc_map_list tbs_nec_map = { 51 51 .map = { 52 52 .scan = tbs_nec, 53 53 .size = ARRAY_SIZE(tbs_nec), ··· 58 58 59 59 static int __init init_rc_map_tbs_nec(void) 60 60 { 61 - return ir_register_map(&tbs_nec_map); 61 + return rc_map_register(&tbs_nec_map); 62 62 } 63 63 64 64 static void __exit exit_rc_map_tbs_nec(void) 65 65 { 66 - ir_unregister_map(&tbs_nec_map); 66 + rc_map_unregister(&tbs_nec_map); 67 67 } 68 68 69 69 module_init(init_rc_map_tbs_nec)
+3 -3
drivers/media/rc/keymaps/rc-terratec-cinergy-xs.c
··· 66 66 { 0x5c, KEY_NEXT}, 67 67 }; 68 68 69 - static struct rc_keymap terratec_cinergy_xs_map = { 69 + static struct rc_map_list terratec_cinergy_xs_map = { 70 70 .map = { 71 71 .scan = terratec_cinergy_xs, 72 72 .size = ARRAY_SIZE(terratec_cinergy_xs), ··· 77 77 78 78 static int __init init_rc_map_terratec_cinergy_xs(void) 79 79 { 80 - return ir_register_map(&terratec_cinergy_xs_map); 80 + return rc_map_register(&terratec_cinergy_xs_map); 81 81 } 82 82 83 83 static void __exit exit_rc_map_terratec_cinergy_xs(void) 84 84 { 85 - ir_unregister_map(&terratec_cinergy_xs_map); 85 + rc_map_unregister(&terratec_cinergy_xs_map); 86 86 } 87 87 88 88 module_init(init_rc_map_terratec_cinergy_xs)
+3 -3
drivers/media/rc/keymaps/rc-terratec-slim.c
··· 53 53 { 0x02bd45, KEY_POWER2 }, /* [red power button] */ 54 54 }; 55 55 56 - static struct rc_keymap terratec_slim_map = { 56 + static struct rc_map_list terratec_slim_map = { 57 57 .map = { 58 58 .scan = terratec_slim, 59 59 .size = ARRAY_SIZE(terratec_slim), ··· 64 64 65 65 static int __init init_rc_map_terratec_slim(void) 66 66 { 67 - return ir_register_map(&terratec_slim_map); 67 + return rc_map_register(&terratec_slim_map); 68 68 } 69 69 70 70 static void __exit exit_rc_map_terratec_slim(void) 71 71 { 72 - ir_unregister_map(&terratec_slim_map); 72 + rc_map_unregister(&terratec_slim_map); 73 73 } 74 74 75 75 module_init(init_rc_map_terratec_slim)
+3 -3
drivers/media/rc/keymaps/rc-tevii-nec.c
··· 62 62 { 0x58, KEY_SWITCHVIDEOMODE}, 63 63 }; 64 64 65 - static struct rc_keymap tevii_nec_map = { 65 + static struct rc_map_list tevii_nec_map = { 66 66 .map = { 67 67 .scan = tevii_nec, 68 68 .size = ARRAY_SIZE(tevii_nec), ··· 73 73 74 74 static int __init init_rc_map_tevii_nec(void) 75 75 { 76 - return ir_register_map(&tevii_nec_map); 76 + return rc_map_register(&tevii_nec_map); 77 77 } 78 78 79 79 static void __exit exit_rc_map_tevii_nec(void) 80 80 { 81 - ir_unregister_map(&tevii_nec_map); 81 + rc_map_unregister(&tevii_nec_map); 82 82 } 83 83 84 84 module_init(init_rc_map_tevii_nec)
+3 -3
drivers/media/rc/keymaps/rc-total-media-in-hand.c
··· 59 59 { 0x02bd45, KEY_INFO }, /* [red (I)] */ 60 60 }; 61 61 62 - static struct rc_keymap total_media_in_hand_map = { 62 + static struct rc_map_list total_media_in_hand_map = { 63 63 .map = { 64 64 .scan = total_media_in_hand, 65 65 .size = ARRAY_SIZE(total_media_in_hand), ··· 70 70 71 71 static int __init init_rc_map_total_media_in_hand(void) 72 72 { 73 - return ir_register_map(&total_media_in_hand_map); 73 + return rc_map_register(&total_media_in_hand_map); 74 74 } 75 75 76 76 static void __exit exit_rc_map_total_media_in_hand(void) 77 77 { 78 - ir_unregister_map(&total_media_in_hand_map); 78 + rc_map_unregister(&total_media_in_hand_map); 79 79 } 80 80 81 81 module_init(init_rc_map_total_media_in_hand)
+3 -3
drivers/media/rc/keymaps/rc-trekstor.c
··· 54 54 { 0x009f, KEY_LEFT }, /* Left */ 55 55 }; 56 56 57 - static struct rc_keymap trekstor_map = { 57 + static struct rc_map_list trekstor_map = { 58 58 .map = { 59 59 .scan = trekstor, 60 60 .size = ARRAY_SIZE(trekstor), ··· 65 65 66 66 static int __init init_rc_map_trekstor(void) 67 67 { 68 - return ir_register_map(&trekstor_map); 68 + return rc_map_register(&trekstor_map); 69 69 } 70 70 71 71 static void __exit exit_rc_map_trekstor(void) 72 72 { 73 - ir_unregister_map(&trekstor_map); 73 + rc_map_unregister(&trekstor_map); 74 74 } 75 75 76 76 module_init(init_rc_map_trekstor)
+3 -3
drivers/media/rc/keymaps/rc-tt-1500.c
··· 56 56 { 0x3f, KEY_FORWARD }, 57 57 }; 58 58 59 - static struct rc_keymap tt_1500_map = { 59 + static struct rc_map_list tt_1500_map = { 60 60 .map = { 61 61 .scan = tt_1500, 62 62 .size = ARRAY_SIZE(tt_1500), ··· 67 67 68 68 static int __init init_rc_map_tt_1500(void) 69 69 { 70 - return ir_register_map(&tt_1500_map); 70 + return rc_map_register(&tt_1500_map); 71 71 } 72 72 73 73 static void __exit exit_rc_map_tt_1500(void) 74 74 { 75 - ir_unregister_map(&tt_1500_map); 75 + rc_map_unregister(&tt_1500_map); 76 76 } 77 77 78 78 module_init(init_rc_map_tt_1500)
+3 -3
drivers/media/rc/keymaps/rc-twinhan1027.c
··· 61 61 { 0x5f, KEY_BLUE }, 62 62 }; 63 63 64 - static struct rc_keymap twinhan_vp1027_map = { 64 + static struct rc_map_list twinhan_vp1027_map = { 65 65 .map = { 66 66 .scan = twinhan_vp1027, 67 67 .size = ARRAY_SIZE(twinhan_vp1027), ··· 72 72 73 73 static int __init init_rc_map_twinhan_vp1027(void) 74 74 { 75 - return ir_register_map(&twinhan_vp1027_map); 75 + return rc_map_register(&twinhan_vp1027_map); 76 76 } 77 77 78 78 static void __exit exit_rc_map_twinhan_vp1027(void) 79 79 { 80 - ir_unregister_map(&twinhan_vp1027_map); 80 + rc_map_unregister(&twinhan_vp1027_map); 81 81 } 82 82 83 83 module_init(init_rc_map_twinhan_vp1027)
+3 -3
drivers/media/rc/keymaps/rc-videomate-s350.c
··· 59 59 { 0x20, KEY_TEXT}, 60 60 }; 61 61 62 - static struct rc_keymap videomate_s350_map = { 62 + static struct rc_map_list videomate_s350_map = { 63 63 .map = { 64 64 .scan = videomate_s350, 65 65 .size = ARRAY_SIZE(videomate_s350), ··· 70 70 71 71 static int __init init_rc_map_videomate_s350(void) 72 72 { 73 - return ir_register_map(&videomate_s350_map); 73 + return rc_map_register(&videomate_s350_map); 74 74 } 75 75 76 76 static void __exit exit_rc_map_videomate_s350(void) 77 77 { 78 - ir_unregister_map(&videomate_s350_map); 78 + rc_map_unregister(&videomate_s350_map); 79 79 } 80 80 81 81 module_init(init_rc_map_videomate_s350)
+3 -3
drivers/media/rc/keymaps/rc-videomate-tv-pvr.c
··· 61 61 { 0x21, KEY_SLEEP }, 62 62 }; 63 63 64 - static struct rc_keymap videomate_tv_pvr_map = { 64 + static struct rc_map_list videomate_tv_pvr_map = { 65 65 .map = { 66 66 .scan = videomate_tv_pvr, 67 67 .size = ARRAY_SIZE(videomate_tv_pvr), ··· 72 72 73 73 static int __init init_rc_map_videomate_tv_pvr(void) 74 74 { 75 - return ir_register_map(&videomate_tv_pvr_map); 75 + return rc_map_register(&videomate_tv_pvr_map); 76 76 } 77 77 78 78 static void __exit exit_rc_map_videomate_tv_pvr(void) 79 79 { 80 - ir_unregister_map(&videomate_tv_pvr_map); 80 + rc_map_unregister(&videomate_tv_pvr_map); 81 81 } 82 82 83 83 module_init(init_rc_map_videomate_tv_pvr)
+3 -3
drivers/media/rc/keymaps/rc-winfast-usbii-deluxe.c
··· 56 56 57 57 }; 58 58 59 - static struct rc_keymap winfast_usbii_deluxe_map = { 59 + static struct rc_map_list winfast_usbii_deluxe_map = { 60 60 .map = { 61 61 .scan = winfast_usbii_deluxe, 62 62 .size = ARRAY_SIZE(winfast_usbii_deluxe), ··· 67 67 68 68 static int __init init_rc_map_winfast_usbii_deluxe(void) 69 69 { 70 - return ir_register_map(&winfast_usbii_deluxe_map); 70 + return rc_map_register(&winfast_usbii_deluxe_map); 71 71 } 72 72 73 73 static void __exit exit_rc_map_winfast_usbii_deluxe(void) 74 74 { 75 - ir_unregister_map(&winfast_usbii_deluxe_map); 75 + rc_map_unregister(&winfast_usbii_deluxe_map); 76 76 } 77 77 78 78 module_init(init_rc_map_winfast_usbii_deluxe)
+3 -3
drivers/media/rc/keymaps/rc-winfast.c
··· 76 76 { 0x3f, KEY_F24 } /* MCE -CH, on Y04G0033 */ 77 77 }; 78 78 79 - static struct rc_keymap winfast_map = { 79 + static struct rc_map_list winfast_map = { 80 80 .map = { 81 81 .scan = winfast, 82 82 .size = ARRAY_SIZE(winfast), ··· 87 87 88 88 static int __init init_rc_map_winfast(void) 89 89 { 90 - return ir_register_map(&winfast_map); 90 + return rc_map_register(&winfast_map); 91 91 } 92 92 93 93 static void __exit exit_rc_map_winfast(void) 94 94 { 95 - ir_unregister_map(&winfast_map); 95 + rc_map_unregister(&winfast_map); 96 96 } 97 97 98 98 module_init(init_rc_map_winfast)
+14 -14
drivers/media/rc/rc-main.c
··· 31 31 static LIST_HEAD(rc_map_list); 32 32 static DEFINE_SPINLOCK(rc_map_lock); 33 33 34 - static struct rc_keymap *seek_rc_map(const char *name) 34 + static struct rc_map_list *seek_rc_map(const char *name) 35 35 { 36 - struct rc_keymap *map = NULL; 36 + struct rc_map_list *map = NULL; 37 37 38 38 spin_lock(&rc_map_lock); 39 39 list_for_each_entry(map, &rc_map_list, list) { ··· 47 47 return NULL; 48 48 } 49 49 50 - struct rc_map *get_rc_map(const char *name) 50 + struct rc_map *rc_map_get(const char *name) 51 51 { 52 52 53 - struct rc_keymap *map; 53 + struct rc_map_list *map; 54 54 55 55 map = seek_rc_map(name); 56 56 #ifdef MODULE ··· 74 74 75 75 return &map->map; 76 76 } 77 - EXPORT_SYMBOL_GPL(get_rc_map); 77 + EXPORT_SYMBOL_GPL(rc_map_get); 78 78 79 - int ir_register_map(struct rc_keymap *map) 79 + int rc_map_register(struct rc_map_list *map) 80 80 { 81 81 spin_lock(&rc_map_lock); 82 82 list_add_tail(&map->list, &rc_map_list); 83 83 spin_unlock(&rc_map_lock); 84 84 return 0; 85 85 } 86 - EXPORT_SYMBOL_GPL(ir_register_map); 86 + EXPORT_SYMBOL_GPL(rc_map_register); 87 87 88 - void ir_unregister_map(struct rc_keymap *map) 88 + void rc_map_unregister(struct rc_map_list *map) 89 89 { 90 90 spin_lock(&rc_map_lock); 91 91 list_del(&map->list); 92 92 spin_unlock(&rc_map_lock); 93 93 } 94 - EXPORT_SYMBOL_GPL(ir_unregister_map); 94 + EXPORT_SYMBOL_GPL(rc_map_unregister); 95 95 96 96 97 97 static struct rc_map_table empty[] = { 98 98 { 0x2a, KEY_COFFEE }, 99 99 }; 100 100 101 - static struct rc_keymap empty_map = { 101 + static struct rc_map_list empty_map = { 102 102 .map = { 103 103 .scan = empty, 104 104 .size = ARRAY_SIZE(empty), ··· 996 996 if (!dev || !dev->map_name) 997 997 return -EINVAL; 998 998 999 - rc_map = get_rc_map(dev->map_name); 999 + rc_map = rc_map_get(dev->map_name); 1000 1000 if (!rc_map) 1001 - rc_map = get_rc_map(RC_MAP_EMPTY); 1001 + rc_map = rc_map_get(RC_MAP_EMPTY); 1002 1002 if (!rc_map || !rc_map->scan || rc_map->size == 0) 1003 1003 return -EINVAL; 1004 1004 ··· 1113 1113 1114 1114 /* Initialize/load the decoders/keymap code that will be used */ 1115 1115 ir_raw_init(); 1116 - ir_register_map(&empty_map); 1116 + rc_map_register(&empty_map); 1117 1117 1118 1118 return 0; 1119 1119 } ··· 1121 1121 static void __exit rc_core_exit(void) 1122 1122 { 1123 1123 class_unregister(&ir_input_class); 1124 - ir_unregister_map(&empty_map); 1124 + rc_map_unregister(&empty_map); 1125 1125 } 1126 1126 1127 1127 module_init(rc_core_init);
+4 -4
include/media/rc-map.h
··· 40 40 spinlock_t lock; 41 41 }; 42 42 43 - struct rc_keymap { 43 + struct rc_map_list { 44 44 struct list_head list; 45 45 struct rc_map map; 46 46 }; 47 47 48 48 /* Routines from rc-map.c */ 49 49 50 - int ir_register_map(struct rc_keymap *map); 51 - void ir_unregister_map(struct rc_keymap *map); 52 - struct rc_map *get_rc_map(const char *name); 50 + int rc_map_register(struct rc_map_list *map); 51 + void rc_map_unregister(struct rc_map_list *map); 52 + struct rc_map *rc_map_get(const char *name); 53 53 void rc_map_init(void); 54 54 55 55 /* Names of the several keytables defined in-kernel */