| /* | |
| * Copyright (C) 2019 MediaTek Inc. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #define LOG_TAG "MediaCtrlConfig" | |
| #include <mtklibv4l2/MediaCtrlConfig.h> | |
| #include <mtklibv4l2/MtkMediaController.h> | |
| #include <string> | |
| #include <dirent.h> | |
| #include <sys/types.h> | |
| #include <sys/stat.h> | |
| using NSCam::BAD_VALUE; | |
| using NSCam::NAME_NOT_FOUND; | |
| using NSCam::NO_ERROR; | |
| using NSCam::NO_INIT; | |
| using NSCam::OK; | |
| using NSCam::PERMISSION_DENIED; | |
| using NSCam::UNKNOWN_ERROR; | |
| #define DEFAULT_PADIDX 0 | |
| // the following define could be found in DIP-V4L2's device topology | |
| enum Dip_Subdevice_Pad_Index { | |
| eP2_RAW_INPUT_PADIDX = 0, | |
| eP2_TUNING_PADIDX, | |
| eP2_VIPI_INPUT_PADIDX, | |
| eP2_LCEI_INPUT_PADIDX, | |
| eP2_MDP0_PADIDX, | |
| eP2_MDP1_PADIDX, | |
| eP2_IMG2_PADIDX, | |
| eP2_IMG3_PADIDX, | |
| }; | |
| // the following define could be found in P1-V4L2's device topology | |
| enum Cam_Subdevice_Pad_Index { | |
| eP1_META_INPUT_PADIDX = 0, | |
| eP1_MAINSTREAM_PADIDX, | |
| eP1_PACKEDOUT_PADIDX, | |
| eP1_META0_PADIDX, | |
| eP1_META1_PADIDX, | |
| eP1_META2_PADIDX, | |
| eP1_META3_PADIDX, | |
| }; | |
| static std::map<MediaDeviceTag, MediaCtrl_P1Topology> gMediaCtrl_P1Topology = { | |
| {MEDIA_CONTROLLER_P1_OUT1, | |
| {MEDIA_CONTROLLER_P1_OUT1, "mtk-cam-p1", "mtk-cam-p1", | |
| "mtk-cam-p1 meta input", "mtk-cam-p1 partial meta 0", | |
| "mtk-cam-p1 partial meta 1", "mtk-cam-p1 partial meta 2", | |
| "mtk-cam-p1 partial meta 3", "mtk-cam-p1 main stream", ""}}, | |
| {MEDIA_CONTROLLER_P1_OUT2, | |
| {MEDIA_CONTROLLER_P1_OUT2, "mtk-cam-p1", "mtk-cam-p1", | |
| "mtk-cam-p1 meta input", "mtk-cam-p1 partial meta 0", | |
| "mtk-cam-p1 partial meta 1", "mtk-cam-p1 partial meta 2", | |
| "mtk-cam-p1 partial meta 3", "mtk-cam-p1 main stream", | |
| "mtk-cam-p1 packed out"}}, | |
| }; | |
| static std::map<MediaDeviceTag, MediaCtrl_P2Topology> gMediaCtrl_P2Topology = { | |
| {MEDIA_CONTROLLER_P2_Preview_OUT1, | |
| {MEDIA_CONTROLLER_P2_Preview_OUT1, "mtk-cam-dip", "mtk-cam-dip preview", | |
| "mtk-cam-dip preview Raw Input", "mtk-cam-dip preview Tuning", | |
| "mtk-cam-dip preview MDP0", ""}}, | |
| {MEDIA_CONTROLLER_P2_Preview_OUT2, | |
| {MEDIA_CONTROLLER_P2_Preview_OUT2, "mtk-cam-dip", "mtk-cam-dip preview", | |
| "mtk-cam-dip preview Raw Input", "mtk-cam-dip preview Tuning", | |
| "mtk-cam-dip preview MDP0", "mtk-cam-dip preview MDP1"}}, | |
| {MEDIA_CONTROLLER_P2_Capture_OUT1, | |
| {MEDIA_CONTROLLER_P2_Capture_OUT1, "mtk-cam-dip", "mtk-cam-dip capture", | |
| "mtk-cam-dip capture Raw Input", "mtk-cam-dip capture Tuning", | |
| "mtk-cam-dip capture MDP0", ""}}, | |
| {MEDIA_CONTROLLER_P2_Capture_OUT2, | |
| {MEDIA_CONTROLLER_P2_Capture_OUT2, "mtk-cam-dip", "mtk-cam-dip capture", | |
| "mtk-cam-dip capture Raw Input", "mtk-cam-dip capture Tuning", | |
| "mtk-cam-dip capture MDP0", "mtk-cam-dip capture MDP1"}}, | |
| {MEDIA_CONTROLLER_P2_Record_OUT1, | |
| {MEDIA_CONTROLLER_P2_Record_OUT1, "mtk-cam-dip", "mtk-cam-dip preview", | |
| "mtk-cam-dip preview Raw Input", "mtk-cam-dip preview Tuning", | |
| "mtk-cam-dip preview MDP0", ""}}, | |
| {MEDIA_CONTROLLER_P2_Record_OUT2, | |
| {MEDIA_CONTROLLER_P2_Record_OUT2, "mtk-cam-dip", "mtk-cam-dip preview", | |
| "mtk-cam-dip preview Raw Input", "mtk-cam-dip preview Tuning", | |
| "mtk-cam-dip preview MDP0", "mtk-cam-dip preview MDP1"}}, | |
| {MEDIA_CONTROLLER_P2_Reprocessing_OUT1, | |
| {MEDIA_CONTROLLER_P2_Reprocessing_OUT1, "mtk-cam-dip", | |
| "mtk-cam-dip reprocess", "mtk-cam-dip reprocess Raw Input", | |
| "mtk-cam-dip reprocess Tuning", "mtk-cam-dip reprocess MDP0", ""}}, | |
| {MEDIA_CONTROLLER_P2_Reprocessing_OUT2, | |
| {MEDIA_CONTROLLER_P2_Reprocessing_OUT2, "mtk-cam-dip", | |
| "mtk-cam-dip reprocess", "mtk-cam-dip reprocess Raw Input", | |
| "mtk-cam-dip reprocess Tuning", "mtk-cam-dip reprocess MDP0", | |
| "mtk-cam-dip reprocess MDP1"}}, | |
| }; | |
| static std::map<MediaDeviceTag, MediaCtrl_P2NewTopology> | |
| gMediaCtrl_P2NewTopology = { | |
| // Need confirm entity names with P2 driver | |
| {MEDIA_CONTROLLER_P2New_Preview_FD_3DNR_IN4OUT4, | |
| {MEDIA_CONTROLLER_P2New_Preview_FD_3DNR_IN4OUT4, "mtk-cam-dip", | |
| "mtk-cam-dip preview", "mtk-cam-dip preview Raw Input", | |
| "mtk-cam-dip preview Tuning", "mtk-cam-dip preview NR Input", | |
| "mtk-cam-dip preview Shading", "mtk-cam-dip preview MDP0", | |
| "mtk-cam-dip preview MDP1", "mtk-cam-dip preview IMG2", | |
| "mtk-cam-dip preview IMG3"}}, | |
| {MEDIA_CONTROLLER_P2New_Capture_FD_3DNR_IN4OUT4, | |
| {MEDIA_CONTROLLER_P2New_Capture_FD_3DNR_IN4OUT4, "mtk-cam-dip", | |
| "mtk-cam-dip capture", "mtk-cam-dip capture Raw Input", | |
| "mtk-cam-dip capture Tuning", "mtk-cam-dip capture NR Input", | |
| "mtk-cam-dip capture Shading", "mtk-cam-dip capture MDP0", | |
| "mtk-cam-dip capture MDP1", "mtk-cam-dip capture IMG2", | |
| "mtk-cam-dip capture IMG3"}}, | |
| {MEDIA_CONTROLLER_P2New_Reprocessing_FD_3DNR_IN4OUT4, | |
| {MEDIA_CONTROLLER_P2New_Reprocessing_FD_3DNR_IN4OUT4, "mtk-cam-dip", | |
| "mtk-cam-dip reprocess", "mtk-cam-dip reprocess Raw Input", | |
| "mtk-cam-dip reprocess Tuning", "mtk-cam-dip reprocess NR Input", | |
| "mtk-cam-dip reprocess Shading", "mtk-cam-dip reprocess MDP0", | |
| "mtk-cam-dip reprocess MDP1", "mtk-cam-dip reprocess IMG2", | |
| "mtk-cam-dip reprocess IMG3"}}, | |
| }; | |
| string MediaCtrlConfig::getMediaDeviceNameByTag(MediaDeviceTag mdevTag) { | |
| LOGD("[%s] mdevTag 0x%08x", __FUNCTION__, mdevTag); | |
| MediaCtrl_P1Topology* SubP1Topology = NULL; | |
| MediaCtrl_P2Topology* SubP2Topology = NULL; | |
| MediaCtrl_P2NewTopology* SubP2NewTopology = NULL; | |
| int Mdevcase = mdevTag & MEDIA_CONTROLLER_TAG; | |
| string modelName; | |
| switch (Mdevcase) { | |
| case MEDIA_CONTROLLER_P1_TAG: { | |
| std::map<MediaDeviceTag, MediaCtrl_P1Topology>::iterator itP1topology = | |
| gMediaCtrl_P1Topology.find(mdevTag); | |
| if (itP1topology != gMediaCtrl_P1Topology.end()) { | |
| SubP1Topology = &(itP1topology->second); | |
| modelName = SubP1Topology->mdev_name; | |
| } else { | |
| LOGW( | |
| "[%s] mdevTag/Mdevcase is not in P1 Media controller definition " | |
| ":0x%08x/0x%08x", | |
| __FUNCTION__, mdevTag, Mdevcase); | |
| } | |
| break; | |
| } | |
| case MEDIA_CONTROLLER_P2_TAG: { | |
| std::map<MediaDeviceTag, MediaCtrl_P2Topology>::iterator itP2topology = | |
| gMediaCtrl_P2Topology.find(mdevTag); | |
| std::map<MediaDeviceTag, MediaCtrl_P2NewTopology>::iterator | |
| itP2Newtopology = gMediaCtrl_P2NewTopology.find(mdevTag); | |
| if (itP2topology != gMediaCtrl_P2Topology.end()) { | |
| SubP2Topology = &(itP2topology->second); | |
| modelName = SubP2Topology->mdev_name; | |
| } else if (itP2Newtopology != gMediaCtrl_P2NewTopology.end()) { | |
| SubP2NewTopology = &(itP2Newtopology->second); | |
| modelName = SubP2NewTopology->mdev_name; | |
| } else { | |
| LOGW( | |
| "[%s] mdevTag/Mdevcase is not in P2 Media controller definition " | |
| ":0x%08x/0x%08x", | |
| __FUNCTION__, mdevTag, Mdevcase); | |
| } | |
| break; | |
| } | |
| default: { | |
| LOGE( | |
| "[%s] mdevTag/Mdevcase is not in Media controller definition " | |
| ":0x%08x/0x%08x", | |
| __FUNCTION__, mdevTag, Mdevcase); | |
| break; | |
| } | |
| } | |
| return modelName; | |
| } | |
| string MediaCtrlConfig::getMediaDevicePathByName(const string& modelName) { | |
| LOGD("[%s] Target name: %s", __FUNCTION__, modelName.c_str()); | |
| const char* MEDIADEVICES = "media"; | |
| const char* DEVICE_PATH = "/dev/"; | |
| string mediaDevicePath; | |
| DIR* dir; | |
| dirent* dirEnt; | |
| vector<string> candidates; | |
| if ((dir = opendir(DEVICE_PATH)) != nullptr) { | |
| while ((dirEnt = readdir(dir)) != nullptr) { | |
| string candidatePath = dirEnt->d_name; | |
| size_t pos = candidatePath.find(MEDIADEVICES); | |
| if (pos != string::npos) { | |
| LOGD("Found media device candidate: %s", candidatePath.c_str()); | |
| string found_one = DEVICE_PATH; | |
| found_one += candidatePath; | |
| candidates.push_back(found_one); | |
| } | |
| } | |
| closedir(dir); | |
| } else { | |
| LOGE("Failed to open directory: %s", DEVICE_PATH); | |
| } | |
| LOGD("candidates size %d", candidates.size()); | |
| status_t retVal = NO_ERROR; | |
| for (const auto& candidate : candidates) { | |
| MtkMediaController controller(modelName.c_str(), candidate.c_str()); | |
| retVal = controller.init(); | |
| // We may run into devices that this HAL won't use -> skip to next | |
| if (retVal == PERMISSION_DENIED) { | |
| LOGD("Not enough permissions to access %s.", candidate.c_str()); | |
| continue; | |
| } else if (retVal != NO_ERROR) { | |
| LOGD(" %s controller.init error value = %d.", candidate.c_str(), retVal); | |
| continue; | |
| } | |
| struct media_device_info info; | |
| int ret = controller.getMediaDevInfo(&info); | |
| if (ret != OK) { | |
| LOGE("Cannot get media device information."); | |
| continue; | |
| } | |
| if (strncmp(info.model, modelName.c_str(), | |
| MIN(sizeof(info.model), modelName.size())) == 0) { | |
| LOGD("Found device that matches: %s %s", modelName.c_str(), | |
| candidate.c_str()); | |
| mediaDevicePath += candidate; | |
| ret = controller.close(); | |
| break; | |
| } | |
| ret = controller.close(); | |
| } | |
| return mediaDevicePath; | |
| } | |
| void MediaCtrlConfig::addVideoNodes(string name, MediaCtlConfig* config) { | |
| if (!name.empty() && config) { | |
| MediaCtlElement mediaCtlElement; | |
| mediaCtlElement.name = name; | |
| config->mVideoNodes.push_back(mediaCtlElement); | |
| LOGD("[%s] add videonode name: %s", __FUNCTION__, name.c_str()); | |
| } else { | |
| LOGE("[%s] name empty or null pointer: %s/%p", __FUNCTION__, name.c_str(), | |
| config); | |
| } | |
| } | |
| void MediaCtrlConfig::addLinkParams(const string& srcName, | |
| int srcPad, | |
| const string& sinkName, | |
| int sinkPad, | |
| int enable, | |
| int flags, | |
| MediaCtlConfig* config) { | |
| if (!srcName.empty() && !sinkName.empty() && config) { | |
| MediaCtlLinkParams mediaCtlLinkParams; | |
| mediaCtlLinkParams.srcName = srcName; | |
| mediaCtlLinkParams.srcPad = srcPad; | |
| mediaCtlLinkParams.sinkName = sinkName; | |
| mediaCtlLinkParams.sinkPad = sinkPad; | |
| mediaCtlLinkParams.enable = enable; | |
| mediaCtlLinkParams.flags = flags; | |
| config->mLinkParams.push_back(mediaCtlLinkParams); | |
| LOGD("[%s] srcName:%s, Pad:%d, sinkName:%s, Pad:%d, enable:%d, flag:0x%08x", | |
| __FUNCTION__, srcName.c_str(), srcPad, sinkName.c_str(), sinkPad, | |
| enable, flags); | |
| } else { | |
| LOGE("[%s] srcname/sinkname empty or null pointer: %s/%s/%p", __FUNCTION__, | |
| srcName.c_str(), sinkName.c_str(), config); | |
| } | |
| } | |
| void MediaCtrlConfig::CreateMediaCtlGraph(MediaDeviceTag mdevTag, | |
| bool hasTuning, | |
| MediaCtlConfig* mediaCtlConfig) { | |
| LOGD("[%s] mdevTag 0x%08x", __FUNCTION__, mdevTag); | |
| bool bNewP2Topology = false; | |
| MediaCtrl_P1Topology* SubP1Topology = NULL; | |
| MediaCtrl_P2Topology* SubP2Topology = NULL; | |
| MediaCtrl_P2NewTopology* SubP2NewTopology = NULL; | |
| int Mdevcase = mdevTag & MEDIA_CONTROLLER_TAG; | |
| switch (Mdevcase) { | |
| case MEDIA_CONTROLLER_P1_TAG: { | |
| std::map<MediaDeviceTag, MediaCtrl_P1Topology>::iterator itP1topology = | |
| gMediaCtrl_P1Topology.find(mdevTag); | |
| if (itP1topology != gMediaCtrl_P1Topology.end()) { | |
| SubP1Topology = &(itP1topology->second); | |
| } else { | |
| LOGE( | |
| "[%s] mdevTag/Mdevcase is not in P1 Media controller definition " | |
| ":0x%08x/0x%08x", | |
| __FUNCTION__, mdevTag, Mdevcase); | |
| break; | |
| } | |
| addVideoNodes(SubP1Topology->hub_name, mediaCtlConfig); | |
| if (hasTuning) { | |
| addVideoNodes(SubP1Topology->tunig_source_name, mediaCtlConfig); | |
| addVideoNodes(SubP1Topology->tunig_sink1_name, mediaCtlConfig); | |
| addVideoNodes(SubP1Topology->tunig_sink2_name, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->tunig_source_name, DEFAULT_PADIDX, | |
| SubP1Topology->hub_name, eP1_META_INPUT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->hub_name, eP1_META0_PADIDX, | |
| SubP1Topology->tunig_sink1_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->hub_name, eP1_META1_PADIDX, | |
| SubP1Topology->tunig_sink2_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addVideoNodes(SubP1Topology->tunig_sink3_name, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->hub_name, eP1_META2_PADIDX, | |
| SubP1Topology->tunig_sink3_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addVideoNodes(SubP1Topology->tunig_sink4_name, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->hub_name, eP1_META3_PADIDX, | |
| SubP1Topology->tunig_sink4_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| } | |
| addVideoNodes(SubP1Topology->imgo_sink_name, mediaCtlConfig); | |
| addVideoNodes(SubP1Topology->rrzo_sink_name, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->hub_name, eP1_MAINSTREAM_PADIDX, | |
| SubP1Topology->imgo_sink_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP1Topology->hub_name, eP1_PACKEDOUT_PADIDX, | |
| SubP1Topology->rrzo_sink_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| break; | |
| } | |
| case MEDIA_CONTROLLER_P2_TAG: { | |
| std::map<MediaDeviceTag, MediaCtrl_P2Topology>::iterator itP2topology = | |
| gMediaCtrl_P2Topology.find(mdevTag); | |
| std::map<MediaDeviceTag, MediaCtrl_P2NewTopology>::iterator | |
| itP2Newtopology = gMediaCtrl_P2NewTopology.find(mdevTag); | |
| if (itP2topology != gMediaCtrl_P2Topology.end()) { | |
| SubP2Topology = &(itP2topology->second); | |
| } else if (itP2Newtopology != gMediaCtrl_P2NewTopology.end()) { | |
| SubP2NewTopology = &(itP2Newtopology->second); | |
| bNewP2Topology = true; | |
| } else { | |
| LOGE( | |
| "[%s] mdevTag/Mdevcase is not in P2 Media controller definition " | |
| ":0x%08x/0x%08x", | |
| __FUNCTION__, mdevTag, Mdevcase); | |
| break; | |
| } | |
| if (bNewP2Topology == false) { | |
| addVideoNodes(SubP2Topology->hub_name, mediaCtlConfig); | |
| addVideoNodes(SubP2Topology->raw_source_name, mediaCtlConfig); | |
| addVideoNodes(SubP2Topology->sink1_name, mediaCtlConfig); | |
| addVideoNodes(SubP2Topology->sink2_name, mediaCtlConfig); | |
| addLinkParams(SubP2Topology->raw_source_name, DEFAULT_PADIDX, | |
| SubP2Topology->hub_name, eP2_RAW_INPUT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2Topology->hub_name, eP2_MDP0_PADIDX, | |
| SubP2Topology->sink1_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2Topology->hub_name, eP2_MDP1_PADIDX, | |
| SubP2Topology->sink2_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| if (hasTuning) { | |
| addVideoNodes(SubP2Topology->tunig_source_name, mediaCtlConfig); | |
| addLinkParams(SubP2Topology->tunig_source_name, DEFAULT_PADIDX, | |
| SubP2Topology->hub_name, eP2_TUNING_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| } | |
| } else { | |
| addVideoNodes(SubP2NewTopology->hub_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->raw_source_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->raw_source2_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->raw_source3_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->sink1_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->sink2_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->sink3_name, mediaCtlConfig); | |
| addVideoNodes(SubP2NewTopology->sink4_name, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->raw_source_name, DEFAULT_PADIDX, | |
| SubP2NewTopology->hub_name, eP2_RAW_INPUT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->raw_source2_name, DEFAULT_PADIDX, | |
| SubP2NewTopology->hub_name, eP2_VIPI_INPUT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->raw_source3_name, DEFAULT_PADIDX, | |
| SubP2NewTopology->hub_name, eP2_LCEI_INPUT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->hub_name, eP2_MDP0_PADIDX, | |
| SubP2NewTopology->sink1_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->hub_name, eP2_MDP1_PADIDX, | |
| SubP2NewTopology->sink2_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->hub_name, eP2_IMG2_PADIDX, | |
| SubP2NewTopology->sink3_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->hub_name, eP2_IMG3_PADIDX, | |
| SubP2NewTopology->sink4_name, DEFAULT_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| if (hasTuning) { | |
| addVideoNodes(SubP2NewTopology->tunig_source_name, mediaCtlConfig); | |
| addLinkParams(SubP2NewTopology->tunig_source_name, DEFAULT_PADIDX, | |
| SubP2NewTopology->hub_name, eP2_TUNING_PADIDX, 1, | |
| MEDIA_LNK_FL_ENABLED, mediaCtlConfig); | |
| } | |
| } | |
| break; | |
| } | |
| default: { | |
| LOGE( | |
| "[%s] mdevTag/Mdevcase is not in Media controller definition " | |
| ":0x%08x/0x%08x", | |
| __FUNCTION__, mdevTag, Mdevcase); | |
| break; | |
| } | |
| } | |
| } |