1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * vivid-touch-cap.c - touch support functions.
4 */
5
6 #include "vivid-core.h"
7 #include "vivid-kthread-touch.h"
8 #include "vivid-vid-common.h"
9 #include "vivid-touch-cap.h"
10
touch_cap_queue_setup(struct vb2_queue * vq,unsigned int * nbuffers,unsigned int * nplanes,unsigned int sizes[],struct device * alloc_devs[])11 static int touch_cap_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
12 unsigned int *nplanes, unsigned int sizes[],
13 struct device *alloc_devs[])
14 {
15 struct vivid_dev *dev = vb2_get_drv_priv(vq);
16 struct v4l2_pix_format *f = &dev->tch_format;
17 unsigned int size = f->sizeimage;
18
19 if (*nplanes) {
20 if (*nplanes != 1)
21 return -EINVAL;
22 return sizes[0] < size ? -EINVAL : 0;
23 }
24
25 *nplanes = 1;
26 sizes[0] = size;
27 return 0;
28 }
29
touch_cap_buf_prepare(struct vb2_buffer * vb)30 static int touch_cap_buf_prepare(struct vb2_buffer *vb)
31 {
32 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
33 struct v4l2_pix_format *f = &dev->tch_format;
34 unsigned int size = f->sizeimage;
35
36 if (dev->buf_prepare_error) {
37 /*
38 * Error injection: test what happens if buf_prepare() returns
39 * an error.
40 */
41 dev->buf_prepare_error = false;
42 return -EINVAL;
43 }
44 if (vb2_plane_size(vb, 0) < size) {
45 dprintk(dev, 1, "%s data will not fit into plane (%lu < %u)\n",
46 __func__, vb2_plane_size(vb, 0), size);
47 return -EINVAL;
48 }
49 vb2_set_plane_payload(vb, 0, size);
50
51 return 0;
52 }
53
touch_cap_buf_queue(struct vb2_buffer * vb)54 static void touch_cap_buf_queue(struct vb2_buffer *vb)
55 {
56 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
57 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
58 struct vivid_buffer *buf = container_of(vbuf, struct vivid_buffer, vb);
59
60 vbuf->field = V4L2_FIELD_NONE;
61 spin_lock(&dev->slock);
62 list_add_tail(&buf->list, &dev->touch_cap_active);
63 spin_unlock(&dev->slock);
64 }
65
touch_cap_start_streaming(struct vb2_queue * vq,unsigned int count)66 static int touch_cap_start_streaming(struct vb2_queue *vq, unsigned int count)
67 {
68 struct vivid_dev *dev = vb2_get_drv_priv(vq);
69 int err;
70
71 dev->touch_cap_seq_count = 0;
72 if (dev->start_streaming_error) {
73 dev->start_streaming_error = false;
74 err = -EINVAL;
75 } else {
76 err = vivid_start_generating_touch_cap(dev);
77 }
78 if (err) {
79 struct vivid_buffer *buf, *tmp;
80
81 list_for_each_entry_safe(buf, tmp,
82 &dev->touch_cap_active, list) {
83 list_del(&buf->list);
84 vb2_buffer_done(&buf->vb.vb2_buf,
85 VB2_BUF_STATE_QUEUED);
86 }
87 }
88 return err;
89 }
90
91 /* abort streaming and wait for last buffer */
touch_cap_stop_streaming(struct vb2_queue * vq)92 static void touch_cap_stop_streaming(struct vb2_queue *vq)
93 {
94 struct vivid_dev *dev = vb2_get_drv_priv(vq);
95
96 vivid_stop_generating_touch_cap(dev);
97 }
98
touch_cap_buf_request_complete(struct vb2_buffer * vb)99 static void touch_cap_buf_request_complete(struct vb2_buffer *vb)
100 {
101 struct vivid_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
102
103 v4l2_ctrl_request_complete(vb->req_obj.req, &dev->ctrl_hdl_touch_cap);
104 }
105
106 const struct vb2_ops vivid_touch_cap_qops = {
107 .queue_setup = touch_cap_queue_setup,
108 .buf_prepare = touch_cap_buf_prepare,
109 .buf_queue = touch_cap_buf_queue,
110 .start_streaming = touch_cap_start_streaming,
111 .stop_streaming = touch_cap_stop_streaming,
112 .buf_request_complete = touch_cap_buf_request_complete,
113 .wait_prepare = vb2_ops_wait_prepare,
114 .wait_finish = vb2_ops_wait_finish,
115 };
116
vivid_enum_fmt_tch(struct file * file,void * priv,struct v4l2_fmtdesc * f)117 int vivid_enum_fmt_tch(struct file *file, void *priv, struct v4l2_fmtdesc *f)
118 {
119 if (f->index)
120 return -EINVAL;
121
122 f->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
123 return 0;
124 }
125
vivid_g_fmt_tch(struct file * file,void * priv,struct v4l2_format * f)126 int vivid_g_fmt_tch(struct file *file, void *priv, struct v4l2_format *f)
127 {
128 struct vivid_dev *dev = video_drvdata(file);
129
130 if (dev->multiplanar)
131 return -ENOTTY;
132 f->fmt.pix = dev->tch_format;
133 return 0;
134 }
135
vivid_g_fmt_tch_mplane(struct file * file,void * priv,struct v4l2_format * f)136 int vivid_g_fmt_tch_mplane(struct file *file, void *priv, struct v4l2_format *f)
137 {
138 struct vivid_dev *dev = video_drvdata(file);
139 struct v4l2_format sp_fmt;
140
141 if (!dev->multiplanar)
142 return -ENOTTY;
143 sp_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
144 sp_fmt.fmt.pix = dev->tch_format;
145 fmt_sp2mp(&sp_fmt, f);
146 return 0;
147 }
148
vivid_g_parm_tch(struct file * file,void * priv,struct v4l2_streamparm * parm)149 int vivid_g_parm_tch(struct file *file, void *priv,
150 struct v4l2_streamparm *parm)
151 {
152 struct vivid_dev *dev = video_drvdata(file);
153
154 if (parm->type != (dev->multiplanar ?
155 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE :
156 V4L2_BUF_TYPE_VIDEO_CAPTURE))
157 return -EINVAL;
158
159 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
160 parm->parm.capture.timeperframe = dev->timeperframe_tch_cap;
161 parm->parm.capture.readbuffers = 1;
162 return 0;
163 }
164
vivid_enum_input_tch(struct file * file,void * priv,struct v4l2_input * inp)165 int vivid_enum_input_tch(struct file *file, void *priv, struct v4l2_input *inp)
166 {
167 if (inp->index)
168 return -EINVAL;
169
170 inp->type = V4L2_INPUT_TYPE_TOUCH;
171 strscpy(inp->name, "Vivid Touch", sizeof(inp->name));
172 inp->capabilities = 0;
173 return 0;
174 }
175
vivid_g_input_tch(struct file * file,void * priv,unsigned int * i)176 int vivid_g_input_tch(struct file *file, void *priv, unsigned int *i)
177 {
178 *i = 0;
179 return 0;
180 }
181
vivid_set_touch(struct vivid_dev * dev,unsigned int i)182 int vivid_set_touch(struct vivid_dev *dev, unsigned int i)
183 {
184 struct v4l2_pix_format *f = &dev->tch_format;
185
186 if (i)
187 return -EINVAL;
188
189 f->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
190 f->width = VIVID_TCH_WIDTH;
191 f->height = VIVID_TCH_HEIGHT;
192 f->field = V4L2_FIELD_NONE;
193 f->colorspace = V4L2_COLORSPACE_RAW;
194 f->bytesperline = f->width * sizeof(s16);
195 f->sizeimage = f->width * f->height * sizeof(s16);
196 return 0;
197 }
198
vivid_s_input_tch(struct file * file,void * priv,unsigned int i)199 int vivid_s_input_tch(struct file *file, void *priv, unsigned int i)
200 {
201 return vivid_set_touch(video_drvdata(file), i);
202 }
203
vivid_fill_buff_noise(__s16 * tch_buf,int size)204 static void vivid_fill_buff_noise(__s16 *tch_buf, int size)
205 {
206 int i;
207
208 /* Fill 10% of the values within range -3 and 3, zero the others */
209 for (i = 0; i < size; i++) {
210 unsigned int rand = get_random_u32();
211
212 if (rand % 10)
213 tch_buf[i] = 0;
214 else
215 tch_buf[i] = (rand / 10) % 7 - 3;
216 }
217 }
218
get_random_pressure(void)219 static inline int get_random_pressure(void)
220 {
221 return get_random_u32_below(VIVID_PRESSURE_LIMIT);
222 }
223
vivid_tch_buf_set(struct v4l2_pix_format * f,__s16 * tch_buf,int index)224 static void vivid_tch_buf_set(struct v4l2_pix_format *f,
225 __s16 *tch_buf,
226 int index)
227 {
228 unsigned int x = index % f->width;
229 unsigned int y = index / f->width;
230 unsigned int offset = VIVID_MIN_PRESSURE;
231
232 tch_buf[index] = offset + get_random_pressure();
233 offset /= 2;
234 if (x)
235 tch_buf[index - 1] = offset + get_random_pressure();
236 if (x < f->width - 1)
237 tch_buf[index + 1] = offset + get_random_pressure();
238 if (y)
239 tch_buf[index - f->width] = offset + get_random_pressure();
240 if (y < f->height - 1)
241 tch_buf[index + f->width] = offset + get_random_pressure();
242 offset /= 2;
243 if (x && y)
244 tch_buf[index - 1 - f->width] = offset + get_random_pressure();
245 if (x < f->width - 1 && y)
246 tch_buf[index + 1 - f->width] = offset + get_random_pressure();
247 if (x && y < f->height - 1)
248 tch_buf[index - 1 + f->width] = offset + get_random_pressure();
249 if (x < f->width - 1 && y < f->height - 1)
250 tch_buf[index + 1 + f->width] = offset + get_random_pressure();
251 }
252
vivid_fillbuff_tch(struct vivid_dev * dev,struct vivid_buffer * buf)253 void vivid_fillbuff_tch(struct vivid_dev *dev, struct vivid_buffer *buf)
254 {
255 struct v4l2_pix_format *f = &dev->tch_format;
256 int size = f->width * f->height;
257 int x, y, xstart, ystart, offset_x, offset_y;
258 unsigned int test_pattern, test_pat_idx, rand;
259
260 __s16 *tch_buf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
261
262 buf->vb.sequence = dev->touch_cap_with_seq_wrap_count;
263 test_pattern = (buf->vb.sequence / TCH_SEQ_COUNT) % TEST_CASE_MAX;
264 test_pat_idx = buf->vb.sequence % TCH_SEQ_COUNT;
265
266 vivid_fill_buff_noise(tch_buf, size);
267
268 if (test_pat_idx >= TCH_PATTERN_COUNT)
269 return;
270
271 if (test_pat_idx == 0)
272 dev->tch_pat_random = get_random_u32();
273 rand = dev->tch_pat_random;
274
275 switch (test_pattern) {
276 case SINGLE_TAP:
277 if (test_pat_idx == 2)
278 vivid_tch_buf_set(f, tch_buf, rand % size);
279 break;
280 case DOUBLE_TAP:
281 if (test_pat_idx == 2 || test_pat_idx == 4)
282 vivid_tch_buf_set(f, tch_buf, rand % size);
283 break;
284 case TRIPLE_TAP:
285 if (test_pat_idx == 2 || test_pat_idx == 4 || test_pat_idx == 6)
286 vivid_tch_buf_set(f, tch_buf, rand % size);
287 break;
288 case MOVE_LEFT_TO_RIGHT:
289 vivid_tch_buf_set(f, tch_buf,
290 (rand % f->height) * f->width +
291 test_pat_idx *
292 (f->width / TCH_PATTERN_COUNT));
293 break;
294 case ZOOM_IN:
295 x = f->width / 2;
296 y = f->height / 2;
297 offset_x = ((TCH_PATTERN_COUNT - 1 - test_pat_idx) * x) /
298 TCH_PATTERN_COUNT;
299 offset_y = ((TCH_PATTERN_COUNT - 1 - test_pat_idx) * y) /
300 TCH_PATTERN_COUNT;
301 vivid_tch_buf_set(f, tch_buf,
302 (x - offset_x) + f->width * (y - offset_y));
303 vivid_tch_buf_set(f, tch_buf,
304 (x + offset_x) + f->width * (y + offset_y));
305 break;
306 case ZOOM_OUT:
307 x = f->width / 2;
308 y = f->height / 2;
309 offset_x = (test_pat_idx * x) / TCH_PATTERN_COUNT;
310 offset_y = (test_pat_idx * y) / TCH_PATTERN_COUNT;
311 vivid_tch_buf_set(f, tch_buf,
312 (x - offset_x) + f->width * (y - offset_y));
313 vivid_tch_buf_set(f, tch_buf,
314 (x + offset_x) + f->width * (y + offset_y));
315 break;
316 case PALM_PRESS:
317 for (x = 0; x < f->width; x++)
318 for (y = f->height / 2; y < f->height; y++)
319 tch_buf[x + f->width * y] = VIVID_MIN_PRESSURE +
320 get_random_pressure();
321 break;
322 case MULTIPLE_PRESS:
323 /* 16 pressure points */
324 for (y = 0; y < 4; y++) {
325 for (x = 0; x < 4; x++) {
326 ystart = (y * f->height) / 4 + f->height / 8;
327 xstart = (x * f->width) / 4 + f->width / 8;
328 vivid_tch_buf_set(f, tch_buf,
329 ystart * f->width + xstart);
330 }
331 }
332 break;
333 }
334 #ifdef __BIG_ENDIAN__
335 for (x = 0; x < size; x++)
336 tch_buf[x] = (__force s16)__cpu_to_le16((u16)tch_buf[x]);
337 #endif
338 }
339