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: i2c: Drop HAS_EVENTS and event handlers

v4l2_subdev_init_finalize() already sets the HAS_EVENTS flag if a
control handler is set, and subdev_do_ioctl() uses
v4l2_ctrl_subdev_subscribe_event() and v4l2_event_subdev_unsubscribe()
as defaults if the subdev doesn't have .(un)subscribe.
Let's drop the HAS_EVENTS flag and event handlers.

Signed-off-by: Tommaso Merciai <tomm.merciai@gmail.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>

authored by

Tommaso Merciai and committed by
Hans Verkuil 17971a43 a3461f73

+15 -106
+1 -4
drivers/media/i2c/alvium-csi2.c
··· 16 16 #include <media/v4l2-async.h> 17 17 #include <media/v4l2-ctrls.h> 18 18 #include <media/v4l2-device.h> 19 - #include <media/v4l2-event.h> 20 19 #include <media/v4l2-fwnode.h> 21 20 #include <media/v4l2-subdev.h> 22 21 ··· 2239 2240 2240 2241 static const struct v4l2_subdev_core_ops alvium_core_ops = { 2241 2242 .log_status = v4l2_ctrl_subdev_log_status, 2242 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 2243 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 2244 2243 }; 2245 2244 2246 2245 static const struct v4l2_subdev_video_ops alvium_video_ops = { ··· 2286 2289 v4l2_i2c_subdev_init(sd, client, &alvium_subdev_ops); 2287 2290 2288 2291 sd->internal_ops = &alvium_internal_ops; 2289 - sd->flags |= V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_HAS_DEVNODE; 2292 + sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 2290 2293 alvium->pad.flags = MEDIA_PAD_FL_SOURCE; 2291 2294 sd->entity.function = MEDIA_ENT_F_CAM_SENSOR; 2292 2295
+1 -4
drivers/media/i2c/ds90ub953.c
··· 24 24 25 25 #include <media/i2c/ds90ub9xx.h> 26 26 #include <media/v4l2-ctrls.h> 27 - #include <media/v4l2-event.h> 28 27 #include <media/v4l2-fwnode.h> 29 28 #include <media/v4l2-mediabus.h> 30 29 #include <media/v4l2-subdev.h> ··· 716 717 717 718 static const struct v4l2_subdev_core_ops ub953_subdev_core_ops = { 718 719 .log_status = ub953_log_status, 719 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 720 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 721 720 }; 722 721 723 722 static const struct v4l2_subdev_ops ub953_subdev_ops = { ··· 1243 1246 priv->sd.internal_ops = &ub953_internal_ops; 1244 1247 1245 1248 priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1246 - V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_STREAMS; 1249 + V4L2_SUBDEV_FL_STREAMS; 1247 1250 priv->sd.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE; 1248 1251 priv->sd.entity.ops = &ub953_entity_ops; 1249 1252
+1 -4
drivers/media/i2c/ds90ub960.c
··· 48 48 #include <media/i2c/ds90ub9xx.h> 49 49 #include <media/mipi-csi2.h> 50 50 #include <media/v4l2-ctrls.h> 51 - #include <media/v4l2-event.h> 52 51 #include <media/v4l2-fwnode.h> 53 52 #include <media/v4l2-subdev.h> 54 53 ··· 3084 3085 3085 3086 static const struct v4l2_subdev_core_ops ub960_subdev_core_ops = { 3086 3087 .log_status = ub960_log_status, 3087 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 3088 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 3089 3088 }; 3090 3089 3091 3090 static const struct v4l2_subdev_internal_ops ub960_internal_ops = { ··· 3664 3667 } 3665 3668 3666 3669 priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 3667 - V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_STREAMS; 3670 + V4L2_SUBDEV_FL_STREAMS; 3668 3671 priv->sd.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE; 3669 3672 priv->sd.entity.ops = &ub960_entity_ops; 3670 3673
-4
drivers/media/i2c/gc0308.c
··· 18 18 #include <media/v4l2-cci.h> 19 19 #include <media/v4l2-ctrls.h> 20 20 #include <media/v4l2-device.h> 21 - #include <media/v4l2-event.h> 22 21 #include <media/v4l2-fwnode.h> 23 22 #include <media/v4l2-subdev.h> 24 23 ··· 986 987 987 988 static const struct v4l2_subdev_core_ops gc0308_core_ops = { 988 989 .log_status = v4l2_ctrl_subdev_log_status, 989 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 990 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 991 990 #ifdef CONFIG_VIDEO_ADV_DEBUG 992 991 .g_register = gc0308_g_register, 993 992 .s_register = gc0308_s_register, ··· 1335 1338 v4l2_i2c_subdev_init(&gc0308->sd, client, &gc0308_subdev_ops); 1336 1339 gc0308->sd.internal_ops = &gc0308_internal_ops; 1337 1340 gc0308->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1338 - gc0308->sd.flags |= V4L2_SUBDEV_FL_HAS_EVENTS; 1339 1341 1340 1342 ret = gc0308_init_controls(gc0308); 1341 1343 if (ret)
+1 -9
drivers/media/i2c/gc05a2.c
··· 24 24 25 25 #include <media/v4l2-cci.h> 26 26 #include <media/v4l2-ctrls.h> 27 - #include <media/v4l2-event.h> 28 27 #include <media/v4l2-fwnode.h> 29 28 #include <media/v4l2-subdev.h> 30 29 ··· 1058 1059 .get_selection = gc05a2_get_selection, 1059 1060 }; 1060 1061 1061 - static const struct v4l2_subdev_core_ops gc05a2_core_ops = { 1062 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 1063 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 1064 - }; 1065 - 1066 1062 static const struct v4l2_subdev_ops gc05a2_subdev_ops = { 1067 - .core = &gc05a2_core_ops, 1068 1063 .video = &gc05a2_video_ops, 1069 1064 .pad = &gc05a2_subdev_pad_ops, 1070 1065 }; ··· 1264 1271 return dev_err_probe(dev, ret, 1265 1272 "failed to init controls\n"); 1266 1273 1267 - gc05a2->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1268 - V4L2_SUBDEV_FL_HAS_EVENTS; 1274 + gc05a2->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1269 1275 gc05a2->pad.flags = MEDIA_PAD_FL_SOURCE; 1270 1276 gc05a2->sd.dev = &client->dev; 1271 1277 gc05a2->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
+1 -9
drivers/media/i2c/gc08a3.c
··· 24 24 25 25 #include <media/v4l2-cci.h> 26 26 #include <media/v4l2-ctrls.h> 27 - #include <media/v4l2-event.h> 28 27 #include <media/v4l2-fwnode.h> 29 28 #include <media/v4l2-subdev.h> 30 29 ··· 1000 1001 .get_selection = gc08a3_get_selection, 1001 1002 }; 1002 1003 1003 - static const struct v4l2_subdev_core_ops gc08a3_core_ops = { 1004 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 1005 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 1006 - }; 1007 - 1008 1004 static const struct v4l2_subdev_ops gc08a3_subdev_ops = { 1009 - .core = &gc08a3_core_ops, 1010 1005 .video = &gc08a3_video_ops, 1011 1006 .pad = &gc08a3_subdev_pad_ops, 1012 1007 }; ··· 1240 1247 goto err_power_off; 1241 1248 } 1242 1249 1243 - gc08a3->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1244 - V4L2_SUBDEV_FL_HAS_EVENTS; 1250 + gc08a3->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1245 1251 gc08a3->pad.flags = MEDIA_PAD_FL_SOURCE; 1246 1252 gc08a3->sd.dev = &client->dev; 1247 1253 gc08a3->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
+1 -9
drivers/media/i2c/gc2145.c
··· 21 21 #include <media/v4l2-cci.h> 22 22 #include <media/v4l2-ctrls.h> 23 23 #include <media/v4l2-device.h> 24 - #include <media/v4l2-event.h> 25 24 #include <media/v4l2-fwnode.h> 26 25 #include <media/v4l2-mediabus.h> 27 26 ··· 1122 1123 GC2145_TEST_UNIFORM | GC2145_TEST_BLACK, 1123 1124 }; 1124 1125 1125 - static const struct v4l2_subdev_core_ops gc2145_core_ops = { 1126 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 1127 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 1128 - }; 1129 - 1130 1126 static const struct v4l2_subdev_video_ops gc2145_video_ops = { 1131 1127 .s_stream = gc2145_set_stream, 1132 1128 }; ··· 1135 1141 }; 1136 1142 1137 1143 static const struct v4l2_subdev_ops gc2145_subdev_ops = { 1138 - .core = &gc2145_core_ops, 1139 1144 .video = &gc2145_video_ops, 1140 1145 .pad = &gc2145_pad_ops, 1141 1146 }; ··· 1400 1407 goto error_power_off; 1401 1408 1402 1409 /* Initialize subdev */ 1403 - gc2145->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1404 - V4L2_SUBDEV_FL_HAS_EVENTS; 1410 + gc2145->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1405 1411 gc2145->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1406 1412 1407 1413 /* Initialize source pad */
+1 -9
drivers/media/i2c/imx219.c
··· 26 26 #include <media/v4l2-cci.h> 27 27 #include <media/v4l2-ctrls.h> 28 28 #include <media/v4l2-device.h> 29 - #include <media/v4l2-event.h> 30 29 #include <media/v4l2-fwnode.h> 31 30 #include <media/v4l2-mediabus.h> 32 31 ··· 921 922 return 0; 922 923 } 923 924 924 - static const struct v4l2_subdev_core_ops imx219_core_ops = { 925 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 926 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 927 - }; 928 - 929 925 static const struct v4l2_subdev_video_ops imx219_video_ops = { 930 926 .s_stream = imx219_set_stream, 931 927 }; ··· 934 940 }; 935 941 936 942 static const struct v4l2_subdev_ops imx219_subdev_ops = { 937 - .core = &imx219_core_ops, 938 943 .video = &imx219_video_ops, 939 944 .pad = &imx219_pad_ops, 940 945 }; ··· 1159 1166 goto error_power_off; 1160 1167 1161 1168 /* Initialize subdev */ 1162 - imx219->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1163 - V4L2_SUBDEV_FL_HAS_EVENTS; 1169 + imx219->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1164 1170 imx219->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1165 1171 1166 1172 /* Initialize source pad */
+1 -9
drivers/media/i2c/imx283.c
··· 32 32 #include <media/v4l2-cci.h> 33 33 #include <media/v4l2-ctrls.h> 34 34 #include <media/v4l2-device.h> 35 - #include <media/v4l2-event.h> 36 35 #include <media/v4l2-fwnode.h> 37 36 #include <media/v4l2-mediabus.h> 38 37 ··· 1283 1284 } 1284 1285 } 1285 1286 1286 - static const struct v4l2_subdev_core_ops imx283_core_ops = { 1287 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 1288 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 1289 - }; 1290 - 1291 1287 static const struct v4l2_subdev_video_ops imx283_video_ops = { 1292 1288 .s_stream = v4l2_subdev_s_stream_helper, 1293 1289 }; ··· 1302 1308 }; 1303 1309 1304 1310 static const struct v4l2_subdev_ops imx283_subdev_ops = { 1305 - .core = &imx283_core_ops, 1306 1311 .video = &imx283_video_ops, 1307 1312 .pad = &imx283_pad_ops, 1308 1313 }; ··· 1541 1548 goto error_pm; 1542 1549 1543 1550 /* Initialize subdev */ 1544 - imx283->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1545 - V4L2_SUBDEV_FL_HAS_EVENTS; 1551 + imx283->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1546 1552 imx283->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1547 1553 imx283->sd.internal_ops = &imx283_internal_ops; 1548 1554
+1 -9
drivers/media/i2c/imx290.c
··· 24 24 #include <media/v4l2-cci.h> 25 25 #include <media/v4l2-ctrls.h> 26 26 #include <media/v4l2-device.h> 27 - #include <media/v4l2-event.h> 28 27 #include <media/v4l2-fwnode.h> 29 28 #include <media/v4l2-subdev.h> 30 29 ··· 1209 1210 return 0; 1210 1211 } 1211 1212 1212 - static const struct v4l2_subdev_core_ops imx290_core_ops = { 1213 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 1214 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 1215 - }; 1216 - 1217 1213 static const struct v4l2_subdev_video_ops imx290_video_ops = { 1218 1214 .s_stream = imx290_set_stream, 1219 1215 }; ··· 1222 1228 }; 1223 1229 1224 1230 static const struct v4l2_subdev_ops imx290_subdev_ops = { 1225 - .core = &imx290_core_ops, 1226 1231 .video = &imx290_video_ops, 1227 1232 .pad = &imx290_pad_ops, 1228 1233 }; ··· 1255 1262 pm_runtime_put_autosuspend(imx290->dev); 1256 1263 1257 1264 imx290->sd.internal_ops = &imx290_internal_ops; 1258 - imx290->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 1259 - V4L2_SUBDEV_FL_HAS_EVENTS; 1265 + imx290->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1260 1266 imx290->sd.entity.ops = &imx290_subdev_entity_ops; 1261 1267 imx290->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1262 1268
+1 -5
drivers/media/i2c/max96714.c
··· 17 17 18 18 #include <media/v4l2-cci.h> 19 19 #include <media/v4l2-ctrls.h> 20 - #include <media/v4l2-event.h> 21 20 #include <media/v4l2-fwnode.h> 22 21 #include <media/v4l2-subdev.h> 23 22 ··· 488 489 489 490 static const struct v4l2_subdev_core_ops max96714_subdev_core_ops = { 490 491 .log_status = max96714_log_status, 491 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 492 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 493 492 }; 494 493 495 494 static const struct v4l2_subdev_video_ops max96714_video_ops = { ··· 602 605 goto err_free_ctrl; 603 606 } 604 607 605 - priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 606 - V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_STREAMS; 608 + priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_STREAMS; 607 609 priv->sd.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE; 608 610 priv->sd.entity.ops = &max96714_entity_ops; 609 611
+1 -5
drivers/media/i2c/max96717.c
··· 17 17 18 18 #include <media/v4l2-cci.h> 19 19 #include <media/v4l2-ctrls.h> 20 - #include <media/v4l2-event.h> 21 20 #include <media/v4l2-fwnode.h> 22 21 #include <media/v4l2-subdev.h> 23 22 ··· 576 577 577 578 static const struct v4l2_subdev_core_ops max96717_subdev_core_ops = { 578 579 .log_status = max96717_log_status, 579 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 580 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 581 580 }; 582 581 583 582 static const struct v4l2_subdev_internal_ops max96717_internal_ops = { ··· 689 692 goto err_free_ctrl; 690 693 } 691 694 692 - priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 693 - V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_STREAMS; 695 + priv->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_STREAMS; 694 696 priv->sd.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE; 695 697 priv->sd.entity.ops = &max96717_entity_ops; 696 698
+1 -5
drivers/media/i2c/ov01a10.c
··· 13 13 14 14 #include <media/v4l2-ctrls.h> 15 15 #include <media/v4l2-device.h> 16 - #include <media/v4l2-event.h> 17 16 #include <media/v4l2-fwnode.h> 18 17 19 18 #define OV01A10_LINK_FREQ_400MHZ 400000000ULL ··· 803 804 804 805 static const struct v4l2_subdev_core_ops ov01a10_core_ops = { 805 806 .log_status = v4l2_ctrl_subdev_log_status, 806 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 807 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 808 807 }; 809 808 810 809 static const struct v4l2_subdev_video_ops ov01a10_video_ops = { ··· 889 892 } 890 893 891 894 ov01a10->sd.state_lock = ov01a10->ctrl_handler.lock; 892 - ov01a10->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | 893 - V4L2_SUBDEV_FL_HAS_EVENTS; 895 + ov01a10->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 894 896 ov01a10->sd.entity.ops = &ov01a10_subdev_entity_ops; 895 897 ov01a10->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 896 898 ov01a10->pad.flags = MEDIA_PAD_FL_SOURCE;
+1 -9
drivers/media/i2c/ov64a40.c
··· 18 18 #include <media/v4l2-cci.h> 19 19 #include <media/v4l2-ctrls.h> 20 20 #include <media/v4l2-device.h> 21 - #include <media/v4l2-event.h> 22 21 #include <media/v4l2-fwnode.h> 23 22 #include <media/v4l2-mediabus.h> 24 23 #include <media/v4l2-subdev.h> ··· 3199 3200 .get_selection = ov64a40_get_selection, 3200 3201 }; 3201 3202 3202 - static const struct v4l2_subdev_core_ops ov64a40_core_ops = { 3203 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 3204 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 3205 - }; 3206 - 3207 3203 static const struct v4l2_subdev_ops ov64a40_subdev_ops = { 3208 - .core = &ov64a40_core_ops, 3209 3204 .video = &ov64a40_video_ops, 3210 3205 .pad = &ov64a40_pad_ops, 3211 3206 }; ··· 3598 3605 3599 3606 /* Initialize subdev */ 3600 3607 ov64a40->sd.internal_ops = &ov64a40_internal_ops; 3601 - ov64a40->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE 3602 - | V4L2_SUBDEV_FL_HAS_EVENTS; 3608 + ov64a40->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE; 3603 3609 ov64a40->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 3604 3610 3605 3611 ov64a40->pad.flags = MEDIA_PAD_FL_SOURCE;
+1 -8
drivers/media/i2c/ov8858.c
··· 24 24 #include <media/v4l2-common.h> 25 25 #include <media/v4l2-ctrls.h> 26 26 #include <media/v4l2-device.h> 27 - #include <media/v4l2-event.h> 28 27 #include <media/v4l2-fwnode.h> 29 28 #include <media/v4l2-mediabus.h> 30 29 #include <media/v4l2-subdev.h> ··· 1499 1500 .set_fmt = ov8858_set_fmt, 1500 1501 }; 1501 1502 1502 - static const struct v4l2_subdev_core_ops ov8858_core_ops = { 1503 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 1504 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 1505 - }; 1506 - 1507 1503 static const struct v4l2_subdev_ops ov8858_subdev_ops = { 1508 - .core = &ov8858_core_ops, 1509 1504 .video = &ov8858_video_ops, 1510 1505 .pad = &ov8858_pad_ops, 1511 1506 }; ··· 1910 1917 return ret; 1911 1918 1912 1919 sd = &ov8858->subdev; 1913 - sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS; 1920 + sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1914 1921 ov8858->pad.flags = MEDIA_PAD_FL_SOURCE; 1915 1922 sd->entity.function = MEDIA_ENT_F_CAM_SENSOR; 1916 1923 ret = media_entity_pads_init(&sd->entity, 1, &ov8858->pad);
+1 -4
drivers/media/i2c/thp7312.c
··· 27 27 #include <media/v4l2-cci.h> 28 28 #include <media/v4l2-ctrls.h> 29 29 #include <media/v4l2-device.h> 30 - #include <media/v4l2-event.h> 31 30 #include <media/v4l2-fwnode.h> 32 31 #include <media/v4l2-subdev.h> 33 32 ··· 878 879 879 880 static const struct v4l2_subdev_core_ops thp7312_core_ops = { 880 881 .log_status = v4l2_ctrl_subdev_log_status, 881 - .subscribe_event = v4l2_ctrl_subdev_subscribe_event, 882 - .unsubscribe_event = v4l2_event_subdev_unsubscribe, 883 882 }; 884 883 885 884 static const struct v4l2_subdev_video_ops thp7312_video_ops = { ··· 2124 2127 2125 2128 v4l2_i2c_subdev_init(&thp7312->sd, client, &thp7312_subdev_ops); 2126 2129 thp7312->sd.internal_ops = &thp7312_internal_ops; 2127 - thp7312->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS; 2130 + thp7312->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 2128 2131 thp7312->pad.flags = MEDIA_PAD_FL_SOURCE; 2129 2132 thp7312->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 2130 2133