| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "imx227.h" |
| #include "imx227-seq.h" |
| #include "imx227-test.h" |
| #include <ddk/binding.h> |
| #include <ddk/debug.h> |
| #include <ddk/metadata.h> |
| #include <ddk/metadata/camera.h> |
| #include <ddk/protocol/i2c-lib.h> |
| #include <endian.h> |
| #include <fbl/alloc_checker.h> |
| #include <fbl/auto_call.h> |
| #include <fbl/auto_lock.h> |
| #include <fbl/unique_ptr.h> |
| #include <hw/reg.h> |
| #include <memory> |
| #include <stdint.h> |
| #include <threads.h> |
| #include <zircon/types.h> |
| |
| namespace camera { |
| |
| namespace { |
| |
| constexpr uint16_t kSensorId = 0x0227; |
| constexpr uint32_t kAGainPrecision = 12; |
| constexpr uint32_t kDGainPrecision = 8; |
| constexpr int32_t kLog2GainShift = 18; |
| constexpr int32_t kSensorExpNumber = 1; |
| constexpr uint32_t kMasterClock = 288000000; |
| |
| } // namespace |
| |
| zx_status_t Imx227Device::InitPdev(zx_device_t* parent) { |
| |
| // I2c for communicating with the sensor. |
| if (!i2c_.is_valid()) { |
| zxlogf(ERROR, "%s; I2C not available\n", __func__); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| // Clk for gating clocks for sensor. |
| if (!clk24_.is_valid()) { |
| zxlogf(ERROR, "%s; clk24_ not available\n", __func__); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| // Mipi for init and de-init. |
| if (!mipi_.is_valid()) { |
| zxlogf(ERROR, "%s; mipi_ not available\n", __func__); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| // GPIOs |
| if (!gpio_vana_enable_.is_valid()) { |
| zxlogf(ERROR, "%s; gpio_vana_enable_ not available\n", __func__); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| if (!gpio_vdig_enable_.is_valid()) { |
| zxlogf(ERROR, "%s; gpio_vdig_enable_ not available\n", __func__); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| if (!gpio_cam_rst_.is_valid()) { |
| zxlogf(ERROR, "%s; gpio_cam_rst_ not available\n", __func__); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| // Set the GPIO to output and set them to their initial values |
| // before the power up sequence. |
| gpio_cam_rst_.ConfigOut(1); |
| gpio_vana_enable_.ConfigOut(0); |
| gpio_vdig_enable_.ConfigOut(0); |
| return ZX_OK; |
| } |
| |
| uint8_t Imx227Device::ReadReg(uint16_t addr) { |
| // Convert the address to Big Endian format. |
| // The camera sensor expects in this format. |
| uint16_t buf = htobe16(addr); |
| uint8_t val = 0; |
| zx_status_t status = i2c_.WriteReadSync(reinterpret_cast<uint8_t*>(&buf), sizeof(buf), |
| &val, sizeof(val)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Imx227Device: could not read reg addr: 0x%08x status: %d\n", addr, status); |
| return -1; |
| } |
| return val; |
| } |
| |
| void Imx227Device::WriteReg(uint16_t addr, uint8_t val) { |
| // Convert the address to Big Endian format. |
| // The camera sensor expects in this format. |
| // First two bytes are the address, third one is the value to be written. |
| uint8_t buf[3]; |
| buf[1] = static_cast<uint8_t>(addr & 0xFF); |
| buf[0] = static_cast<uint8_t>((addr >> 8) & 0xFF); |
| buf[2] = val; |
| |
| zx_status_t status = i2c_.WriteSync(buf, 3); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "Imx227Device: could not write reg addr/val: 0x%08x/0x%08x status: %d\n", |
| addr, val, status); |
| } |
| } |
| |
| bool Imx227Device::ValidateSensorID() { |
| uint16_t sensor_id = static_cast<uint16_t>((ReadReg(0x0016) << 8) | ReadReg(0x0017)); |
| if (sensor_id != kSensorId) { |
| zxlogf(ERROR, "Imx227Device: Invalid sensor ID\n"); |
| return false; |
| } |
| return true; |
| } |
| |
| zx_status_t Imx227Device::InitSensor(uint8_t idx) { |
| if (idx >= countof(kSEQUENCE_TABLE)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| const init_seq_fmt_t* sequence = kSEQUENCE_TABLE[idx]; |
| bool init_command = true; |
| |
| while (init_command) { |
| uint16_t address = sequence->address; |
| uint8_t value = sequence->value; |
| |
| switch (address) { |
| case 0x0000: { |
| if (sequence->value == 0 && sequence->len == 0) { |
| init_command = false; |
| } else { |
| WriteReg(address, value); |
| } |
| break; |
| } |
| default: |
| WriteReg(address, value); |
| break; |
| } |
| sequence++; |
| } |
| return ZX_OK; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorInit() { |
| // Power up sequence. Reference: Page 51- IMX227-0AQH5-C datasheet. |
| gpio_vana_enable_.Write(1); |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(50))); |
| |
| gpio_vdig_enable_.Write(1); |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(50))); |
| |
| // Enable 24M clock for sensor. |
| clk24_.Enable(); |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(10))); |
| |
| gpio_cam_rst_.Write(0); |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(50))); |
| |
| // Get Sensor ID to validate initialization sequence. |
| if (!ValidateSensorID()) { |
| return ZX_ERR_INTERNAL; |
| } |
| |
| // Initialize Sensor Context. |
| ctx_.seq_width = 1; |
| ctx_.streaming_flag = 0; |
| ctx_.again_old = 0; |
| ctx_.change_flag = 0; |
| ctx_.again_limit = 8 << kAGainPrecision; |
| ctx_.dgain_limit = 15 << kDGainPrecision; |
| |
| // Initialize Sensor Parameters. |
| ctx_.param.again_accuracy = 1 << kLog2GainShift; |
| ctx_.param.sensor_exp_number = kSensorExpNumber; |
| ctx_.param.again_log2_max = 3 << kLog2GainShift; |
| ctx_.param.dgain_log2_max = 3 << kLog2GainShift; |
| ctx_.param.integration_time_apply_delay = 2; |
| ctx_.param.isp_exposure_channel_delay = 0; |
| |
| initialized_ = true; |
| zxlogf(INFO, "%s IMX227 Camera Sensor Brought out of reset\n", __func__); |
| return ZX_OK; |
| } |
| |
| void Imx227Device::CameraSensorDeInit() { |
| mipi_.DeInit(); |
| // Enable 24M clock for sensor. |
| clk24_.Disable(); |
| // Reference code has it, mostly likely needed for the clock to |
| // stabalize. No other way of knowing for sure if sensor is now off. |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(10))); |
| initialized_ = false; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorGetInfo(sensor_info_t* out_info) { |
| if (out_info == nullptr) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| memcpy(out_info, &ctx_.param, sizeof(sensor_info_t)); |
| return ZX_OK; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorGetSupportedModes(sensor_mode_t* out_modes_list, |
| size_t modes_count, |
| size_t* out_modes_actual) { |
| if (out_modes_list == nullptr || out_modes_actual == nullptr) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| if (modes_count > countof(supported_modes)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| memcpy(out_modes_list, &supported_modes, sizeof(sensor_mode_t) * countof(supported_modes)); |
| *out_modes_actual = countof(supported_modes); |
| return ZX_OK; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorSetMode(uint8_t mode) { |
| zxlogf(INFO, "%s IMX227 Camera Sensor Mode Set request to %d\n", __func__, mode); |
| |
| // Get Sensor ID to see if sensor is initialized. |
| if (!IsSensorInitialized() || !ValidateSensorID()) { |
| return ZX_ERR_INTERNAL; |
| } |
| |
| if (mode >= countof(supported_modes)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| switch (supported_modes[mode].wdr_mode) { |
| case WDR_MODE_LINEAR: { |
| |
| InitSensor(supported_modes[mode].idx); |
| |
| ctx_.again_delay = 0; |
| ctx_.dgain_delay = 0; |
| ctx_.param.integration_time_apply_delay = 2; |
| ctx_.param.isp_exposure_channel_delay = 0; |
| ctx_.hdr_flag = 0; |
| break; |
| } |
| // TODO(braval) : Support other modes. |
| default: |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| ctx_.param.active.width = supported_modes[mode].resolution.width; |
| ctx_.param.active.height = supported_modes[mode].resolution.height; |
| ctx_.HMAX = static_cast<uint16_t>(ReadReg(0x342) << 8 | ReadReg(0x343)); |
| ctx_.VMAX = static_cast<uint16_t>(ReadReg(0x340) << 8 | ReadReg(0x341)); |
| ctx_.int_max = 0x0ADE; // Max allowed for 30fps = 2782 (dec), 0x0ADE (hex) |
| ctx_.int_time_min = 1; |
| ctx_.int_time_limit = ctx_.int_max; |
| ctx_.param.total.height = ctx_.VMAX; |
| ctx_.param.total.width = ctx_.HMAX; |
| ctx_.param.pixels_per_line = ctx_.param.total.width; |
| |
| uint32_t master_clock = kMasterClock; |
| ctx_.param.lines_per_second = master_clock / ctx_.HMAX; |
| |
| ctx_.param.integration_time_min = ctx_.int_time_min; |
| ctx_.param.integration_time_limit = ctx_.int_time_limit; |
| ctx_.param.integration_time_max = ctx_.int_time_limit; |
| ctx_.param.integration_time_long_max = ctx_.int_time_limit; |
| ctx_.param.mode = mode; |
| ctx_.param.bayer = supported_modes[mode].bayer; |
| ctx_.wdr_mode = supported_modes[mode].wdr_mode; |
| |
| mipi_info_t mipi_info; |
| mipi_adap_info_t adap_info; |
| |
| mipi_info.lanes = supported_modes[mode].lanes; |
| mipi_info.ui_value = 1000 / supported_modes[mode].mbps; |
| if ((1000 % supported_modes[mode].mbps) != 0) { |
| mipi_info.ui_value += 1; |
| } |
| |
| switch (supported_modes[mode].bits) { |
| case 10: |
| adap_info.format = IMAGE_FORMAT_AM_RAW10; |
| break; |
| case 12: |
| adap_info.format = IMAGE_FORMAT_AM_RAW12; |
| break; |
| default: |
| adap_info.format = IMAGE_FORMAT_AM_RAW10; |
| break; |
| } |
| |
| adap_info.resolution.width = supported_modes[mode].resolution.width; |
| adap_info.resolution.height = supported_modes[mode].resolution.height; |
| adap_info.path = MIPI_PATH_PATH0; |
| adap_info.mode = MIPI_MODES_DIR_MODE; |
| return mipi_.Init(&mipi_info, &adap_info); |
| } |
| |
| zx_status_t Imx227Device::CameraSensorStartStreaming() { |
| if (!IsSensorInitialized() || ctx_.streaming_flag) { |
| return ZX_ERR_BAD_STATE; |
| } |
| zxlogf(INFO, "%s Camera Sensor Start Streaming\n", __func__); |
| ctx_.streaming_flag = 1; |
| WriteReg(0x0100, 0x01); |
| return ZX_OK; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorStopStreaming() { |
| if (!IsSensorInitialized() || !ctx_.streaming_flag) { |
| return ZX_ERR_BAD_STATE; |
| } |
| ctx_.streaming_flag = 0; |
| WriteReg(0x0100, 0x00); |
| return ZX_OK; |
| } |
| |
| int32_t Imx227Device::CameraSensorSetAnalogGain(int32_t gain) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| int32_t Imx227Device::CameraSensorSetDigitalGain(int32_t gain) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorSetIntegrationTime(int32_t int_time) { |
| // TODO(braval): Add support for this. |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| zx_status_t Imx227Device::CameraSensorUpdate() { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| // static |
| zx_status_t Imx227Device::Setup(void* ctx, |
| zx_device_t* parent, |
| std::unique_ptr<Imx227Device>* out) { |
| ddk::CompositeProtocolClient composite(parent); |
| if (!composite.is_valid()) { |
| zxlogf(ERROR, "%s could not get composite protocoln", __func__); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| zx_device_t* components[COMPONENT_COUNT]; |
| size_t actual; |
| composite.GetComponents(components, COMPONENT_COUNT, &actual); |
| if (actual != COMPONENT_COUNT) { |
| zxlogf(ERROR, "%s Could not get components\n", __func__); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| fbl::AllocChecker ac; |
| auto sensor_device = std::unique_ptr<Imx227Device>( |
| new (&ac) Imx227Device(parent, |
| components[COMPONENT_I2C], |
| components[COMPONENT_GPIO_VANA], |
| components[COMPONENT_GPIO_VDIG], |
| components[COMPONENT_GPIO_CAM_RST], |
| components[COMPONENT_CLK24], |
| components[COMPONENT_MIPICSI])); |
| if (!ac.check()) { |
| zxlogf(ERROR, "%s Could not create Imx227Device device\n", __func__); |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| zx_status_t status = sensor_device->InitPdev(parent); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s InitPdev failed\n", __func__); |
| return status; |
| } |
| *out = std::move(sensor_device); |
| return status; |
| } |
| |
| void Imx227Device::ShutDown() { |
| } |
| |
| void Imx227Device::DdkUnbind() { |
| DdkRemove(); |
| } |
| |
| void Imx227Device::DdkRelease() { |
| ShutDown(); |
| delete this; |
| } |
| |
| zx_status_t imx227_bind(void* ctx, zx_device_t* device) { |
| std::unique_ptr<Imx227Device> sensor_device; |
| zx_status_t status = camera::Imx227Device::Setup(ctx, device, &sensor_device); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "imx227: Could not setup imx227 sensor device: %d\n", status); |
| return status; |
| } |
| zx_device_prop_t props[] = { |
| {BIND_PLATFORM_DEV_VID, 0, PDEV_VID_SONY}, |
| {BIND_PLATFORM_DEV_PID, 0, PDEV_PID_SONY_IMX227}, |
| {BIND_PLATFORM_DEV_DID, 0, PDEV_DID_CAMERA_SENSOR}, |
| }; |
| |
| // Run the unit tests for this device |
| // TODO(braval): CAM-44 (Run only when build flag enabled) |
| // This needs to be replaced with run unittests hooks when |
| // the framework is available. |
| status = camera::Imx227DeviceTester::RunTests(sensor_device.get()); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "%s: Device Unit Tests Failed \n", __func__); |
| return status; |
| } |
| |
| status = sensor_device->DdkAdd("imx227", 0, props, countof(props)); |
| if (status != ZX_OK) { |
| zxlogf(ERROR, "imx227: Could not add imx227 sensor device: %d\n", status); |
| return status; |
| } else { |
| zxlogf(INFO, "imx227 driver added\n"); |
| } |
| |
| // sensor_device intentionally leaked as it is now held by DevMgr. |
| __UNUSED auto* dev = sensor_device.release(); |
| return ZX_OK; |
| } |
| |
| static zx_driver_ops_t driver_ops = []() { |
| zx_driver_ops_t ops; |
| ops.version = DRIVER_OPS_VERSION; |
| ops.bind = imx227_bind; |
| return ops; |
| }(); |
| |
| } // namespace camera |
| |
| // clang-format off |
| ZIRCON_DRIVER_BEGIN(imx227, camera::driver_ops, "imx227", "0.1", 4) |
| BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_COMPOSITE), |
| BI_ABORT_IF(NE, BIND_PLATFORM_DEV_VID, PDEV_VID_SONY), |
| BI_ABORT_IF(NE, BIND_PLATFORM_DEV_PID, PDEV_PID_SONY_IMX227), |
| BI_MATCH_IF(EQ, BIND_PLATFORM_DEV_DID, PDEV_DID_CAMERA_SENSOR), |
| ZIRCON_DRIVER_END(imx227) |
