projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] imon: fix other RC type protocol support
[linux-2.6-block.git] / drivers / media / platform / vivid / vivid-core.c
CommitLineData
c88a96b0
HV		 1/*
2 * vivid-core.c - A Virtual Video Test Driver, core initialization
3 *
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17 * SOFTWARE.
18 */
19
20#include <linux/module.h>
21#include <linux/errno.h>
22#include <linux/kernel.h>
23#include <linux/init.h>
24#include <linux/sched.h>
25#include <linux/slab.h>
5754d0d5 26#include <linux/vmalloc.h>
c88a96b0
HV		 27#include <linux/font.h>
28#include <linux/mutex.h>
29#include <linux/videodev2.h>
30#include <linux/v4l2-dv-timings.h>
31#include <media/videobuf2-vmalloc.h>
32#include <media/v4l2-dv-timings.h>
33#include <media/v4l2-ioctl.h>
34#include <media/v4l2-fh.h>
35#include <media/v4l2-event.h>
36
37#include "vivid-core.h"
38#include "vivid-vid-common.h"
39#include "vivid-vid-cap.h"
40#include "vivid-vid-out.h"
41#include "vivid-radio-common.h"
42#include "vivid-radio-rx.h"
43#include "vivid-radio-tx.h"
44#include "vivid-sdr-cap.h"
45#include "vivid-vbi-cap.h"
46#include "vivid-vbi-out.h"
47#include "vivid-osd.h"
48#include "vivid-ctrls.h"
49
50#define VIVID_MODULE_NAME "vivid"
51
52/* The maximum number of vivid devices */
53#define VIVID_MAX_DEVS 64
54
55MODULE_DESCRIPTION("Virtual Video Test Driver");
56MODULE_AUTHOR("Hans Verkuil");
57MODULE_LICENSE("GPL");
58
59static unsigned n_devs = 1;
60module_param(n_devs, uint, 0444);
61MODULE_PARM_DESC(n_devs, " number of driver instances to create");
62
63static int vid_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
64module_param_array(vid_cap_nr, int, NULL, 0444);
65MODULE_PARM_DESC(vid_cap_nr, " videoX start number, -1 is autodetect");
66
67static int vid_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
68module_param_array(vid_out_nr, int, NULL, 0444);
69MODULE_PARM_DESC(vid_out_nr, " videoX start number, -1 is autodetect");
70
71static int vbi_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
72module_param_array(vbi_cap_nr, int, NULL, 0444);
73MODULE_PARM_DESC(vbi_cap_nr, " vbiX start number, -1 is autodetect");
74
75static int vbi_out_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
76module_param_array(vbi_out_nr, int, NULL, 0444);
77MODULE_PARM_DESC(vbi_out_nr, " vbiX start number, -1 is autodetect");
78
79static int sdr_cap_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
80module_param_array(sdr_cap_nr, int, NULL, 0444);
81MODULE_PARM_DESC(sdr_cap_nr, " swradioX start number, -1 is autodetect");
82
83static int radio_rx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
84module_param_array(radio_rx_nr, int, NULL, 0444);
85MODULE_PARM_DESC(radio_rx_nr, " radioX start number, -1 is autodetect");
86
87static int radio_tx_nr[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
88module_param_array(radio_tx_nr, int, NULL, 0444);
89MODULE_PARM_DESC(radio_tx_nr, " radioX start number, -1 is autodetect");
90
91static int ccs_cap_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
92module_param_array(ccs_cap_mode, int, NULL, 0444);
93MODULE_PARM_DESC(ccs_cap_mode, " capture crop/compose/scale mode:\n"
94 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
95 "\t\t -1=user-controlled (default)");
96
97static int ccs_out_mode[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = -1 };
98module_param_array(ccs_out_mode, int, NULL, 0444);
99MODULE_PARM_DESC(ccs_out_mode, " output crop/compose/scale mode:\n"
100 "\t\t bit 0=crop, 1=compose, 2=scale,\n"
101 "\t\t -1=user-controlled (default)");
102
103static unsigned multiplanar[VIVID_MAX_DEVS];
104module_param_array(multiplanar, uint, NULL, 0444);
105MODULE_PARM_DESC(multiplanar, " 0 (default) is alternating single and multiplanar devices,\n"
106 "\t\t 1 is single planar devices,\n"
107 "\t\t 2 is multiplanar devices");
108
109/* Default: video + vbi-cap (raw and sliced) + radio rx + radio tx + sdr + vbi-out + vid-out */
110static unsigned node_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0x1d3d };
111module_param_array(node_types, uint, NULL, 0444);
112MODULE_PARM_DESC(node_types, " node types, default is 0x1d3d. Bitmask with the following meaning:\n"
113 "\t\t bit 0: Video Capture node\n"
114 "\t\t bit 2-3: VBI Capture node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
115 "\t\t bit 4: Radio Receiver node\n"
116 "\t\t bit 5: Software Defined Radio Receiver node\n"
117 "\t\t bit 8: Video Output node\n"
118 "\t\t bit 10-11: VBI Output node: 0 = none, 1 = raw vbi, 2 = sliced vbi, 3 = both\n"
119 "\t\t bit 12: Radio Transmitter node\n"
120 "\t\t bit 16: Framebuffer for testing overlays");
121
122/* Default: 4 inputs */
123static unsigned num_inputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 4 };
124module_param_array(num_inputs, uint, NULL, 0444);
125MODULE_PARM_DESC(num_inputs, " number of inputs, default is 4");
126
127/* Default: input 0 = WEBCAM, 1 = TV, 2 = SVID, 3 = HDMI */
128static unsigned input_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 0xe4 };
129module_param_array(input_types, uint, NULL, 0444);
130MODULE_PARM_DESC(input_types, " input types, default is 0xe4. Two bits per input,\n"
131 "\t\t bits 0-1 == input 0, bits 31-30 == input 15.\n"
132 "\t\t Type 0 == webcam, 1 == TV, 2 == S-Video, 3 == HDMI");
133
134/* Default: 2 outputs */
135static unsigned num_outputs[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
136module_param_array(num_outputs, uint, NULL, 0444);
137MODULE_PARM_DESC(num_outputs, " number of outputs, default is 2");
138
139/* Default: output 0 = SVID, 1 = HDMI */
140static unsigned output_types[VIVID_MAX_DEVS] = { [0 ... (VIVID_MAX_DEVS - 1)] = 2 };
141module_param_array(output_types, uint, NULL, 0444);
142MODULE_PARM_DESC(output_types, " output types, default is 0x02. One bit per output,\n"
143 "\t\t bit 0 == output 0, bit 15 == output 15.\n"
144 "\t\t Type 0 == S-Video, 1 == HDMI");
145
146unsigned vivid_debug;
147module_param(vivid_debug, uint, 0644);
148MODULE_PARM_DESC(vivid_debug, " activates debug info");
149
150static bool no_error_inj;
151module_param(no_error_inj, bool, 0444);
152MODULE_PARM_DESC(no_error_inj, " if set disable the error injecting controls");
153
154static struct vivid_dev *vivid_devs[VIVID_MAX_DEVS];
155
156const struct v4l2_rect vivid_min_rect = {
157 0, 0, MIN_WIDTH, MIN_HEIGHT
158};
159
160const struct v4l2_rect vivid_max_rect = {
161 0, 0, MAX_WIDTH * MAX_ZOOM, MAX_HEIGHT * MAX_ZOOM
162};
163
164static const u8 vivid_hdmi_edid[256] = {
165 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
166 0x63, 0x3a, 0xaa, 0x55, 0x00, 0x00, 0x00, 0x00,
167 0x0a, 0x18, 0x01, 0x03, 0x80, 0x10, 0x09, 0x78,
168 0x0e, 0x00, 0xb2, 0xa0, 0x57, 0x49, 0x9b, 0x26,
169 0x10, 0x48, 0x4f, 0x2f, 0xcf, 0x00, 0x31, 0x59,
170 0x45, 0x59, 0x81, 0x80, 0x81, 0x40, 0x90, 0x40,
171 0x95, 0x00, 0xa9, 0x40, 0xb3, 0x00, 0x02, 0x3a,
172 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
173 0x46, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x1e,
174 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18,
175 0x5e, 0x11, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20,
176 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 'v',
177 '4', 'l', '2', '-', 'h', 'd', 'm', 'i',
178 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x10,
179 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
180 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf0,
181
182 0x02, 0x03, 0x1a, 0xc0, 0x48, 0xa2, 0x10, 0x04,
183 0x02, 0x01, 0x21, 0x14, 0x13, 0x23, 0x09, 0x07,
184 0x07, 0x65, 0x03, 0x0c, 0x00, 0x10, 0x00, 0xe2,
185 0x00, 0x2a, 0x01, 0x1d, 0x00, 0x80, 0x51, 0xd0,
186 0x1c, 0x20, 0x40, 0x80, 0x35, 0x00, 0x00, 0x00,
187 0x00, 0x00, 0x00, 0x1e, 0x8c, 0x0a, 0xd0, 0x8a,
188 0x20, 0xe0, 0x2d, 0x10, 0x10, 0x3e, 0x96, 0x00,
189 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00,
190 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
191 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
192 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
193 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
194 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
195 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
196 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
197 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd7
198};
199
200void vivid_lock(struct vb2_queue *vq)
201{
202 struct vivid_dev *dev = vb2_get_drv_priv(vq);
203
204 mutex_lock(&dev->mutex);
205}
206
207void vivid_unlock(struct vb2_queue *vq)
208{
209 struct vivid_dev *dev = vb2_get_drv_priv(vq);
210
211 mutex_unlock(&dev->mutex);
212}
213
214static int vidioc_querycap(struct file *file, void *priv,
215 struct v4l2_capability *cap)
216{
217 struct vivid_dev *dev = video_drvdata(file);
218 struct video_device *vdev = video_devdata(file);
219
220 strcpy(cap->driver, "vivid");
221 strcpy(cap->card, "vivid");
222 snprintf(cap->bus_info, sizeof(cap->bus_info),
223 "platform:%s", dev->v4l2_dev.name);
224
225 if (vdev->vfl_type == VFL_TYPE_GRABBER && vdev->vfl_dir == VFL_DIR_RX)
226 cap->device_caps = dev->vid_cap_caps;
227 if (vdev->vfl_type == VFL_TYPE_GRABBER && vdev->vfl_dir == VFL_DIR_TX)
228 cap->device_caps = dev->vid_out_caps;
229 else if (vdev->vfl_type == VFL_TYPE_VBI && vdev->vfl_dir == VFL_DIR_RX)
230 cap->device_caps = dev->vbi_cap_caps;
231 else if (vdev->vfl_type == VFL_TYPE_VBI && vdev->vfl_dir == VFL_DIR_TX)
232 cap->device_caps = dev->vbi_out_caps;
233 else if (vdev->vfl_type == VFL_TYPE_SDR)
234 cap->device_caps = dev->sdr_cap_caps;
235 else if (vdev->vfl_type == VFL_TYPE_RADIO && vdev->vfl_dir == VFL_DIR_RX)
236 cap->device_caps = dev->radio_rx_caps;
237 else if (vdev->vfl_type == VFL_TYPE_RADIO && vdev->vfl_dir == VFL_DIR_TX)
238 cap->device_caps = dev->radio_tx_caps;
239 cap->capabilities = dev->vid_cap_caps | dev->vid_out_caps |
240 dev->vbi_cap_caps | dev->vbi_out_caps |
241 dev->radio_rx_caps | dev->radio_tx_caps |
242 dev->sdr_cap_caps | V4L2_CAP_DEVICE_CAPS;
243 return 0;
244}
245
246static int vidioc_s_hw_freq_seek(struct file *file, void *fh, const struct v4l2_hw_freq_seek *a)
247{
248 struct video_device *vdev = video_devdata(file);
249
250 if (vdev->vfl_type == VFL_TYPE_RADIO)
251 return vivid_radio_rx_s_hw_freq_seek(file, fh, a);
252 return -ENOTTY;
253}
254
255static int vidioc_enum_freq_bands(struct file *file, void *fh, struct v4l2_frequency_band *band)
256{
257 struct video_device *vdev = video_devdata(file);
258
259 if (vdev->vfl_type == VFL_TYPE_RADIO)
260 return vivid_radio_rx_enum_freq_bands(file, fh, band);
261 if (vdev->vfl_type == VFL_TYPE_SDR)
262 return vivid_sdr_enum_freq_bands(file, fh, band);
263 return -ENOTTY;
264}
265
266static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
267{
268 struct video_device *vdev = video_devdata(file);
269
270 if (vdev->vfl_type == VFL_TYPE_RADIO)
271 return vivid_radio_rx_g_tuner(file, fh, vt);
272 if (vdev->vfl_type == VFL_TYPE_SDR)
273 return vivid_sdr_g_tuner(file, fh, vt);
274 return vivid_video_g_tuner(file, fh, vt);
275}
276
277static int vidioc_s_tuner(struct file *file, void *fh, const struct v4l2_tuner *vt)
278{
279 struct video_device *vdev = video_devdata(file);
280
281 if (vdev->vfl_type == VFL_TYPE_RADIO)
282 return vivid_radio_rx_s_tuner(file, fh, vt);
283 if (vdev->vfl_type == VFL_TYPE_SDR)
284 return vivid_sdr_s_tuner(file, fh, vt);
285 return vivid_video_s_tuner(file, fh, vt);
286}
287
288static int vidioc_g_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
289{
290 struct vivid_dev *dev = video_drvdata(file);
291 struct video_device *vdev = video_devdata(file);
292
293 if (vdev->vfl_type == VFL_TYPE_RADIO)
294 return vivid_radio_g_frequency(file,
295 vdev->vfl_dir == VFL_DIR_RX ?
296 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
297 if (vdev->vfl_type == VFL_TYPE_SDR)
298 return vivid_sdr_g_frequency(file, fh, vf);
299 return vivid_video_g_frequency(file, fh, vf);
300}
301
302static int vidioc_s_frequency(struct file *file, void *fh, const struct v4l2_frequency *vf)
303{
304 struct vivid_dev *dev = video_drvdata(file);
305 struct video_device *vdev = video_devdata(file);
306
307 if (vdev->vfl_type == VFL_TYPE_RADIO)
308 return vivid_radio_s_frequency(file,
309 vdev->vfl_dir == VFL_DIR_RX ?
310 &dev->radio_rx_freq : &dev->radio_tx_freq, vf);
311 if (vdev->vfl_type == VFL_TYPE_SDR)
312 return vivid_sdr_s_frequency(file, fh, vf);
313 return vivid_video_s_frequency(file, fh, vf);
314}
315
316static int vidioc_overlay(struct file *file, void *fh, unsigned i)
317{
318 struct video_device *vdev = video_devdata(file);
319
320 if (vdev->vfl_dir == VFL_DIR_RX)
321 return vivid_vid_cap_overlay(file, fh, i);
322 return vivid_vid_out_overlay(file, fh, i);
323}
324
325static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *a)
326{
327 struct video_device *vdev = video_devdata(file);
328
329 if (vdev->vfl_dir == VFL_DIR_RX)
330 return vivid_vid_cap_g_fbuf(file, fh, a);
331 return vivid_vid_out_g_fbuf(file, fh, a);
332}
333
334static int vidioc_s_fbuf(struct file *file, void *fh, const struct v4l2_framebuffer *a)
335{
336 struct video_device *vdev = video_devdata(file);
337
338 if (vdev->vfl_dir == VFL_DIR_RX)
339 return vivid_vid_cap_s_fbuf(file, fh, a);
340 return vivid_vid_out_s_fbuf(file, fh, a);
341}
342
343static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id)
344{
345 struct video_device *vdev = video_devdata(file);
346
347 if (vdev->vfl_dir == VFL_DIR_RX)
348 return vivid_vid_cap_s_std(file, fh, id);
349 return vivid_vid_out_s_std(file, fh, id);
350}
351
352static int vidioc_s_dv_timings(struct file *file, void *fh, struct v4l2_dv_timings *timings)
353{
354 struct video_device *vdev = video_devdata(file);
355
356 if (vdev->vfl_dir == VFL_DIR_RX)
357 return vivid_vid_cap_s_dv_timings(file, fh, timings);
358 return vivid_vid_out_s_dv_timings(file, fh, timings);
359}
360
361static int vidioc_cropcap(struct file *file, void *fh, struct v4l2_cropcap *cc)
362{
363 struct video_device *vdev = video_devdata(file);
364
365 if (vdev->vfl_dir == VFL_DIR_RX)
366 return vivid_vid_cap_cropcap(file, fh, cc);
367 return vivid_vid_out_cropcap(file, fh, cc);
368}
369
370static int vidioc_g_selection(struct file *file, void *fh,
371 struct v4l2_selection *sel)
372{
373 struct video_device *vdev = video_devdata(file);
374
375 if (vdev->vfl_dir == VFL_DIR_RX)
376 return vivid_vid_cap_g_selection(file, fh, sel);
377 return vivid_vid_out_g_selection(file, fh, sel);
378}
379
380static int vidioc_s_selection(struct file *file, void *fh,
381 struct v4l2_selection *sel)
382{
383 struct video_device *vdev = video_devdata(file);
384
385 if (vdev->vfl_dir == VFL_DIR_RX)
386 return vivid_vid_cap_s_selection(file, fh, sel);
387 return vivid_vid_out_s_selection(file, fh, sel);
388}
389
390static int vidioc_g_parm(struct file *file, void *fh,
391 struct v4l2_streamparm *parm)
392{
393 struct video_device *vdev = video_devdata(file);
394
395 if (vdev->vfl_dir == VFL_DIR_RX)
396 return vivid_vid_cap_g_parm(file, fh, parm);
397 return vivid_vid_out_g_parm(file, fh, parm);
398}
399
400static int vidioc_s_parm(struct file *file, void *fh,
401 struct v4l2_streamparm *parm)
402{
403 struct video_device *vdev = video_devdata(file);
404
405 if (vdev->vfl_dir == VFL_DIR_RX)
406 return vivid_vid_cap_s_parm(file, fh, parm);
407 return vivid_vid_out_g_parm(file, fh, parm);
408}
409
410static ssize_t vivid_radio_read(struct file *file, char __user *buf,
411 size_t size, loff_t *offset)
412{
413 struct video_device *vdev = video_devdata(file);
414
415 if (vdev->vfl_dir == VFL_DIR_TX)
416 return -EINVAL;
417 return vivid_radio_rx_read(file, buf, size, offset);
418}
419
420static ssize_t vivid_radio_write(struct file *file, const char __user *buf,
421 size_t size, loff_t *offset)
422{
423 struct video_device *vdev = video_devdata(file);
424
425 if (vdev->vfl_dir == VFL_DIR_RX)
426 return -EINVAL;
427 return vivid_radio_tx_write(file, buf, size, offset);
428}
429
430static unsigned int vivid_radio_poll(struct file *file, struct poll_table_struct *wait)
431{
432 struct video_device *vdev = video_devdata(file);
433
434 if (vdev->vfl_dir == VFL_DIR_RX)
435 return vivid_radio_rx_poll(file, wait);
436 return vivid_radio_tx_poll(file, wait);
437}
438
439static bool vivid_is_in_use(struct video_device *vdev)
440{
441 unsigned long flags;
442 bool res;
443
444 spin_lock_irqsave(&vdev->fh_lock, flags);
445 res = !list_empty(&vdev->fh_list);
446 spin_unlock_irqrestore(&vdev->fh_lock, flags);
447 return res;
448}
449
450static bool vivid_is_last_user(struct vivid_dev *dev)
451{
452 unsigned uses = vivid_is_in_use(&dev->vid_cap_dev) +
453 vivid_is_in_use(&dev->vid_out_dev) +
454 vivid_is_in_use(&dev->vbi_cap_dev) +
455 vivid_is_in_use(&dev->vbi_out_dev) +
456 vivid_is_in_use(&dev->sdr_cap_dev) +
457 vivid_is_in_use(&dev->radio_rx_dev) +
458 vivid_is_in_use(&dev->radio_tx_dev);
459
460 return uses == 1;
461}
462
463static int vivid_fop_release(struct file *file)
464{
465 struct vivid_dev *dev = video_drvdata(file);
466 struct video_device *vdev = video_devdata(file);
467
468 mutex_lock(&dev->mutex);
469 if (!no_error_inj && v4l2_fh_is_singular_file(file) &&
470 !video_is_registered(vdev) && vivid_is_last_user(dev)) {
471 /*
472 * I am the last user of this driver, and a disconnect
473 * was forced (since this video_device is unregistered),
474 * so re-register all video_device's again.
475 */
476 v4l2_info(&dev->v4l2_dev, "reconnect\n");
477 set_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
478 set_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
479 set_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
480 set_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
481 set_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
482 set_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
483 set_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
484 }
485 mutex_unlock(&dev->mutex);
486 if (file->private_data == dev->overlay_cap_owner)
487 dev->overlay_cap_owner = NULL;
488 if (file->private_data == dev->radio_rx_rds_owner) {
489 dev->radio_rx_rds_last_block = 0;
490 dev->radio_rx_rds_owner = NULL;
491 }
492 if (file->private_data == dev->radio_tx_rds_owner) {
493 dev->radio_tx_rds_last_block = 0;
494 dev->radio_tx_rds_owner = NULL;
495 }
496 if (vdev->queue)
497 return vb2_fop_release(file);
498 return v4l2_fh_release(file);
499}
500
501static const struct v4l2_file_operations vivid_fops = {
502 .owner = THIS_MODULE,
503 .open = v4l2_fh_open,
504 .release = vivid_fop_release,
505 .read = vb2_fop_read,
506 .write = vb2_fop_write,
507 .poll = vb2_fop_poll,
508 .unlocked_ioctl = video_ioctl2,
509 .mmap = vb2_fop_mmap,
510};
511
512static const struct v4l2_file_operations vivid_radio_fops = {
513 .owner = THIS_MODULE,
514 .open = v4l2_fh_open,
515 .release = vivid_fop_release,
516 .read = vivid_radio_read,
517 .write = vivid_radio_write,
518 .poll = vivid_radio_poll,
519 .unlocked_ioctl = video_ioctl2,
520};
521
522static const struct v4l2_ioctl_ops vivid_ioctl_ops = {
523 .vidioc_querycap = vidioc_querycap,
524
525 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid,
526 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
527 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
528 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
529 .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_mplane,
530 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt_vid_cap_mplane,
531 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt_vid_cap_mplane,
532 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt_vid_cap_mplane,
533
534 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid,
535 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out,
536 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out,
537 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
538 .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_mplane,
539 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt_vid_out_mplane,
540 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt_vid_out_mplane,
541 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt_vid_out_mplane,
542
543 .vidioc_g_selection = vidioc_g_selection,
544 .vidioc_s_selection = vidioc_s_selection,
545 .vidioc_cropcap = vidioc_cropcap,
546
547 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
548 .vidioc_try_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
549 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
550
551 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
552 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_fmt_sliced_vbi_cap,
553 .vidioc_s_fmt_sliced_vbi_cap = vidioc_s_fmt_sliced_vbi_cap,
554 .vidioc_g_sliced_vbi_cap = vidioc_g_sliced_vbi_cap,
555
556 .vidioc_g_fmt_vbi_out = vidioc_g_fmt_vbi_out,
557 .vidioc_try_fmt_vbi_out = vidioc_g_fmt_vbi_out,
558 .vidioc_s_fmt_vbi_out = vidioc_s_fmt_vbi_out,
559
560 .vidioc_g_fmt_sliced_vbi_out = vidioc_g_fmt_sliced_vbi_out,
561 .vidioc_try_fmt_sliced_vbi_out = vidioc_try_fmt_sliced_vbi_out,
562 .vidioc_s_fmt_sliced_vbi_out = vidioc_s_fmt_sliced_vbi_out,
563
564 .vidioc_enum_fmt_sdr_cap = vidioc_enum_fmt_sdr_cap,
565 .vidioc_g_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
566 .vidioc_try_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
567 .vidioc_s_fmt_sdr_cap = vidioc_g_fmt_sdr_cap,
568
569 .vidioc_overlay = vidioc_overlay,
570 .vidioc_enum_framesizes = vidioc_enum_framesizes,
571 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
572 .vidioc_g_parm = vidioc_g_parm,
573 .vidioc_s_parm = vidioc_s_parm,
574
575 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
576 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
577 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
578 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
579 .vidioc_g_fmt_vid_out_overlay = vidioc_g_fmt_vid_out_overlay,
580 .vidioc_try_fmt_vid_out_overlay = vidioc_try_fmt_vid_out_overlay,
581 .vidioc_s_fmt_vid_out_overlay = vidioc_s_fmt_vid_out_overlay,
c88a96b0
HV		 582 .vidioc_g_fbuf = vidioc_g_fbuf,
583 .vidioc_s_fbuf = vidioc_s_fbuf,
584
585 .vidioc_reqbufs = vb2_ioctl_reqbufs,
586 .vidioc_create_bufs = vb2_ioctl_create_bufs,
587 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
588 .vidioc_querybuf = vb2_ioctl_querybuf,
589 .vidioc_qbuf = vb2_ioctl_qbuf,
590 .vidioc_dqbuf = vb2_ioctl_dqbuf,
591/* Not yet .vidioc_expbuf = vb2_ioctl_expbuf,*/
592 .vidioc_streamon = vb2_ioctl_streamon,
593 .vidioc_streamoff = vb2_ioctl_streamoff,
594
595 .vidioc_enum_input = vidioc_enum_input,
596 .vidioc_g_input = vidioc_g_input,
597 .vidioc_s_input = vidioc_s_input,
598 .vidioc_s_audio = vidioc_s_audio,
599 .vidioc_g_audio = vidioc_g_audio,
600 .vidioc_enumaudio = vidioc_enumaudio,
601 .vidioc_s_frequency = vidioc_s_frequency,
602 .vidioc_g_frequency = vidioc_g_frequency,
603 .vidioc_s_tuner = vidioc_s_tuner,
604 .vidioc_g_tuner = vidioc_g_tuner,
605 .vidioc_s_modulator = vidioc_s_modulator,
606 .vidioc_g_modulator = vidioc_g_modulator,
607 .vidioc_s_hw_freq_seek = vidioc_s_hw_freq_seek,
608 .vidioc_enum_freq_bands = vidioc_enum_freq_bands,
609
610 .vidioc_enum_output = vidioc_enum_output,
611 .vidioc_g_output = vidioc_g_output,
612 .vidioc_s_output = vidioc_s_output,
613 .vidioc_s_audout = vidioc_s_audout,
614 .vidioc_g_audout = vidioc_g_audout,
615 .vidioc_enumaudout = vidioc_enumaudout,
616
617 .vidioc_querystd = vidioc_querystd,
618 .vidioc_g_std = vidioc_g_std,
619 .vidioc_s_std = vidioc_s_std,
620 .vidioc_s_dv_timings = vidioc_s_dv_timings,
621 .vidioc_g_dv_timings = vidioc_g_dv_timings,
622 .vidioc_query_dv_timings = vidioc_query_dv_timings,
623 .vidioc_enum_dv_timings = vidioc_enum_dv_timings,
624 .vidioc_dv_timings_cap = vidioc_dv_timings_cap,
625 .vidioc_g_edid = vidioc_g_edid,
626 .vidioc_s_edid = vidioc_s_edid,
627
628 .vidioc_log_status = v4l2_ctrl_log_status,
629 .vidioc_subscribe_event = vidioc_subscribe_event,
630 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
631};
632
633/* -----------------------------------------------------------------
634 Initialization and module stuff
635 ------------------------------------------------------------------*/
636
637static int __init vivid_create_instance(int inst)
638{
639 static const struct v4l2_dv_timings def_dv_timings =
640 V4L2_DV_BT_CEA_1280X720P60;
641 unsigned in_type_counter[4] = { 0, 0, 0, 0 };
642 unsigned out_type_counter[4] = { 0, 0, 0, 0 };
643 int ccs_cap = ccs_cap_mode[inst];
644 int ccs_out = ccs_out_mode[inst];
645 bool has_tuner;
646 bool has_modulator;
647 struct vivid_dev *dev;
648 struct video_device *vfd;
649 struct vb2_queue *q;
650 unsigned node_type = node_types[inst];
651 v4l2_std_id tvnorms_cap = 0, tvnorms_out = 0;
652 int ret;
653 int i;
654
655 /* allocate main vivid state structure */
656 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
657 if (!dev)
658 return -ENOMEM;
659
660 dev->inst = inst;
661
662 /* register v4l2_device */
663 snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
664 "%s-%03d", VIVID_MODULE_NAME, inst);
665 ret = v4l2_device_register(NULL, &dev->v4l2_dev);
666 if (ret)
667 goto free_dev;
668
669 /* start detecting feature set */
670
671 /* do we use single- or multi-planar? */
672 if (multiplanar[inst] == 0)
673 dev->multiplanar = inst & 1;
674 else
675 dev->multiplanar = multiplanar[inst] > 1;
676 v4l2_info(&dev->v4l2_dev, "using %splanar format API\n",
677 dev->multiplanar ? "multi" : "single ");
678
679 /* how many inputs do we have and of what type? */
680 dev->num_inputs = num_inputs[inst];
681 if (dev->num_inputs < 1)
682 dev->num_inputs = 1;
683 if (dev->num_inputs >= MAX_INPUTS)
684 dev->num_inputs = MAX_INPUTS;
685 for (i = 0; i < dev->num_inputs; i++) {
686 dev->input_type[i] = (input_types[inst] >> (i * 2)) & 0x3;
687 dev->input_name_counter[i] = in_type_counter[dev->input_type[i]]++;
688 }
689 dev->has_audio_inputs = in_type_counter[TV] && in_type_counter[SVID];
690
691 /* how many outputs do we have and of what type? */
692 dev->num_outputs = num_outputs[inst];
693 if (dev->num_outputs < 1)
694 dev->num_outputs = 1;
695 if (dev->num_outputs >= MAX_OUTPUTS)
696 dev->num_outputs = MAX_OUTPUTS;
697 for (i = 0; i < dev->num_outputs; i++) {
698 dev->output_type[i] = ((output_types[inst] >> i) & 1) ? HDMI : SVID;
699 dev->output_name_counter[i] = out_type_counter[dev->output_type[i]]++;
700 }
701 dev->has_audio_outputs = out_type_counter[SVID];
702
703 /* do we create a video capture device? */
704 dev->has_vid_cap = node_type & 0x0001;
705
706 /* do we create a vbi capture device? */
707 if (in_type_counter[TV] || in_type_counter[SVID]) {
708 dev->has_raw_vbi_cap = node_type & 0x0004;
709 dev->has_sliced_vbi_cap = node_type & 0x0008;
710 dev->has_vbi_cap = dev->has_raw_vbi_cap | dev->has_sliced_vbi_cap;
711 }
712
713 /* do we create a video output device? */
714 dev->has_vid_out = node_type & 0x0100;
715
716 /* do we create a vbi output device? */
717 if (out_type_counter[SVID]) {
718 dev->has_raw_vbi_out = node_type & 0x0400;
719 dev->has_sliced_vbi_out = node_type & 0x0800;
720 dev->has_vbi_out = dev->has_raw_vbi_out | dev->has_sliced_vbi_out;
721 }
722
723 /* do we create a radio receiver device? */
724 dev->has_radio_rx = node_type & 0x0010;
725
726 /* do we create a radio transmitter device? */
727 dev->has_radio_tx = node_type & 0x1000;
728
729 /* do we create a software defined radio capture device? */
730 dev->has_sdr_cap = node_type & 0x0020;
731
732 /* do we have a tuner? */
733 has_tuner = ((dev->has_vid_cap || dev->has_vbi_cap) && in_type_counter[TV]) ||
734 dev->has_radio_rx || dev->has_sdr_cap;
735
736 /* do we have a modulator? */
737 has_modulator = dev->has_radio_tx;
738
739 if (dev->has_vid_cap)
740 /* do we have a framebuffer for overlay testing? */
741 dev->has_fb = node_type & 0x10000;
742
743 /* can we do crop/compose/scaling while capturing? */
744 if (no_error_inj && ccs_cap == -1)
745 ccs_cap = 7;
746
747 /* if ccs_cap == -1, then the use can select it using controls */
748 if (ccs_cap != -1) {
749 dev->has_crop_cap = ccs_cap & 1;
750 dev->has_compose_cap = ccs_cap & 2;
751 dev->has_scaler_cap = ccs_cap & 4;
752 v4l2_info(&dev->v4l2_dev, "Capture Crop: %c Compose: %c Scaler: %c\n",
753 dev->has_crop_cap ? 'Y' : 'N',
754 dev->has_compose_cap ? 'Y' : 'N',
755 dev->has_scaler_cap ? 'Y' : 'N');
756 }
757
758 /* can we do crop/compose/scaling with video output? */
759 if (no_error_inj && ccs_out == -1)
760 ccs_out = 7;
761
762 /* if ccs_out == -1, then the use can select it using controls */
763 if (ccs_out != -1) {
764 dev->has_crop_out = ccs_out & 1;
765 dev->has_compose_out = ccs_out & 2;
766 dev->has_scaler_out = ccs_out & 4;
767 v4l2_info(&dev->v4l2_dev, "Output Crop: %c Compose: %c Scaler: %c\n",
768 dev->has_crop_out ? 'Y' : 'N',
769 dev->has_compose_out ? 'Y' : 'N',
770 dev->has_scaler_out ? 'Y' : 'N');
771 }
772
773 /* end detecting feature set */
774
775 if (dev->has_vid_cap) {
776 /* set up the capabilities of the video capture device */
777 dev->vid_cap_caps = dev->multiplanar ?
778 V4L2_CAP_VIDEO_CAPTURE_MPLANE :
779 V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OVERLAY;
780 dev->vid_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
781 if (dev->has_audio_inputs)
782 dev->vid_cap_caps |= V4L2_CAP_AUDIO;
783 if (in_type_counter[TV])
784 dev->vid_cap_caps |= V4L2_CAP_TUNER;
785 }
786 if (dev->has_vid_out) {
787 /* set up the capabilities of the video output device */
788 dev->vid_out_caps = dev->multiplanar ?
789 V4L2_CAP_VIDEO_OUTPUT_MPLANE :
790 V4L2_CAP_VIDEO_OUTPUT;
791 if (dev->has_fb)
792 dev->vid_out_caps |= V4L2_CAP_VIDEO_OUTPUT_OVERLAY;
793 dev->vid_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
794 if (dev->has_audio_outputs)
795 dev->vid_out_caps |= V4L2_CAP_AUDIO;
796 }
797 if (dev->has_vbi_cap) {
798 /* set up the capabilities of the vbi capture device */
799 dev->vbi_cap_caps = (dev->has_raw_vbi_cap ? V4L2_CAP_VBI_CAPTURE : 0) |
800 (dev->has_sliced_vbi_cap ? V4L2_CAP_SLICED_VBI_CAPTURE : 0);
801 dev->vbi_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
802 if (dev->has_audio_inputs)
803 dev->vbi_cap_caps |= V4L2_CAP_AUDIO;
804 if (in_type_counter[TV])
805 dev->vbi_cap_caps |= V4L2_CAP_TUNER;
806 }
807 if (dev->has_vbi_out) {
808 /* set up the capabilities of the vbi output device */
809 dev->vbi_out_caps = (dev->has_raw_vbi_out ? V4L2_CAP_VBI_OUTPUT : 0) |
810 (dev->has_sliced_vbi_out ? V4L2_CAP_SLICED_VBI_OUTPUT : 0);
811 dev->vbi_out_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
812 if (dev->has_audio_outputs)
813 dev->vbi_out_caps |= V4L2_CAP_AUDIO;
814 }
815 if (dev->has_sdr_cap) {
816 /* set up the capabilities of the sdr capture device */
817 dev->sdr_cap_caps = V4L2_CAP_SDR_CAPTURE | V4L2_CAP_TUNER;
818 dev->sdr_cap_caps |= V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
819 }
820 /* set up the capabilities of the radio receiver device */
821 if (dev->has_radio_rx)
822 dev->radio_rx_caps = V4L2_CAP_RADIO | V4L2_CAP_RDS_CAPTURE |
823 V4L2_CAP_HW_FREQ_SEEK | V4L2_CAP_TUNER |
824 V4L2_CAP_READWRITE;
825 /* set up the capabilities of the radio transmitter device */
826 if (dev->has_radio_tx)
827 dev->radio_tx_caps = V4L2_CAP_RDS_OUTPUT | V4L2_CAP_MODULATOR |
828 V4L2_CAP_READWRITE;
829
830 /* initialize the test pattern generator */
831 tpg_init(&dev->tpg, 640, 360);
832 if (tpg_alloc(&dev->tpg, MAX_ZOOM * MAX_WIDTH))
833 goto free_dev;
834 dev->scaled_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
835 if (!dev->scaled_line)
836 goto free_dev;
837 dev->blended_line = vzalloc(MAX_ZOOM * MAX_WIDTH);
838 if (!dev->blended_line)
839 goto free_dev;
840
841 /* load the edid */
842 dev->edid = vmalloc(256 * 128);
843 if (!dev->edid)
844 goto free_dev;
845
846 /* create a string array containing the names of all the preset timings */
847 while (v4l2_dv_timings_presets[dev->query_dv_timings_size].bt.width)
848 dev->query_dv_timings_size++;
849 dev->query_dv_timings_qmenu = kmalloc(dev->query_dv_timings_size *
850 (sizeof(void *) + 32), GFP_KERNEL);
851 if (dev->query_dv_timings_qmenu == NULL)
852 goto free_dev;
853 for (i = 0; i < dev->query_dv_timings_size; i++) {
854 const struct v4l2_bt_timings *bt = &v4l2_dv_timings_presets[i].bt;
855 char *p = (char *)&dev->query_dv_timings_qmenu[dev->query_dv_timings_size];
856 u32 htot, vtot;
857
858 p += i * 32;
859 dev->query_dv_timings_qmenu[i] = p;
860
861 htot = V4L2_DV_BT_FRAME_WIDTH(bt);
862 vtot = V4L2_DV_BT_FRAME_HEIGHT(bt);
863 snprintf(p, 32, "%ux%u%s%u",
864 bt->width, bt->height, bt->interlaced ? "i" : "p",
865 (u32)bt->pixelclock / (htot * vtot));
866 }
867
868 /* disable invalid ioctls based on the feature set */
869 if (!dev->has_audio_inputs) {
870 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_AUDIO);
871 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_AUDIO);
872 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMAUDIO);
873 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_AUDIO);
874 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_AUDIO);
875 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_ENUMAUDIO);
876 }
877 if (!dev->has_audio_outputs) {
878 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_AUDOUT);
879 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_AUDOUT);
880 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMAUDOUT);
881 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_AUDOUT);
882 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_AUDOUT);
883 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_ENUMAUDOUT);
884 }
885 if (!in_type_counter[TV] && !in_type_counter[SVID]) {
886 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_STD);
887 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_STD);
888 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUMSTD);
889 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERYSTD);
890 }
891 if (!out_type_counter[SVID]) {
892 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_STD);
893 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_STD);
894 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUMSTD);
895 }
896 if (!has_tuner && !has_modulator) {
897 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_FREQUENCY);
898 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_FREQUENCY);
899 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_FREQUENCY);
900 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_FREQUENCY);
901 }
902 if (!has_tuner) {
903 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_TUNER);
904 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_TUNER);
905 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_TUNER);
906 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_G_TUNER);
907 }
908 if (in_type_counter[HDMI] == 0) {
909 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_EDID);
910 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_EDID);
911 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_DV_TIMINGS_CAP);
912 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_G_DV_TIMINGS);
913 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_DV_TIMINGS);
914 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_ENUM_DV_TIMINGS);
915 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_QUERY_DV_TIMINGS);
916 }
917 if (out_type_counter[HDMI] == 0) {
918 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_EDID);
919 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_DV_TIMINGS_CAP);
920 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_DV_TIMINGS);
921 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_DV_TIMINGS);
922 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_DV_TIMINGS);
923 }
924 if (!dev->has_fb) {
925 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FBUF);
926 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FBUF);
927 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_OVERLAY);
928 }
929 v4l2_disable_ioctl(&dev->vid_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
930 v4l2_disable_ioctl(&dev->vbi_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
931 v4l2_disable_ioctl(&dev->sdr_cap_dev, VIDIOC_S_HW_FREQ_SEEK);
932 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_S_FREQUENCY);
933 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_G_FREQUENCY);
934 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMESIZES);
935 v4l2_disable_ioctl(&dev->vid_out_dev, VIDIOC_ENUM_FRAMEINTERVALS);
936 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_S_FREQUENCY);
937 v4l2_disable_ioctl(&dev->vbi_out_dev, VIDIOC_G_FREQUENCY);
938
939 /* configure internal data */
940 dev->fmt_cap = &vivid_formats[0];
941 dev->fmt_out = &vivid_formats[0];
942 if (!dev->multiplanar)
943 vivid_formats[0].data_offset[0] = 0;
944 dev->webcam_size_idx = 1;
945 dev->webcam_ival_idx = 3;
946 tpg_s_fourcc(&dev->tpg, dev->fmt_cap->fourcc);
947 dev->std_cap = V4L2_STD_PAL;
948 dev->std_out = V4L2_STD_PAL;
949 if (dev->input_type[0] == TV || dev->input_type[0] == SVID)
950 tvnorms_cap = V4L2_STD_ALL;
951 if (dev->output_type[0] == SVID)
952 tvnorms_out = V4L2_STD_ALL;
953 dev->dv_timings_cap = def_dv_timings;
954 dev->dv_timings_out = def_dv_timings;
955 dev->tv_freq = 2804 /* 175.25 * 16 */;
956 dev->tv_audmode = V4L2_TUNER_MODE_STEREO;
957 dev->tv_field_cap = V4L2_FIELD_INTERLACED;
958 dev->tv_field_out = V4L2_FIELD_INTERLACED;
959 dev->radio_rx_freq = 95000 * 16;
960 dev->radio_rx_audmode = V4L2_TUNER_MODE_STEREO;
961 if (dev->has_radio_tx) {
962 dev->radio_tx_freq = 95500 * 16;
963 dev->radio_rds_loop = false;
964 }
965 dev->radio_tx_subchans = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_RDS;
966 dev->sdr_adc_freq = 300000;
967 dev->sdr_fm_freq = 50000000;
968 dev->edid_max_blocks = dev->edid_blocks = 2;
969 memcpy(dev->edid, vivid_hdmi_edid, sizeof(vivid_hdmi_edid));
970 ktime_get_ts(&dev->radio_rds_init_ts);
971
972 /* create all controls */
973 ret = vivid_create_controls(dev, ccs_cap == -1, ccs_out == -1, no_error_inj,
974 in_type_counter[TV] || in_type_counter[SVID] ||
975 out_type_counter[SVID],
976 in_type_counter[HDMI] || out_type_counter[HDMI]);
977 if (ret)
978 goto unreg_dev;
979
980 /*
981 * update the capture and output formats to do a proper initial
982 * configuration.
983 */
984 vivid_update_format_cap(dev, false);
985 vivid_update_format_out(dev);
986
987 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
988 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_out);
989 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_cap);
990 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vbi_out);
991 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_rx);
992 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_radio_tx);
993 v4l2_ctrl_handler_setup(&dev->ctrl_hdl_sdr_cap);
994
995 /* initialize overlay */
996 dev->fb_cap.fmt.width = dev->src_rect.width;
997 dev->fb_cap.fmt.height = dev->src_rect.height;
998 dev->fb_cap.fmt.pixelformat = dev->fmt_cap->fourcc;
999 dev->fb_cap.fmt.bytesperline = dev->src_rect.width * tpg_g_twopixelsize(&dev->tpg, 0) / 2;
1000 dev->fb_cap.fmt.sizeimage = dev->src_rect.height * dev->fb_cap.fmt.bytesperline;
1001
1002 /* initialize locks */
1003 spin_lock_init(&dev->slock);
1004 mutex_init(&dev->mutex);
1005
1006 /* init dma queues */
1007 INIT_LIST_HEAD(&dev->vid_cap_active);
1008 INIT_LIST_HEAD(&dev->vid_out_active);
1009 INIT_LIST_HEAD(&dev->vbi_cap_active);
1010 INIT_LIST_HEAD(&dev->vbi_out_active);
1011 INIT_LIST_HEAD(&dev->sdr_cap_active);
1012
1013 /* start creating the vb2 queues */
1014 if (dev->has_vid_cap) {
1015 /* initialize vid_cap queue */
1016 q = &dev->vb_vid_cap_q;
1017 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
1018 V4L2_BUF_TYPE_VIDEO_CAPTURE;
1019 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1020 q->drv_priv = dev;
1021 q->buf_struct_size = sizeof(struct vivid_buffer);
1022 q->ops = &vivid_vid_cap_qops;
1023 q->mem_ops = &vb2_vmalloc_memops;
1024 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1025 q->min_buffers_needed = 2;
1026
1027 ret = vb2_queue_init(q);
1028 if (ret)
1029 goto unreg_dev;
1030 }
1031
1032 if (dev->has_vid_out) {
1033 /* initialize vid_out queue */
1034 q = &dev->vb_vid_out_q;
1035 q->type = dev->multiplanar ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE :
1036 V4L2_BUF_TYPE_VIDEO_OUTPUT;
1037 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1038 q->drv_priv = dev;
1039 q->buf_struct_size = sizeof(struct vivid_buffer);
1040 q->ops = &vivid_vid_out_qops;
1041 q->mem_ops = &vb2_vmalloc_memops;
1042 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1043 q->min_buffers_needed = 2;
1044
1045 ret = vb2_queue_init(q);
1046 if (ret)
1047 goto unreg_dev;
1048 }
1049
1050 if (dev->has_vbi_cap) {
1051 /* initialize vbi_cap queue */
1052 q = &dev->vb_vbi_cap_q;
1053 q->type = dev->has_raw_vbi_cap ? V4L2_BUF_TYPE_VBI_CAPTURE :
1054 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
1055 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1056 q->drv_priv = dev;
1057 q->buf_struct_size = sizeof(struct vivid_buffer);
1058 q->ops = &vivid_vbi_cap_qops;
1059 q->mem_ops = &vb2_vmalloc_memops;
1060 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1061 q->min_buffers_needed = 2;
1062
1063 ret = vb2_queue_init(q);
1064 if (ret)
1065 goto unreg_dev;
1066 }
1067
1068 if (dev->has_vbi_out) {
1069 /* initialize vbi_out queue */
1070 q = &dev->vb_vbi_out_q;
1071 q->type = dev->has_raw_vbi_out ? V4L2_BUF_TYPE_VBI_OUTPUT :
1072 V4L2_BUF_TYPE_SLICED_VBI_OUTPUT;
1073 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_WRITE;
1074 q->drv_priv = dev;
1075 q->buf_struct_size = sizeof(struct vivid_buffer);
1076 q->ops = &vivid_vbi_out_qops;
1077 q->mem_ops = &vb2_vmalloc_memops;
1078 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1079 q->min_buffers_needed = 2;
1080
1081 ret = vb2_queue_init(q);
1082 if (ret)
1083 goto unreg_dev;
1084 }
1085
1086 if (dev->has_sdr_cap) {
1087 /* initialize sdr_cap queue */
1088 q = &dev->vb_sdr_cap_q;
1089 q->type = V4L2_BUF_TYPE_SDR_CAPTURE;
1090 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1091 q->drv_priv = dev;
1092 q->buf_struct_size = sizeof(struct vivid_buffer);
1093 q->ops = &vivid_sdr_cap_qops;
1094 q->mem_ops = &vb2_vmalloc_memops;
1095 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1096 q->min_buffers_needed = 8;
1097
1098 ret = vb2_queue_init(q);
1099 if (ret)
1100 goto unreg_dev;
1101 }
1102
1103 if (dev->has_fb) {
1104 /* Create framebuffer for testing capture/output overlay */
1105 ret = vivid_fb_init(dev);
1106 if (ret)
1107 goto unreg_dev;
1108 v4l2_info(&dev->v4l2_dev, "Framebuffer device registered as fb%d\n",
1109 dev->fb_info.node);
1110 }
1111
1112 /* finally start creating the device nodes */
1113 if (dev->has_vid_cap) {
1114 vfd = &dev->vid_cap_dev;
1115 strlcpy(vfd->name, "vivid-vid-cap", sizeof(vfd->name));
1116 vfd->fops = &vivid_fops;
1117 vfd->ioctl_ops = &vivid_ioctl_ops;
1118 vfd->release = video_device_release_empty;
1119 vfd->v4l2_dev = &dev->v4l2_dev;
1120 vfd->queue = &dev->vb_vid_cap_q;
1121 vfd->tvnorms = tvnorms_cap;
1122
1123 /*
1124 * Provide a mutex to v4l2 core. It will be used to protect
1125 * all fops and v4l2 ioctls.
1126 */
1127 vfd->lock = &dev->mutex;
1128 video_set_drvdata(vfd, dev);
1129
1130 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_cap_nr[inst]);
1131 if (ret < 0)
1132 goto unreg_dev;
1133 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1134 video_device_node_name(vfd));
1135 }
1136
1137 if (dev->has_vid_out) {
1138 vfd = &dev->vid_out_dev;
1139 strlcpy(vfd->name, "vivid-vid-out", sizeof(vfd->name));
1140 vfd->vfl_dir = VFL_DIR_TX;
1141 vfd->fops = &vivid_fops;
1142 vfd->ioctl_ops = &vivid_ioctl_ops;
1143 vfd->release = video_device_release_empty;
1144 vfd->v4l2_dev = &dev->v4l2_dev;
1145 vfd->queue = &dev->vb_vid_out_q;
1146 vfd->tvnorms = tvnorms_out;
1147
1148 /*
1149 * Provide a mutex to v4l2 core. It will be used to protect
1150 * all fops and v4l2 ioctls.
1151 */
1152 vfd->lock = &dev->mutex;
1153 video_set_drvdata(vfd, dev);
1154
1155 ret = video_register_device(vfd, VFL_TYPE_GRABBER, vid_out_nr[inst]);
1156 if (ret < 0)
1157 goto unreg_dev;
1158 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s\n",
1159 video_device_node_name(vfd));
1160 }
1161
1162 if (dev->has_vbi_cap) {
1163 vfd = &dev->vbi_cap_dev;
1164 strlcpy(vfd->name, "vivid-vbi-cap", sizeof(vfd->name));
1165 vfd->fops = &vivid_fops;
1166 vfd->ioctl_ops = &vivid_ioctl_ops;
1167 vfd->release = video_device_release_empty;
1168 vfd->v4l2_dev = &dev->v4l2_dev;
1169 vfd->queue = &dev->vb_vbi_cap_q;
1170 vfd->lock = &dev->mutex;
1171 vfd->tvnorms = tvnorms_cap;
1172 video_set_drvdata(vfd, dev);
1173
1174 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_cap_nr[inst]);
1175 if (ret < 0)
1176 goto unreg_dev;
1177 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s, supports %s VBI\n",
1178 video_device_node_name(vfd),
1179 (dev->has_raw_vbi_cap && dev->has_sliced_vbi_cap) ?
1180 "raw and sliced" :
1181 (dev->has_raw_vbi_cap ? "raw" : "sliced"));
1182 }
1183
1184 if (dev->has_vbi_out) {
1185 vfd = &dev->vbi_out_dev;
1186 strlcpy(vfd->name, "vivid-vbi-out", sizeof(vfd->name));
1187 vfd->vfl_dir = VFL_DIR_TX;
1188 vfd->fops = &vivid_fops;
1189 vfd->ioctl_ops = &vivid_ioctl_ops;
1190 vfd->release = video_device_release_empty;
1191 vfd->v4l2_dev = &dev->v4l2_dev;
1192 vfd->queue = &dev->vb_vbi_out_q;
1193 vfd->lock = &dev->mutex;
1194 vfd->tvnorms = tvnorms_out;
1195 video_set_drvdata(vfd, dev);
1196
1197 ret = video_register_device(vfd, VFL_TYPE_VBI, vbi_out_nr[inst]);
1198 if (ret < 0)
1199 goto unreg_dev;
1200 v4l2_info(&dev->v4l2_dev, "V4L2 output device registered as %s, supports %s VBI\n",
1201 video_device_node_name(vfd),
1202 (dev->has_raw_vbi_out && dev->has_sliced_vbi_out) ?
1203 "raw and sliced" :
1204 (dev->has_raw_vbi_out ? "raw" : "sliced"));
1205 }
1206
1207 if (dev->has_sdr_cap) {
1208 vfd = &dev->sdr_cap_dev;
1209 strlcpy(vfd->name, "vivid-sdr-cap", sizeof(vfd->name));
1210 vfd->fops = &vivid_fops;
1211 vfd->ioctl_ops = &vivid_ioctl_ops;
1212 vfd->release = video_device_release_empty;
1213 vfd->v4l2_dev = &dev->v4l2_dev;
1214 vfd->queue = &dev->vb_sdr_cap_q;
1215 vfd->lock = &dev->mutex;
1216 video_set_drvdata(vfd, dev);
1217
1218 ret = video_register_device(vfd, VFL_TYPE_SDR, sdr_cap_nr[inst]);
1219 if (ret < 0)
1220 goto unreg_dev;
1221 v4l2_info(&dev->v4l2_dev, "V4L2 capture device registered as %s\n",
1222 video_device_node_name(vfd));
1223 }
1224
1225 if (dev->has_radio_rx) {
1226 vfd = &dev->radio_rx_dev;
1227 strlcpy(vfd->name, "vivid-rad-rx", sizeof(vfd->name));
1228 vfd->fops = &vivid_radio_fops;
1229 vfd->ioctl_ops = &vivid_ioctl_ops;
1230 vfd->release = video_device_release_empty;
1231 vfd->v4l2_dev = &dev->v4l2_dev;
1232 vfd->lock = &dev->mutex;
1233 video_set_drvdata(vfd, dev);
1234
1235 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_rx_nr[inst]);
1236 if (ret < 0)
1237 goto unreg_dev;
1238 v4l2_info(&dev->v4l2_dev, "V4L2 receiver device registered as %s\n",
1239 video_device_node_name(vfd));
1240 }
1241
1242 if (dev->has_radio_tx) {
1243 vfd = &dev->radio_tx_dev;
1244 strlcpy(vfd->name, "vivid-rad-tx", sizeof(vfd->name));
1245 vfd->vfl_dir = VFL_DIR_TX;
1246 vfd->fops = &vivid_radio_fops;
1247 vfd->ioctl_ops = &vivid_ioctl_ops;
1248 vfd->release = video_device_release_empty;
1249 vfd->v4l2_dev = &dev->v4l2_dev;
1250 vfd->lock = &dev->mutex;
1251 video_set_drvdata(vfd, dev);
1252
1253 ret = video_register_device(vfd, VFL_TYPE_RADIO, radio_tx_nr[inst]);
1254 if (ret < 0)
1255 goto unreg_dev;
1256 v4l2_info(&dev->v4l2_dev, "V4L2 transmitter device registered as %s\n",
1257 video_device_node_name(vfd));
1258 }
1259
1260 /* Now that everything is fine, let's add it to device list */
1261 vivid_devs[inst] = dev;
1262
1263 return 0;
1264
1265unreg_dev:
1266 video_unregister_device(&dev->radio_tx_dev);
1267 video_unregister_device(&dev->radio_rx_dev);
1268 video_unregister_device(&dev->sdr_cap_dev);
1269 video_unregister_device(&dev->vbi_out_dev);
1270 video_unregister_device(&dev->vbi_cap_dev);
1271 video_unregister_device(&dev->vid_out_dev);
1272 video_unregister_device(&dev->vid_cap_dev);
1273 vivid_free_controls(dev);
1274 v4l2_device_unregister(&dev->v4l2_dev);
1275free_dev:
1276 vfree(dev->scaled_line);
1277 vfree(dev->blended_line);
1278 vfree(dev->edid);
1279 tpg_free(&dev->tpg);
1280 kfree(dev->query_dv_timings_qmenu);
1281 kfree(dev);
1282 return ret;
1283}
1284
1285/* This routine allocates from 1 to n_devs virtual drivers.
1286
1287 The real maximum number of virtual drivers will depend on how many drivers
1288 will succeed. This is limited to the maximum number of devices that
1289 videodev supports, which is equal to VIDEO_NUM_DEVICES.
1290 */
1291static int __init vivid_init(void)
1292{
1293 const struct font_desc *font = find_font("VGA8x16");
1294 int ret = 0, i;
1295
1296 if (font == NULL) {
1297 pr_err("vivid: could not find font\n");
1298 return -ENODEV;
1299 }
1300
1301 tpg_set_font(font->data);
1302
1303 n_devs = clamp_t(unsigned, n_devs, 1, VIVID_MAX_DEVS);
1304
1305 for (i = 0; i < n_devs; i++) {
1306 ret = vivid_create_instance(i);
1307 if (ret) {
1308 /* If some instantiations succeeded, keep driver */
1309 if (i)
1310 ret = 0;
1311 break;
1312 }
1313 }
1314
1315 if (ret < 0) {
1316 pr_err("vivid: error %d while loading driver\n", ret);
1317 return ret;
1318 }
1319
1320 /* n_devs will reflect the actual number of allocated devices */
1321 n_devs = i;
1322
1323 return ret;
1324}
1325
1326static void __exit vivid_exit(void)
1327{
1328 struct vivid_dev *dev;
1329 unsigned i;
1330
1331 for (i = 0; vivid_devs[i]; i++) {
1332 dev = vivid_devs[i];
1333
1334 if (dev->has_vid_cap) {
1335 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1336 video_device_node_name(&dev->vid_cap_dev));
1337 video_unregister_device(&dev->vid_cap_dev);
1338 }
1339 if (dev->has_vid_out) {
1340 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1341 video_device_node_name(&dev->vid_out_dev));
1342 video_unregister_device(&dev->vid_out_dev);
1343 }
1344 if (dev->has_vbi_cap) {
1345 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1346 video_device_node_name(&dev->vbi_cap_dev));
1347 video_unregister_device(&dev->vbi_cap_dev);
1348 }
1349 if (dev->has_vbi_out) {
1350 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1351 video_device_node_name(&dev->vbi_out_dev));
1352 video_unregister_device(&dev->vbi_out_dev);
1353 }
1354 if (dev->has_sdr_cap) {
1355 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1356 video_device_node_name(&dev->sdr_cap_dev));
1357 video_unregister_device(&dev->sdr_cap_dev);
1358 }
1359 if (dev->has_radio_rx) {
1360 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1361 video_device_node_name(&dev->radio_rx_dev));
1362 video_unregister_device(&dev->radio_rx_dev);
1363 }
1364 if (dev->has_radio_tx) {
1365 v4l2_info(&dev->v4l2_dev, "unregistering %s\n",
1366 video_device_node_name(&dev->radio_tx_dev));
1367 video_unregister_device(&dev->radio_tx_dev);
1368 }
1369 if (dev->has_fb) {
1370 v4l2_info(&dev->v4l2_dev, "unregistering fb%d\n",
1371 dev->fb_info.node);
1372 unregister_framebuffer(&dev->fb_info);
1373 vivid_fb_release_buffers(dev);
1374 }
1375 v4l2_device_unregister(&dev->v4l2_dev);
1376 vivid_free_controls(dev);
1377 vfree(dev->scaled_line);
1378 vfree(dev->blended_line);
1379 vfree(dev->edid);
1380 vfree(dev->bitmap_cap);
1381 vfree(dev->bitmap_out);
1382 tpg_free(&dev->tpg);
1383 kfree(dev->query_dv_timings_qmenu);
1384 kfree(dev);
1385 vivid_devs[i] = NULL;
1386 }
1387}
1388
1389module_init(vivid_init);
1390module_exit(vivid_exit);
Linux 6.x block layer and io_uring tree(s)