Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'media/v6.8-4' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media fixes from Mauro Carvalho Chehab:
- regression fix for rkisp1 shared IRQ logic
- fix atomisp breakage due to a kAPI change
- permission fix for remote controller BPF support
- memleak fix in ir_toy driver
- Kconfig dependency fix for pwm-ir-rx
* tag 'media/v6.8-4' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media:
media: pwm-ir-tx: Depend on CONFIG_HIGH_RES_TIMERS
media: ir_toy: fix a memleak in irtoy_tx
media: rc: bpf attach/detach requires write permission
media: atomisp: Adjust for v4l2_subdev_state handling changes in 6.8
media: rkisp1: Fix IRQ handling due to shared interrupts
media: Revert "media: rkisp1: Drop IRQF_SHARED"
+156
-68
+3
drivers/media/platform/rockchip/rkisp1/rkisp1-capture.c
+3
drivers/media/platform/rockchip/rkisp1/rkisp1-capture.c
+2
drivers/media/platform/rockchip/rkisp1/rkisp1-common.h
+2
drivers/media/platform/rockchip/rkisp1/rkisp1-common.h
···
450
450
* @debug: debug params to be exposed on debugfs
451
451
* @info: version-specific ISP information
452
452
* @irqs: IRQ line numbers
453
+
* @irqs_enabled: the hardware is enabled and can cause interrupts
453
454
*/
454
455
struct rkisp1_device {
455
456
void __iomem *base_addr;
···
472
471
struct rkisp1_debug debug;
473
472
const struct rkisp1_info *info;
474
473
int irqs[RKISP1_NUM_IRQS];
474
+
bool irqs_enabled;
475
475
};
476
476
477
477
/*
+3
drivers/media/platform/rockchip/rkisp1/rkisp1-csi.c
+3
drivers/media/platform/rockchip/rkisp1/rkisp1-csi.c
+23
-1
drivers/media/platform/rockchip/rkisp1/rkisp1-dev.c
+23
-1
drivers/media/platform/rockchip/rkisp1/rkisp1-dev.c
···
305
305
{
306
306
struct rkisp1_device *rkisp1 = dev_get_drvdata(dev);
307
307
308
+
rkisp1->irqs_enabled = false;
309
+
/* Make sure the IRQ handler will see the above */
310
+
mb();
311
+
312
+
/*
313
+
* Wait until any running IRQ handler has returned. The IRQ handler
314
+
* may get called even after this (as it's a shared interrupt line)
315
+
* but the 'irqs_enabled' flag will make the handler return immediately.
316
+
*/
317
+
for (unsigned int il = 0; il < ARRAY_SIZE(rkisp1->irqs); ++il) {
318
+
if (rkisp1->irqs[il] == -1)
319
+
continue;
320
+
321
+
/* Skip if the irq line is the same as previous */
322
+
if (il == 0 || rkisp1->irqs[il - 1] != rkisp1->irqs[il])
323
+
synchronize_irq(rkisp1->irqs[il]);
324
+
}
325
+
308
326
clk_bulk_disable_unprepare(rkisp1->clk_size, rkisp1->clks);
309
327
return pinctrl_pm_select_sleep_state(dev);
310
328
}
···
338
320
ret = clk_bulk_prepare_enable(rkisp1->clk_size, rkisp1->clks);
339
321
if (ret)
340
322
return ret;
323
+
324
+
rkisp1->irqs_enabled = true;
325
+
/* Make sure the IRQ handler will see the above */
326
+
mb();
341
327
342
328
return 0;
343
329
}
···
581
559
rkisp1->irqs[il] = irq;
582
560
}
583
561
584
-
ret = devm_request_irq(dev, irq, info->isrs[i].isr, 0,
562
+
ret = devm_request_irq(dev, irq, info->isrs[i].isr, IRQF_SHARED,
585
563
dev_driver_string(dev), dev);
586
564
if (ret) {
587
565
dev_err(dev, "request irq failed: %d\n", ret);
+3
drivers/media/platform/rockchip/rkisp1/rkisp1-isp.c
+3
drivers/media/platform/rockchip/rkisp1/rkisp1-isp.c
+1
drivers/media/rc/Kconfig
+1
drivers/media/rc/Kconfig
+3
-3
drivers/media/rc/bpf-lirc.c
+3
-3
drivers/media/rc/bpf-lirc.c
···
253
253
if (attr->attach_flags)
254
254
return -EINVAL;
255
255
256
-
rcdev = rc_dev_get_from_fd(attr->target_fd);
256
+
rcdev = rc_dev_get_from_fd(attr->target_fd, true);
257
257
if (IS_ERR(rcdev))
258
258
return PTR_ERR(rcdev);
259
259
···
278
278
if (IS_ERR(prog))
279
279
return PTR_ERR(prog);
280
280
281
-
rcdev = rc_dev_get_from_fd(attr->target_fd);
281
+
rcdev = rc_dev_get_from_fd(attr->target_fd, true);
282
282
if (IS_ERR(rcdev)) {
283
283
bpf_prog_put(prog);
284
284
return PTR_ERR(rcdev);
···
303
303
if (attr->query.query_flags)
304
304
return -EINVAL;
305
305
306
-
rcdev = rc_dev_get_from_fd(attr->query.target_fd);
306
+
rcdev = rc_dev_get_from_fd(attr->query.target_fd, false);
307
307
if (IS_ERR(rcdev))
308
308
return PTR_ERR(rcdev);
309
309
+2
drivers/media/rc/ir_toy.c
+2
drivers/media/rc/ir_toy.c
···
332
332
sizeof(COMMAND_SMODE_EXIT), STATE_COMMAND_NO_RESP);
333
333
if (err) {
334
334
dev_err(irtoy->dev, "exit sample mode: %d\n", err);
335
+
kfree(buf);
335
336
return err;
336
337
}
337
338
···
340
339
sizeof(COMMAND_SMODE_ENTER), STATE_COMMAND);
341
340
if (err) {
342
341
dev_err(irtoy->dev, "enter sample mode: %d\n", err);
342
+
kfree(buf);
343
343
return err;
344
344
}
345
345
+4
-1
drivers/media/rc/lirc_dev.c
+4
-1
drivers/media/rc/lirc_dev.c
···
814
814
unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
815
815
}
816
816
817
-
struct rc_dev *rc_dev_get_from_fd(int fd)
817
+
struct rc_dev *rc_dev_get_from_fd(int fd, bool write)
818
818
{
819
819
struct fd f = fdget(fd);
820
820
struct lirc_fh *fh;
···
827
827
fdput(f);
828
828
return ERR_PTR(-EINVAL);
829
829
}
830
+
831
+
if (write && !(f.file->f_mode & FMODE_WRITE))
832
+
return ERR_PTR(-EPERM);
830
833
831
834
fh = f.file->private_data;
832
835
dev = fh->rc;
+1
-1
drivers/media/rc/rc-core-priv.h
+1
-1
drivers/media/rc/rc-core-priv.h
···
325
325
void lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc);
326
326
int lirc_register(struct rc_dev *dev);
327
327
void lirc_unregister(struct rc_dev *dev);
328
-
struct rc_dev *rc_dev_get_from_fd(int fd);
328
+
struct rc_dev *rc_dev_get_from_fd(int fd, bool write);
329
329
#else
330
330
static inline int lirc_dev_init(void) { return 0; }
331
331
static inline void lirc_dev_exit(void) {}
+34
-24
drivers/staging/media/atomisp/pci/atomisp_cmd.c
+34
-24
drivers/staging/media/atomisp/pci/atomisp_cmd.c
···
3723
3723
3724
3724
static int atomisp_set_crop(struct atomisp_device *isp,
3725
3725
const struct v4l2_mbus_framefmt *format,
3726
+
struct v4l2_subdev_state *sd_state,
3726
3727
int which)
3727
3728
{
3728
3729
struct atomisp_input_subdev *input = &isp->inputs[isp->asd.input_curr];
3729
-
struct v4l2_subdev_state pad_state = {
3730
-
.pads = &input->pad_cfg,
3731
-
};
3732
3730
struct v4l2_subdev_selection sel = {
3733
3731
.which = which,
3734
3732
.target = V4L2_SEL_TGT_CROP,
···
3752
3754
sel.r.left = ((input->native_rect.width - sel.r.width) / 2) & ~1;
3753
3755
sel.r.top = ((input->native_rect.height - sel.r.height) / 2) & ~1;
3754
3756
3755
-
ret = v4l2_subdev_call(input->camera, pad, set_selection, &pad_state, &sel);
3757
+
ret = v4l2_subdev_call(input->camera, pad, set_selection, sd_state, &sel);
3756
3758
if (ret)
3757
3759
dev_err(isp->dev, "Error setting crop to %ux%u @%ux%u: %d\n",
3758
3760
sel.r.width, sel.r.height, sel.r.left, sel.r.top, ret);
···
3768
3770
const struct atomisp_format_bridge *fmt, *snr_fmt;
3769
3771
struct atomisp_sub_device *asd = &isp->asd;
3770
3772
struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
3771
-
struct v4l2_subdev_state pad_state = {
3772
-
.pads = &input->pad_cfg,
3773
-
};
3774
3773
struct v4l2_subdev_format format = {
3775
3774
.which = V4L2_SUBDEV_FORMAT_TRY,
3776
3775
};
···
3804
3809
dev_dbg(isp->dev, "try_mbus_fmt: asking for %ux%u\n",
3805
3810
format.format.width, format.format.height);
3806
3811
3807
-
ret = atomisp_set_crop(isp, &format.format, V4L2_SUBDEV_FORMAT_TRY);
3808
-
if (ret)
3809
-
return ret;
3812
+
v4l2_subdev_lock_state(input->try_sd_state);
3810
3813
3811
-
ret = v4l2_subdev_call(input->camera, pad, set_fmt, &pad_state, &format);
3814
+
ret = atomisp_set_crop(isp, &format.format, input->try_sd_state,
3815
+
V4L2_SUBDEV_FORMAT_TRY);
3816
+
if (ret == 0)
3817
+
ret = v4l2_subdev_call(input->camera, pad, set_fmt,
3818
+
input->try_sd_state, &format);
3819
+
3820
+
v4l2_subdev_unlock_state(input->try_sd_state);
3821
+
3812
3822
if (ret)
3813
3823
return ret;
3814
3824
···
4238
4238
struct atomisp_device *isp = asd->isp;
4239
4239
struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
4240
4240
const struct atomisp_format_bridge *format;
4241
-
struct v4l2_subdev_state pad_state = {
4242
-
.pads = &input->pad_cfg,
4243
-
};
4241
+
struct v4l2_subdev_state *act_sd_state;
4244
4242
struct v4l2_subdev_format vformat = {
4245
4243
.which = V4L2_SUBDEV_FORMAT_TRY,
4246
4244
};
···
4266
4268
4267
4269
/* Disable dvs if resolution can't be supported by sensor */
4268
4270
if (asd->params.video_dis_en && asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) {
4269
-
ret = atomisp_set_crop(isp, &vformat.format, V4L2_SUBDEV_FORMAT_TRY);
4270
-
if (ret)
4271
-
return ret;
4271
+
v4l2_subdev_lock_state(input->try_sd_state);
4272
4272
4273
-
vformat.which = V4L2_SUBDEV_FORMAT_TRY;
4274
-
ret = v4l2_subdev_call(input->camera, pad, set_fmt, &pad_state, &vformat);
4273
+
ret = atomisp_set_crop(isp, &vformat.format, input->try_sd_state,
4274
+
V4L2_SUBDEV_FORMAT_TRY);
4275
+
if (ret == 0) {
4276
+
vformat.which = V4L2_SUBDEV_FORMAT_TRY;
4277
+
ret = v4l2_subdev_call(input->camera, pad, set_fmt,
4278
+
input->try_sd_state, &vformat);
4279
+
}
4280
+
4281
+
v4l2_subdev_unlock_state(input->try_sd_state);
4282
+
4275
4283
if (ret)
4276
4284
return ret;
4277
4285
···
4295
4291
}
4296
4292
}
4297
4293
4298
-
ret = atomisp_set_crop(isp, &vformat.format, V4L2_SUBDEV_FORMAT_ACTIVE);
4299
-
if (ret)
4300
-
return ret;
4294
+
act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
4301
4295
4302
-
vformat.which = V4L2_SUBDEV_FORMAT_ACTIVE;
4303
-
ret = v4l2_subdev_call(input->camera, pad, set_fmt, NULL, &vformat);
4296
+
ret = atomisp_set_crop(isp, &vformat.format, act_sd_state,
4297
+
V4L2_SUBDEV_FORMAT_ACTIVE);
4298
+
if (ret == 0) {
4299
+
vformat.which = V4L2_SUBDEV_FORMAT_ACTIVE;
4300
+
ret = v4l2_subdev_call(input->camera, pad, set_fmt, act_sd_state, &vformat);
4301
+
}
4302
+
4303
+
if (act_sd_state)
4304
+
v4l2_subdev_unlock_state(act_sd_state);
4305
+
4304
4306
if (ret)
4305
4307
return ret;
4306
4308
+2
-2
drivers/staging/media/atomisp/pci/atomisp_internal.h
+2
-2
drivers/staging/media/atomisp/pci/atomisp_internal.h
···
132
132
/* Sensor rects for sensors which support crop */
133
133
struct v4l2_rect native_rect;
134
134
struct v4l2_rect active_rect;
135
-
/* Sensor pad_cfg for which == V4L2_SUBDEV_FORMAT_TRY calls */
136
-
struct v4l2_subdev_pad_config pad_cfg;
135
+
/* Sensor state for which == V4L2_SUBDEV_FORMAT_TRY calls */
136
+
struct v4l2_subdev_state *try_sd_state;
137
137
138
138
struct v4l2_subdev *motor;
139
139
+31
-21
drivers/staging/media/atomisp/pci/atomisp_ioctl.c
+31
-21
drivers/staging/media/atomisp/pci/atomisp_ioctl.c
···
781
781
.which = V4L2_SUBDEV_FORMAT_ACTIVE,
782
782
.code = input->code,
783
783
};
784
+
struct v4l2_subdev_state *act_sd_state;
784
785
int ret;
786
+
787
+
if (!input->camera)
788
+
return -EINVAL;
785
789
786
790
if (input->crop_support)
787
791
return atomisp_enum_framesizes_crop(isp, fsize);
788
792
789
-
ret = v4l2_subdev_call(input->camera, pad, enum_frame_size, NULL, &fse);
793
+
act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
794
+
ret = v4l2_subdev_call(input->camera, pad, enum_frame_size,
795
+
act_sd_state, &fse);
796
+
if (act_sd_state)
797
+
v4l2_subdev_unlock_state(act_sd_state);
790
798
if (ret)
791
799
return ret;
792
800
···
811
803
struct video_device *vdev = video_devdata(file);
812
804
struct atomisp_device *isp = video_get_drvdata(vdev);
813
805
struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
806
+
struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
814
807
struct v4l2_subdev_frame_interval_enum fie = {
815
-
.code = atomisp_in_fmt_conv[0].code,
808
+
.code = atomisp_in_fmt_conv[0].code,
816
809
.index = fival->index,
817
810
.width = fival->width,
818
811
.height = fival->height,
819
812
.which = V4L2_SUBDEV_FORMAT_ACTIVE,
820
813
};
814
+
struct v4l2_subdev_state *act_sd_state;
821
815
int ret;
822
816
823
-
ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
824
-
pad, enum_frame_interval, NULL,
825
-
&fie);
817
+
if (!input->camera)
818
+
return -EINVAL;
819
+
820
+
act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
821
+
ret = v4l2_subdev_call(input->camera, pad, enum_frame_interval,
822
+
act_sd_state, &fie);
823
+
if (act_sd_state)
824
+
v4l2_subdev_unlock_state(act_sd_state);
826
825
if (ret)
827
826
return ret;
828
827
···
845
830
struct video_device *vdev = video_devdata(file);
846
831
struct atomisp_device *isp = video_get_drvdata(vdev);
847
832
struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
833
+
struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
848
834
struct v4l2_subdev_mbus_code_enum code = {
849
835
.which = V4L2_SUBDEV_FORMAT_ACTIVE,
850
836
};
851
837
const struct atomisp_format_bridge *format;
852
-
struct v4l2_subdev *camera;
838
+
struct v4l2_subdev_state *act_sd_state;
853
839
unsigned int i, fi = 0;
854
-
int rval;
840
+
int ret;
855
841
856
-
camera = isp->inputs[asd->input_curr].camera;
857
-
if(!camera) {
858
-
dev_err(isp->dev, "%s(): camera is NULL, device is %s\n",
859
-
__func__, vdev->name);
842
+
if (!input->camera)
860
843
return -EINVAL;
861
-
}
862
844
863
-
rval = v4l2_subdev_call(camera, pad, enum_mbus_code, NULL, &code);
864
-
if (rval == -ENOIOCTLCMD) {
865
-
dev_warn(isp->dev,
866
-
"enum_mbus_code pad op not supported by %s. Please fix your sensor driver!\n",
867
-
camera->name);
868
-
}
869
-
870
-
if (rval)
871
-
return rval;
845
+
act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
846
+
ret = v4l2_subdev_call(input->camera, pad, enum_mbus_code,
847
+
act_sd_state, &code);
848
+
if (act_sd_state)
849
+
v4l2_subdev_unlock_state(act_sd_state);
850
+
if (ret)
851
+
return ret;
872
852
873
853
for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
874
854
format = &atomisp_output_fmts[i];
+44
-15
drivers/staging/media/atomisp/pci/atomisp_v4l2.c
+44
-15
drivers/staging/media/atomisp/pci/atomisp_v4l2.c
···
862
862
v4l2_device_unregister(&isp->v4l2_dev);
863
863
media_device_unregister(&isp->media_dev);
864
864
media_device_cleanup(&isp->media_dev);
865
+
866
+
for (i = 0; i < isp->input_cnt; i++)
867
+
__v4l2_subdev_state_free(isp->inputs[i].try_sd_state);
865
868
}
866
869
867
870
static int atomisp_register_entities(struct atomisp_device *isp)
···
936
933
937
934
static void atomisp_init_sensor(struct atomisp_input_subdev *input)
938
935
{
936
+
static struct lock_class_key try_sd_state_key;
939
937
struct v4l2_subdev_mbus_code_enum mbus_code_enum = { };
940
938
struct v4l2_subdev_frame_size_enum fse = { };
941
-
struct v4l2_subdev_state sd_state = {
942
-
.pads = &input->pad_cfg,
943
-
};
944
939
struct v4l2_subdev_selection sel = { };
940
+
struct v4l2_subdev_state *try_sd_state, *act_sd_state;
945
941
int i, err;
946
942
943
+
/*
944
+
* FIXME: Drivers are not supposed to use __v4l2_subdev_state_alloc()
945
+
* but atomisp needs this for try_fmt on its /dev/video# node since
946
+
* it emulates a normal v4l2 device there, passing through try_fmt /
947
+
* set_fmt to the sensor.
948
+
*/
949
+
try_sd_state = __v4l2_subdev_state_alloc(input->camera,
950
+
"atomisp:try_sd_state->lock", &try_sd_state_key);
951
+
if (IS_ERR(try_sd_state))
952
+
return;
953
+
954
+
input->try_sd_state = try_sd_state;
955
+
956
+
act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
957
+
947
958
mbus_code_enum.which = V4L2_SUBDEV_FORMAT_ACTIVE;
948
-
err = v4l2_subdev_call(input->camera, pad, enum_mbus_code, NULL, &mbus_code_enum);
959
+
err = v4l2_subdev_call(input->camera, pad, enum_mbus_code,
960
+
act_sd_state, &mbus_code_enum);
949
961
if (!err)
950
962
input->code = mbus_code_enum.code;
951
963
952
964
sel.which = V4L2_SUBDEV_FORMAT_ACTIVE;
953
965
sel.target = V4L2_SEL_TGT_NATIVE_SIZE;
954
-
err = v4l2_subdev_call(input->camera, pad, get_selection, NULL, &sel);
966
+
err = v4l2_subdev_call(input->camera, pad, get_selection,
967
+
act_sd_state, &sel);
955
968
if (err)
956
-
return;
969
+
goto unlock_act_sd_state;
957
970
958
971
input->native_rect = sel.r;
959
972
960
973
sel.which = V4L2_SUBDEV_FORMAT_ACTIVE;
961
974
sel.target = V4L2_SEL_TGT_CROP_DEFAULT;
962
-
err = v4l2_subdev_call(input->camera, pad, get_selection, NULL, &sel);
975
+
err = v4l2_subdev_call(input->camera, pad, get_selection,
976
+
act_sd_state, &sel);
963
977
if (err)
964
-
return;
978
+
goto unlock_act_sd_state;
965
979
966
980
input->active_rect = sel.r;
967
981
···
993
973
fse.code = input->code;
994
974
fse.which = V4L2_SUBDEV_FORMAT_ACTIVE;
995
975
996
-
err = v4l2_subdev_call(input->camera, pad, enum_frame_size, NULL, &fse);
976
+
err = v4l2_subdev_call(input->camera, pad, enum_frame_size,
977
+
act_sd_state, &fse);
997
978
if (err)
998
979
break;
999
980
···
1010
989
* for padding, set the crop rect to cover the entire sensor instead
1011
990
* of only the default active area.
1012
991
*
1013
-
* Do this for both try and active formats since the try_crop rect in
1014
-
* pad_cfg may influence (clamp) future try_fmt calls with which == try.
992
+
* Do this for both try and active formats since the crop rect in
993
+
* try_sd_state may influence (clamp size) in calls with which == try.
1015
994
*/
1016
995
sel.which = V4L2_SUBDEV_FORMAT_TRY;
1017
996
sel.target = V4L2_SEL_TGT_CROP;
1018
997
sel.r = input->native_rect;
1019
-
err = v4l2_subdev_call(input->camera, pad, set_selection, &sd_state, &sel);
998
+
v4l2_subdev_lock_state(input->try_sd_state);
999
+
err = v4l2_subdev_call(input->camera, pad, set_selection,
1000
+
input->try_sd_state, &sel);
1001
+
v4l2_subdev_unlock_state(input->try_sd_state);
1020
1002
if (err)
1021
-
return;
1003
+
goto unlock_act_sd_state;
1022
1004
1023
1005
sel.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1024
1006
sel.target = V4L2_SEL_TGT_CROP;
1025
1007
sel.r = input->native_rect;
1026
-
err = v4l2_subdev_call(input->camera, pad, set_selection, NULL, &sel);
1008
+
err = v4l2_subdev_call(input->camera, pad, set_selection,
1009
+
act_sd_state, &sel);
1027
1010
if (err)
1028
-
return;
1011
+
goto unlock_act_sd_state;
1029
1012
1030
1013
dev_info(input->camera->dev, "Supports crop native %dx%d active %dx%d binning %d\n",
1031
1014
input->native_rect.width, input->native_rect.height,
···
1037
1012
input->binning_support);
1038
1013
1039
1014
input->crop_support = true;
1015
+
1016
+
unlock_act_sd_state:
1017
+
if (act_sd_state)
1018
+
v4l2_subdev_unlock_state(act_sd_state);
1040
1019
}
1041
1020
1042
1021
int atomisp_register_device_nodes(struct atomisp_device *isp)