xref: /linux/drivers/media/pci/mgb4/mgb4_sysfs_out.c (revision 870b7fdc660b38c4e1bd8bf48e62aa352ddf8f42)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2021-2023 Digiteq Automotive
4  *     author: Martin Tuma <martin.tuma@digiteqautomotive.com>
5  *
6  * This module handles all the sysfs info/configuration that is related to the
7  * v4l2 output devices.
8  */
9 
10 #include <linux/device.h>
11 #include <linux/nospec.h>
12 #include "mgb4_core.h"
13 #include "mgb4_i2c.h"
14 #include "mgb4_vout.h"
15 #include "mgb4_vin.h"
16 #include "mgb4_cmt.h"
17 #include "mgb4_sysfs.h"
18 
19 static int loopin_cnt(struct mgb4_vin_dev *vindev)
20 {
21 	struct mgb4_vout_dev *voutdev;
22 	u32 config;
23 	int i, cnt = 0;
24 
25 	for (i = 0; i < MGB4_VOUT_DEVICES; i++) {
26 		voutdev = vindev->mgbdev->vout[i];
27 		if (!voutdev)
28 			continue;
29 
30 		config = mgb4_read_reg(&voutdev->mgbdev->video,
31 				       voutdev->config->regs.config);
32 		if ((config & 0xc) >> 2 == vindev->config->id)
33 			cnt++;
34 	}
35 
36 	return cnt;
37 }
38 
39 static bool is_busy(struct video_device *dev)
40 {
41 	bool ret;
42 
43 	mutex_lock(dev->lock);
44 	ret = vb2_is_busy(dev->queue);
45 	mutex_unlock(dev->lock);
46 
47 	return ret;
48 }
49 
50 /* Common for both FPDL3 and GMSL */
51 
52 static ssize_t output_id_show(struct device *dev,
53 			      struct device_attribute *attr, char *buf)
54 {
55 	struct video_device *vdev = to_video_device(dev);
56 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
57 
58 	return sprintf(buf, "%d\n", voutdev->config->id);
59 }
60 
61 static ssize_t video_source_show(struct device *dev,
62 				 struct device_attribute *attr, char *buf)
63 {
64 	struct video_device *vdev = to_video_device(dev);
65 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
66 	u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
67 	  voutdev->config->regs.config);
68 
69 	return sprintf(buf, "%u\n", (config & 0xc) >> 2);
70 }
71 
72 /*
73  * Video source change may affect the buffer queue of ANY video input/output on
74  * the card thus if any of the inputs/outputs is in use, we do not allow
75  * the change.
76  *
77  * As we do not want to lock all the video devices at the same time, a two-stage
78  * locking strategy is used. In addition to the video device locking there is
79  * a global (PCI device) variable "io_reconfig" atomically checked/set when
80  * the reconfiguration is running. All the video devices check the variable in
81  * their queue_setup() functions and do not allow to start the queue when
82  * the reconfiguration has started.
83  */
84 static ssize_t video_source_store(struct device *dev,
85 				  struct device_attribute *attr,
86 				  const char *buf, size_t count)
87 {
88 	struct video_device *vdev = to_video_device(dev);
89 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
90 	struct mgb4_dev *mgbdev = voutdev->mgbdev;
91 	struct mgb4_vin_dev *loopin_new = NULL, *loopin_old = NULL;
92 	unsigned long val;
93 	ssize_t ret;
94 	u32 config;
95 	int i;
96 
97 	ret = kstrtoul(buf, 10, &val);
98 	if (ret)
99 		return ret;
100 	if (val > 3)
101 		return -EINVAL;
102 
103 	if (test_and_set_bit(0, &mgbdev->io_reconfig))
104 		return -EBUSY;
105 
106 	ret = -EBUSY;
107 	for (i = 0; i < MGB4_VIN_DEVICES; i++)
108 		if (mgbdev->vin[i] && is_busy(&mgbdev->vin[i]->vdev))
109 			goto end;
110 	for (i = 0; i < MGB4_VOUT_DEVICES; i++)
111 		if (mgbdev->vout[i] && is_busy(&mgbdev->vout[i]->vdev))
112 			goto end;
113 
114 	config = mgb4_read_reg(&mgbdev->video, voutdev->config->regs.config);
115 
116 	if (((config & 0xc) >> 2) < MGB4_VIN_DEVICES)
117 		loopin_old = mgbdev->vin[(config & 0xc) >> 2];
118 	if (val < MGB4_VIN_DEVICES) {
119 		val = array_index_nospec(val, MGB4_VIN_DEVICES);
120 		loopin_new = mgbdev->vin[val];
121 	}
122 	if (loopin_old && loopin_cnt(loopin_old) == 1)
123 		mgb4_mask_reg(&mgbdev->video, loopin_old->config->regs.config,
124 			      0x2, 0x0);
125 	if (loopin_new)
126 		mgb4_mask_reg(&mgbdev->video, loopin_new->config->regs.config,
127 			      0x2, 0x2);
128 
129 	if (val == voutdev->config->id + MGB4_VIN_DEVICES)
130 		mgb4_write_reg(&mgbdev->video, voutdev->config->regs.config,
131 			       config & ~(1 << 1));
132 	else
133 		mgb4_write_reg(&mgbdev->video, voutdev->config->regs.config,
134 			       config | (1U << 1));
135 
136 	mgb4_mask_reg(&mgbdev->video, voutdev->config->regs.config, 0xc,
137 		      val << 2);
138 
139 	ret = count;
140 end:
141 	clear_bit(0, &mgbdev->io_reconfig);
142 
143 	return ret;
144 }
145 
146 static ssize_t display_width_show(struct device *dev,
147 				  struct device_attribute *attr, char *buf)
148 {
149 	struct video_device *vdev = to_video_device(dev);
150 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
151 	u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
152 	  voutdev->config->regs.resolution);
153 
154 	return sprintf(buf, "%u\n", config >> 16);
155 }
156 
157 static ssize_t display_width_store(struct device *dev,
158 				   struct device_attribute *attr,
159 				   const char *buf, size_t count)
160 {
161 	struct video_device *vdev = to_video_device(dev);
162 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
163 	unsigned long val;
164 	int ret;
165 
166 	ret = kstrtoul(buf, 10, &val);
167 	if (ret)
168 		return ret;
169 	if (val > 0xFFFF)
170 		return -EINVAL;
171 
172 	mutex_lock(voutdev->vdev.lock);
173 	if (vb2_is_busy(voutdev->vdev.queue)) {
174 		mutex_unlock(voutdev->vdev.lock);
175 		return -EBUSY;
176 	}
177 
178 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.resolution,
179 		      0xFFFF0000, val << 16);
180 
181 	mutex_unlock(voutdev->vdev.lock);
182 
183 	return count;
184 }
185 
186 static ssize_t display_height_show(struct device *dev,
187 				   struct device_attribute *attr, char *buf)
188 {
189 	struct video_device *vdev = to_video_device(dev);
190 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
191 	u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
192 	  voutdev->config->regs.resolution);
193 
194 	return sprintf(buf, "%u\n", config & 0xFFFF);
195 }
196 
197 static ssize_t display_height_store(struct device *dev,
198 				    struct device_attribute *attr,
199 				    const char *buf, size_t count)
200 {
201 	struct video_device *vdev = to_video_device(dev);
202 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
203 	unsigned long val;
204 	int ret;
205 
206 	ret = kstrtoul(buf, 10, &val);
207 	if (ret)
208 		return ret;
209 	if (val > 0xFFFF)
210 		return -EINVAL;
211 
212 	mutex_lock(voutdev->vdev.lock);
213 	if (vb2_is_busy(voutdev->vdev.queue)) {
214 		mutex_unlock(voutdev->vdev.lock);
215 		return -EBUSY;
216 	}
217 
218 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.resolution,
219 		      0xFFFF, val);
220 
221 	mutex_unlock(voutdev->vdev.lock);
222 
223 	return count;
224 }
225 
226 static ssize_t frame_rate_show(struct device *dev,
227 			       struct device_attribute *attr, char *buf)
228 {
229 	struct video_device *vdev = to_video_device(dev);
230 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
231 	u32 period = mgb4_read_reg(&voutdev->mgbdev->video,
232 				   voutdev->config->regs.frame_limit);
233 
234 	return sprintf(buf, "%u\n", period ? MGB4_HW_FREQ / period : 0);
235 }
236 
237 /*
238  * Frame rate change is expected to be called on live streams. Video device
239  * locking/queue check is not needed.
240  */
241 static ssize_t frame_rate_store(struct device *dev,
242 				struct device_attribute *attr, const char *buf,
243 				size_t count)
244 {
245 	struct video_device *vdev = to_video_device(dev);
246 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
247 	unsigned long val;
248 	int limit, ret;
249 
250 	ret = kstrtoul(buf, 10, &val);
251 	if (ret)
252 		return ret;
253 
254 	limit = val ? MGB4_HW_FREQ / val : 0;
255 	mgb4_write_reg(&voutdev->mgbdev->video,
256 		       voutdev->config->regs.frame_limit, limit);
257 
258 	return count;
259 }
260 
261 static ssize_t hsync_width_show(struct device *dev,
262 				struct device_attribute *attr, char *buf)
263 {
264 	struct video_device *vdev = to_video_device(dev);
265 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
266 	u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
267 				voutdev->config->regs.hsync);
268 
269 	return sprintf(buf, "%u\n", (sig & 0x00FF0000) >> 16);
270 }
271 
272 /*
273  * HSYNC width change is expected to be called on live streams. Video device
274  * locking/queue check is not needed.
275  */
276 static ssize_t hsync_width_store(struct device *dev,
277 				 struct device_attribute *attr, const char *buf,
278 				 size_t count)
279 {
280 	struct video_device *vdev = to_video_device(dev);
281 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
282 	unsigned long val;
283 	int ret;
284 
285 	ret = kstrtoul(buf, 10, &val);
286 	if (ret)
287 		return ret;
288 	if (val > 0xFF)
289 		return -EINVAL;
290 
291 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
292 		      0x00FF0000, val << 16);
293 
294 	return count;
295 }
296 
297 static ssize_t vsync_width_show(struct device *dev,
298 				struct device_attribute *attr, char *buf)
299 {
300 	struct video_device *vdev = to_video_device(dev);
301 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
302 	u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
303 				voutdev->config->regs.vsync);
304 
305 	return sprintf(buf, "%u\n", (sig & 0x00FF0000) >> 16);
306 }
307 
308 /*
309  * VSYNC vidth change is expected to be called on live streams. Video device
310  * locking/queue check is not needed.
311  */
312 static ssize_t vsync_width_store(struct device *dev,
313 				 struct device_attribute *attr, const char *buf,
314 				 size_t count)
315 {
316 	struct video_device *vdev = to_video_device(dev);
317 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
318 	unsigned long val;
319 	int ret;
320 
321 	ret = kstrtoul(buf, 10, &val);
322 	if (ret)
323 		return ret;
324 	if (val > 0xFF)
325 		return -EINVAL;
326 
327 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
328 		      0x00FF0000, val << 16);
329 
330 	return count;
331 }
332 
333 static ssize_t hback_porch_show(struct device *dev,
334 				struct device_attribute *attr, char *buf)
335 {
336 	struct video_device *vdev = to_video_device(dev);
337 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
338 	u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
339 				voutdev->config->regs.hsync);
340 
341 	return sprintf(buf, "%u\n", (sig & 0x0000FF00) >> 8);
342 }
343 
344 /*
345  * hback porch change is expected to be called on live streams. Video device
346  * locking/queue check is not needed.
347  */
348 static ssize_t hback_porch_store(struct device *dev,
349 				 struct device_attribute *attr, const char *buf,
350 				 size_t count)
351 {
352 	struct video_device *vdev = to_video_device(dev);
353 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
354 	unsigned long val;
355 	int ret;
356 
357 	ret = kstrtoul(buf, 10, &val);
358 	if (ret)
359 		return ret;
360 	if (val > 0xFF)
361 		return -EINVAL;
362 
363 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
364 		      0x0000FF00, val << 8);
365 
366 	return count;
367 }
368 
369 static ssize_t vback_porch_show(struct device *dev,
370 				struct device_attribute *attr, char *buf)
371 {
372 	struct video_device *vdev = to_video_device(dev);
373 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
374 	u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
375 				voutdev->config->regs.vsync);
376 
377 	return sprintf(buf, "%u\n", (sig & 0x0000FF00) >> 8);
378 }
379 
380 /*
381  * vback porch change is expected to be called on live streams. Video device
382  * locking/queue check is not needed.
383  */
384 static ssize_t vback_porch_store(struct device *dev,
385 				 struct device_attribute *attr, const char *buf,
386 				 size_t count)
387 {
388 	struct video_device *vdev = to_video_device(dev);
389 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
390 	unsigned long val;
391 	int ret;
392 
393 	ret = kstrtoul(buf, 10, &val);
394 	if (ret)
395 		return ret;
396 	if (val > 0xFF)
397 		return -EINVAL;
398 
399 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
400 		      0x0000FF00, val << 8);
401 
402 	return count;
403 }
404 
405 static ssize_t hfront_porch_show(struct device *dev,
406 				 struct device_attribute *attr, char *buf)
407 {
408 	struct video_device *vdev = to_video_device(dev);
409 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
410 	u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
411 				voutdev->config->regs.hsync);
412 
413 	return sprintf(buf, "%u\n", (sig & 0x000000FF));
414 }
415 
416 /*
417  * hfront porch change is expected to be called on live streams. Video device
418  * locking/queue check is not needed.
419  */
420 static ssize_t hfront_porch_store(struct device *dev,
421 				  struct device_attribute *attr,
422 				  const char *buf, size_t count)
423 {
424 	struct video_device *vdev = to_video_device(dev);
425 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
426 	unsigned long val;
427 	int ret;
428 
429 	ret = kstrtoul(buf, 10, &val);
430 	if (ret)
431 		return ret;
432 	if (val > 0xFF)
433 		return -EINVAL;
434 
435 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
436 		      0x000000FF, val);
437 
438 	return count;
439 }
440 
441 static ssize_t vfront_porch_show(struct device *dev,
442 				 struct device_attribute *attr, char *buf)
443 {
444 	struct video_device *vdev = to_video_device(dev);
445 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
446 	u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
447 				voutdev->config->regs.vsync);
448 
449 	return sprintf(buf, "%u\n", (sig & 0x000000FF));
450 }
451 
452 /*
453  * vfront porch change is expected to be called on live streams. Video device
454  * locking/queue check is not needed.
455  */
456 static ssize_t vfront_porch_store(struct device *dev,
457 				  struct device_attribute *attr, const char *buf,
458 				  size_t count)
459 {
460 	struct video_device *vdev = to_video_device(dev);
461 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
462 	unsigned long val;
463 	int ret;
464 
465 	ret = kstrtoul(buf, 10, &val);
466 	if (ret)
467 		return ret;
468 	if (val > 0xFF)
469 		return -EINVAL;
470 
471 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
472 		      0x000000FF, val);
473 
474 	return count;
475 }
476 
477 /* FPDL3 only */
478 
479 static ssize_t hsync_polarity_show(struct device *dev,
480 				   struct device_attribute *attr, char *buf)
481 {
482 	struct video_device *vdev = to_video_device(dev);
483 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
484 	u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
485 	  voutdev->config->regs.hsync);
486 
487 	return sprintf(buf, "%u\n", (config & (1U << 31)) >> 31);
488 }
489 
490 /*
491  * HSYNC polarity change is expected to be called on live streams. Video device
492  * locking/queue check is not needed.
493  */
494 static ssize_t hsync_polarity_store(struct device *dev,
495 				    struct device_attribute *attr,
496 				    const char *buf, size_t count)
497 {
498 	struct video_device *vdev = to_video_device(dev);
499 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
500 	unsigned long val;
501 	int ret;
502 
503 	ret = kstrtoul(buf, 10, &val);
504 	if (ret)
505 		return ret;
506 	if (val > 1)
507 		return -EINVAL;
508 
509 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
510 		      (1U << 31), val << 31);
511 
512 	return count;
513 }
514 
515 static ssize_t vsync_polarity_show(struct device *dev,
516 				   struct device_attribute *attr, char *buf)
517 {
518 	struct video_device *vdev = to_video_device(dev);
519 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
520 	u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
521 	  voutdev->config->regs.vsync);
522 
523 	return sprintf(buf, "%u\n", (config & (1U << 31)) >> 31);
524 }
525 
526 /*
527  * VSYNC polarity change is expected to be called on live streams. Video device
528  * locking/queue check is not needed.
529  */
530 static ssize_t vsync_polarity_store(struct device *dev,
531 				    struct device_attribute *attr,
532 				    const char *buf, size_t count)
533 {
534 	struct video_device *vdev = to_video_device(dev);
535 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
536 	unsigned long val;
537 	int ret;
538 
539 	ret = kstrtoul(buf, 10, &val);
540 	if (ret)
541 		return ret;
542 	if (val > 1)
543 		return -EINVAL;
544 
545 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
546 		      (1U << 31), val << 31);
547 
548 	return count;
549 }
550 
551 static ssize_t de_polarity_show(struct device *dev,
552 				struct device_attribute *attr, char *buf)
553 {
554 	struct video_device *vdev = to_video_device(dev);
555 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
556 	u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
557 	  voutdev->config->regs.vsync);
558 
559 	return sprintf(buf, "%u\n", (config & (1U << 30)) >> 30);
560 }
561 
562 /*
563  * DE polarity change is expected to be called on live streams. Video device
564  * locking/queue check is not needed.
565  */
566 static ssize_t de_polarity_store(struct device *dev,
567 				 struct device_attribute *attr, const char *buf,
568 				 size_t count)
569 {
570 	struct video_device *vdev = to_video_device(dev);
571 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
572 	unsigned long val;
573 	int ret;
574 
575 	ret = kstrtoul(buf, 10, &val);
576 	if (ret)
577 		return ret;
578 	if (val > 1)
579 		return -EINVAL;
580 
581 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
582 		      (1U << 30), val << 30);
583 
584 	return count;
585 }
586 
587 static ssize_t fpdl3_output_width_show(struct device *dev,
588 				       struct device_attribute *attr, char *buf)
589 {
590 	struct video_device *vdev = to_video_device(dev);
591 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
592 	s32 ret;
593 
594 	mutex_lock(&voutdev->mgbdev->i2c_lock);
595 	ret = mgb4_i2c_read_byte(&voutdev->ser, 0x5B);
596 	mutex_unlock(&voutdev->mgbdev->i2c_lock);
597 	if (ret < 0)
598 		return -EIO;
599 
600 	switch ((u8)ret & 0x03) {
601 	case 0:
602 		return sprintf(buf, "0\n");
603 	case 1:
604 		return sprintf(buf, "1\n");
605 	case 3:
606 		return sprintf(buf, "2\n");
607 	default:
608 		return -EINVAL;
609 	}
610 }
611 
612 /*
613  * FPD-Link width change is expected to be called on live streams. Video device
614  * locking/queue check is not needed.
615  */
616 static ssize_t fpdl3_output_width_store(struct device *dev,
617 					struct device_attribute *attr,
618 					const char *buf, size_t count)
619 {
620 	struct video_device *vdev = to_video_device(dev);
621 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
622 	u8 i2c_data;
623 	unsigned long val;
624 	int ret;
625 
626 	ret = kstrtoul(buf, 10, &val);
627 	if (ret)
628 		return ret;
629 
630 	switch (val) {
631 	case 0: /* auto */
632 		i2c_data = 0x00;
633 		break;
634 	case 1: /* single */
635 		i2c_data = 0x01;
636 		break;
637 	case 2: /* dual */
638 		i2c_data = 0x03;
639 		break;
640 	default:
641 		return -EINVAL;
642 	}
643 
644 	mutex_lock(&voutdev->mgbdev->i2c_lock);
645 	ret = mgb4_i2c_mask_byte(&voutdev->ser, 0x5B, 0x03, i2c_data);
646 	mutex_unlock(&voutdev->mgbdev->i2c_lock);
647 	if (ret < 0)
648 		return -EIO;
649 
650 	return count;
651 }
652 
653 static ssize_t pclk_frequency_show(struct device *dev,
654 				   struct device_attribute *attr, char *buf)
655 {
656 	struct video_device *vdev = to_video_device(dev);
657 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
658 
659 	return sprintf(buf, "%u\n", voutdev->freq);
660 }
661 
662 static ssize_t pclk_frequency_store(struct device *dev,
663 				    struct device_attribute *attr,
664 				    const char *buf, size_t count)
665 {
666 	struct video_device *vdev = to_video_device(dev);
667 	struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
668 	unsigned long val;
669 	int ret;
670 	unsigned int dp;
671 
672 	ret = kstrtoul(buf, 10, &val);
673 	if (ret)
674 		return ret;
675 
676 	mutex_lock(voutdev->vdev.lock);
677 	if (vb2_is_busy(voutdev->vdev.queue)) {
678 		mutex_unlock(voutdev->vdev.lock);
679 		return -EBUSY;
680 	}
681 
682 	dp = (val > 50000) ? 1 : 0;
683 	voutdev->freq = mgb4_cmt_set_vout_freq(voutdev, val >> dp) << dp;
684 
685 	mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.config,
686 		      0x10, dp << 4);
687 	mutex_lock(&voutdev->mgbdev->i2c_lock);
688 	ret = mgb4_i2c_mask_byte(&voutdev->ser, 0x4F, 1 << 6, ((~dp) & 1) << 6);
689 	mutex_unlock(&voutdev->mgbdev->i2c_lock);
690 
691 	mutex_unlock(voutdev->vdev.lock);
692 
693 	return (ret < 0) ? -EIO : count;
694 }
695 
696 static DEVICE_ATTR_RO(output_id);
697 static DEVICE_ATTR_RW(video_source);
698 static DEVICE_ATTR_RW(display_width);
699 static DEVICE_ATTR_RW(display_height);
700 static DEVICE_ATTR_RW(frame_rate);
701 static DEVICE_ATTR_RW(hsync_polarity);
702 static DEVICE_ATTR_RW(vsync_polarity);
703 static DEVICE_ATTR_RW(de_polarity);
704 static DEVICE_ATTR_RW(pclk_frequency);
705 static DEVICE_ATTR_RW(hsync_width);
706 static DEVICE_ATTR_RW(vsync_width);
707 static DEVICE_ATTR_RW(hback_porch);
708 static DEVICE_ATTR_RW(hfront_porch);
709 static DEVICE_ATTR_RW(vback_porch);
710 static DEVICE_ATTR_RW(vfront_porch);
711 
712 static DEVICE_ATTR_RW(fpdl3_output_width);
713 
714 struct attribute *mgb4_fpdl3_out_attrs[] = {
715 	&dev_attr_output_id.attr,
716 	&dev_attr_video_source.attr,
717 	&dev_attr_display_width.attr,
718 	&dev_attr_display_height.attr,
719 	&dev_attr_frame_rate.attr,
720 	&dev_attr_hsync_polarity.attr,
721 	&dev_attr_vsync_polarity.attr,
722 	&dev_attr_de_polarity.attr,
723 	&dev_attr_pclk_frequency.attr,
724 	&dev_attr_hsync_width.attr,
725 	&dev_attr_vsync_width.attr,
726 	&dev_attr_hback_porch.attr,
727 	&dev_attr_hfront_porch.attr,
728 	&dev_attr_vback_porch.attr,
729 	&dev_attr_vfront_porch.attr,
730 	&dev_attr_fpdl3_output_width.attr,
731 	NULL
732 };
733 
734 struct attribute *mgb4_gmsl_out_attrs[] = {
735 	&dev_attr_output_id.attr,
736 	&dev_attr_video_source.attr,
737 	&dev_attr_display_width.attr,
738 	&dev_attr_display_height.attr,
739 	&dev_attr_frame_rate.attr,
740 	NULL
741 };
742