rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/uvc-gadget/libuvc-camera/uvc_camera.cpp

1291 lines
37 KiB
C++
Executable File
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* libuvc-camera (camera link and rkaiq)
*
* Copyright (C) 2022 Rockchip Electronics Co., Ltd.
*
* Author: Bin Yang <yangbin@rock-chips.com>
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <inttypes.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <mediactl.h>
#include <mediactl/mediactl-priv.h>
#include <linux/v4l2-subdev.h>
#include <linux/videodev2.h>
#include <log/log.h>
#include <vector>
#include <map>
#include "rkisp_control_loop.h"
#include "rkisp_control_aiq.h"
#include "tinyxml2.h"
#include "uvc-camera.h"
#define CLEAR(x) memset(&(x), 0, sizeof(x))
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "UVC-RKCAM"
#define rkaiq_info(format, ...) ALOGI(format, ##__VA_ARGS__)
#define rkaiq_warn(format, ...) ALOGW(format, ##__VA_ARGS__)
#define rkaiq_err(format, ...) ALOGE(format, ##__VA_ARGS__)
/* Private v4l2 event */
#define CIFISP_V4L2_EVENT_STREAM_START \
(V4L2_EVENT_PRIVATE_START + 1)
#define CIFISP_V4L2_EVENT_STREAM_STOP \
(V4L2_EVENT_PRIVATE_START + 2)
#define FILE_PATH_LEN 64
#define CAMS_NUM_MAX 3
#define FLASH_NUM_MAX 3
#define MAX_MEDIA_DEV_NUM 2 * CAMS_NUM_MAX
enum media_type {
MEDIA_UNKNOWN = 0,
MEDIA_RKCIF,
MEDIA_RKISP
};
struct UVC_Cam_Info {
char dev_name[FILE_PATH_LEN];
char sensor_name[FILE_PATH_LEN];
char model_name[FILE_PATH_LEN];
char mipi_name[FILE_PATH_LEN];
char phy_name[FILE_PATH_LEN];
char isp_name[FILE_PATH_LEN];
struct v4l2_pix_format format;
};
/* The SensorDriverDescriptor instance that describes sensor device and
* connected sub-device informations.
* @sensor_entity_name,
* @sd_isp_path, the isp sub-device path, e.g. /dev/v4l-subdev0
* @vd_params_path, the params video device path
* @vd_stats_path, the stats video device path
* @cams, multipe cameras can attache to isp, but only one can be active
* @sd_sensor_path, the sensor sub-device path
* @sd_lens_path, the lens sub-device path that attached to sensor
* @sd_flash_path, the flash sub-device path that attached to sensor,
* can be two or more.
* @link_enabled, the link status of this sensor
*/
struct SensorDriverDescriptor {
/* sensor entity name format:
* m01_b_ov13850 1-0010, where 'm01' means
* module index number, 'b' means
* back or front, 'ov13850' is real
* sensor name, '1-0010' means the i2c bus
* and sensor i2c slave address
*/
int module_idx;
char sensor_entity_name[FILE_PATH_LEN];
char sd_sensor_path[FILE_PATH_LEN];
char sd_lens_path[FILE_PATH_LEN];
char sd_flash_path[FLASH_NUM_MAX][FILE_PATH_LEN];
bool link_enabled;
bool sensorLinkedToCIF;
char linkedModelName[32];
std::string mSensorName;
std::string mDeviceName;
std::string mParentMediaDev;
std::string mModuleRealSensorName; //parsed frome sensor entity name
std::string mModuleIndexStr; // parsed from sensor entity name
char mPhyModuleOrient; // parsed from sensor entity name
};
std::vector<struct SensorDriverDescriptor> mSensorInfos;
std::map<uint32_t, const char*> mHdrModeConfigs;
/* The media topology instance that describes video device and
* sub-device informations.
*
* @sd_isp_path, the isp sub-device path, e.g. /dev/v4l-subdev0
* @vd_params_path, the params video device path
* @vd_stats_path, the stats video device path
* @cams, multipe cameras can attache to isp, but only one can be active
* @sd_sensor_path, the sensor sub-device path
* @sd_lens_path, the lens sub-device path that attached to sensor
* @sd_flash_path, the flash sub-device path that attached to sensor,
* can be two or more.
* @link_enabled, the link status of this sensor
*/
struct rkisp_media_info {
char sd_isp_path[FILE_PATH_LEN];
char vd_params_path[FILE_PATH_LEN];
char vd_stats_path[FILE_PATH_LEN];
SensorDriverDescriptor sensorInfo;
const char *hdrmode;
char mdev_path[32];
int isp_fd;
int available;
void* aiq_ctx;
};
static struct rkisp_media_info media_infos[CAMS_NUM_MAX];
static struct UVC_Cam_Info uvc_cams[CAMS_NUM_MAX];
static void* rkisp_engine;
static const char *hdrmode = "NORMAL";
static int width = 2688;
static int height = 1520;
const char* kDefaultCfgPath = "/vendor/etc/multi_camera_config.xml";
static int xioctl(int fh, int request, void *arg)
{
int r;
do {
r = ioctl(fh, request, arg);
} while (-1 == r && EINTR == errno);
return r;
}
static int v4l2_subdev_open(struct media_entity *entity)
{
if (entity->fd != -1)
return 0;
entity->fd = open(entity->devname, O_RDWR);
if (entity->fd == -1) {
int ret = -errno;
rkaiq_err("%s: Failed to open subdev device node %s\n", __func__,
entity->devname);
return ret;
}
return 0;
}
static void v4l2_subdev_close(struct media_entity *entity)
{
close(entity->fd);
entity->fd = -1;
}
static int v4l2_subdev_get_format(struct media_entity *entity,
struct v4l2_mbus_framefmt *format)
{
struct v4l2_subdev_format fmt;
int ret = 0;
ret = v4l2_subdev_open(entity);
if (ret < 0)
return ret;
memset(&fmt, 0, sizeof(fmt));
fmt.pad = 0;
fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
ret = ioctl(entity->fd, VIDIOC_SUBDEV_G_FMT, &fmt);
if (ret < 0) {
ret = -errno;
goto err;
}
*format = fmt.format;
err:
v4l2_subdev_close(entity);
return ret;
}
static int rkisp_get_devname(struct media_device *device, const char *name,
char *dev_name)
{
const char *devname;
media_entity *entity = NULL;
entity = media_get_entity_by_name(device, name, strlen(name));
if (!entity)
return -1;
devname = media_entity_get_devname(entity);
if (!devname) {
rkaiq_err("can't find %s device path!", name);
return -1;
}
strncpy(dev_name, devname, FILE_PATH_LEN);
rkaiq_info("get %s devname: %s\n", name, dev_name);
return 0;
}
static int parseModuleInfo(const std::string &entity_name,
SensorDriverDescriptor &drv_info)
{
int ret = 0;
/*
* sensor entity name format SHOULD be like this:
* m00_b_ov13850 1-0010
*/
if (entity_name.empty())
return -1;
int parse_index = 0;
if (entity_name.at(parse_index) != 'm') {
rkaiq_err("%d:parse sensor entity name %s error at %d, "
"please check sensor driver !\n",
__LINE__, entity_name.c_str(), parse_index);
return -1;
}
std::string index_str = entity_name.substr (parse_index, 3);
drv_info.mModuleIndexStr = index_str;
parse_index += 3;
if (entity_name.at(parse_index) != '_') {
rkaiq_err("%d:parse sensor entity name %s error at %d, "
"please check sensor driver !\n",
__LINE__, entity_name.c_str(), parse_index);
return -1;
}
parse_index++;
if (entity_name.at(parse_index) != 'b' &&
entity_name.at(parse_index) != 'f') {
rkaiq_err("%d:parse sensor entity name %s error at %d, "
"please check sensor driver !\n",
__LINE__, entity_name.c_str(), parse_index);
return -1;
}
drv_info.mPhyModuleOrient = entity_name.at(parse_index);
parse_index++;
if (entity_name.at(parse_index) != '_') {
rkaiq_err("%d:parse sensor entity name %s error at %d, "
"please check sensor driver !\n",
__LINE__, entity_name.c_str(), parse_index);
return -1;
}
parse_index++;
std::size_t real_name_end = std::string::npos;
if ((real_name_end = entity_name.find(' ')) == std::string::npos) {
rkaiq_err("%d:parse sensor entity name %s error at %d, "
"please check sensor driver !\n",
__LINE__, entity_name.c_str(), parse_index);
return -1;
}
std::string real_name_str = entity_name.substr(parse_index, real_name_end - parse_index);
drv_info.mModuleRealSensorName = real_name_str;
rkaiq_info("%s:%d, real sensor name %s, module ori %c, module id %s\n",
__FUNCTION__, __LINE__, drv_info.mModuleRealSensorName.c_str(),
drv_info.mPhyModuleOrient, drv_info.mModuleIndexStr.c_str());
return ret;
}
static int rkisp_enumrate_modules (struct media_device *device)
{
uint32_t nents, i;
const char* subdev_path = NULL;
int active_sensor = -1;
SensorDriverDescriptor drvInfo;
int ret;
const struct media_device_info *info = NULL;
CLEAR(drvInfo);
drvInfo.mSensorName = "none";
drvInfo.link_enabled = false;
nents = media_get_entities_count (device);
for (i = 0; i < nents; ++i) {
int module_idx = -1;
struct media_entity *e;
const struct media_entity_desc *ef;
const struct media_link *link;
e = media_get_entity(device, i);
ef = media_entity_get_info(e);
if (ef->type != MEDIA_ENT_T_V4L2_SUBDEV_SENSOR &&
ef->type != MEDIA_ENT_T_V4L2_SUBDEV_FLASH &&
ef->type != MEDIA_ENT_T_V4L2_SUBDEV_LENS)
continue;
if (ef->name[0] != 'm' && ef->name[3] != '_') {
rkaiq_err("sensor/lens/flash entity name format is incorrect,"
"pls check driver version !\n");
return -1;
}
/* Retrive the sensor index from sensor name,
* which is indicated by two characters after 'm',
* e.g. m00_b_ov13850 1-0010
* ^^, 00 is the module index
*/
module_idx = atoi(ef->name + 1);
if (module_idx >= CAMS_NUM_MAX) {
rkaiq_err("multiple sensors more than two not supported, %s\n", ef->name);
continue;
}
subdev_path = media_entity_get_devname (e);
switch (ef->type) {
case MEDIA_ENT_T_V4L2_SUBDEV_SENSOR:
drvInfo.module_idx = module_idx;
drvInfo.mSensorName = ef->name;
strncpy(drvInfo.sd_sensor_path,
subdev_path, FILE_PATH_LEN);
strcpy(drvInfo.sensor_entity_name, ef->name);
rkaiq_info("%s(%d) sensor_entity_name(%s)\n",
__FUNCTION__, __LINE__, drvInfo.sensor_entity_name);
ret = parseModuleInfo(drvInfo.mSensorName, drvInfo);
link = media_entity_get_link(e, 0);
if (link && (link->flags & MEDIA_LNK_FL_ENABLED)) {
drvInfo.link_enabled = true;
} else {
rkaiq_info("%s(%d) sensor(%s) not linked!\n",
__FUNCTION__, __LINE__, drvInfo.mSensorName.c_str());
}
break;
case MEDIA_ENT_T_V4L2_SUBDEV_FLASH:
// TODO, support multiple flashes attached to one module
strncpy(drvInfo.sd_flash_path[0],
subdev_path, FILE_PATH_LEN);
break;
case MEDIA_ENT_T_V4L2_SUBDEV_LENS:
strncpy(drvInfo.sd_lens_path,
subdev_path, FILE_PATH_LEN);
break;
default:
break;
}
}
if (drvInfo.mSensorName != "none" && drvInfo.link_enabled) {
info = media_get_info(device);
if (info && !strncmp(info->driver, "rkcif", strlen("rkcif"))) {
drvInfo.sensorLinkedToCIF = true;
} else {
drvInfo.sensorLinkedToCIF = false;
}
strncpy(drvInfo.linkedModelName, info->model, sizeof(info->model));
rkaiq_info("module_idx(%d) sensor_entity_name(%s), linkedModelName(%s).\n",
drvInfo.module_idx, drvInfo.sensor_entity_name, drvInfo.linkedModelName);
mSensorInfos.push_back(drvInfo);
//media_infos[drvInfo.module_idx].sensorInfo = drvInfo;
} else {
rkaiq_info("media path: %s, no camera sensor found!\n", device->devnode);
}
return 0;
}
static bool compareFuncForSensorInfo(struct SensorDriverDescriptor s1,
struct SensorDriverDescriptor s2) {
return (s1.mModuleIndexStr < s2.mModuleIndexStr);
}
/* get sensor media info */
static int rkisp_get_sensor_info() {
int ret = 0;
unsigned int i, index = 0;
char sys_path[64];
int find_sensor = 0;
int find_isp = 0;
int linked_sensor = -1;
struct media_device *device = NULL;
while (index < MAX_MEDIA_DEV_NUM) {
snprintf(sys_path, 64, "/dev/media%d", index++);
//rkaiq_info("media get sys_path: %s\n", sys_path);
if(access(sys_path,F_OK))
continue;
device = media_device_new(sys_path);
if (device == NULL) {
rkaiq_err("Failed to create media %s\n", sys_path);
continue;
}
ret = media_device_enumerate(device);
if (ret < 0) {
rkaiq_err("Failed to enumerate %s (%d)\n", sys_path, ret);
media_device_unref(device);
continue;
}
ret = rkisp_enumrate_modules(device);
if (ret < 0) {
rkaiq_err("Failed to enumerate modules%s (%d)\n", sys_path, ret);
media_device_unref(device);
continue;
}
media_device_unref(device);
}
std:sort(mSensorInfos.begin(), mSensorInfos.end(), compareFuncForSensorInfo);
if (mSensorInfos.size() == 0) {
// No registered drivers found
rkaiq_err("ERROR no sensor driver registered in medias!\n");
ret = -1;
}
rkaiq_info("%s:%d, find available camera num:%d!\n", __FUNCTION__,
__LINE__, (unsigned int)mSensorInfos.size());
for (size_t i = 0; i < mSensorInfos.size(); i++) {
media_infos[i].sensorInfo = mSensorInfos[i];
rkaiq_info("media_infos: module_idx(%d) sensor_entity_name(%s)\n",
media_infos[i].sensorInfo.module_idx,
media_infos[i].sensorInfo.sensor_entity_name);
}
return ret;
}
/* Get sensor binded isp subdevs */
static int rkisp_enumrate_ispdev_info (struct media_device *device)
{
uint32_t nents, i;
const char* subdev_path = NULL;
int active_sensor = -1;
SensorDriverDescriptor drvInfo;
int ret;
const struct media_device_info *info = NULL;
char Temp[FILE_PATH_LEN];
CLEAR(drvInfo);
drvInfo.mSensorName = "none";
for (size_t i = 0; i < mSensorInfos.size(); i++) {
drvInfo = media_infos[i].sensorInfo;
rkaiq_info("@%s, Target sensor name: %s, candidate media: %s.\n",
__FUNCTION__, drvInfo.mSensorName.c_str(), device->devnode);
if (drvInfo.sensorLinkedToCIF) {
ret = rkisp_get_devname(device, drvInfo.linkedModelName, Temp);
if (ret < 0) {
rkaiq_err("%s is direct linked to sensor, not linked to cif!\n", device->devnode);
continue;
}
ret = rkisp_get_devname(device, "rkisp-isp-subdev", media_infos[i].sd_isp_path);
ret |= rkisp_get_devname(device, "rkisp-input-params", media_infos[i].vd_params_path);
ret |= rkisp_get_devname(device, "rkisp-statistics", media_infos[i].vd_stats_path);
strncpy(media_infos[i].mdev_path, device->devnode, sizeof(media_infos[i].mdev_path));
} else {
ret = rkisp_get_devname(device, drvInfo.sensor_entity_name, Temp);
if (ret < 0) {
rkaiq_err("%s not direct linked to sensor!\n", device->devnode);
continue;
}
ret = rkisp_get_devname(device, "rkisp-isp-subdev", media_infos[i].sd_isp_path);
ret |= rkisp_get_devname(device, "rkisp-input-params", media_infos[i].vd_params_path);
ret |= rkisp_get_devname(device, "rkisp-statistics", media_infos[i].vd_stats_path);
strncpy(media_infos[i].mdev_path, device->devnode, sizeof(media_infos[i].mdev_path));
}
}
return 0;
}
/* get sensor binded isp info */
static int rkisp_get_cif_linked_info() {
int ret = 0;
unsigned int i, index = 0;
char sys_path[64];
int find_sensor = 0;
int find_isp = 0;
int linked_sensor = -1;
struct media_device *device = NULL;
const struct media_device_info *info = NULL;
char model[64] = "\0";
while (index < MAX_MEDIA_DEV_NUM) {
info = NULL;
snprintf(sys_path, 64, "/dev/media%d", index++);
//rkaiq_info("media get sys_path: %s\n", sys_path);
if(access(sys_path,F_OK))
continue;
device = media_device_new(sys_path);
if (device == NULL) {
rkaiq_info("Failed to create media %s\n", sys_path);
continue;
}
ret = media_device_enumerate(device);
if (ret < 0) {
rkaiq_info("Failed to enumerate %s (%d)\n", sys_path, ret);
media_device_unref(device);
continue;
}
info = media_get_info(device);
if (info && !strncmp(info->driver, "rkcif", strlen("rkcif"))) {
rkaiq_info("media: %s is cif node, skip!\n", sys_path);
media_device_unref(device);
continue;
}
ret = rkisp_enumrate_ispdev_info(device);
if (ret < 0) {
rkaiq_err("Failed to enumerate ispdev info:%s (%d)\n", sys_path, ret);
media_device_unref(device);
continue;
}
media_device_unref(device);
}
return ret;
}
static int init_engine(struct rkisp_media_info *media_info)
{
int ret = 0;
for (int i = 0; i < CAMS_NUM_MAX; i++) {
if (!media_info->sensorInfo.link_enabled) {
rkaiq_info("Link disabled, skipped\n");
continue;
}
ret = rkisp_cl_rkaiq_init(&(media_info->aiq_ctx), NULL, NULL,
media_info->sensorInfo.sensor_entity_name);
if (ret) {
rkaiq_err("rkisp engine init failed !\n");
return -1;
}
/* Workaround: ISP read-back isuess */
if (mSensorInfos.size() > 2)
setMulCamConc(media_info->aiq_ctx, true);
break;
}
return 0;
}
static int prepare_engine(struct rkisp_media_info *media_info)
{
struct rkisp_cl_prepare_params_s params;
int ret = 0;
CLEAR(params);
params.isp_sd_node_path = media_info->sd_isp_path;
params.isp_vd_params_path = media_info->vd_params_path;
params.isp_vd_stats_path = media_info->vd_stats_path;
params.staticMeta = NULL;
params.width = width;
params.height = height;
params.work_mode = media_info->hdrmode;
rkaiq_info("%s--set workingmode(%s)\n", __FUNCTION__, params.work_mode);
for (int i = 0; i < CAMS_NUM_MAX; i++) {
if (!media_info->sensorInfo.link_enabled) {
rkaiq_info("Link disabled, skipped\n");
continue;
}
rkaiq_info("%s - %s: link enabled : %d\n",
media_info->sensorInfo.sd_sensor_path,
media_info->sensorInfo.sensor_entity_name,
media_info->sensorInfo.link_enabled);
if (strlen(media_info->sensorInfo.sd_lens_path))
params.lens_sd_node_path = media_info->sensorInfo.sd_lens_path;
if (strlen(media_info->sensorInfo.sd_flash_path[0]))
params.flashlight_sd_node_path[0] = media_info->sensorInfo.sd_flash_path[0];
params.sensor_sd_node_path = media_info->sensorInfo.sd_sensor_path;
if (rkisp_cl_prepare(media_info->aiq_ctx, &params)) {
rkaiq_err("rkisp engine prepare failed !\n");
return -1;
}
break;
}
return 0;
}
static int start_engine(struct rkisp_media_info *media_info)
{
rkaiq_info("rkaiq start\n");
rkisp_cl_start(media_info->aiq_ctx);
if (media_info->aiq_ctx == NULL) {
rkaiq_err("rkaiq_start engine failed\n");
return -1;
} else {
rkaiq_info("rkaiq_start engine succeed\n");
}
return 0;
}
static void stop_engine(struct rkisp_media_info *media_info)
{
rkisp_cl_stop(media_info->aiq_ctx);
}
static void deinit_engine(struct rkisp_media_info *media_info)
{
rkisp_cl_deinit(media_info->aiq_ctx);
if (media_info->aiq_ctx)
media_info->aiq_ctx = NULL;
}
/* engine process */
static int engine_process(struct rkisp_media_info *media_info)
{
int ret = 0;
int isp_fd;
isp_fd = open(media_info->vd_params_path, O_RDWR);
if (isp_fd < 0) {
rkaiq_err("open %s failed %s\n", media_info->vd_params_path, strerror(errno));
return -1;
}
ret = init_engine(media_info);
if (ret)
goto err_exit;
rkaiq_info("%s: init engine success...\n", media_info->mdev_path);
ret = prepare_engine(media_info);
if (ret)
goto err_exit;
rkaiq_info("%s: wait stream start event success ...\n", media_info->mdev_path);
ret = start_engine(media_info);
if (ret)
goto err_exit;
media_info->isp_fd = isp_fd;
err_exit:
return ret;
}
static bool updateModeList(tinyxml2::XMLElement* modeList,
std::map<uint32_t, const char*>& modeConfigs) {
using namespace tinyxml2;
rkaiq_info("@%s enter!\n", __FUNCTION__);
XMLElement* row = modeList->FirstChildElement("CameraId");
while (row != nullptr) {
uint32_t moduleId;
const char * mode = nullptr;
moduleId = row->UnsignedAttribute("moduleId"),
mode = row->Attribute("hdrmode");
if (mode == nullptr) {
rkaiq_err("%s: mode Config list must config mode!", __FUNCTION__);
return false;
}
modeConfigs.insert(std::make_pair(moduleId, mode));
row = row->NextSiblingElement("CameraId");
}
return true;
}
static int loadFromCfg(const char* cfgPath) {
using namespace tinyxml2;
XMLDocument configXml;
int errorID;
errorID = configXml.LoadFile(cfgPath);
if (errorID != XML_SUCCESS) {
rkaiq_err("%s: Unable to load aiq camera config file: %s. ErrorID: %d\n",
__FUNCTION__, cfgPath, errorID);
return errorID;
} else {
rkaiq_err("%s: load aiq camera config succeed!\n", __FUNCTION__);
}
XMLElement *aiqCamConfig = configXml.FirstChildElement("AiqCameraConfig");
if (aiqCamConfig == nullptr) {
rkaiq_err("%s: no aiq camera config specified\n", __FUNCTION__);
return -1;
}
XMLElement *modelist = aiqCamConfig->FirstChildElement("modeConfigList");
if (modelist == nullptr) {
rkaiq_info("%s: no mode list specified\n", __FUNCTION__);
} else {
if (!updateModeList(modelist, mHdrModeConfigs)) {
return -1;
}
}
return 0;
}
static int uvc_rkaiq_setBrightness(unsigned short level)
{
for (int i = 0; i < mSensorInfos.size(); i++) {
if ((&media_infos[i])->aiq_ctx)
rkisp_cl_setBrightness((&media_infos[i])->aiq_ctx, level);
}
rkaiq_info("uvc_rkaiq_setBrightness: %d \n", level);
return 0;
}
static int uvc_rkaiq_getBrightness(unsigned short *level)
{
if ((&media_infos[0])->aiq_ctx)
rkisp_cl_getBrightness((&media_infos[0])->aiq_ctx, (unsigned int *)level);
return 0;
}
static int uvc_rkaiq_setContrast(unsigned short level)
{
for (int i = 0; i < mSensorInfos.size(); i++) {
if ((&media_infos[i])->aiq_ctx)
rkisp_cl_setContrast((&media_infos[i])->aiq_ctx, level);
}
rkaiq_info("uvc_rkaiq_setContrast: %d \n", level);
return 0;
}
static int uvc_rkaiq_getContrast(unsigned short *level)
{
if ((&media_infos[0])->aiq_ctx)
rkisp_cl_getContrast((&media_infos[0])->aiq_ctx, (unsigned int *)level);
return 0;
}
static int uvc_rkaiq_setSaturation(unsigned short level)
{
for (int i = 0; i < mSensorInfos.size(); i++) {
if ((&media_infos[i])->aiq_ctx)
rkisp_cl_setSaturation((&media_infos[i])->aiq_ctx, level);
}
rkaiq_info("uvc_rkaiq_setSaturation: %d \n", level);
return 0;
}
static int uvc_rkaiq_getSaturation(unsigned short *level)
{
if ((&media_infos[0])->aiq_ctx)
rkisp_cl_getSaturation((&media_infos[0])->aiq_ctx, (unsigned int *)level);
return 0;
}
int uvc_rkaiq_ct(struct uvc_request_param *param, struct uvc_request_ct *ct)
{
unsigned char scan_mode = 0x0;
switch (param->cs) {
case UVC_CT_CONTROL_UNDEFINED:
break;
case UVC_CT_SCANNING_MODE_CONTROL:
if (param->dir == USB_TRAN_IN) {
ct->scan_mode[U_CUR] = 0x0;
ct->scan_mode[U_MIN] = 0x0;
ct->scan_mode[U_MAX] = 0x0;
ct->scan_mode[U_DEF] = 0x0;
ct->scan_mode[U_RES] = 0x0;
} else {
scan_mode = ct->scan_mode[U_CUR];
}
break;
case UVC_CT_AE_MODE_CONTROL:
case UVC_CT_AE_PRIORITY_CONTROL:
case UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL:
case UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL:
case UVC_CT_FOCUS_ABSOLUTE_CONTROL:
case UVC_CT_FOCUS_RELATIVE_CONTROL:
case UVC_CT_FOCUS_AUTO_CONTROL:
case UVC_CT_IRIS_ABSOLUTE_CONTROL:
case UVC_CT_IRIS_RELATIVE_CONTROL:
case UVC_CT_ZOOM_ABSOLUTE_CONTROL:
case UVC_CT_ZOOM_RELATIVE_CONTROL:
case UVC_CT_PANTILT_ABSOLUTE_CONTROL:
case UVC_CT_PANTILT_RELATIVE_CONTROL:
case UVC_CT_ROLL_ABSOLUTE_CONTROL:
case UVC_CT_ROLL_RELATIVE_CONTROL:
case UVC_CT_PRIVACY_CONTROL:
break;
default:
break;
}
return 0;
}
int uvc_rkaiq_pu(struct uvc_request_param *param, struct uvc_request_pu *pu)
{
switch (param->cs) {
case UVC_PU_CONTROL_UNDEFINED:
break;
case UVC_PU_BACKLIGHT_COMPENSATION_CONTROL:
break;
case UVC_PU_BRIGHTNESS_CONTROL:
if (param->dir == USB_TRAN_IN) {
uvc_rkaiq_getBrightness(&pu->brightness[U_CUR]);
pu->brightness[U_MIN] = 0;
pu->brightness[U_MAX] = 255;
pu->brightness[U_DEF] = 128;
} else if (param->dir == USB_TRAN_OUT) {
uvc_rkaiq_setBrightness(pu->brightness[U_CUR]);
}
break;
case UVC_PU_CONTRAST_CONTROL:
if (param->dir == USB_TRAN_IN) {
uvc_rkaiq_getContrast(&pu->contrast[U_CUR]);
pu->contrast[U_MIN] = 0;
pu->contrast[U_MAX] = 255;
pu->contrast[U_DEF] = 128;
} else if (param->dir == USB_TRAN_OUT) {
uvc_rkaiq_setContrast(pu->contrast[U_CUR]);
}
break;
case UVC_PU_GAIN_CONTROL:
pu->gain[U_CUR] = 0x0;
break;
case UVC_PU_POWER_LINE_FREQUENCY_CONTROL:
pu->pl_freq[U_CUR] = 0x0;
break;
case UVC_PU_HUE_CONTROL:
pu->hue[U_CUR] = 0x0;
break;
case UVC_PU_SATURATION_CONTROL:
if (param->dir == USB_TRAN_IN) {
uvc_rkaiq_getSaturation(&pu->saturation[U_CUR]);
pu->saturation[U_MIN] = 0;
pu->saturation[U_MAX] = 255;
pu->saturation[U_DEF] = 128;
} else if (param->dir == USB_TRAN_OUT) {
uvc_rkaiq_setSaturation(pu->saturation[U_CUR]);
}
break;
case UVC_PU_SHARPNESS_CONTROL:
pu->sharpness[U_CUR] = 0x0;
break;
case UVC_PU_GAMMA_CONTROL:
pu->gamma[U_CUR] = 0x0;
break;
case UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL:
pu->wb_temp[U_CUR] = 0x0;
break;
case UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL:
pu->wb_temp_auto[U_CUR] = 0x0;
break;
case UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL:
pu->wb_component[U_CUR] = 0x0;
break;
case UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL:
pu->wb_component_auto[U_CUR] = 0x0;
break;
case UVC_PU_DIGITAL_MULTIPLIER_CONTROL:
pu->digital_mult[U_CUR] = 0x0;
break;
case UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL:
pu->digital_mult_limit[U_CUR] = 0x0;
break;
case UVC_PU_HUE_AUTO_CONTROL:
pu->hue_auto[U_CUR] = 0x0;
break;
case UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL:
pu->analog_video[U_CUR] = 0x0;
break;
case UVC_PU_ANALOG_LOCK_STATUS_CONTROL:
pu->analog_lock[U_CUR] = 0x0;
break;
default:
break;
}
return 0;
}
int uvc_rkaiq_start(void)
{
int i = 0, ret = 0;
for (i = 0; i < mSensorInfos.size(); i++) {
rkaiq_info("uvc rkaiq start.\n");
engine_process(&media_infos[i]);
rkaiq_info("uvc rkaiq start success.\n");
}
return 0;
}
int uvc_rkaiq_stop(void)
{
int i = 0;
for (i = 0; i < mSensorInfos.size(); i++) {
rkaiq_info("uvc rkaiq stop.\n");
if (media_infos[i].isp_fd) {
stop_engine(&media_infos[i]);
deinit_engine(&media_infos[i]);
close(media_infos[i].isp_fd);
}
rkaiq_info("uvc rkaiq stop success.\n");
}
return 0;
}
static int uvc_camera_media_clr_index(unsigned int index)
{
char *command = NULL;
asprintf(&command,"/vendor/bin/media-ctl -d /dev/media%u -r", index);
system(command);
free(command);
rkaiq_info("clear rk camera media%u config.", index);
return 0;
}
static int uvc_camera_media_clr(void)
{
unsigned int index = 0;
char sys_path[64] = {0};
while (index < MAX_MEDIA_DEV_NUM) {
snprintf(sys_path, 64, "/dev/media%d", index);
if(!access(sys_path, F_OK))
uvc_camera_media_clr_index(index);
index++;
}
return 0;
}
static void camera_media_link(char media, const char *in_name, char in_num,
const char *out_name, char out_num, bool enable)
{
char *command = NULL;
asprintf(&command, "/vendor/bin/media-ctl -d /dev/media%u "
"-l '\"%s\":%u->\"%s\":%u[%d]'",
media, in_name, in_num, out_name, out_num, enable);
system(command);
free(command);
}
static int uvc_camera_media_cfg_index(enum media_type type,
unsigned int index, unsigned int cam_index)
{
const char *sensor_name = uvc_cams[cam_index].sensor_name;
const char *model_name = uvc_cams[cam_index].model_name;
const char *phy_name = uvc_cams[cam_index].phy_name;
const char *mipi_name = uvc_cams[cam_index].mipi_name;
const char *isp_name = uvc_cams[cam_index].isp_name;
const char *input_name = "rkisp-input-params";
#if defined(ISP_HW_V30)
if (type == MEDIA_RKCIF) {
camera_media_link(index, sensor_name, 0, phy_name, 0, 1);
camera_media_link(index, phy_name, 1, mipi_name, 0, 1);
camera_media_link(index, mipi_name, 1, "stream_cif_mipi_id0", 0, 1);
camera_media_link(index, mipi_name, 2, "stream_cif_mipi_id1", 0, 1);
camera_media_link(index, mipi_name, 3, "stream_cif_mipi_id2", 0, 1);
camera_media_link(index, mipi_name, 4, "stream_cif_mipi_id3", 0, 1);
camera_media_link(index, mipi_name, 5, "rkcif_scale_ch0", 0, 1);
camera_media_link(index, mipi_name, 6, "rkcif_scale_ch1", 0, 1);
camera_media_link(index, mipi_name, 7, "rkcif_scale_ch2", 0, 1);
camera_media_link(index, mipi_name, 8, "rkcif_scale_ch3", 0, 1);
} else if (type == MEDIA_RKISP) {
camera_media_link(index, model_name, 0, isp_name, 0, 1);
camera_media_link(index, input_name, 0, isp_name, 1, 1);
camera_media_link(index, isp_name, 3, "rkisp-statistics", 0, 1);
camera_media_link(index, isp_name, 2, "rkisp_mainpath", 0, 1);
camera_media_link(index, isp_name, 2, "rkisp_selfpath", 0, 1);
}
rkaiq_info("start rk3588 camera media%u config.", index);
#elif defined(ISP_HW_V21)
if (type == MEDIA_RKCIF) {
/* TODO */
} else if (type == MEDIA_RKISP) {
/* TODO */
}
rkaiq_info("start rk356x camera media%u config.", index);
#endif
return 0;
}
static int uvc_camera_media_cfg(unsigned int cam_num)
{
unsigned int index = 0;
unsigned int cam_index = 0;
char sys_path[64];
enum media_type type = MEDIA_UNKNOWN;
uvc_camera_media_clr();
while (index < MAX_MEDIA_DEV_NUM) {
snprintf(sys_path, 64, "/dev/media%d", index);
if(!access(sys_path, F_OK)) {
if (index < cam_num) {
type = MEDIA_RKCIF;
cam_index = index;
uvc_camera_media_cfg_index(type, index, cam_index);
} else if (index < 2*cam_num) {
type = MEDIA_RKISP;
cam_index = index - cam_num;
uvc_camera_media_cfg_index(type, index, cam_index);
}
}
index++;
}
return 0;
}
static enum media_type rkisp_get_device_info(struct media_device *device,
struct UVC_Cam_Info *uvc_cam)
{
uint32_t nents, i;
enum media_type type = MEDIA_UNKNOWN;
nents = media_get_entities_count (device);
for (i = 0; i < nents; ++i) {
const char* subdev_path = NULL;
struct media_entity *e;
const struct media_entity_desc *ef;
e = media_get_entity(device, i);
ef = media_entity_get_info(e);
subdev_path = media_entity_get_devname (e);
switch (ef->type) {
case MEDIA_ENT_T_V4L2_SUBDEV_SENSOR:
strcpy(uvc_cam->sensor_name, ef->name);
break;
case MEDIA_ENT_T_V4L2_SUBDEV:
if (strstr(ef->name, "dphy")) {
strcpy(uvc_cam->phy_name, ef->name);
} else if (strstr(ef->name, "mipi-csi")) {
strcpy(uvc_cam->mipi_name, ef->name);
type = MEDIA_RKCIF;
} else if (strstr(ef->name, "isp-subdev")) {
struct v4l2_mbus_framefmt format;
if (!v4l2_subdev_get_format(e, &format)) {
uvc_cam->format.width = format.width;
uvc_cam->format.height = format.height;
uvc_cam->format.pixelformat = format.code;
}
strcpy(uvc_cam->isp_name, ef->name);
type = MEDIA_RKISP;
} else if (strstr(ef->name, "lvds")) {
strcpy(uvc_cam->model_name, ef->name);
}
break;
case MEDIA_ENT_T_V4L2_VIDEO:
if (!strcmp(ef->name, "rkisp_mainpath"))
strcpy(uvc_cam->dev_name, subdev_path);
break;
default:
break;
}
}
return type;
}
static int rkisp_get_uvc_camera_info(unsigned int *cam_num)
{
int ret = 0;
unsigned int i, index = 0;
unsigned int cam_index = 0;
char sys_path[64];
struct media_device *device = NULL;
enum media_type type = MEDIA_UNKNOWN;
struct UVC_Cam_Info uvc_cam;
char devname[FILE_PATH_LEN];
CLEAR(uvc_cams);
while (index < MAX_MEDIA_DEV_NUM) {
snprintf(sys_path, 64, "/dev/media%d", index++);
if(access(sys_path,F_OK))
continue;
device = media_device_new(sys_path);
if (device == NULL) {
rkaiq_err("Failed to create media %s\n", sys_path);
continue;
}
ret = media_device_enumerate(device);
if (ret < 0) {
rkaiq_err("Failed to enumerate %s (%d)\n", sys_path, ret);
media_device_unref(device);
continue;
}
CLEAR(uvc_cam);
type = rkisp_get_device_info(device, &uvc_cam);
if (type == MEDIA_RKCIF) {
if ((cam_index >= CAMS_NUM_MAX) || ((index - 1) != cam_index)) {
rkaiq_err("get media cif info fail, index:%d, cam_index:%d, "
"CAMS_NUM_MAX:%d \n",
(index-1), cam_index, CAMS_NUM_MAX);
goto err;
}
memcpy(&uvc_cams[cam_index], &uvc_cam, sizeof(uvc_cam));
cam_index++;
} else if (type == MEDIA_RKISP) {
if (index - 1 < cam_index) {
rkaiq_err("get media isp info fail, index:%d, cam_index:%d\n",
(index-1), cam_index);
goto err;
}
memcpy(uvc_cams[index-cam_index-1].model_name, uvc_cam.model_name,
sizeof(uvc_cam.model_name));
memcpy(uvc_cams[index-cam_index-1].isp_name, uvc_cam.isp_name,
sizeof(uvc_cam.isp_name));
memcpy(uvc_cams[index-cam_index-1].dev_name, uvc_cam.dev_name,
sizeof(uvc_cam.dev_name));
memcpy(&uvc_cams[index-cam_index-1].format, &uvc_cam.format,
sizeof(uvc_cam.format));
}
err:
media_device_unref(device);
}
*cam_num = cam_index;
return ret;
}
int uvc_rkaiq_get_video(char ** cap_device, unsigned int index)
{
if (index >= CAMS_NUM_MAX) {
rkaiq_err("uvc get input device failed,"
"index:%d exceed %d\n", index, CAMS_NUM_MAX);
return -1;
}
*cap_device = uvc_cams[index].dev_name;
return 0;
}
int uvc_rkaiq_get_format(struct v4l2_pix_format *format, unsigned int index)
{
int ret = 0;
if (index >= CAMS_NUM_MAX) {
rkaiq_err("uvc get input format failed,"
"index:%d exceed %d\n", index, CAMS_NUM_MAX);
return -1;
}
*format = uvc_cams[index].format;
if (!format->width || !format->height) {
rkaiq_err("uvc get input size failed!\n");
ret = -1;
} else {
rkaiq_info("uvc get input size:%ux%u \n",
format->width, format->height);
}
return ret;
}
int uvc_rkaiq_init(bool link_en)
{
int i = 0;
unsigned int cam_num = 0;
CLEAR(media_infos);
mSensorInfos.clear();
mHdrModeConfigs.clear();
rkisp_get_uvc_camera_info(&cam_num);
if (link_en)
uvc_camera_media_cfg(cam_num);
/* get physical sensor infos */
if (rkisp_get_sensor_info()) {
rkaiq_err("Bad media topology error %d, %s\n", errno, strerror(errno));
return -errno;
}
/* get sensor binded isp infos */
if (rkisp_get_cif_linked_info()) {
rkaiq_err("Bad media info error %d, %s\n", errno, strerror(errno));
return -errno;
}
/* sensor mode config & mutex init */
loadFromCfg(kDefaultCfgPath);
if (mHdrModeConfigs.empty()) {
rkaiq_err("Using default hdr configs! (%s)\n", media_infos[i].mdev_path);
for (i = 0; i < mSensorInfos.size(); i++) {
media_infos[i].hdrmode = hdrmode;
}
} else {
for (i = 0; i < mSensorInfos.size(); i++) {
media_infos[i].hdrmode = mHdrModeConfigs[i];
rkaiq_info("camera:%d, hdrmode: %s.\n", i, media_infos[i].hdrmode);
}
}
return 0;
}
int uvc_rkaiq_deinit(bool link_en)
{
if (link_en)
uvc_camera_media_clr();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink