移动了文件位置

drivers/source/camera/csi-rtos/excam/ex_x3d.c

@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2022 Semidrive Semiconductor.
+ * All rights reserved.
+ */
+
+#include "ex_x3d.h"
+
+#define X3D_DEVICE_ID 0x58
+#define X3D_SERSOR_ADDR 0x2C
+
+#define CONFIG_OV_X3D_FPS 54
+
+#ifdef CONFIG_OV_X3D_FPS
+static uint32_t s_x3d_fps = CONFIG_OV_X3D_FPS;
+#else
+static uint32_t s_x3d_fps = 30;
+#endif
+
+#ifdef CONFIG_OV_X3D_W
+static uint32_t s_x3d_width = CONFIG_OV_X3D_W;
+#else
+static uint32_t s_x3d_width = 1280;
+#endif
+
+#ifdef CONFIG_OV_X3D_H
+static uint32_t s_x3d_height = CONFIG_OV_X3D_H;
+#else
+static uint32_t s_x3d_height = 720;
+#endif
+
+enum x3d_status {
+    SERSOR_IDLE,
+    SERSOR_STREAM_ON,
+};
+
+struct x3d_dev {
+    struct vdev_device vdev;
+    void *i2c_handle;
+    uint8_t sensor_addr; 
+
+    uint32_t gpio_pwn;
+    uint32_t gpio_intn;
+
+    osMutexId_t lock;
+    uint32_t status;
+};
+
+__UNUSED static int x3d_write_reg(struct x3d_dev *sensor, uint8_t reg, uint8_t val)
+{
+    uint8_t buf[2];
+    int ret = 0;
+
+    sensor_info("%s: addr=0x%x, reg=0x%x, val=0x%x\n", __func__,
+               sensor->sensor_addr, reg, val);
+    buf[0] = reg;
+    buf[1] = val;
+    ret = i2c_write(sensor->i2c_handle, sensor->sensor_addr, buf, 2);
+    if (ret < 0) {
+        sensor_err("%s: error: reg=0x%x, val=%x\n", __func__, reg, val);
+        return ret;
+    }
+
+    return ret;
+}
+
+__UNUSED static int x3d_read_reg(struct x3d_dev *sensor, uint8_t reg, uint8_t *val)
+{
+    uint8_t buf[1];
+    int ret = 0;
+
+    memset(buf, 0, sizeof(buf));
+    ret = i2c_write_read(sensor->i2c_handle, sensor->sensor_addr, &reg, 1, buf, 1);
+    if (ret < 0) {
+        sensor_err("%s: error: read reg=0x%02x\n", __func__, reg);
+        return ret;
+    }
+
+    *val = buf[0];
+    return 0;
+}
+
+static int x3d_check_chip_id(struct x3d_dev *sensor)
+{
+    sensor_info("%s\n", __func__);
+	return 0;
+}
+
+static int x3d_init_setup(struct x3d_dev *sensor)
+{
+    sensor_info("x3d init setup done\n");
+    return 0;
+}
+
+//extern gpio_dev_t g_gpio_safety;
+
+static int x3d_s_power(struct vdev_device *vdev, int enable)
+{
+    struct x3d_dev *sensor;
+    uint32_t pin;
+    //gpio_dev_t *gpio_dev = &g_gpio_safety;
+
+    if (!vdev) {
+        return -1;
+    }
+    sensor = (struct x3d_dev *)vdev->priv_data;
+    pin = sensor->gpio_pwn;
+
+    sensor_info("%s: pin %d,  enable %d\n", __func__, pin, enable);
+    //gpio_set(gpio_dev, pin, enable ? true : false);
+    //usleep_range(10000, 11000);
+    return 0;
+}
+
+static int x3d_enum_mbus_fmt(struct vdev_device *vdev,
+                               struct vdev_mbus_framefmt *fme)
+{
+    struct x3d_dev *sensor;
+
+    if ((vdev == NULL) || (fme == NULL)) {
+        return -1;
+    }
+
+    sensor = (struct x3d_dev *)vdev->priv_data;
+
+    if (fme->index > 0) {
+        fme->index = 0;
+        return -1;
+    }
+
+    fme->code = sensor->vdev.fmt.code;
+    fme->field = sensor->vdev.fmt.field;
+    fme->colorspace = sensor->vdev.fmt.colorspace;
+    return 0;
+}
+
+static int x3d_enum_frame_size(struct vdev_device *vdev,
+                                 struct vdev_frame_size_enum *fse)
+{
+    struct x3d_dev *sensor;
+
+    if (!vdev || !fse) {
+        return -1;
+    }
+
+    sensor = (struct x3d_dev *)vdev->priv_data;
+
+    if (fse->index > 0) {
+        fse->index = 0;
+        return -1;
+    }
+
+    fse->min_width = sensor->vdev.fmt.width;
+    fse->max_width = sensor->vdev.fmt.width;
+    fse->min_height = sensor->vdev.fmt.height;
+    fse->max_height = sensor->vdev.fmt.height;
+
+    return 0;
+}
+
+static int x3d_enum_frame_interval(struct vdev_device *vdev,
+                                     struct vdev_frame_interval_enum *fie)
+{
+    return 0;
+}
+
+static int x3d_get_frame_interval(struct vdev_device *vdev,
+                                    struct vdev_fract *fi)
+{
+    if (!vdev || !fi) {
+        return -1;
+    }
+
+    *fi = vdev->frame_interval;
+    return 0;
+}
+
+static int x3d_set_frame_interval(struct vdev_device *vdev,
+                                    struct vdev_fract fi)
+{
+    return 0;
+}
+
+static int x3d_get_fmt(struct vdev_device *vdev,
+                         struct vdev_mbus_framefmt *fmt)
+{
+    if (!vdev) {
+        return -1;
+    }
+
+    *fmt = vdev->fmt;
+    return 0;
+}
+
+static int x3d_set_fmt(struct vdev_device *vdev,
+                         struct vdev_mbus_framefmt fmt)
+{
+    return 0;
+}
+
+static int x3d_s_stream(struct vdev_device *vdev, int enable)
+{
+    int ret = 0;
+    struct x3d_dev *sensor;
+
+	printf("%s \r\n",__func__);
+    if (!vdev) {
+        return -1;
+    }
+
+    sensor = (struct x3d_dev *)vdev->priv_data;
+    osMutexAcquire(sensor->lock, 0);
+
+    if (enable == 1) {
+        if (sensor->status == SERSOR_STREAM_ON) {
+            sensor_info("%s: already stream on\n", __func__);
+            goto exit;
+        }
+
+        ret = x3d_init_setup(sensor);
+        if (ret < 0)
+            goto exit;
+
+        sensor->status = SERSOR_STREAM_ON;
+
+    } else {
+        sensor->status = SERSOR_IDLE;
+    }
+
+exit:
+    osMutexRelease(sensor->lock);
+    return ret;
+}
+
+static int x3d_deinit(struct vdev_device *vdev)
+{
+    struct x3d_dev *sensor;
+
+    if (!vdev) {
+        return -1;
+    }
+
+    sensor = (struct x3d_dev *)vdev->priv_data;
+    osMutexDelete(sensor->lock);
+    free(sensor);
+
+    return 0;
+}
+
+static const struct vdev_dev_ops x3d_vdev_ops = {
+    .s_power = x3d_s_power,
+    .enum_mbus_fmt = x3d_enum_mbus_fmt,
+    .enum_frame_size = x3d_enum_frame_size,
+    .enum_frame_interval = x3d_enum_frame_interval,
+    .g_frame_interval = x3d_get_frame_interval,
+    .s_frame_interval = x3d_set_frame_interval,
+    .get_fmt = x3d_get_fmt,
+    .set_fmt = x3d_set_fmt,
+    .s_stream = x3d_s_stream,
+    .close = x3d_deinit,
+};
+
+struct x3d_dev *g_x3d = NULL;
+
+struct vdev_device *x3d_init(void *init_data)
+{
+    int ret;
+    struct x3d_dev *sensor;
+    struct camera_res_cfg *cfg = (struct camera_res_cfg *)init_data;
+
+    sensor = malloc(sizeof(struct x3d_dev));
+    if (!sensor || !cfg)
+        return NULL;
+
+    memset(sensor, 0, sizeof(struct x3d_dev));
+    sensor->i2c_handle = cfg->i2c_handle;
+    sensor->sensor_addr = X3D_SERSOR_ADDR;
+
+    sensor->gpio_pwn = cfg->gpio[0];
+    sensor->gpio_intn = cfg->gpio[1];
+    sensor->vdev.priv_data = (void *)sensor;
+
+    sensor->lock = osMutexNew(NULL);
+
+    x3d_s_power(&sensor->vdev, 1);
+    ret = x3d_check_chip_id(sensor);
+    if (ret == 0)
+        x3d_s_stream(&sensor->vdev, 0);
+    x3d_s_power(&sensor->vdev, 0);
+    if (ret < 0)
+        goto err;
+
+    sensor->vdev.ep.bus_type = VDEV_MBUS_PARALLEL2;
+    sensor->vdev.frame_interval.numerator = 1;
+    sensor->vdev.frame_interval.denominator = s_x3d_fps;
+    sensor->vdev.fmt.width = s_x3d_width;
+    sensor->vdev.fmt.height = s_x3d_height;
+    sensor->vdev.fmt.code = VDEV_MBUS_FMT_YUYV;
+    sensor->vdev.fmt.field = VDEV_FIELD_NONE;
+    sensor->vdev.fmt.colorspace = VDEV_COLORSPACE_SRGB;
+    sensor->vdev.ops = x3d_vdev_ops;
+
+    g_x3d = sensor;
+    return &sensor->vdev;
+
+err:
+    free(sensor);
+    return NULL;
+}