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

[media] rc: abstract access to allowed/enabled protocols

The allowed and enabled protocol masks need to be expanded to be per
filter type in order to support wakeup filter protocol selection. To
ease that process abstract access to the rc_dev::allowed_protos and
rc_dev::enabled_protocols members with inline functions.

Signed-off-by: James Hogan <james.hogan@imgtec.com>
Reviewed-by: Antti Seppälä <a.seppala@gmail.com>
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>

authored by

James Hogan and committed by
Mauro Carvalho Chehab 1a1934fa b8c7d915

+73 -50
+1 -1
drivers/hid/hid-picolcd_cir.c
··· 114 114 115 115 rdev->priv = data; 116 116 rdev->driver_type = RC_DRIVER_IR_RAW; 117 - rdev->allowed_protos = RC_BIT_ALL; 117 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 118 118 rdev->open = picolcd_cir_open; 119 119 rdev->close = picolcd_cir_close; 120 120 rdev->input_name = data->hdev->name;
+1 -1
drivers/media/common/siano/smsir.c
··· 88 88 89 89 dev->priv = coredev; 90 90 dev->driver_type = RC_DRIVER_IR_RAW; 91 - dev->allowed_protos = RC_BIT_ALL; 91 + rc_set_allowed_protocols(dev, RC_BIT_ALL); 92 92 dev->map_name = sms_get_board(board_id)->rc_codes; 93 93 dev->driver_name = MODULE_NAME; 94 94
+2 -2
drivers/media/i2c/ir-kbd-i2c.c
··· 431 431 * Initialize the other fields of rc_dev 432 432 */ 433 433 rc->map_name = ir->ir_codes; 434 - rc->allowed_protos = rc_type; 435 - rc->enabled_protocols = rc_type; 434 + rc_set_allowed_protocols(rc, rc_type); 435 + rc_set_enabled_protocols(rc, rc_type); 436 436 if (!rc->driver_name) 437 437 rc->driver_name = MODULE_NAME; 438 438
+1 -1
drivers/media/pci/cx23885/cx23885-input.c
··· 346 346 } 347 347 rc->dev.parent = &dev->pci->dev; 348 348 rc->driver_type = driver_type; 349 - rc->allowed_protos = allowed_protos; 349 + rc_set_allowed_protocols(rc, allowed_protos); 350 350 rc->priv = kernel_ir; 351 351 rc->open = cx23885_input_ir_open; 352 352 rc->close = cx23885_input_ir_close;
+1 -1
drivers/media/pci/cx88/cx88-input.c
··· 469 469 dev->timeout = 10 * 1000 * 1000; /* 10 ms */ 470 470 } else { 471 471 dev->driver_type = RC_DRIVER_SCANCODE; 472 - dev->allowed_protos = rc_type; 472 + rc_set_allowed_protocols(dev, rc_type); 473 473 } 474 474 475 475 ir->core = core;
+1 -1
drivers/media/rc/ati_remote.c
··· 784 784 785 785 rdev->priv = ati_remote; 786 786 rdev->driver_type = RC_DRIVER_SCANCODE; 787 - rdev->allowed_protos = RC_BIT_OTHER; 787 + rc_set_allowed_protocols(rdev, RC_BIT_OTHER); 788 788 rdev->driver_name = "ati_remote"; 789 789 790 790 rdev->open = ati_remote_rc_open;
+1 -1
drivers/media/rc/ene_ir.c
··· 1059 1059 learning_mode_force = false; 1060 1060 1061 1061 rdev->driver_type = RC_DRIVER_IR_RAW; 1062 - rdev->allowed_protos = RC_BIT_ALL; 1062 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 1063 1063 rdev->priv = dev; 1064 1064 rdev->open = ene_open; 1065 1065 rdev->close = ene_close;
+1 -1
drivers/media/rc/fintek-cir.c
··· 541 541 /* Set up the rc device */ 542 542 rdev->priv = fintek; 543 543 rdev->driver_type = RC_DRIVER_IR_RAW; 544 - rdev->allowed_protos = RC_BIT_ALL; 544 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 545 545 rdev->open = fintek_open; 546 546 rdev->close = fintek_close; 547 547 rdev->input_name = FINTEK_DESCRIPTION;
+2 -2
drivers/media/rc/gpio-ir-recv.c
··· 145 145 rcdev->dev.parent = &pdev->dev; 146 146 rcdev->driver_name = GPIO_IR_DRIVER_NAME; 147 147 if (pdata->allowed_protos) 148 - rcdev->allowed_protos = pdata->allowed_protos; 148 + rc_set_allowed_protocols(rcdev, pdata->allowed_protos); 149 149 else 150 - rcdev->allowed_protos = RC_BIT_ALL; 150 + rc_set_allowed_protocols(rcdev, RC_BIT_ALL); 151 151 rcdev->map_name = pdata->map_name ?: RC_MAP_EMPTY; 152 152 153 153 gpio_dev->rcdev = rcdev;
+1 -1
drivers/media/rc/iguanair.c
··· 495 495 usb_to_input_id(ir->udev, &rc->input_id); 496 496 rc->dev.parent = &intf->dev; 497 497 rc->driver_type = RC_DRIVER_IR_RAW; 498 - rc->allowed_protos = RC_BIT_ALL; 498 + rc_set_allowed_protocols(rc, RC_BIT_ALL); 499 499 rc->priv = ir; 500 500 rc->open = iguanair_open; 501 501 rc->close = iguanair_close;
+4 -3
drivers/media/rc/imon.c
··· 1017 1017 unsigned char ir_proto_packet[] = { 1018 1018 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86 }; 1019 1019 1020 - if (*rc_type && !(*rc_type & rc->allowed_protos)) 1020 + if (*rc_type && !rc_protocols_allowed(rc, *rc_type)) 1021 1021 dev_warn(dev, "Looks like you're trying to use an IR protocol " 1022 1022 "this device does not support\n"); 1023 1023 ··· 1867 1867 1868 1868 rdev->priv = ictx; 1869 1869 rdev->driver_type = RC_DRIVER_SCANCODE; 1870 - rdev->allowed_protos = RC_BIT_OTHER | RC_BIT_RC6_MCE; /* iMON PAD or MCE */ 1870 + /* iMON PAD or MCE */ 1871 + rc_set_allowed_protocols(rdev, RC_BIT_OTHER | RC_BIT_RC6_MCE); 1871 1872 rdev->change_protocol = imon_ir_change_protocol; 1872 1873 rdev->driver_name = MOD_NAME; 1873 1874 ··· 1881 1880 1882 1881 if (ictx->product == 0xffdc) { 1883 1882 imon_get_ffdc_type(ictx); 1884 - rdev->allowed_protos = ictx->rc_type; 1883 + rc_set_allowed_protocols(rdev, ictx->rc_type); 1885 1884 } 1886 1885 1887 1886 imon_set_display_type(ictx);
+1 -1
drivers/media/rc/ir-jvc-decoder.c
··· 47 47 { 48 48 struct jvc_dec *data = &dev->raw->jvc; 49 49 50 - if (!(dev->enabled_protocols & RC_BIT_JVC)) 50 + if (!rc_protocols_enabled(dev, RC_BIT_JVC)) 51 51 return 0; 52 52 53 53 if (!is_timing_event(ev)) {
+1 -1
drivers/media/rc/ir-lirc-codec.c
··· 35 35 struct lirc_codec *lirc = &dev->raw->lirc; 36 36 int sample; 37 37 38 - if (!(dev->enabled_protocols & RC_BIT_LIRC)) 38 + if (!rc_protocols_enabled(dev, RC_BIT_LIRC)) 39 39 return 0; 40 40 41 41 if (!dev->raw->lirc.drv || !dev->raw->lirc.drv->rbuf)
+1 -1
drivers/media/rc/ir-mce_kbd-decoder.c
··· 216 216 u32 scancode; 217 217 unsigned long delay; 218 218 219 - if (!(dev->enabled_protocols & RC_BIT_MCE_KBD)) 219 + if (!rc_protocols_enabled(dev, RC_BIT_MCE_KBD)) 220 220 return 0; 221 221 222 222 if (!is_timing_event(ev)) {
+1 -1
drivers/media/rc/ir-nec-decoder.c
··· 52 52 u8 address, not_address, command, not_command; 53 53 bool send_32bits = false; 54 54 55 - if (!(dev->enabled_protocols & RC_BIT_NEC)) 55 + if (!rc_protocols_enabled(dev, RC_BIT_NEC)) 56 56 return 0; 57 57 58 58 if (!is_timing_event(ev)) {
+1 -1
drivers/media/rc/ir-raw.c
··· 256 256 return -ENOMEM; 257 257 258 258 dev->raw->dev = dev; 259 - dev->enabled_protocols = ~0; 259 + rc_set_enabled_protocols(dev, ~0); 260 260 rc = kfifo_alloc(&dev->raw->kfifo, 261 261 sizeof(struct ir_raw_event) * MAX_IR_EVENT_SIZE, 262 262 GFP_KERNEL);
+3 -3
drivers/media/rc/ir-rc5-decoder.c
··· 52 52 u8 toggle; 53 53 u32 scancode; 54 54 55 - if (!(dev->enabled_protocols & (RC_BIT_RC5 | RC_BIT_RC5X))) 55 + if (!rc_protocols_enabled(dev, RC_BIT_RC5 | RC_BIT_RC5X)) 56 56 return 0; 57 57 58 58 if (!is_timing_event(ev)) { ··· 128 128 if (data->wanted_bits == RC5X_NBITS) { 129 129 /* RC5X */ 130 130 u8 xdata, command, system; 131 - if (!(dev->enabled_protocols & RC_BIT_RC5X)) { 131 + if (!rc_protocols_enabled(dev, RC_BIT_RC5X)) { 132 132 data->state = STATE_INACTIVE; 133 133 return 0; 134 134 } ··· 145 145 } else { 146 146 /* RC5 */ 147 147 u8 command, system; 148 - if (!(dev->enabled_protocols & RC_BIT_RC5)) { 148 + if (!rc_protocols_enabled(dev, RC_BIT_RC5)) { 149 149 data->state = STATE_INACTIVE; 150 150 return 0; 151 151 }
+1 -1
drivers/media/rc/ir-rc5-sz-decoder.c
··· 48 48 u8 toggle, command, system; 49 49 u32 scancode; 50 50 51 - if (!(dev->enabled_protocols & RC_BIT_RC5_SZ)) 51 + if (!rc_protocols_enabled(dev, RC_BIT_RC5_SZ)) 52 52 return 0; 53 53 54 54 if (!is_timing_event(ev)) {
+3 -3
drivers/media/rc/ir-rc6-decoder.c
··· 89 89 u32 scancode; 90 90 u8 toggle; 91 91 92 - if (!(dev->enabled_protocols & 93 - (RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 | RC_BIT_RC6_6A_24 | 94 - RC_BIT_RC6_6A_32 | RC_BIT_RC6_MCE))) 92 + if (!rc_protocols_enabled(dev, RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 | 93 + RC_BIT_RC6_6A_24 | RC_BIT_RC6_6A_32 | 94 + RC_BIT_RC6_MCE)) 95 95 return 0; 96 96 97 97 if (!is_timing_event(ev)) {
+1 -1
drivers/media/rc/ir-sanyo-decoder.c
··· 58 58 u32 scancode; 59 59 u8 address, command, not_command; 60 60 61 - if (!(dev->enabled_protocols & RC_BIT_SANYO)) 61 + if (!rc_protocols_enabled(dev, RC_BIT_SANYO)) 62 62 return 0; 63 63 64 64 if (!is_timing_event(ev)) {
+1 -1
drivers/media/rc/ir-sharp-decoder.c
··· 48 48 struct sharp_dec *data = &dev->raw->sharp; 49 49 u32 msg, echo, address, command, scancode; 50 50 51 - if (!(dev->enabled_protocols & RC_BIT_SHARP)) 51 + if (!rc_protocols_enabled(dev, RC_BIT_SHARP)) 52 52 return 0; 53 53 54 54 if (!is_timing_event(ev)) {
+5 -5
drivers/media/rc/ir-sony-decoder.c
··· 45 45 u32 scancode; 46 46 u8 device, subdevice, function; 47 47 48 - if (!(dev->enabled_protocols & 49 - (RC_BIT_SONY12 | RC_BIT_SONY15 | RC_BIT_SONY20))) 48 + if (!rc_protocols_enabled(dev, RC_BIT_SONY12 | RC_BIT_SONY15 | 49 + RC_BIT_SONY20)) 50 50 return 0; 51 51 52 52 if (!is_timing_event(ev)) { ··· 124 124 125 125 switch (data->count) { 126 126 case 12: 127 - if (!(dev->enabled_protocols & RC_BIT_SONY12)) { 127 + if (!rc_protocols_enabled(dev, RC_BIT_SONY12)) { 128 128 data->state = STATE_INACTIVE; 129 129 return 0; 130 130 } ··· 133 133 function = bitrev8((data->bits >> 4) & 0xFE); 134 134 break; 135 135 case 15: 136 - if (!(dev->enabled_protocols & RC_BIT_SONY15)) { 136 + if (!rc_protocols_enabled(dev, RC_BIT_SONY15)) { 137 137 data->state = STATE_INACTIVE; 138 138 return 0; 139 139 } ··· 142 142 function = bitrev8((data->bits >> 7) & 0xFE); 143 143 break; 144 144 case 20: 145 - if (!(dev->enabled_protocols & RC_BIT_SONY20)) { 145 + if (!rc_protocols_enabled(dev, RC_BIT_SONY20)) { 146 146 data->state = STATE_INACTIVE; 147 147 return 0; 148 148 }
+1 -1
drivers/media/rc/ite-cir.c
··· 1563 1563 /* set up ir-core props */ 1564 1564 rdev->priv = itdev; 1565 1565 rdev->driver_type = RC_DRIVER_IR_RAW; 1566 - rdev->allowed_protos = RC_BIT_ALL; 1566 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 1567 1567 rdev->open = ite_open; 1568 1568 rdev->close = ite_close; 1569 1569 rdev->s_idle = ite_s_idle;
+1 -1
drivers/media/rc/mceusb.c
··· 1211 1211 rc->dev.parent = dev; 1212 1212 rc->priv = ir; 1213 1213 rc->driver_type = RC_DRIVER_IR_RAW; 1214 - rc->allowed_protos = RC_BIT_ALL; 1214 + rc_set_allowed_protocols(rc, RC_BIT_ALL); 1215 1215 rc->timeout = MS_TO_NS(100); 1216 1216 if (!ir->flags.no_tx) { 1217 1217 rc->s_tx_mask = mceusb_set_tx_mask;
+1 -1
drivers/media/rc/nuvoton-cir.c
··· 1044 1044 /* Set up the rc device */ 1045 1045 rdev->priv = nvt; 1046 1046 rdev->driver_type = RC_DRIVER_IR_RAW; 1047 - rdev->allowed_protos = RC_BIT_ALL; 1047 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 1048 1048 rdev->open = nvt_open; 1049 1049 rdev->close = nvt_close; 1050 1050 rdev->tx_ir = nvt_tx_ir;
+1 -1
drivers/media/rc/rc-loopback.c
··· 195 195 rc->map_name = RC_MAP_EMPTY; 196 196 rc->priv = &loopdev; 197 197 rc->driver_type = RC_DRIVER_IR_RAW; 198 - rc->allowed_protos = RC_BIT_ALL; 198 + rc_set_allowed_protocols(rc, RC_BIT_ALL); 199 199 rc->timeout = 100 * 1000 * 1000; /* 100 ms */ 200 200 rc->min_timeout = 1; 201 201 rc->max_timeout = UINT_MAX;
+1 -1
drivers/media/rc/redrat3.c
··· 922 922 rc->dev.parent = dev; 923 923 rc->priv = rr3; 924 924 rc->driver_type = RC_DRIVER_IR_RAW; 925 - rc->allowed_protos = RC_BIT_ALL; 925 + rc_set_allowed_protocols(rc, RC_BIT_ALL); 926 926 rc->timeout = US_TO_NS(2750); 927 927 rc->tx_ir = redrat3_transmit_ir; 928 928 rc->s_tx_carrier = redrat3_set_tx_carrier;
+1 -1
drivers/media/rc/st_rc.c
··· 287 287 st_rc_hardware_init(rc_dev); 288 288 289 289 rdev->driver_type = RC_DRIVER_IR_RAW; 290 - rdev->allowed_protos = RC_BIT_ALL; 290 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 291 291 /* rx sampling rate is 10Mhz */ 292 292 rdev->rx_resolution = 100; 293 293 rdev->timeout = US_TO_NS(MAX_SYMB_TIME);
+1 -1
drivers/media/rc/streamzap.c
··· 322 322 rdev->dev.parent = dev; 323 323 rdev->priv = sz; 324 324 rdev->driver_type = RC_DRIVER_IR_RAW; 325 - rdev->allowed_protos = RC_BIT_ALL; 325 + rc_set_allowed_protocols(rdev, RC_BIT_ALL); 326 326 rdev->driver_name = DRIVER_NAME; 327 327 rdev->map_name = RC_MAP_STREAMZAP; 328 328
+1 -1
drivers/media/rc/ttusbir.c
··· 318 318 usb_to_input_id(tt->udev, &rc->input_id); 319 319 rc->dev.parent = &intf->dev; 320 320 rc->driver_type = RC_DRIVER_IR_RAW; 321 - rc->allowed_protos = RC_BIT_ALL; 321 + rc_set_allowed_protocols(rc, RC_BIT_ALL); 322 322 rc->priv = tt; 323 323 rc->driver_name = DRIVER_NAME; 324 324 rc->map_name = RC_MAP_TT_1500;
+1 -1
drivers/media/rc/winbond-cir.c
··· 1082 1082 data->dev->dev.parent = &device->dev; 1083 1083 data->dev->timeout = MS_TO_NS(100); 1084 1084 data->dev->rx_resolution = US_TO_NS(2); 1085 - data->dev->allowed_protos = RC_BIT_ALL; 1085 + rc_set_allowed_protocols(data->dev, RC_BIT_ALL); 1086 1086 1087 1087 err = rc_register_device(data->dev); 1088 1088 if (err)
+1 -1
drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
··· 164 164 dev->driver_name = (char *) d->props->driver_name; 165 165 dev->map_name = d->rc.map_name; 166 166 dev->driver_type = d->rc.driver_type; 167 - dev->allowed_protos = d->rc.allowed_protos; 167 + rc_set_allowed_protocols(dev, d->rc.allowed_protos); 168 168 dev->change_protocol = d->rc.change_protocol; 169 169 dev->priv = d; 170 170
+1 -1
drivers/media/usb/dvb-usb/dvb-usb-remote.c
··· 272 272 dev->driver_name = d->props.rc.core.module_name; 273 273 dev->map_name = d->props.rc.core.rc_codes; 274 274 dev->change_protocol = d->props.rc.core.change_protocol; 275 - dev->allowed_protos = d->props.rc.core.allowed_protos; 275 + rc_set_allowed_protocols(dev, d->props.rc.core.allowed_protos); 276 276 dev->driver_type = d->props.rc.core.driver_type; 277 277 usb_to_input_id(d->udev, &dev->input_id); 278 278 dev->input_name = "IR-receiver inside an USB DVB receiver";
+4 -4
drivers/media/usb/em28xx/em28xx-input.c
··· 727 727 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2: 728 728 rc->map_name = RC_MAP_HAUPPAUGE; 729 729 ir->get_key_i2c = em28xx_get_key_em_haup; 730 - rc->allowed_protos = RC_BIT_RC5; 730 + rc_set_allowed_protocols(rc, RC_BIT_RC5); 731 731 break; 732 732 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE: 733 733 rc->map_name = RC_MAP_WINFAST_USBII_DELUXE; ··· 743 743 switch (dev->chip_id) { 744 744 case CHIP_ID_EM2860: 745 745 case CHIP_ID_EM2883: 746 - rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC; 746 + rc_set_allowed_protocols(rc, RC_BIT_RC5 | RC_BIT_NEC); 747 747 ir->get_key = default_polling_getkey; 748 748 break; 749 749 case CHIP_ID_EM2884: ··· 751 751 case CHIP_ID_EM28174: 752 752 case CHIP_ID_EM28178: 753 753 ir->get_key = em2874_polling_getkey; 754 - rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC | 755 - RC_BIT_RC6_0; 754 + rc_set_allowed_protocols(rc, RC_BIT_RC5 | RC_BIT_NEC | 755 + RC_BIT_RC6_0); 756 756 break; 757 757 default: 758 758 err = -ENODEV;
+1 -1
drivers/media/usb/tm6000/tm6000-input.c
··· 422 422 ir->rc = rc; 423 423 424 424 /* input setup */ 425 - rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC; 425 + rc_set_allowed_protocols(rc, RC_BIT_RC5 | RC_BIT_NEC); 426 426 /* Neded, in order to support NEC remotes with 24 or 32 bits */ 427 427 rc->scanmask = 0xffff; 428 428 rc->priv = ir;
+22
include/media/rc-core.h
··· 160 160 161 161 #define to_rc_dev(d) container_of(d, struct rc_dev, dev) 162 162 163 + static inline bool rc_protocols_allowed(struct rc_dev *rdev, u64 protos) 164 + { 165 + return rdev->allowed_protos & protos; 166 + } 167 + 168 + /* should be called prior to registration or with mutex held */ 169 + static inline void rc_set_allowed_protocols(struct rc_dev *rdev, u64 protos) 170 + { 171 + rdev->allowed_protos = protos; 172 + } 173 + 174 + static inline bool rc_protocols_enabled(struct rc_dev *rdev, u64 protos) 175 + { 176 + return rdev->enabled_protocols & protos; 177 + } 178 + 179 + /* should be called prior to registration or with mutex held */ 180 + static inline void rc_set_enabled_protocols(struct rc_dev *rdev, u64 protos) 181 + { 182 + rdev->enabled_protocols = protos; 183 + } 184 + 163 185 /* 164 186 * From rc-main.c 165 187 * Those functions can be used on any type of Remote Controller. They