1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2012-2015 Synaptics Incorporated
4 * Copyright (C) 2016 Zodiac Inflight Innovations
7 #include <linux/kernel.h>
9 #include <linux/input.h>
10 #include <linux/slab.h>
11 #include <linux/delay.h>
12 #include <linux/i2c.h>
13 #include <media/v4l2-device.h>
14 #include <media/v4l2-ioctl.h>
15 #include <media/videobuf2-v4l2.h>
16 #include <media/videobuf2-vmalloc.h>
17 #include "rmi_driver.h"
19 #define F54_NAME "rmi4_f54"
21 /* F54 data offsets */
22 #define F54_REPORT_DATA_OFFSET 3
23 #define F54_FIFO_OFFSET 1
24 #define F54_NUM_TX_OFFSET 1
25 #define F54_NUM_RX_OFFSET 0
28 #define F54_GET_REPORT 1
29 #define F54_FORCE_CAL 2
31 /* F54 capabilities */
32 #define F54_CAP_BASELINE (1 << 2)
33 #define F54_CAP_IMAGE8 (1 << 3)
34 #define F54_CAP_IMAGE16 (1 << 6)
37 * enum rmi_f54_report_type - RMI4 F54 report types
39 * @F54_8BIT_IMAGE: Normalized 8-Bit Image Report. The capacitance variance
40 * from baseline for each pixel.
42 * @F54_16BIT_IMAGE: Normalized 16-Bit Image Report. The capacitance variance
43 * from baseline for each pixel.
45 * @F54_RAW_16BIT_IMAGE:
46 * Raw 16-Bit Image Report. The raw capacitance for each
49 * @F54_TRUE_BASELINE: True Baseline Report. The baseline capacitance for each
52 * @F54_FULL_RAW_CAP: Full Raw Capacitance Report. The raw capacitance with
53 * low reference set to its minimum value and high
54 * reference set to its maximum value.
56 * @F54_FULL_RAW_CAP_RX_OFFSET_REMOVED:
57 * Full Raw Capacitance with Receiver Offset Removed
58 * Report. Set Low reference to its minimum value and high
59 * references to its maximum value, then report the raw
60 * capacitance for each pixel.
62 enum rmi_f54_report_type {
66 F54_RAW_16BIT_IMAGE = 3,
67 F54_TRUE_BASELINE = 9,
68 F54_FULL_RAW_CAP = 19,
69 F54_FULL_RAW_CAP_RX_OFFSET_REMOVED = 20,
73 static const char * const rmi_f54_report_type_names[] = {
74 [F54_REPORT_NONE] = "Unknown",
75 [F54_8BIT_IMAGE] = "Normalized 8-Bit Image",
76 [F54_16BIT_IMAGE] = "Normalized 16-Bit Image",
77 [F54_RAW_16BIT_IMAGE] = "Raw 16-Bit Image",
78 [F54_TRUE_BASELINE] = "True Baseline",
79 [F54_FULL_RAW_CAP] = "Full Raw Capacitance",
80 [F54_FULL_RAW_CAP_RX_OFFSET_REMOVED]
81 = "Full Raw Capacitance RX Offset Removed",
85 struct rmi_function *fn;
93 enum rmi_f54_report_type report_type;
98 struct mutex status_mutex;
99 struct mutex data_mutex;
101 struct workqueue_struct *workqueue;
102 struct delayed_work work;
103 unsigned long timeout;
105 struct completion cmd_done;
108 struct v4l2_device v4l2;
109 struct v4l2_pix_format format;
110 struct video_device vdev;
111 struct vb2_queue queue;
115 enum rmi_f54_report_type inputs[F54_MAX_REPORT_TYPE];
119 * Basic checks on report_type to ensure we write a valid type
122 static bool is_f54_report_type_valid(struct f54_data *f54,
123 enum rmi_f54_report_type reptype)
127 return f54->capabilities & F54_CAP_IMAGE8;
128 case F54_16BIT_IMAGE:
129 case F54_RAW_16BIT_IMAGE:
130 return f54->capabilities & F54_CAP_IMAGE16;
131 case F54_TRUE_BASELINE:
132 return f54->capabilities & F54_CAP_IMAGE16;
133 case F54_FULL_RAW_CAP:
134 case F54_FULL_RAW_CAP_RX_OFFSET_REMOVED:
141 static enum rmi_f54_report_type rmi_f54_get_reptype(struct f54_data *f54,
144 if (i >= F54_MAX_REPORT_TYPE)
145 return F54_REPORT_NONE;
147 return f54->inputs[i];
150 static void rmi_f54_create_input_map(struct f54_data *f54)
153 enum rmi_f54_report_type reptype;
155 for (reptype = 1; reptype < F54_MAX_REPORT_TYPE; reptype++) {
156 if (!is_f54_report_type_valid(f54, reptype))
159 f54->inputs[i++] = reptype;
162 /* Remaining values are zero via kzalloc */
165 static int rmi_f54_request_report(struct rmi_function *fn, u8 report_type)
167 struct f54_data *f54 = dev_get_drvdata(&fn->dev);
168 struct rmi_device *rmi_dev = fn->rmi_dev;
171 /* Write Report Type into F54_AD_Data0 */
172 if (f54->report_type != report_type) {
173 error = rmi_write(rmi_dev, f54->fn->fd.data_base_addr,
177 f54->report_type = report_type;
181 * Small delay after disabling interrupts to avoid race condition
182 * in firmare. This value is a bit higher than absolutely necessary.
183 * Should be removed once issue is resolved in firmware.
185 usleep_range(2000, 3000);
187 mutex_lock(&f54->data_mutex);
189 error = rmi_write(rmi_dev, fn->fd.command_base_addr, F54_GET_REPORT);
193 init_completion(&f54->cmd_done);
196 f54->timeout = jiffies + msecs_to_jiffies(100);
198 queue_delayed_work(f54->workqueue, &f54->work, 0);
201 mutex_unlock(&f54->data_mutex);
206 static size_t rmi_f54_get_report_size(struct f54_data *f54)
208 struct rmi_device *rmi_dev = f54->fn->rmi_dev;
209 struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
210 u8 rx = drv_data->num_rx_electrodes ? : f54->num_rx_electrodes;
211 u8 tx = drv_data->num_tx_electrodes ? : f54->num_tx_electrodes;
214 switch (rmi_f54_get_reptype(f54, f54->input)) {
218 case F54_16BIT_IMAGE:
219 case F54_RAW_16BIT_IMAGE:
220 case F54_TRUE_BASELINE:
221 case F54_FULL_RAW_CAP:
222 case F54_FULL_RAW_CAP_RX_OFFSET_REMOVED:
223 size = sizeof(u16) * rx * tx;
232 static int rmi_f54_get_pixel_fmt(enum rmi_f54_report_type reptype, u32 *pixfmt)
238 *pixfmt = V4L2_TCH_FMT_DELTA_TD08;
241 case F54_16BIT_IMAGE:
242 *pixfmt = V4L2_TCH_FMT_DELTA_TD16;
245 case F54_RAW_16BIT_IMAGE:
246 case F54_TRUE_BASELINE:
247 case F54_FULL_RAW_CAP:
248 case F54_FULL_RAW_CAP_RX_OFFSET_REMOVED:
249 *pixfmt = V4L2_TCH_FMT_TU16;
252 case F54_REPORT_NONE:
253 case F54_MAX_REPORT_TYPE:
261 static const struct v4l2_file_operations rmi_f54_video_fops = {
262 .owner = THIS_MODULE,
263 .open = v4l2_fh_open,
264 .release = vb2_fop_release,
265 .unlocked_ioctl = video_ioctl2,
266 .read = vb2_fop_read,
267 .mmap = vb2_fop_mmap,
268 .poll = vb2_fop_poll,
271 static int rmi_f54_queue_setup(struct vb2_queue *q, unsigned int *nbuffers,
272 unsigned int *nplanes, unsigned int sizes[],
273 struct device *alloc_devs[])
275 struct f54_data *f54 = q->drv_priv;
278 return sizes[0] < rmi_f54_get_report_size(f54) ? -EINVAL : 0;
281 sizes[0] = rmi_f54_get_report_size(f54);
286 static void rmi_f54_buffer_queue(struct vb2_buffer *vb)
288 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
289 struct f54_data *f54 = vb2_get_drv_priv(vb->vb2_queue);
291 enum vb2_buffer_state state;
292 enum rmi_f54_report_type reptype;
295 mutex_lock(&f54->status_mutex);
297 vb2_set_plane_payload(vb, 0, 0);
298 reptype = rmi_f54_get_reptype(f54, f54->input);
299 if (reptype == F54_REPORT_NONE) {
300 state = VB2_BUF_STATE_ERROR;
305 state = VB2_BUF_STATE_ERROR;
309 ret = rmi_f54_request_report(f54->fn, reptype);
311 dev_err(&f54->fn->dev, "Error requesting F54 report\n");
312 state = VB2_BUF_STATE_ERROR;
317 mutex_lock(&f54->data_mutex);
319 while (f54->is_busy) {
320 mutex_unlock(&f54->data_mutex);
321 if (!wait_for_completion_timeout(&f54->cmd_done,
322 msecs_to_jiffies(1000))) {
323 dev_err(&f54->fn->dev, "Timed out\n");
324 state = VB2_BUF_STATE_ERROR;
327 mutex_lock(&f54->data_mutex);
330 ptr = vb2_plane_vaddr(vb, 0);
332 dev_err(&f54->fn->dev, "Error acquiring frame ptr\n");
333 state = VB2_BUF_STATE_ERROR;
337 memcpy(ptr, f54->report_data, f54->report_size);
338 vb2_set_plane_payload(vb, 0, rmi_f54_get_report_size(f54));
339 state = VB2_BUF_STATE_DONE;
342 mutex_unlock(&f54->data_mutex);
344 vb->timestamp = ktime_get_ns();
345 vbuf->field = V4L2_FIELD_NONE;
346 vbuf->sequence = f54->sequence++;
347 vb2_buffer_done(vb, state);
348 mutex_unlock(&f54->status_mutex);
351 static void rmi_f54_stop_streaming(struct vb2_queue *q)
353 struct f54_data *f54 = vb2_get_drv_priv(q);
358 /* V4L2 structures */
359 static const struct vb2_ops rmi_f54_queue_ops = {
360 .queue_setup = rmi_f54_queue_setup,
361 .buf_queue = rmi_f54_buffer_queue,
362 .stop_streaming = rmi_f54_stop_streaming,
363 .wait_prepare = vb2_ops_wait_prepare,
364 .wait_finish = vb2_ops_wait_finish,
367 static const struct vb2_queue rmi_f54_queue = {
368 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
369 .io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ,
370 .buf_struct_size = sizeof(struct vb2_v4l2_buffer),
371 .ops = &rmi_f54_queue_ops,
372 .mem_ops = &vb2_vmalloc_memops,
373 .timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC,
376 static int rmi_f54_vidioc_querycap(struct file *file, void *priv,
377 struct v4l2_capability *cap)
379 struct f54_data *f54 = video_drvdata(file);
381 strlcpy(cap->driver, F54_NAME, sizeof(cap->driver));
382 strlcpy(cap->card, SYNAPTICS_INPUT_DEVICE_NAME, sizeof(cap->card));
383 snprintf(cap->bus_info, sizeof(cap->bus_info),
384 "rmi4:%s", dev_name(&f54->fn->dev));
389 static int rmi_f54_vidioc_enum_input(struct file *file, void *priv,
390 struct v4l2_input *i)
392 struct f54_data *f54 = video_drvdata(file);
393 enum rmi_f54_report_type reptype;
395 reptype = rmi_f54_get_reptype(f54, i->index);
396 if (reptype == F54_REPORT_NONE)
399 i->type = V4L2_INPUT_TYPE_TOUCH;
401 strlcpy(i->name, rmi_f54_report_type_names[reptype], sizeof(i->name));
405 static int rmi_f54_set_input(struct f54_data *f54, unsigned int i)
407 struct rmi_device *rmi_dev = f54->fn->rmi_dev;
408 struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
409 u8 rx = drv_data->num_rx_electrodes ? : f54->num_rx_electrodes;
410 u8 tx = drv_data->num_tx_electrodes ? : f54->num_tx_electrodes;
411 struct v4l2_pix_format *f = &f54->format;
412 enum rmi_f54_report_type reptype;
415 reptype = rmi_f54_get_reptype(f54, i);
416 if (reptype == F54_REPORT_NONE)
419 ret = rmi_f54_get_pixel_fmt(reptype, &f->pixelformat);
427 f->field = V4L2_FIELD_NONE;
428 f->colorspace = V4L2_COLORSPACE_RAW;
429 f->bytesperline = f->width * sizeof(u16);
430 f->sizeimage = f->width * f->height * sizeof(u16);
435 static int rmi_f54_vidioc_s_input(struct file *file, void *priv, unsigned int i)
437 return rmi_f54_set_input(video_drvdata(file), i);
440 static int rmi_f54_vidioc_g_input(struct file *file, void *priv,
443 struct f54_data *f54 = video_drvdata(file);
450 static int rmi_f54_vidioc_fmt(struct file *file, void *priv,
451 struct v4l2_format *f)
453 struct f54_data *f54 = video_drvdata(file);
455 f->fmt.pix = f54->format;
460 static int rmi_f54_vidioc_enum_fmt(struct file *file, void *priv,
461 struct v4l2_fmtdesc *fmt)
463 struct f54_data *f54 = video_drvdata(file);
465 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
471 fmt->pixelformat = f54->format.pixelformat;
476 static int rmi_f54_vidioc_g_parm(struct file *file, void *fh,
477 struct v4l2_streamparm *a)
479 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
482 a->parm.capture.readbuffers = 1;
483 a->parm.capture.timeperframe.numerator = 1;
484 a->parm.capture.timeperframe.denominator = 10;
488 static const struct v4l2_ioctl_ops rmi_f54_video_ioctl_ops = {
489 .vidioc_querycap = rmi_f54_vidioc_querycap,
491 .vidioc_enum_fmt_vid_cap = rmi_f54_vidioc_enum_fmt,
492 .vidioc_s_fmt_vid_cap = rmi_f54_vidioc_fmt,
493 .vidioc_g_fmt_vid_cap = rmi_f54_vidioc_fmt,
494 .vidioc_try_fmt_vid_cap = rmi_f54_vidioc_fmt,
495 .vidioc_g_parm = rmi_f54_vidioc_g_parm,
497 .vidioc_enum_input = rmi_f54_vidioc_enum_input,
498 .vidioc_g_input = rmi_f54_vidioc_g_input,
499 .vidioc_s_input = rmi_f54_vidioc_s_input,
501 .vidioc_reqbufs = vb2_ioctl_reqbufs,
502 .vidioc_create_bufs = vb2_ioctl_create_bufs,
503 .vidioc_querybuf = vb2_ioctl_querybuf,
504 .vidioc_qbuf = vb2_ioctl_qbuf,
505 .vidioc_dqbuf = vb2_ioctl_dqbuf,
506 .vidioc_expbuf = vb2_ioctl_expbuf,
508 .vidioc_streamon = vb2_ioctl_streamon,
509 .vidioc_streamoff = vb2_ioctl_streamoff,
512 static const struct video_device rmi_f54_video_device = {
513 .name = "Synaptics RMI4",
514 .fops = &rmi_f54_video_fops,
515 .ioctl_ops = &rmi_f54_video_ioctl_ops,
516 .release = video_device_release_empty,
517 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TOUCH |
518 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING,
521 static void rmi_f54_work(struct work_struct *work)
523 struct f54_data *f54 = container_of(work, struct f54_data, work.work);
524 struct rmi_function *fn = f54->fn;
530 report_size = rmi_f54_get_report_size(f54);
531 if (report_size == 0) {
532 dev_err(&fn->dev, "Bad report size, report type=%d\n",
535 goto error; /* retry won't help */
538 mutex_lock(&f54->data_mutex);
541 * Need to check if command has completed.
542 * If not try again later.
544 error = rmi_read(fn->rmi_dev, f54->fn->fd.command_base_addr,
547 dev_err(&fn->dev, "Failed to read back command\n");
550 if (command & F54_GET_REPORT) {
551 if (time_after(jiffies, f54->timeout)) {
552 dev_err(&fn->dev, "Get report command timed out\n");
559 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Get report command completed, reading data\n");
563 error = rmi_write_block(fn->rmi_dev,
564 fn->fd.data_base_addr + F54_FIFO_OFFSET,
567 dev_err(&fn->dev, "Failed to set fifo start offset\n");
571 error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr +
572 F54_REPORT_DATA_OFFSET, f54->report_data,
575 dev_err(&fn->dev, "%s: read [%d bytes] returned %d\n",
576 __func__, report_size, error);
581 f54->report_size = error ? 0 : report_size;
586 if (report_size == 0 && !error) {
587 queue_delayed_work(f54->workqueue, &f54->work,
588 msecs_to_jiffies(1));
590 f54->is_busy = false;
591 complete(&f54->cmd_done);
594 mutex_unlock(&f54->data_mutex);
597 static int rmi_f54_config(struct rmi_function *fn)
599 struct rmi_driver *drv = fn->rmi_dev->driver;
601 drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
606 static int rmi_f54_detect(struct rmi_function *fn)
609 struct f54_data *f54;
612 f54 = dev_get_drvdata(&fn->dev);
614 error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
617 dev_err(&fn->dev, "%s: Failed to query F54 properties\n",
622 f54->num_rx_electrodes = buf[0];
623 f54->num_tx_electrodes = buf[1];
624 f54->capabilities = buf[2];
625 f54->clock_rate = buf[3] | (buf[4] << 8);
626 f54->family = buf[5];
628 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "F54 num_rx_electrodes: %d\n",
629 f54->num_rx_electrodes);
630 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "F54 num_tx_electrodes: %d\n",
631 f54->num_tx_electrodes);
632 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "F54 capabilities: 0x%x\n",
634 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "F54 clock rate: 0x%x\n",
636 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "F54 family: 0x%x\n",
639 f54->is_busy = false;
644 static int rmi_f54_probe(struct rmi_function *fn)
646 struct f54_data *f54;
650 f54 = devm_kzalloc(&fn->dev, sizeof(struct f54_data), GFP_KERNEL);
655 dev_set_drvdata(&fn->dev, f54);
657 ret = rmi_f54_detect(fn);
661 mutex_init(&f54->data_mutex);
662 mutex_init(&f54->status_mutex);
664 rx = f54->num_rx_electrodes;
665 tx = f54->num_tx_electrodes;
666 f54->report_data = devm_kzalloc(&fn->dev,
667 array3_size(tx, rx, sizeof(u16)),
669 if (f54->report_data == NULL)
672 INIT_DELAYED_WORK(&f54->work, rmi_f54_work);
674 f54->workqueue = create_singlethread_workqueue("rmi4-poller");
678 rmi_f54_create_input_map(f54);
679 rmi_f54_set_input(f54, 0);
681 /* register video device */
682 strlcpy(f54->v4l2.name, F54_NAME, sizeof(f54->v4l2.name));
683 ret = v4l2_device_register(&fn->dev, &f54->v4l2);
685 dev_err(&fn->dev, "Unable to register video dev.\n");
689 /* initialize the queue */
690 mutex_init(&f54->lock);
691 f54->queue = rmi_f54_queue;
692 f54->queue.drv_priv = f54;
693 f54->queue.lock = &f54->lock;
694 f54->queue.dev = &fn->dev;
696 ret = vb2_queue_init(&f54->queue);
700 f54->vdev = rmi_f54_video_device;
701 f54->vdev.v4l2_dev = &f54->v4l2;
702 f54->vdev.lock = &f54->lock;
703 f54->vdev.vfl_dir = VFL_DIR_RX;
704 f54->vdev.queue = &f54->queue;
705 video_set_drvdata(&f54->vdev, f54);
707 ret = video_register_device(&f54->vdev, VFL_TYPE_TOUCH, -1);
709 dev_err(&fn->dev, "Unable to register video subdevice.");
716 v4l2_device_unregister(&f54->v4l2);
718 cancel_delayed_work_sync(&f54->work);
719 flush_workqueue(f54->workqueue);
720 destroy_workqueue(f54->workqueue);
724 static void rmi_f54_remove(struct rmi_function *fn)
726 struct f54_data *f54 = dev_get_drvdata(&fn->dev);
728 video_unregister_device(&f54->vdev);
729 v4l2_device_unregister(&f54->v4l2);
730 destroy_workqueue(f54->workqueue);
733 struct rmi_function_handler rmi_f54_handler = {
738 .probe = rmi_f54_probe,
739 .config = rmi_f54_config,
740 .remove = rmi_f54_remove,