413 lines
14 KiB
C++
413 lines
14 KiB
C++
/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
// System dependencies
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <media/msm_cam_sensor-land.h>
|
|
|
|
// Camera dependencies
|
|
#include "HAL3/QCamera3HWI.h"
|
|
#include "QCameraFlash.h"
|
|
|
|
extern "C" {
|
|
#include "mm_camera_dbg.h"
|
|
}
|
|
|
|
#define STRING_LENGTH_OF_64_BIT_NUMBER 21
|
|
|
|
volatile uint32_t gCamHal3LogLevel = 1;
|
|
|
|
namespace qcamera {
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : getInstance
|
|
*
|
|
* DESCRIPTION: Get and create the QCameraFlash singleton.
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraFlash& QCameraFlash::getInstance()
|
|
{
|
|
static QCameraFlash flashInstance;
|
|
return flashInstance;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : QCameraFlash
|
|
*
|
|
* DESCRIPTION: default constructor of QCameraFlash
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraFlash::QCameraFlash() : m_callbacks(NULL)
|
|
{
|
|
memset(&m_flashOn, 0, sizeof(m_flashOn));
|
|
memset(&m_cameraOpen, 0, sizeof(m_cameraOpen));
|
|
for (int pos = 0; pos < MM_CAMERA_MAX_NUM_SENSORS; pos++) {
|
|
m_flashFds[pos] = -1;
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : ~QCameraFlash
|
|
*
|
|
* DESCRIPTION: deconstructor of QCameraFlash
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
QCameraFlash::~QCameraFlash()
|
|
{
|
|
for (int pos = 0; pos < MM_CAMERA_MAX_NUM_SENSORS; pos++) {
|
|
if (m_flashFds[pos] >= 0)
|
|
{
|
|
setFlashMode(pos, false);
|
|
close(m_flashFds[pos]);
|
|
m_flashFds[pos] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : registerCallbacks
|
|
*
|
|
* DESCRIPTION: provide flash module with reference to callbacks to framework
|
|
*
|
|
* PARAMETERS : None
|
|
*
|
|
* RETURN : None
|
|
*==========================================================================*/
|
|
int32_t QCameraFlash::registerCallbacks(
|
|
const camera_module_callbacks_t* callbacks)
|
|
{
|
|
int32_t retVal = 0;
|
|
m_callbacks = callbacks;
|
|
return retVal;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : initFlash
|
|
*
|
|
* DESCRIPTION: Reserve and initialize the flash unit associated with a
|
|
* given camera id. This function is blocking until the
|
|
* operation completes or fails. Each flash unit can be "inited"
|
|
* by only one process at a time.
|
|
*
|
|
* PARAMETERS :
|
|
* @camera_id : Camera id of the flash.
|
|
*
|
|
* RETURN :
|
|
* 0 : success
|
|
* -EBUSY : The flash unit or the resource needed to turn on the
|
|
* the flash is busy, typically because the flash is
|
|
* already in use.
|
|
* -EINVAL : No flash present at camera_id.
|
|
*==========================================================================*/
|
|
int32_t QCameraFlash::initFlash(const int camera_id)
|
|
{
|
|
int32_t retVal = 0;
|
|
bool hasFlash = false;
|
|
char flashNode[QCAMERA_MAX_FILEPATH_LENGTH];
|
|
char flashPath[QCAMERA_MAX_FILEPATH_LENGTH] = "/dev/";
|
|
|
|
if (camera_id < 0 || camera_id >= MM_CAMERA_MAX_NUM_SENSORS) {
|
|
LOGE("Invalid camera id: %d", camera_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
QCamera3HardwareInterface::getFlashInfo(camera_id,
|
|
hasFlash,
|
|
flashNode);
|
|
|
|
strlcat(flashPath,
|
|
flashNode,
|
|
sizeof(flashPath));
|
|
|
|
if (!hasFlash) {
|
|
LOGE("No flash available for camera id: %d",
|
|
camera_id);
|
|
retVal = -EINVAL;
|
|
} else if (m_cameraOpen[camera_id]) {
|
|
LOGE("Camera in use for camera id: %d",
|
|
camera_id);
|
|
retVal = -EBUSY;
|
|
} else if (m_flashFds[camera_id] >= 0) {
|
|
LOGD("Flash is already inited for camera id: %d",
|
|
camera_id);
|
|
} else {
|
|
m_flashFds[camera_id] = open(flashPath, O_RDWR | O_NONBLOCK);
|
|
|
|
if (m_flashFds[camera_id] < 0) {
|
|
LOGE("Unable to open node '%s'",
|
|
flashPath);
|
|
retVal = -EBUSY;
|
|
} else {
|
|
struct msm_flash_cfg_data_t cfg;
|
|
struct msm_flash_init_info_t init_info;
|
|
memset(&cfg, 0, sizeof(struct msm_flash_cfg_data_t));
|
|
memset(&init_info, 0, sizeof(struct msm_flash_init_info_t));
|
|
init_info.flash_driver_type = FLASH_DRIVER_DEFAULT;
|
|
cfg.cfg.flash_init_info = &init_info;
|
|
cfg.cfg_type = CFG_FLASH_INIT;
|
|
retVal = ioctl(m_flashFds[camera_id],
|
|
VIDIOC_MSM_FLASH_CFG,
|
|
&cfg);
|
|
if (retVal < 0) {
|
|
LOGE("Unable to init flash for camera id: %d",
|
|
camera_id);
|
|
close(m_flashFds[camera_id]);
|
|
m_flashFds[camera_id] = -1;
|
|
}
|
|
|
|
/* wait for PMIC to init */
|
|
usleep(5000);
|
|
}
|
|
}
|
|
|
|
LOGD("X, retVal = %d", retVal);
|
|
return retVal;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : setFlashMode
|
|
*
|
|
* DESCRIPTION: Turn on or off the flash associated with a given handle.
|
|
* This function is blocking until the operation completes or
|
|
* fails.
|
|
*
|
|
* PARAMETERS :
|
|
* @camera_id : Camera id of the flash
|
|
* @on : Whether to turn flash on (true) or off (false)
|
|
*
|
|
* RETURN :
|
|
* 0 : success
|
|
* -EINVAL : No camera present at camera_id, or it is not inited.
|
|
* -EALREADY: Flash is already in requested state
|
|
*==========================================================================*/
|
|
int32_t QCameraFlash::setFlashMode(const int camera_id, const bool mode)
|
|
{
|
|
int32_t retVal = 0;
|
|
struct msm_flash_cfg_data_t cfg;
|
|
|
|
if (camera_id < 0 || camera_id >= MM_CAMERA_MAX_NUM_SENSORS) {
|
|
LOGE("Invalid camera id: %d", camera_id);
|
|
retVal = -EINVAL;
|
|
} else if (mode == m_flashOn[camera_id]) {
|
|
LOGD("flash %d is already in requested state: %d",
|
|
camera_id,
|
|
mode);
|
|
retVal = -EALREADY;
|
|
} else if (m_flashFds[camera_id] < 0) {
|
|
LOGE("called for uninited flash: %d", camera_id);
|
|
retVal = -EINVAL;
|
|
} else {
|
|
memset(&cfg, 0, sizeof(struct msm_flash_cfg_data_t));
|
|
for (int i = 0; i < MAX_LED_TRIGGERS; i++)
|
|
cfg.flash_current[i] = QCAMERA_TORCH_CURRENT_VALUE;
|
|
cfg.cfg_type = mode ? CFG_FLASH_LOW: CFG_FLASH_OFF;
|
|
|
|
retVal = ioctl(m_flashFds[camera_id],
|
|
VIDIOC_MSM_FLASH_CFG,
|
|
&cfg);
|
|
if (retVal < 0) {
|
|
LOGE("Unable to change flash mode to %d for camera id: %d",
|
|
mode, camera_id);
|
|
} else
|
|
{
|
|
m_flashOn[camera_id] = mode;
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : deinitFlash
|
|
*
|
|
* DESCRIPTION: Release the flash unit associated with a given camera
|
|
* position. This function is blocking until the operation
|
|
* completes or fails.
|
|
*
|
|
* PARAMETERS :
|
|
* @camera_id : Camera id of the flash.
|
|
*
|
|
* RETURN :
|
|
* 0 : success
|
|
* -EINVAL : No camera present at camera_id or not inited.
|
|
*==========================================================================*/
|
|
int32_t QCameraFlash::deinitFlash(const int camera_id)
|
|
{
|
|
int32_t retVal = 0;
|
|
|
|
if (camera_id < 0 || camera_id >= MM_CAMERA_MAX_NUM_SENSORS) {
|
|
LOGE("Invalid camera id: %d", camera_id);
|
|
retVal = -EINVAL;
|
|
} else if (m_flashFds[camera_id] < 0) {
|
|
LOGE("called deinitFlash for uninited flash");
|
|
retVal = -EINVAL;
|
|
} else {
|
|
setFlashMode(camera_id, false);
|
|
|
|
struct msm_flash_cfg_data_t cfg;
|
|
cfg.cfg_type = CFG_FLASH_RELEASE;
|
|
retVal = ioctl(m_flashFds[camera_id],
|
|
VIDIOC_MSM_FLASH_CFG,
|
|
&cfg);
|
|
if (retVal < 0) {
|
|
LOGE("Failed to release flash for camera id: %d",
|
|
camera_id);
|
|
}
|
|
|
|
close(m_flashFds[camera_id]);
|
|
m_flashFds[camera_id] = -1;
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : reserveFlashForCamera
|
|
*
|
|
* DESCRIPTION: Give control of the flash to the camera, and notify
|
|
* framework that the flash has become unavailable.
|
|
*
|
|
* PARAMETERS :
|
|
* @camera_id : Camera id of the flash.
|
|
*
|
|
* RETURN :
|
|
* 0 : success
|
|
* -EINVAL : No camera present at camera_id or not inited.
|
|
* -ENOSYS : No callback available for torch_mode_status_change.
|
|
*==========================================================================*/
|
|
int32_t QCameraFlash::reserveFlashForCamera(const int camera_id)
|
|
{
|
|
int32_t retVal = 0;
|
|
|
|
if (camera_id < 0 || camera_id >= MM_CAMERA_MAX_NUM_SENSORS) {
|
|
LOGE("Invalid camera id: %d", camera_id);
|
|
retVal = -EINVAL;
|
|
} else if (m_cameraOpen[camera_id]) {
|
|
LOGD("Flash already reserved for camera id: %d",
|
|
camera_id);
|
|
} else {
|
|
if (m_flashOn[camera_id]) {
|
|
setFlashMode(camera_id, false);
|
|
deinitFlash(camera_id);
|
|
}
|
|
m_cameraOpen[camera_id] = true;
|
|
|
|
bool hasFlash = false;
|
|
char flashNode[QCAMERA_MAX_FILEPATH_LENGTH];
|
|
|
|
QCamera3HardwareInterface::getFlashInfo(camera_id,
|
|
hasFlash,
|
|
flashNode);
|
|
|
|
if (m_callbacks == NULL ||
|
|
m_callbacks->torch_mode_status_change == NULL) {
|
|
LOGE("Callback is not defined!");
|
|
retVal = -ENOSYS;
|
|
} else if (!hasFlash) {
|
|
LOGD("Suppressing callback "
|
|
"because no flash exists for camera id: %d",
|
|
camera_id);
|
|
} else {
|
|
char cameraIdStr[STRING_LENGTH_OF_64_BIT_NUMBER];
|
|
snprintf(cameraIdStr, STRING_LENGTH_OF_64_BIT_NUMBER,
|
|
"%d", camera_id);
|
|
m_callbacks->torch_mode_status_change(m_callbacks,
|
|
cameraIdStr,
|
|
TORCH_MODE_STATUS_NOT_AVAILABLE);
|
|
}
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/*===========================================================================
|
|
* FUNCTION : releaseFlashFromCamera
|
|
*
|
|
* DESCRIPTION: Release control of the flash from the camera, and notify
|
|
* framework that the flash has become available.
|
|
*
|
|
* PARAMETERS :
|
|
* @camera_id : Camera id of the flash.
|
|
*
|
|
* RETURN :
|
|
* 0 : success
|
|
* -EINVAL : No camera present at camera_id or not inited.
|
|
* -ENOSYS : No callback available for torch_mode_status_change.
|
|
*==========================================================================*/
|
|
int32_t QCameraFlash::releaseFlashFromCamera(const int camera_id)
|
|
{
|
|
int32_t retVal = 0;
|
|
|
|
if (camera_id < 0 || camera_id >= MM_CAMERA_MAX_NUM_SENSORS) {
|
|
LOGE("Invalid camera id: %d", camera_id);
|
|
retVal = -EINVAL;
|
|
} else if (!m_cameraOpen[camera_id]) {
|
|
LOGD("Flash not reserved for camera id: %d",
|
|
camera_id);
|
|
} else {
|
|
m_cameraOpen[camera_id] = false;
|
|
|
|
bool hasFlash = false;
|
|
char flashNode[QCAMERA_MAX_FILEPATH_LENGTH];
|
|
|
|
QCamera3HardwareInterface::getFlashInfo(camera_id,
|
|
hasFlash,
|
|
flashNode);
|
|
|
|
if (m_callbacks == NULL ||
|
|
m_callbacks->torch_mode_status_change == NULL) {
|
|
LOGE("Callback is not defined!");
|
|
retVal = -ENOSYS;
|
|
} else if (!hasFlash) {
|
|
LOGD("Suppressing callback "
|
|
"because no flash exists for camera id: %d",
|
|
camera_id);
|
|
} else {
|
|
char cameraIdStr[STRING_LENGTH_OF_64_BIT_NUMBER];
|
|
snprintf(cameraIdStr, STRING_LENGTH_OF_64_BIT_NUMBER,
|
|
"%d", camera_id);
|
|
m_callbacks->torch_mode_status_change(m_callbacks,
|
|
cameraIdStr,
|
|
TORCH_MODE_STATUS_AVAILABLE_OFF);
|
|
}
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
}; // namespace qcamera
|