1 // SPDX-License-Identifier: GPL-2.0
3 * video-i2c.c - Support for I2C transport video devices
5 * Copyright (C) 2018 Matt Ranostay <matt.ranostay@konsulko.com>
8 * - Panasonic AMG88xx Grid-Eye Sensors
9 * - Melexis MLX90640 Thermal Cameras
12 #include <linux/delay.h>
13 #include <linux/freezer.h>
14 #include <linux/hwmon.h>
15 #include <linux/kthread.h>
16 #include <linux/i2c.h>
17 #include <linux/list.h>
18 #include <linux/module.h>
19 #include <linux/mutex.h>
20 #include <linux/of_device.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/nvmem-provider.h>
23 #include <linux/regmap.h>
24 #include <linux/sched.h>
25 #include <linux/slab.h>
26 #include <linux/videodev2.h>
27 #include <media/v4l2-common.h>
28 #include <media/v4l2-device.h>
29 #include <media/v4l2-event.h>
30 #include <media/v4l2-fh.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/videobuf2-v4l2.h>
33 #include <media/videobuf2-vmalloc.h>
35 #define VIDEO_I2C_DRIVER "video-i2c"
37 struct video_i2c_chip;
39 struct video_i2c_buffer {
40 struct vb2_v4l2_buffer vb;
41 struct list_head list;
44 struct video_i2c_data {
45 struct regmap *regmap;
46 const struct video_i2c_chip *chip;
49 unsigned int sequence;
50 struct mutex queue_lock;
52 struct v4l2_device v4l2_dev;
53 struct video_device vdev;
54 struct vb2_queue vb_vidq;
56 struct task_struct *kthread_vid_cap;
57 struct list_head vid_cap_active;
59 struct v4l2_fract frame_interval;
62 static const struct v4l2_fmtdesc amg88xx_format = {
63 .pixelformat = V4L2_PIX_FMT_Y12,
66 static const struct v4l2_frmsize_discrete amg88xx_size = {
71 static const struct v4l2_fmtdesc mlx90640_format = {
72 .pixelformat = V4L2_PIX_FMT_Y16_BE,
75 static const struct v4l2_frmsize_discrete mlx90640_size = {
77 .height = 26, /* 24 lines of pixel data + 2 lines of processing data */
80 static const struct regmap_config amg88xx_regmap_config = {
86 static const struct regmap_config mlx90640_regmap_config = {
91 struct video_i2c_chip {
92 /* video dimensions */
93 const struct v4l2_fmtdesc *format;
94 const struct v4l2_frmsize_discrete *size;
96 /* available frame intervals */
97 const struct v4l2_fract *frame_intervals;
98 unsigned int num_frame_intervals;
100 /* pixel buffer size */
101 unsigned int buffer_size;
103 /* pixel size in bits */
106 const struct regmap_config *regmap_config;
107 struct nvmem_config *nvmem_config;
110 int (*setup)(struct video_i2c_data *data);
113 int (*xfer)(struct video_i2c_data *data, char *buf);
115 /* power control function */
116 int (*set_power)(struct video_i2c_data *data, bool on);
118 /* hwmon init function */
119 int (*hwmon_init)(struct video_i2c_data *data);
122 static int mlx90640_nvram_read(void *priv, unsigned int offset, void *val,
125 struct video_i2c_data *data = priv;
127 return regmap_bulk_read(data->regmap, 0x2400 + offset, val, bytes);
130 static struct nvmem_config mlx90640_nvram_config = {
131 .name = "mlx90640_nvram",
135 .reg_read = mlx90640_nvram_read,
138 /* Power control register */
139 #define AMG88XX_REG_PCTL 0x00
140 #define AMG88XX_PCTL_NORMAL 0x00
141 #define AMG88XX_PCTL_SLEEP 0x10
144 #define AMG88XX_REG_RST 0x01
145 #define AMG88XX_RST_FLAG 0x30
146 #define AMG88XX_RST_INIT 0x3f
148 /* Frame rate register */
149 #define AMG88XX_REG_FPSC 0x02
150 #define AMG88XX_FPSC_1FPS BIT(0)
152 /* Thermistor register */
153 #define AMG88XX_REG_TTHL 0x0e
155 /* Temperature register */
156 #define AMG88XX_REG_T01L 0x80
158 /* Control register */
159 #define MLX90640_REG_CTL1 0x800d
160 #define MLX90640_REG_CTL1_MASK 0x0380
161 #define MLX90640_REG_CTL1_MASK_SHIFT 7
163 static int amg88xx_xfer(struct video_i2c_data *data, char *buf)
165 return regmap_bulk_read(data->regmap, AMG88XX_REG_T01L, buf,
166 data->chip->buffer_size);
169 static int mlx90640_xfer(struct video_i2c_data *data, char *buf)
171 return regmap_bulk_read(data->regmap, 0x400, buf,
172 data->chip->buffer_size);
175 static int amg88xx_setup(struct video_i2c_data *data)
177 unsigned int mask = AMG88XX_FPSC_1FPS;
180 if (data->frame_interval.numerator == data->frame_interval.denominator)
185 return regmap_update_bits(data->regmap, AMG88XX_REG_FPSC, mask, val);
188 static int mlx90640_setup(struct video_i2c_data *data)
192 for (n = 0; n < data->chip->num_frame_intervals - 1; n++) {
193 if (V4L2_FRACT_COMPARE(data->frame_interval, ==,
194 data->chip->frame_intervals[n]))
198 idx = data->chip->num_frame_intervals - n - 1;
200 return regmap_update_bits(data->regmap, MLX90640_REG_CTL1,
201 MLX90640_REG_CTL1_MASK,
202 idx << MLX90640_REG_CTL1_MASK_SHIFT);
205 static int amg88xx_set_power_on(struct video_i2c_data *data)
209 ret = regmap_write(data->regmap, AMG88XX_REG_PCTL, AMG88XX_PCTL_NORMAL);
215 ret = regmap_write(data->regmap, AMG88XX_REG_RST, AMG88XX_RST_INIT);
219 usleep_range(2000, 3000);
221 ret = regmap_write(data->regmap, AMG88XX_REG_RST, AMG88XX_RST_FLAG);
226 * Wait two frames before reading thermistor and temperature registers
233 static int amg88xx_set_power_off(struct video_i2c_data *data)
237 ret = regmap_write(data->regmap, AMG88XX_REG_PCTL, AMG88XX_PCTL_SLEEP);
241 * Wait for a while to avoid resuming normal mode immediately after
242 * entering sleep mode, otherwise the device occasionally goes wrong
243 * (thermistor and temperature registers are not updated at all)
250 static int amg88xx_set_power(struct video_i2c_data *data, bool on)
253 return amg88xx_set_power_on(data);
255 return amg88xx_set_power_off(data);
258 #if IS_REACHABLE(CONFIG_HWMON)
260 static const u32 amg88xx_temp_config[] = {
265 static const struct hwmon_channel_info amg88xx_temp = {
267 .config = amg88xx_temp_config,
270 static const struct hwmon_channel_info *amg88xx_info[] = {
275 static umode_t amg88xx_is_visible(const void *drvdata,
276 enum hwmon_sensor_types type,
277 u32 attr, int channel)
282 static int amg88xx_read(struct device *dev, enum hwmon_sensor_types type,
283 u32 attr, int channel, long *val)
285 struct video_i2c_data *data = dev_get_drvdata(dev);
289 tmp = pm_runtime_resume_and_get(regmap_get_device(data->regmap));
293 tmp = regmap_bulk_read(data->regmap, AMG88XX_REG_TTHL, &buf, 2);
294 pm_runtime_mark_last_busy(regmap_get_device(data->regmap));
295 pm_runtime_put_autosuspend(regmap_get_device(data->regmap));
299 tmp = le16_to_cpu(buf);
302 * Check for sign bit, this isn't a two's complement value but an
303 * absolute temperature that needs to be inverted in the case of being
307 tmp = -(tmp & 0x7ff);
309 *val = (tmp * 625) / 10;
314 static const struct hwmon_ops amg88xx_hwmon_ops = {
315 .is_visible = amg88xx_is_visible,
316 .read = amg88xx_read,
319 static const struct hwmon_chip_info amg88xx_chip_info = {
320 .ops = &amg88xx_hwmon_ops,
321 .info = amg88xx_info,
324 static int amg88xx_hwmon_init(struct video_i2c_data *data)
326 struct device *dev = regmap_get_device(data->regmap);
327 void *hwmon = devm_hwmon_device_register_with_info(dev, "amg88xx", data,
328 &amg88xx_chip_info, NULL);
330 return PTR_ERR_OR_ZERO(hwmon);
333 #define amg88xx_hwmon_init NULL
341 static const struct v4l2_fract amg88xx_frame_intervals[] = {
346 static const struct v4l2_fract mlx90640_frame_intervals[] = {
357 static const struct video_i2c_chip video_i2c_chip[] = {
359 .size = &amg88xx_size,
360 .format = &amg88xx_format,
361 .frame_intervals = amg88xx_frame_intervals,
362 .num_frame_intervals = ARRAY_SIZE(amg88xx_frame_intervals),
365 .regmap_config = &amg88xx_regmap_config,
366 .setup = &amg88xx_setup,
367 .xfer = &amg88xx_xfer,
368 .set_power = amg88xx_set_power,
369 .hwmon_init = amg88xx_hwmon_init,
372 .size = &mlx90640_size,
373 .format = &mlx90640_format,
374 .frame_intervals = mlx90640_frame_intervals,
375 .num_frame_intervals = ARRAY_SIZE(mlx90640_frame_intervals),
378 .regmap_config = &mlx90640_regmap_config,
379 .nvmem_config = &mlx90640_nvram_config,
380 .setup = mlx90640_setup,
381 .xfer = mlx90640_xfer,
385 static const struct v4l2_file_operations video_i2c_fops = {
386 .owner = THIS_MODULE,
387 .open = v4l2_fh_open,
388 .release = vb2_fop_release,
389 .poll = vb2_fop_poll,
390 .read = vb2_fop_read,
391 .mmap = vb2_fop_mmap,
392 .unlocked_ioctl = video_ioctl2,
395 static int queue_setup(struct vb2_queue *vq,
396 unsigned int *nbuffers, unsigned int *nplanes,
397 unsigned int sizes[], struct device *alloc_devs[])
399 struct video_i2c_data *data = vb2_get_drv_priv(vq);
400 unsigned int size = data->chip->buffer_size;
402 if (vq->num_buffers + *nbuffers < 2)
406 return sizes[0] < size ? -EINVAL : 0;
414 static int buffer_prepare(struct vb2_buffer *vb)
416 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
417 struct video_i2c_data *data = vb2_get_drv_priv(vb->vb2_queue);
418 unsigned int size = data->chip->buffer_size;
420 if (vb2_plane_size(vb, 0) < size)
423 vbuf->field = V4L2_FIELD_NONE;
424 vb2_set_plane_payload(vb, 0, size);
429 static void buffer_queue(struct vb2_buffer *vb)
431 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
432 struct video_i2c_data *data = vb2_get_drv_priv(vb->vb2_queue);
433 struct video_i2c_buffer *buf =
434 container_of(vbuf, struct video_i2c_buffer, vb);
436 spin_lock(&data->slock);
437 list_add_tail(&buf->list, &data->vid_cap_active);
438 spin_unlock(&data->slock);
441 static int video_i2c_thread_vid_cap(void *priv)
443 struct video_i2c_data *data = priv;
444 unsigned int delay = mult_frac(HZ, data->frame_interval.numerator,
445 data->frame_interval.denominator);
450 unsigned long start_jiffies = jiffies;
451 struct video_i2c_buffer *vid_cap_buf = NULL;
456 spin_lock(&data->slock);
458 if (!list_empty(&data->vid_cap_active)) {
459 vid_cap_buf = list_last_entry(&data->vid_cap_active,
460 struct video_i2c_buffer, list);
461 list_del(&vid_cap_buf->list);
464 spin_unlock(&data->slock);
467 struct vb2_buffer *vb2_buf = &vid_cap_buf->vb.vb2_buf;
468 void *vbuf = vb2_plane_vaddr(vb2_buf, 0);
471 ret = data->chip->xfer(data, vbuf);
472 vb2_buf->timestamp = ktime_get_ns();
473 vid_cap_buf->vb.sequence = data->sequence++;
474 vb2_buffer_done(vb2_buf, ret ?
475 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
478 schedule_delay = delay - (jiffies - start_jiffies);
480 if (time_after(jiffies, start_jiffies + delay))
481 schedule_delay = delay;
483 schedule_timeout_interruptible(schedule_delay);
484 } while (!kthread_should_stop());
489 static void video_i2c_del_list(struct vb2_queue *vq, enum vb2_buffer_state state)
491 struct video_i2c_data *data = vb2_get_drv_priv(vq);
492 struct video_i2c_buffer *buf, *tmp;
494 spin_lock(&data->slock);
496 list_for_each_entry_safe(buf, tmp, &data->vid_cap_active, list) {
497 list_del(&buf->list);
498 vb2_buffer_done(&buf->vb.vb2_buf, state);
501 spin_unlock(&data->slock);
504 static int start_streaming(struct vb2_queue *vq, unsigned int count)
506 struct video_i2c_data *data = vb2_get_drv_priv(vq);
507 struct device *dev = regmap_get_device(data->regmap);
510 if (data->kthread_vid_cap)
513 ret = pm_runtime_resume_and_get(dev);
517 ret = data->chip->setup(data);
522 data->kthread_vid_cap = kthread_run(video_i2c_thread_vid_cap, data,
523 "%s-vid-cap", data->v4l2_dev.name);
524 ret = PTR_ERR_OR_ZERO(data->kthread_vid_cap);
529 pm_runtime_mark_last_busy(dev);
530 pm_runtime_put_autosuspend(dev);
532 video_i2c_del_list(vq, VB2_BUF_STATE_QUEUED);
537 static void stop_streaming(struct vb2_queue *vq)
539 struct video_i2c_data *data = vb2_get_drv_priv(vq);
541 if (data->kthread_vid_cap == NULL)
544 kthread_stop(data->kthread_vid_cap);
545 data->kthread_vid_cap = NULL;
546 pm_runtime_mark_last_busy(regmap_get_device(data->regmap));
547 pm_runtime_put_autosuspend(regmap_get_device(data->regmap));
549 video_i2c_del_list(vq, VB2_BUF_STATE_ERROR);
552 static const struct vb2_ops video_i2c_video_qops = {
553 .queue_setup = queue_setup,
554 .buf_prepare = buffer_prepare,
555 .buf_queue = buffer_queue,
556 .start_streaming = start_streaming,
557 .stop_streaming = stop_streaming,
558 .wait_prepare = vb2_ops_wait_prepare,
559 .wait_finish = vb2_ops_wait_finish,
562 static int video_i2c_querycap(struct file *file, void *priv,
563 struct v4l2_capability *vcap)
565 struct video_i2c_data *data = video_drvdata(file);
566 struct device *dev = regmap_get_device(data->regmap);
567 struct i2c_client *client = to_i2c_client(dev);
569 strscpy(vcap->driver, data->v4l2_dev.name, sizeof(vcap->driver));
570 strscpy(vcap->card, data->vdev.name, sizeof(vcap->card));
572 sprintf(vcap->bus_info, "I2C:%d-%d", client->adapter->nr, client->addr);
577 static int video_i2c_g_input(struct file *file, void *fh, unsigned int *inp)
584 static int video_i2c_s_input(struct file *file, void *fh, unsigned int inp)
586 return (inp > 0) ? -EINVAL : 0;
589 static int video_i2c_enum_input(struct file *file, void *fh,
590 struct v4l2_input *vin)
595 strscpy(vin->name, "Camera", sizeof(vin->name));
597 vin->type = V4L2_INPUT_TYPE_CAMERA;
602 static int video_i2c_enum_fmt_vid_cap(struct file *file, void *fh,
603 struct v4l2_fmtdesc *fmt)
605 struct video_i2c_data *data = video_drvdata(file);
606 enum v4l2_buf_type type = fmt->type;
611 *fmt = *data->chip->format;
617 static int video_i2c_enum_framesizes(struct file *file, void *fh,
618 struct v4l2_frmsizeenum *fsize)
620 const struct video_i2c_data *data = video_drvdata(file);
621 const struct v4l2_frmsize_discrete *size = data->chip->size;
623 /* currently only one frame size is allowed */
624 if (fsize->index > 0)
627 if (fsize->pixel_format != data->chip->format->pixelformat)
630 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
631 fsize->discrete.width = size->width;
632 fsize->discrete.height = size->height;
637 static int video_i2c_enum_frameintervals(struct file *file, void *priv,
638 struct v4l2_frmivalenum *fe)
640 const struct video_i2c_data *data = video_drvdata(file);
641 const struct v4l2_frmsize_discrete *size = data->chip->size;
643 if (fe->index >= data->chip->num_frame_intervals)
646 if (fe->width != size->width || fe->height != size->height)
649 fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
650 fe->discrete = data->chip->frame_intervals[fe->index];
655 static int video_i2c_try_fmt_vid_cap(struct file *file, void *fh,
656 struct v4l2_format *fmt)
658 const struct video_i2c_data *data = video_drvdata(file);
659 const struct v4l2_frmsize_discrete *size = data->chip->size;
660 struct v4l2_pix_format *pix = &fmt->fmt.pix;
661 unsigned int bpp = data->chip->bpp / 8;
663 pix->width = size->width;
664 pix->height = size->height;
665 pix->pixelformat = data->chip->format->pixelformat;
666 pix->field = V4L2_FIELD_NONE;
667 pix->bytesperline = pix->width * bpp;
668 pix->sizeimage = pix->bytesperline * pix->height;
669 pix->colorspace = V4L2_COLORSPACE_RAW;
674 static int video_i2c_s_fmt_vid_cap(struct file *file, void *fh,
675 struct v4l2_format *fmt)
677 struct video_i2c_data *data = video_drvdata(file);
679 if (vb2_is_busy(&data->vb_vidq))
682 return video_i2c_try_fmt_vid_cap(file, fh, fmt);
685 static int video_i2c_g_parm(struct file *filp, void *priv,
686 struct v4l2_streamparm *parm)
688 struct video_i2c_data *data = video_drvdata(filp);
690 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
693 parm->parm.capture.readbuffers = 1;
694 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
695 parm->parm.capture.timeperframe = data->frame_interval;
700 static int video_i2c_s_parm(struct file *filp, void *priv,
701 struct v4l2_streamparm *parm)
703 struct video_i2c_data *data = video_drvdata(filp);
706 for (i = 0; i < data->chip->num_frame_intervals - 1; i++) {
707 if (V4L2_FRACT_COMPARE(parm->parm.capture.timeperframe, <=,
708 data->chip->frame_intervals[i]))
711 data->frame_interval = data->chip->frame_intervals[i];
713 return video_i2c_g_parm(filp, priv, parm);
716 static const struct v4l2_ioctl_ops video_i2c_ioctl_ops = {
717 .vidioc_querycap = video_i2c_querycap,
718 .vidioc_g_input = video_i2c_g_input,
719 .vidioc_s_input = video_i2c_s_input,
720 .vidioc_enum_input = video_i2c_enum_input,
721 .vidioc_enum_fmt_vid_cap = video_i2c_enum_fmt_vid_cap,
722 .vidioc_enum_framesizes = video_i2c_enum_framesizes,
723 .vidioc_enum_frameintervals = video_i2c_enum_frameintervals,
724 .vidioc_g_fmt_vid_cap = video_i2c_try_fmt_vid_cap,
725 .vidioc_s_fmt_vid_cap = video_i2c_s_fmt_vid_cap,
726 .vidioc_g_parm = video_i2c_g_parm,
727 .vidioc_s_parm = video_i2c_s_parm,
728 .vidioc_try_fmt_vid_cap = video_i2c_try_fmt_vid_cap,
729 .vidioc_reqbufs = vb2_ioctl_reqbufs,
730 .vidioc_create_bufs = vb2_ioctl_create_bufs,
731 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
732 .vidioc_querybuf = vb2_ioctl_querybuf,
733 .vidioc_qbuf = vb2_ioctl_qbuf,
734 .vidioc_dqbuf = vb2_ioctl_dqbuf,
735 .vidioc_streamon = vb2_ioctl_streamon,
736 .vidioc_streamoff = vb2_ioctl_streamoff,
739 static void video_i2c_release(struct video_device *vdev)
741 struct video_i2c_data *data = video_get_drvdata(vdev);
743 v4l2_device_unregister(&data->v4l2_dev);
744 mutex_destroy(&data->lock);
745 mutex_destroy(&data->queue_lock);
746 regmap_exit(data->regmap);
750 static int video_i2c_probe(struct i2c_client *client,
751 const struct i2c_device_id *id)
753 struct video_i2c_data *data;
754 struct v4l2_device *v4l2_dev;
755 struct vb2_queue *queue;
758 data = kzalloc(sizeof(*data), GFP_KERNEL);
762 if (dev_fwnode(&client->dev))
763 data->chip = device_get_match_data(&client->dev);
765 data->chip = &video_i2c_chip[id->driver_data];
767 goto error_free_device;
769 data->regmap = regmap_init_i2c(client, data->chip->regmap_config);
770 if (IS_ERR(data->regmap)) {
771 ret = PTR_ERR(data->regmap);
772 goto error_free_device;
775 v4l2_dev = &data->v4l2_dev;
776 strscpy(v4l2_dev->name, VIDEO_I2C_DRIVER, sizeof(v4l2_dev->name));
778 ret = v4l2_device_register(&client->dev, v4l2_dev);
780 goto error_regmap_exit;
782 mutex_init(&data->lock);
783 mutex_init(&data->queue_lock);
785 queue = &data->vb_vidq;
786 queue->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
787 queue->io_modes = VB2_DMABUF | VB2_MMAP | VB2_USERPTR | VB2_READ;
788 queue->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
789 queue->drv_priv = data;
790 queue->buf_struct_size = sizeof(struct video_i2c_buffer);
791 queue->min_buffers_needed = 1;
792 queue->ops = &video_i2c_video_qops;
793 queue->mem_ops = &vb2_vmalloc_memops;
795 ret = vb2_queue_init(queue);
797 goto error_unregister_device;
799 data->vdev.queue = queue;
800 data->vdev.queue->lock = &data->queue_lock;
802 snprintf(data->vdev.name, sizeof(data->vdev.name),
803 "I2C %d-%d Transport Video",
804 client->adapter->nr, client->addr);
806 data->vdev.v4l2_dev = v4l2_dev;
807 data->vdev.fops = &video_i2c_fops;
808 data->vdev.lock = &data->lock;
809 data->vdev.ioctl_ops = &video_i2c_ioctl_ops;
810 data->vdev.release = video_i2c_release;
811 data->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
812 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
814 spin_lock_init(&data->slock);
815 INIT_LIST_HEAD(&data->vid_cap_active);
817 data->frame_interval = data->chip->frame_intervals[0];
819 video_set_drvdata(&data->vdev, data);
820 i2c_set_clientdata(client, data);
822 if (data->chip->set_power) {
823 ret = data->chip->set_power(data, true);
825 goto error_unregister_device;
828 pm_runtime_get_noresume(&client->dev);
829 pm_runtime_set_active(&client->dev);
830 pm_runtime_enable(&client->dev);
831 pm_runtime_set_autosuspend_delay(&client->dev, 2000);
832 pm_runtime_use_autosuspend(&client->dev);
834 if (data->chip->hwmon_init) {
835 ret = data->chip->hwmon_init(data);
837 dev_warn(&client->dev,
838 "failed to register hwmon device\n");
842 if (data->chip->nvmem_config) {
843 struct nvmem_config *config = data->chip->nvmem_config;
844 struct nvmem_device *device;
847 config->dev = &client->dev;
849 device = devm_nvmem_register(&client->dev, config);
851 if (IS_ERR(device)) {
852 dev_warn(&client->dev,
853 "failed to register nvmem device\n");
857 ret = video_register_device(&data->vdev, VFL_TYPE_VIDEO, -1);
859 goto error_pm_disable;
861 pm_runtime_mark_last_busy(&client->dev);
862 pm_runtime_put_autosuspend(&client->dev);
867 pm_runtime_disable(&client->dev);
868 pm_runtime_set_suspended(&client->dev);
869 pm_runtime_put_noidle(&client->dev);
871 if (data->chip->set_power)
872 data->chip->set_power(data, false);
874 error_unregister_device:
875 v4l2_device_unregister(v4l2_dev);
876 mutex_destroy(&data->lock);
877 mutex_destroy(&data->queue_lock);
880 regmap_exit(data->regmap);
888 static int video_i2c_remove(struct i2c_client *client)
890 struct video_i2c_data *data = i2c_get_clientdata(client);
892 pm_runtime_get_sync(&client->dev);
893 pm_runtime_disable(&client->dev);
894 pm_runtime_set_suspended(&client->dev);
895 pm_runtime_put_noidle(&client->dev);
897 if (data->chip->set_power)
898 data->chip->set_power(data, false);
900 video_unregister_device(&data->vdev);
907 static int video_i2c_pm_runtime_suspend(struct device *dev)
909 struct video_i2c_data *data = i2c_get_clientdata(to_i2c_client(dev));
911 if (!data->chip->set_power)
914 return data->chip->set_power(data, false);
917 static int video_i2c_pm_runtime_resume(struct device *dev)
919 struct video_i2c_data *data = i2c_get_clientdata(to_i2c_client(dev));
921 if (!data->chip->set_power)
924 return data->chip->set_power(data, true);
929 static const struct dev_pm_ops video_i2c_pm_ops = {
930 SET_RUNTIME_PM_OPS(video_i2c_pm_runtime_suspend,
931 video_i2c_pm_runtime_resume, NULL)
934 static const struct i2c_device_id video_i2c_id_table[] = {
935 { "amg88xx", AMG88XX },
936 { "mlx90640", MLX90640 },
939 MODULE_DEVICE_TABLE(i2c, video_i2c_id_table);
941 static const struct of_device_id video_i2c_of_match[] = {
942 { .compatible = "panasonic,amg88xx", .data = &video_i2c_chip[AMG88XX] },
943 { .compatible = "melexis,mlx90640", .data = &video_i2c_chip[MLX90640] },
946 MODULE_DEVICE_TABLE(of, video_i2c_of_match);
948 static struct i2c_driver video_i2c_driver = {
950 .name = VIDEO_I2C_DRIVER,
951 .of_match_table = video_i2c_of_match,
952 .pm = &video_i2c_pm_ops,
954 .probe = video_i2c_probe,
955 .remove = video_i2c_remove,
956 .id_table = video_i2c_id_table,
959 module_i2c_driver(video_i2c_driver);
961 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
962 MODULE_DESCRIPTION("I2C transport video support");
963 MODULE_LICENSE("GPL v2");