Linux CCS driver preparation
Sakari Ailus
maintainercover Linux CCS driver preparation
Hello everyone,
Here's a set of patches that turn the existing SMIA driver into a MIPI CCS driver while maintaining SMIA support. A number of bugs in the existing code are fixed in this set, too.
The changes at this point are primarily focused on dealing with new mandatory driver features related to PLL configuration (as CCS allows for much more variation there) and things such as integer conversion from U16.U16 format instead of float. There are some other new features as well such as digital gain and support for getting device specific analogue gain coefficients.
A new feature in CCS is CCS static data which makes it possible to obtain sensor's capabilities and limits from a file chosen based on sensor identification. CCS static data is used also for storing MSR registers so supporting new, CCS compliant devices requires no driver changes.
Note that the library as well as the register definitions are dual licensed under GNU GPL v2 OR BSD 3-clause licenses for use outside the Linux kernel.
Also DT bindings are updated accordingly and converted to YAML format.
More information on MIPI CCS can be found here:
<URL:https://www.mipi.org/specifications/camera-command-set>
Comments are welcome.
since the big, big patchset (v2):
- Split into more easily reviewable chunks (this is the first of maybe three). The cover page describes the entire big set. This set contains mostly cleanups for the smiapp driver that prepare for support for additional features as well as DT bindings, as well as using CCS limits.
- Fix SPDX tags. Some were left accidentally with BSD-3-Clause license only.
- Fix bus-type alignment in DT bindings.
- Add CCS driver documentation
- Add -u option to the CCS register definition generator.
- Add static keyword for ccs_limit_offset array.
- Add generated CCS register definitions, and do not generate the definitions as part of the build process.
- Remove ccs-os.h header.
ccs: Add the generator for CCS register definitions and limits
Documentation: ccs: Add CCS driver documentation
smiapp: Import CCS definitions
smiapp: Use CCS register flags
smiapp: Calculate CCS limit offsets and limit buffer size
smiapp: Remove macros for defining registers, merge definitions
smiapp: Add macros for accessing CCS registers
smiapp: Use MIPI CCS version and manufacturer ID information
smiapp: Read CCS limit values
smiapp: Switch to CCS limits
smiapp: Obtain frame descriptor from CCS limits
smiapp: Use CCS limits in reading data format descriptors
smiapp: Use CCS limits in reading binning capabilities
smiapp: Use CCS registers
smiapp: Remove quirk function for writing a single 8-bit register
smiapp: Rename register access functions
smiapp: Internal rename to CCS
smiapp: Differentiate CCS sensors from SMIA in subdev naming
smiapp: Rename as "ccs"
ccs: Remove profile concept
ccs: Give all subdevs a function
dt-bindings: nokia,smia: Fix link-frequencies documentation
dt-bindings: nokia,smia: Make vana-supply optional
dt-bindings: nokia,smia: Remove nokia,nvm-size property
dt-bindings: nokia,smia: Convert to YAML
dt-bindings: nokia,smia: Use better active polarity for reset
dt-bindings: nokia,smia: Amend SMIA bindings with MIPI CCS support
dt-bindings: mipi-ccs: Add bus-type for C-PHY support
ccs: Request for "reset" GPIO
.../bindings/media/i2c/mipi-ccs.yaml | 128 ++
.../bindings/media/i2c/nokia,smia.txt | 66 -
.../driver-api/media/drivers/ccs/ccs-regs.txt | 1041 ++++++++++
.../driver-api/media/drivers/ccs/ccs.rst | 82 +
.../driver-api/media/drivers/ccs/mk-ccs-regs | 410 ++++
.../driver-api/media/drivers/index.rst | 1 +
MAINTAINERS | 20 +-
drivers/media/i2c/Kconfig | 2 +-
drivers/media/i2c/Makefile | 2 +-
drivers/media/i2c/{smiapp => ccs}/Kconfig | 7 +-
drivers/media/i2c/ccs/Makefile | 6 +
.../{smiapp/smiapp-core.c => ccs/ccs-core.c} | 1828 +++++++++--------
drivers/media/i2c/ccs/ccs-limits.c | 239 +++
drivers/media/i2c/ccs/ccs-limits.h | 258 +++
.../smiapp-quirk.c => ccs/ccs-quirk.c} | 92 +-
.../smiapp-quirk.h => ccs/ccs-quirk.h} | 52 +-
.../smiapp-regs.c => ccs/ccs-reg-access.c} | 85 +-
drivers/media/i2c/ccs/ccs-reg-access.h | 38 +
drivers/media/i2c/ccs/ccs-regs.h | 953 +++++++++
.../media/i2c/{smiapp/smiapp.h => ccs/ccs.h} | 164 +-
drivers/media/i2c/ccs/smiapp-reg-defs.h | 580 ++++++
drivers/media/i2c/smiapp/Makefile | 6 -
drivers/media/i2c/smiapp/smiapp-limits.c | 118 --
drivers/media/i2c/smiapp/smiapp-limits.h | 114 -
drivers/media/i2c/smiapp/smiapp-reg-defs.h | 489 -----
drivers/media/i2c/smiapp/smiapp-reg.h | 116 --
drivers/media/i2c/smiapp/smiapp-regs.h | 36 -
27 files changed, 4921 insertions(+), 2012 deletions(-)
create mode 100644 Documentation/devicetree/bindings/media/i2c/mipi-ccs.yaml
delete mode 100644 Documentation/devicetree/bindings/media/i2c/nokia,smia.txt
create mode 100644 Documentation/driver-api/media/drivers/ccs/ccs-regs.txt
create mode 100644 Documentation/driver-api/media/drivers/ccs/ccs.rst
create mode 100755 Documentation/driver-api/media/drivers/ccs/mk-ccs-regs
rename drivers/media/i2c/{smiapp => ccs}/Kconfig (55%)
create mode 100644 drivers/media/i2c/ccs/Makefile
rename drivers/media/i2c/{smiapp/smiapp-core.c => ccs/ccs-core.c} (53%)
create mode 100644 drivers/media/i2c/ccs/ccs-limits.c
create mode 100644 drivers/media/i2c/ccs/ccs-limits.h
rename drivers/media/i2c/{smiapp/smiapp-quirk.c => ccs/ccs-quirk.c} (66%)
rename drivers/media/i2c/{smiapp/smiapp-quirk.h => ccs/ccs-quirk.h} (55%)
rename drivers/media/i2c/{smiapp/smiapp-regs.c => ccs/ccs-reg-access.c} (66%)
create mode 100644 drivers/media/i2c/ccs/ccs-reg-access.h
create mode 100644 drivers/media/i2c/ccs/ccs-regs.h
rename drivers/media/i2c/{smiapp/smiapp.h => ccs/ccs.h} (57%)
create mode 100644 drivers/media/i2c/ccs/smiapp-reg-defs.h
delete mode 100644 drivers/media/i2c/smiapp/Makefile
delete mode 100644 drivers/media/i2c/smiapp/smiapp-limits.c
delete mode 100644 drivers/media/i2c/smiapp/smiapp-limits.h
delete mode 100644 drivers/media/i2c/smiapp/smiapp-reg-defs.h
delete mode 100644 drivers/media/i2c/smiapp/smiapp-reg.h
delete mode 100644 drivers/media/i2c/smiapp/smiapp-regs.hSignature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 1/29 ccs: Add the generator for CCS register definitions and limits
Add register definitions of the MIPI CCS 1.1 standard.
The CCS driver makes extended use of device's capability registers that are dependent on CCS version. This involves having an in-memory data structure for limit and capability information, creating that data structure and accessing it.
The register definitions as well as the definitions of this data structure are generated from a text file using a Perl script. Add the generator script to make it easy to update the generated files.
--- .../driver-api/media/drivers/ccs/ccs-regs.txt | 1041 +++++++++++++++++ .../driver-api/media/drivers/ccs/mk-ccs-regs | 410 +++++++ 2 files changed, 1451 insertions(+) create mode 100644 Documentation/driver-api/media/drivers/ccs/ccs-regs.txt create mode 100755 Documentation/driver-api/media/drivers/ccs/mk-ccs-regs
Documentation/driver-api/media/drivers/ccs/ccs-regs.txt new file +1041 -0
@@ -0,0 +1,1041 @@ +# Copyright (C) 2019--2020 Intel Corporation +# SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause + +# register rflags +# - f field LSB MSB rflags +# - e enum value # after a field +# - e enum value [LSB MSB] +# - b bool bit +# - l arg name min max elsize [discontig...] +# +# rflags +# 8, 16, 32 register bits (default is 8) +# v1.1 defined in version 1.1 +# f formula +# float_ireal iReal or IEEE 754; 32 bits +# ireal unsigned iReal + +# general status registers +module_model_id 0x0000 16 +module_revision_number_major 0x0002 8 +frame_count 0x0005 8 +pixel_order 0x0006 8 +- e GRBG 0 +- e RGGB 1 +- e BGGR 2 +- e GBRG 3 +MIPI_CCS_version 0x0007 8 +- e v1_0 0x10 +- e v1_1 0x11 +- f major 4 7 +- f minor 0 3 +data_pedestal 0x0008 16 +module_manufacturer_id 0x000e 16 +module_revision_number_minor 0x0010 8 +module_date_year 0x0012 8 +module_date_month 0x0013 8 +module_date_day 0x0014 8 +module_date_phase 0x0015 8 +- f 0 2 +- e ts 0 +- e es 1 +- e cs 2 +- e mp 3 +sensor_model_id 0x0016 16 +sensor_revision_number 0x0018 8 +sensor_firmware_version 0x001a 8 +serial_number 0x001c 32 +sensor_manufacturer_id 0x0020 16 +sensor_revision_number_16 0x0022 16 + +# frame format description registers +frame_format_model_type 0x0040 8 +- e 2-byte 1 +- e 4-byte 2 +frame_format_model_subtype 0x0041 8 +- f rows 0 3 +- f columns 4 7 +frame_format_descriptor(n) 0x0042 16 f +- l n 0 14 2 +- f pixels 0 11 +- f pcode 12 15 +- e embedded 1 +- e dummy_pixel 2 +- e black_pixel 3 +- e dark_pixel 4 +- e visible_pixel 5 +- e manuf_specific_0 8 +- e manuf_specific_1 9 +- e manuf_specific_2 10 +- e manuf_specific_3 11 +- e manuf_specific_4 12 +- e manuf_specific_5 13 +- e manuf_specific_6 14 +frame_format_descriptor_4(n) 0x0060 32 f +- l n 0 7 4 +- f pixels 0 15 +- f pcode 28 31 +- e embedded 1 +- e dummy_pixel 2 +- e black_pixel 3 +- e dark_pixel 4 +- e visible_pixel 5 +- e manuf_specific_0 8 +- e manuf_specific_1 9 +- e manuf_specific_2 10 +- e manuf_specific_3 11 +- e manuf_specific_4 12 +- e manuf_specific_5 13 +- e manuf_specific_6 14 + +# analog gain description registers +analog_gain_capability 0x0080 16 +- e global 0 +- e alternate_global 2 +analog_gain_code_min 0x0084 16 +analog_gain_code_max 0x0086 16 +analog_gain_code_step 0x0088 16 +analog_gain_type 0x008a 16 +analog_gain_m0 0x008c 16 +analog_gain_c0 0x008e 16 +analog_gain_m1 0x0090 16 +analog_gain_c1 0x0092 16 +analog_linear_gain_min 0x0094 16 v1.1 +analog_linear_gain_max 0x0096 16 v1.1 +analog_linear_gain_step_size 0x0098 16 v1.1 +analog_exponential_gain_min 0x009a 16 v1.1 +analog_exponential_gain_max 0x009c 16 v1.1 +analog_exponential_gain_step_size 0x009e 16 v1.1 + +# data format description registers +data_format_model_type 0x00c0 8 +- e normal 1 +- e extended 2 +data_format_model_subtype 0x00c1 8 +- f rows 0 3 +- f columns 4 7 +data_format_descriptor(n) 0x00c2 16 f +- l n 0 15 2 +- f compressed 0 7 +- f uncompressed 8 15 + +# general set-up registers +mode_select 0x0100 8 +- e software_standby 0 +- e streaming 1 +image_orientation 0x0101 8 +- b horizontal_mirror 0 +- b vertical_flip 1 +software_reset 0x0103 8 +- e off 0 +- e on 1 +grouped_parameter_hold 0x0104 8 +mask_corrupted_frames 0x0105 8 +- e allow 0 +- e mask 1 +fast_standby_ctrl 0x0106 8 +- e complete_frames 0 +- e frame_truncation 1 +CCI_address_ctrl 0x0107 8 +2nd_CCI_if_ctrl 0x0108 8 +- b enable 0 +- b ack 1 +2nd_CCI_address_ctrl 0x0109 8 +CSI_channel_identifier 0x0110 8 +CSI_signaling_mode 0x0111 8 +- e csi_2_dphy 2 +- e csi_2_cphy 3 +CSI_data_format 0x0112 16 +CSI_lane_mode 0x0114 8 +DPCM_Frame_DT 0x011d 8 +Bottom_embedded_data_DT 0x011e 8 +Bottom_embedded_data_VC 0x011f 8 + +gain_mode 0x0120 8 +- e global 0 +- e alternate 1 +ADC_bit_depth 0x0121 8 +emb_data_ctrl 0x0122 v1.1 +- b raw8_packing_for_raw16 0 +- b raw10_packing_for_raw20 1 +- b raw12_packing_for_raw24 2 + +GPIO_TRIG_mode 0x0130 8 +extclk_frequency_mhz 0x0136 16 ireal +temp_sensor_ctrl 0x0138 8 +- b enable 0 +temp_sensor_mode 0x0139 8 +temp_sensor_output 0x013a 8 + +# integration time registers +fine_integration_time 0x0200 16 +coarse_integration_time 0x0202 16 + +# analog gain registers +analog_gain_code_global 0x0204 16 +analog_linear_gain_global 0x0206 16 v1.1 +analog_exponential_gain_global 0x0208 16 v1.1 + +# digital gain registers +digital_gain_global 0x020e 16 + +# hdr control registers +Short_analog_gain_global 0x0216 16 +Short_digital_gain_global 0x0218 16 + +HDR_mode 0x0220 8 +- b enabled 0 +- b separate_analog_gain 1 +- b upscaling 2 +- b reset_sync 3 +- b timing_mode 4 +- b exposure_ctrl_direct 5 +- b separate_digital_gain 6 +HDR_resolution_reduction 0x0221 8 +- f row 0 3 +- f column 4 7 +Exposure_ratio 0x0222 8 +HDR_internal_bit_depth 0x0223 8 +Direct_short_integration_time 0x0224 16 +Short_analog_linear_gain_global 0x0226 16 v1.1 +Short_analog_exponential_gain_global 0x0228 16 v1.1 + +# clock set-up registers +vt_pix_clk_div 0x0300 16 +vt_sys_clk_div 0x0302 16 +pre_pll_clk_div 0x0304 16 +#vt_pre_pll_clk_div 0x0304 16 +pll_multiplier 0x0306 16 +#vt_pll_multiplier 0x0306 16 +op_pix_clk_div 0x0308 16 +op_sys_clk_div 0x030a 16 +op_pre_pll_clk_div 0x030c 16 +op_pll_multiplier 0x031e 16 +pll_mode 0x0310 8 +- f 0 0 +- e single 0 +- e dual 1 +op_pix_clk_div_rev 0x0312 16 v1.1 +op_sys_clk_div_rev 0x0314 16 v1.1 + +# frame timing registers +frame_length_lines 0x0340 16 +line_length_pck 0x0342 16 + +# image size registers +x_addr_start 0x0344 16 +y_addr_start 0x0346 16 +x_addr_end 0x0348 16 +y_addr_end 0x034a 16 +x_output_size 0x034c 16 +y_output_size 0x034e 16 + +# timing mode registers +Frame_length_ctrl 0x0350 8 +- b automatic 0 +Timing_mode_ctrl 0x0352 8 +- b manual_readout 0 +- b delayed_exposure 1 +Start_readout_rs 0x0353 8 +- b manual_readout_start 0 +Frame_margin 0x0354 16 + +# sub-sampling registers +x_even_inc 0x0380 16 +x_odd_inc 0x0382 16 +y_even_inc 0x0384 16 +y_odd_inc 0x0386 16 + +# monochrome readout registers +monochrome_en 0x0390 v1.1 +- e enabled 0 + +# image scaling registers +Scaling_mode 0x0400 16 +- e no_scaling 0 +- e horizontal 1 +scale_m 0x0404 16 +scale_n 0x0406 16 +digital_crop_x_offset 0x0408 16 +digital_crop_y_offset 0x040a 16 +digital_crop_image_width 0x040c 16 +digital_crop_image_height 0x040e 16 + +# image compression registers +compression_mode 0x0500 16 +- e none 0 +- e dpcm_pcm_simple 1 + +# test pattern registers +test_pattern_mode 0x0600 16 +- e none 0 +- e solid_color 1 +- e color_bars 2 +- e fade_to_grey 3 +- e pn9 4 +- e color_tile 5 +test_data_red 0x0602 16 +test_data_greenR 0x0604 16 +test_data_blue 0x0606 16 +test_data_greenB 0x0608 16 +value_step_size_smooth 0x060a 8 +value_step_size_quantised 0x060b 8 + +# phy configuration registers +tclk_post 0x0800 8 +ths_prepare 0x0801 8 +ths_zero_min 0x0802 8 +ths_trail 0x0803 8 +tclk_trail_min 0x0804 8 +tclk_prepare 0x0805 8 +tclk_zero 0x0806 8 +tlpx 0x0807 8 +phy_ctrl 0x0808 8 +- e auto 0 +- e UI 1 +- e manual 2 +tclk_post_ex 0x080a 16 +ths_prepare_ex 0x080c 16 +ths_zero_min_ex 0x080e 16 +ths_trail_ex 0x0810 16 +tclk_trail_min_ex 0x0812 16 +tclk_prepare_ex 0x0814 16 +tclk_zero_ex 0x0816 16 +tlpx_ex 0x0818 16 + +# link rate register +requested_link_rate 0x0820 32 u16.16 + +# equalization control registers +DPHY_equalization_mode 0x0824 8 v1.1 +- b eq2 0 +PHY_equalization_ctrl 0x0825 8 v1.1 +- b enable 0 + +# d-phy preamble control registers +DPHY_preamble_ctrl 0x0826 8 v1.1 +- b enable 0 +DPHY_preamble_length 0x0826 8 v1.1 + +# d-phy spread spectrum control registers +PHY_SSC_ctrl 0x0828 8 v1.1 +- b enable 0 + +# manual lp control register +manual_LP_ctrl 0x0829 8 v1.1 +- b enable 0 + +# additional phy configuration registers +twakeup 0x082a v1.1 +tinit 0x082b v1.1 +ths_exit 0x082c v1.1 +ths_exit_ex 0x082e 16 v1.1 + +# phy calibration configuration registers +PHY_periodic_calibration_ctrl 0x0830 8 +- b frame_blanking 0 +PHY_periodic_calibration_interval 0x0831 8 +PHY_init_calibration_ctrl 0x0832 8 +- b stream_start 0 +DPHY_calibration_mode 0x0833 8 v1.1 +- b also_alternate 0 +CPHY_calibration_mode 0x0834 8 v1.1 +- e format_1 0 +- e format_2 1 +- e format_3 2 +t3_calpreamble_length 0x0835 8 v1.1 +t3_calpreamble_length_per 0x0836 8 v1.1 +t3_calaltseq_length 0x0837 8 v1.1 +t3_calaltseq_length_per 0x0838 8 v1.1 +FM2_init_seed 0x083a 16 v1.1 +t3_caludefseq_length 0x083c 16 v1.1 +t3_caludefseq_length_per 0x083e 16 v1.1 + +# c-phy manual control registers +TGR_Preamble_Length 0x0841 8 +- b preamable_prog_seq 7 +- f begin_preamble_length 0 5 +TGR_Post_Length 0x0842 8 +- f post_length 0 4 +TGR_Preamble_Prog_Sequence(n2) 0x0843 +- l n2 0 6 1 +- f symbol_n_1 3 5 +- f symbol_n 0 2 +t3_prepare 0x084e 16 +t3_lpx 0x0850 16 + +# alps control register +ALPS_ctrl 0x085a 8 +- b lvlp_dphy 0 +- b lvlp_cphy 1 +- b alp_cphy 2 + +# lrte control registers +TX_REG_CSI_EPD_EN_SSP_cphy 0x0860 16 +TX_REG_CSI_EPD_OP_SLP_cphy 0x0862 16 +TX_REG_CSI_EPD_EN_SSP_dphy 0x0864 16 +TX_REG_CSI_EPD_OP_SLP_dphy 0x0866 16 +TX_REG_CSI_EPD_MISC_OPTION_cphy 0x0868 v1.1 +TX_REG_CSI_EPD_MISC_OPTION_dphy 0x0869 v1.1 + +# scrambling control registers +Scrambling_ctrl 0x0870 +- b enabled 0 +- f 2 3 +- e 1_seed_cphy 0 +- e 4_seed_cphy 3 +lane_seed_value(seed, lane) 0x0872 16 +- l seed 0 3 0x10 +- l lane 0 7 0x2 + +# usl control registers +TX_USL_REV_ENTRY 0x08c0 16 v1.1 +TX_USL_REV_Clock_Counter 0x08c2 16 v1.1 +TX_USL_REV_LP_Counter 0x08c4 16 v1.1 +TX_USL_REV_Frame_Counter 0x08c6 16 v1.1 +TX_USL_REV_Chronological_Timer 0x08c8 16 v1.1 +TX_USL_FWD_ENTRY 0x08ca 16 v1.1 +TX_USL_GPIO 0x08cc 16 v1.1 +TX_USL_Operation 0x08ce 16 v1.1 +- b reset 0 +TX_USL_ALP_ctrl 0x08d0 16 v1.1 +- b clock_pause 0 +TX_USL_APP_BTA_ACK_TIMEOUT 0x08d2 16 v1.1 +TX_USL_SNS_BTA_ACK_TIMEOUT 0x08d2 16 v1.1 +USL_Clock_Mode_d_ctrl 0x08d2 v1.1 +- b cont_clock_standby 0 +- b cont_clock_vblank 1 +- b cont_clock_hblank 2 + +# binning configuration registers +binning_mode 0x0900 8 +binning_type 0x0901 8 +binning_weighting 0x0902 8 + +# data transfer interface registers +data_transfer_if_1_ctrl 0x0a00 8 +- b enable 0 +- b write 1 +- b clear_error 2 +data_transfer_if_1_status 0x0a01 8 +- b read_if_ready 0 +- b write_if_ready 1 +- b data_corrupted 2 +- b improper_if_usage 3 +data_transfer_if_1_page_select 0x0a02 8 +data_transfer_if_1_data(p) 0x0a04 8 f +- l p 0 63 1 + +# image processing and sensor correction configuration registers +shading_correction_en 0x0b00 8 +- b enable 0 +luminance_correction_level 0x0b01 8 +green_imbalance_filter_en 0x0b02 8 +- b enable 0 +mapped_defect_correct_en 0x0b05 8 +- b enable 0 +single_defect_correct_en 0x0b06 8 +- b enable 0 +dynamic_couplet_correct_en 0x0b08 8 +- b enable 0 +combined_defect_correct_en 0x0b0a 8 +- b enable 0 +module_specific_correction_en 0x0b0c 8 +- b enable 0 +dynamic_triplet_defect_correct_en 0x0b13 8 +- b enable 0 +NF_ctrl 0x0b15 8 +- b luma 0 +- b chroma 1 +- b combined 2 + +# optical black pixel readout registers +OB_readout_control 0x0b30 8 +- b enable 0 +- b interleaving 1 +OB_virtual_channel 0x0b31 8 +OB_DT 0x0b32 8 +OB_data_format 0x0b33 8 + +# color temperature feedback registers +color_temperature 0x0b8c 16 +absolute_gain_greenr 0x0b8e 16 +absolute_gain_red 0x0b90 16 +absolute_gain_blue 0x0b92 16 +absolute_gain_greenb 0x0b94 16 + +# cfa conversion registers +CFA_conversion_ctrl 0x0ba0 v1.1 +- b bayer_conversion_enable 0 + +# flash strobe and sa strobe control registers +flash_strobe_adjustment 0x0c12 8 +flash_strobe_start_point 0x0c14 16 +tflash_strobe_delay_rs_ctrl 0x0c16 16 +tflash_strobe_width_high_rs_ctrl 0x0c18 16 +flash_mode_rs 0x0c1a 8 +- b continuous 0 +- b truncate 1 +- b async 3 +flash_trigger_rs 0x0c1b 8 +flash_status 0x0c1c 8 +- b retimed 0 +sa_strobe_mode 0x0c1d 8 +- b continuous 0 +- b truncate 1 +- b async 3 +- b adjust_edge 4 +sa_strobe_start_point 0x0c1e 16 +tsa_strobe_delay_ctrl 0x0c20 16 +tsa_strobe_width_ctrl 0x0c22 16 +sa_strobe_trigger 0x0c24 8 +sa_strobe_status 0x0c25 8 +- b retimed 0 +tSA_strobe_re_delay_ctrl 0x0c30 16 +tSA_strobe_fe_delay_ctrl 0x0c32 16 + +# pdaf control registers +PDAF_ctrl 0x0d00 16 +- b enable 0 +- b processed 1 +- b interleaved 2 +- b visible_pdaf_correction 3 +PDAF_VC 0x0d02 8 +PDAF_DT 0x0d03 8 +pd_x_addr_start 0x0d04 16 +pd_y_addr_start 0x0d06 16 +pd_x_addr_end 0x0d08 16 +pd_y_addr_end 0x0d0a 16 + +# bracketing interface configuration registers +bracketing_LUT_ctrl 0x0e00 8 +bracketing_LUT_mode 0x0e01 8 +- b continue_streaming 0 +- b loop_mode 1 +bracketing_LUT_entry_ctrl 0x0e02 8 +bracketing_LUT_frame(n) 0x0e10 v1.1 f +- l n 0 0xef 1 + +# integration time and gain parameter limit registers +integration_time_capability 0x1000 16 +- b fine 0 +coarse_integration_time_min 0x1004 16 +coarse_integration_time_max_margin 0x1006 16 +fine_integration_time_min 0x1008 16 +fine_integration_time_max_margin 0x100a 16 + +# digital gain parameter limit registers +digital_gain_capability 0x1081 +- e none 0 +- e global 2 +digital_gain_min 0x1084 16 +digital_gain_max 0x1086 16 +digital_gain_step_size 0x1088 16 + +# data pedestal capability registers +Pedestal_capability 0x10e0 8 v1.1 + +# adc capability registers +ADC_capability 0x10f0 8 +- b bit_depth_ctrl 0 +ADC_bit_depth_capability 0x10f4 32 v1.1 + +# video timing parameter limit registers +min_ext_clk_freq_mhz 0x1100 32 float_ireal +max_ext_clk_freq_mhz 0x1104 32 float_ireal +min_pre_pll_clk_div 0x1108 16 +# min_vt_pre_pll_clk_div 0x1108 16 +max_pre_pll_clk_div 0x110a 16 +# max_vt_pre_pll_clk_div 0x110a 16 +min_pll_ip_clk_freq_mhz 0x110c 32 float_ireal +# min_vt_pll_ip_clk_freq_mhz 0x110c 32 float_ireal +max_pll_ip_clk_freq_mhz 0x1110 32 float_ireal +# max_vt_pll_ip_clk_freq_mhz 0x1110 32 float_ireal +min_pll_multiplier 0x1114 16 +# min_vt_pll_multiplier 0x1114 16 +max_pll_multiplier 0x1116 16 +# max_vt_pll_multiplier 0x1116 16 +min_pll_op_clk_freq_mhz 0x1118 32 float_ireal +max_pll_op_clk_freq_mhz 0x111c 32 float_ireal + +# video timing set-up capability registers +min_vt_sys_clk_div 0x1120 16 +max_vt_sys_clk_div 0x1122 16 +min_vt_sys_clk_freq_mhz 0x1124 32 float_ireal +max_vt_sys_clk_freq_mhz 0x1128 32 float_ireal +min_vt_pix_clk_freq_mhz 0x112c 32 float_ireal +max_vt_pix_clk_freq_mhz 0x1130 32 float_ireal +min_vt_pix_clk_div 0x1134 16 +max_vt_pix_clk_div 0x1136 16 +clock_calculation 0x1138 +- b lane_speed 0 +- b link_decoupled 1 +- b dual_pll_op_sys_ddr 2 +- b dual_pll_op_pix_ddr 3 +num_of_vt_lanes 0x1139 +num_of_op_lanes 0x113a +op_bits_per_lane 0x113b 8 v1.1 + +# frame timing parameter limits +min_frame_length_lines 0x1140 16 +max_frame_length_lines 0x1142 16 +min_line_length_pck 0x1144 16 +max_line_length_pck 0x1146 16 +min_line_blanking_pck 0x1148 16 +min_frame_blanking_lines 0x114a 16 +min_line_length_pck_step_size 0x114c +timing_mode_capability 0x114d +- b auto_frame_length 0 +- b rolling_shutter_manual_readout 2 +- b delayed_exposure_start 3 +- b manual_exposure_embedded_data 4 +frame_margin_max_value 0x114e 16 +frame_margin_min_value 0x1150 +gain_delay_type 0x1151 +- e fixed 0 +- e variable 1 + +# output clock set-up capability registers +min_op_sys_clk_div 0x1160 16 +max_op_sys_clk_div 0x1162 16 +min_op_sys_clk_freq_mhz 0x1164 32 float_ireal +max_op_sys_clk_freq_mhz 0x1168 32 float_ireal +min_op_pix_clk_div 0x116c 16 +max_op_pix_clk_div 0x116e 16 +min_op_pix_clk_freq_mhz 0x1170 32 float_ireal +max_op_pix_clk_freq_mhz 0x1174 32 float_ireal + +# image size parameter limit registers +x_addr_min 0x1180 16 +y_addr_min 0x1182 16 +x_addr_max 0x1184 16 +y_addr_max 0x1186 16 +min_x_output_size 0x1188 16 +min_y_output_size 0x118a 16 +max_x_output_size 0x118c 16 +max_y_output_size 0x118e 16 + +x_addr_start_div_constant 0x1190 v1.1 +y_addr_start_div_constant 0x1191 v1.1 +x_addr_end_div_constant 0x1192 v1.1 +y_addr_end_div_constant 0x1193 v1.1 +x_size_div 0x1194 v1.1 +y_size_div 0x1195 v1.1 +x_output_div 0x1196 v1.1 +y_output_div 0x1197 v1.1 +non_flexible_resolution_support 0x1198 v1.1 +- b new_pix_addr 0 +- b new_output_res 1 +- b output_crop_no_pad 2 +- b output_size_lane_dep 3 + +min_op_pre_pll_clk_div 0x11a0 16 +max_op_pre_pll_clk_div 0x11a2 16 +min_op_pll_ip_clk_freq_mhz 0x11a4 32 float_ireal +max_op_pll_ip_clk_freq_mhz 0x11a8 32 float_ireal +min_op_pll_multiplier 0x11ac 16 +max_op_pll_multiplier 0x11ae 16 +min_op_pll_op_clk_freq_mhz 0x11b0 32 float_ireal +max_op_pll_op_clk_freq_mhz 0x11b4 32 float_ireal +clock_tree_pll_capability 0x11b8 8 +- b dual_pll 0 +- b single_pll 1 +- b ext_divider 2 +- b flexible_op_pix_clk_div 3 +clock_capa_type_capability 0x11b9 v1.1 +- b ireal 0 + +# sub-sampling parameters limit registers +min_even_inc 0x11c0 16 +min_odd_inc 0x11c2 16 +max_even_inc 0x11c4 16 +max_odd_inc 0x11c6 16 +aux_subsamp_capability 0x11c8 v1.1 +- b factor_power_of_2 1 +aux_subsamp_mono_capability 0x11c9 v1.1 +- b factor_power_of_2 1 +monochrome_capability 0x11ca v1.1 +- e inc_odd 0 +- e inc_even 1 +pixel_readout_capability 0x11cb v1.1 +- e bayer 0 +- e monochrome 1 +- e bayer_and_mono 2 +min_even_inc_mono 0x11cc 16 v1.1 +max_even_inc_mono 0x11ce 16 v1.1 +min_odd_inc_mono 0x11d0 16 v1.1 +max_odd_inc_mono 0x11d2 16 v1.1 +min_even_inc_bc2 0x11d4 16 v1.1 +max_even_inc_bc2 0x11d6 16 v1.1 +min_odd_inc_bc2 0x11d8 16 v1.1 +max_odd_inc_bc2 0x11da 16 v1.1 +min_even_inc_mono_bc2 0x11dc 16 v1.1 +max_even_inc_mono_bc2 0x11de 16 v1.1 +min_odd_inc_mono_bc2 0x11f0 16 v1.1 +max_odd_inc_mono_bc2 0x11f2 16 v1.1 + +# image scaling limit parameters +scaling_capability 0x1200 16 +- e none 0 +- e horizontal 1 +- e reserved 2 +scaler_m_min 0x1204 16 +scaler_m_max 0x1206 16 +scaler_n_min 0x1208 16 +scaler_n_max 0x120a 16 +digital_crop_capability 0x120e +- e none 0 +- e input_crop 1 + +# hdr limit registers +hdr_capability_1 0x1210 +- b 2x2_binning 0 +- b combined_analog_gain 1 +- b separate_analog_gain 2 +- b upscaling 3 +- b reset_sync 4 +- b direct_short_exp_timing 5 +- b direct_short_exp_synthesis 6 +min_hdr_bit_depth 0x1211 +hdr_resolution_sub_types 0x1212 +hdr_resolution_sub_type(n) 0x1213 +- l n 0 1 1 +- f row 0 3 +- f column 4 7 +hdr_capability_2 0x121b +- b combined_digital_gain 0 +- b separate_digital_gain 1 +- b timing_mode 3 +- b synthesis_mode 4 +max_hdr_bit_depth 0x121c + +# usl capability register +usl_support_capability 0x1230 v1.1 +- b clock_tree 0 +- b rev_clock_tree 1 +- b rev_clock_calc 2 +usl_clock_mode_d_capability 0x1231 v1.1 +- b cont_clock_standby 0 +- b cont_clock_vblank 1 +- b cont_clock_hblank 2 +- b noncont_clock_standby 3 +- b noncont_clock_vblank 4 +- b noncont_clock_hblank 5 +min_op_sys_clk_div_rev 0x1234 v1.1 +max_op_sys_clk_div_rev 0x1236 v1.1 +min_op_pix_clk_div_rev 0x1238 v1.1 +max_op_pix_clk_div_rev 0x123a v1.1 +min_op_sys_clk_freq_rev_mhz 0x123c 32 v1.1 float_ireal +max_op_sys_clk_freq_rev_mhz 0x1240 32 v1.1 float_ireal +min_op_pix_clk_freq_rev_mhz 0x1244 32 v1.1 float_ireal +max_op_pix_clk_freq_rev_mhz 0x1248 32 v1.1 float_ireal +max_bitrate_rev_d_mode_mbps 0x124c 32 v1.1 ireal +max_symrate_rev_c_mode_msps 0x1250 32 v1.1 ireal + +# image compression capability registers +compression_capability 0x1300 +- b dpcm_pcm_simple 0 + +# test mode capability registers +test_mode_capability 0x1310 16 +- b solid_color 0 +- b color_bars 1 +- b fade_to_grey 2 +- b pn9 3 +- b color_tile 5 +pn9_data_format1 0x1312 +pn9_data_format2 0x1313 +pn9_data_format3 0x1314 +pn9_data_format4 0x1315 +pn9_misc_capability 0x1316 +- f num_pixels 0 2 +- b compression 3 +test_pattern_capability 0x1317 v1.1 +- b no_repeat 1 +pattern_size_div_m1 0x1318 v1.1 + +# fifo capability registers +fifo_support_capability 0x1502 +- e none 0 +- e derating 1 +- e derating_overrating 2 + +# csi-2 capability registers +phy_ctrl_capability 0x1600 +- b auto_phy_ctl 0 +- b ui_phy_ctl 1 +- b dphy_time_ui_reg_1_ctl 2 +- b dphy_time_ui_reg_2_ctl 3 +- b dphy_time_ctl 4 +- b dphy_ext_time_ui_reg_1_ctl 5 +- b dphy_ext_time_ui_reg_2_ctl 6 +- b dphy_ext_time_ctl 7 +csi_dphy_lane_mode_capability 0x1601 +- b 1_lane 0 +- b 2_lane 1 +- b 3_lane 2 +- b 4_lane 3 +- b 5_lane 4 +- b 6_lane 5 +- b 7_lane 6 +- b 8_lane 7 +csi_signaling_mode_capability 0x1602 +- b csi_dphy 2 +- b csi_cphy 3 +fast_standby_capability 0x1603 +- e no_frame_truncation 0 +- e frame_truncation 1 +csi_address_control_capability 0x1604 +- b cci_addr_change 0 +- b 2nd_cci_addr 1 +- b sw_changeable_2nd_cci_addr 2 +data_type_capability 0x1605 +- b dpcm_programmable 0 +- b bottom_embedded_dt_programmable 1 +- b bottom_embedded_vc_programmable 2 +- b ext_vc_range 3 +csi_cphy_lane_mode_capability 0x1606 +- b 1_lane 0 +- b 2_lane 1 +- b 3_lane 2 +- b 4_lane 3 +- b 5_lane 4 +- b 6_lane 5 +- b 7_lane 6 +- b 8_lane 7 +emb_data_capability 0x1607 v1.1 +- b two_bytes_per_raw16 0 +- b two_bytes_per_raw20 1 +- b two_bytes_per_raw24 2 +- b no_one_byte_per_raw16 3 +- b no_one_byte_per_raw20 4 +- b no_one_byte_per_raw24 5 +max_per_lane_bitrate_lane_d_mode_mbps(n) 0x1608 32 ireal +- l n 0 7 4 4,0x32 +temp_sensor_capability 0x1618 +- b supported 0 +- b CCS_format 1 +- b reset_0x80 2 +max_per_lane_bitrate_lane_c_mode_mbps(n) 0x161a 32 ireal +- l n 0 7 4 4,0x30 +dphy_equalization_capability 0x162b +- b equalization_ctrl 0 +- b eq1 1 +- b eq2 2 +cphy_equalization_capability 0x162c +- b equalization_ctrl 0 +dphy_preamble_capability 0x162d +- b preamble_seq_ctrl 0 +dphy_ssc_capability 0x162e +- b supported 0 +cphy_calibration_capability 0x162f +- b manual 0 +- b manual_streaming 1 +- b format_1_ctrl 2 +- b format_2_ctrl 3 +- b format_3_ctrl 4 +dphy_calibration_capability 0x1630 +- b manual 0 +- b manual_streaming 1 +- b alternate_seq 2 +phy_ctrl_capability_2 0x1631 +- b tgr_length 0 +- b tgr_preamble_prog_seq 1 +- b extra_cphy_manual_timing 2 +- b clock_based_manual_cdphy 3 +- b clock_based_manual_dphy 4 +- b clock_based_manual_cphy 5 +- b manual_lp_dphy 6 +- b manual_lp_cphy 7 +lrte_cphy_capability 0x1632 +- b pdq_short 0 +- b spacer_short 1 +- b pdq_long 2 +- b spacer_long 3 +- b spacer_no_pdq 4 +lrte_dphy_capability 0x1633 +- b pdq_short_opt1 0 +- b spacer_short_opt1 1 +- b pdq_long_opt1 2 +- b spacer_long_opt1 3 +- b spacer_short_opt2 4 +- b spacer_long_opt2 5 +- b spacer_no_pdq_opt1 6 +- b spacer_variable_opt2 7 +alps_capability_dphy 0x1634 +- e lvlp_not_supported 0 0x3 +- e lvlp_supported 1 0x3 +- e controllable_lvlp 2 0x3 +alps_capability_cphy 0x1635 +- e lvlp_not_supported 0 0x3 +- e lvlp_supported 1 0x3 +- e controllable_lvlp 2 0x3 +- e alp_not_supported 0xc 0xc +- e alp_supported 0xd 0xc +- e controllable_alp 0xe 0xc +scrambling_capability 0x1636 +- b scrambling_supported 0 +- f max_seeds_per_lane_c 1 2 +- e 1 0 +- e 4 3 +- f num_seed_regs 3 5 +- e 0 0 +- e 1 1 +- e 4 4 +- b num_seed_per_lane 6 +dphy_manual_constant 0x1637 +cphy_manual_constant 0x1638 +CSI2_interface_capability_misc 0x1639 v1.1 +- b eotp_short_pkt_opt2 0 +PHY_ctrl_capability_3 0x165c v1.1 +- b dphy_timing_not_multiple 0 +- b dphy_min_timing_value_1 1 +- b twakeup_supported 2 +- b tinit_supported 3 +- b ths_exit_supported 4 +- b cphy_timing_not_multiple 5 +- b cphy_min_timing_value_1 6 +dphy_sf 0x165d v1.1 +cphy_sf 0x165e v1.1 +- f twakeup 0 3 +- f tinit 4 7 +dphy_limits_1 0x165f v1.1 +- f ths_prepare 0 3 +- f ths_zero 4 7 +dphy_limits_2 0x1660 v1.1 +- f ths_trail 0 3 +- f tclk_trail_min 4 7 +dphy_limits_3 0x1661 v1.1 +- f tclk_prepare 0 3 +- f tclk_zero 4 7 +dphy_limits_4 0x1662 v1.1 +- f tclk_post 0 3 +- f tlpx 4 7 +dphy_limits_5 0x1663 v1.1 +- f ths_exit 0 3 +- f twakeup 4 7 +dphy_limits_6 0x1664 v1.1 +- f tinit 0 3 +cphy_limits_1 0x1665 v1.1 +- f t3_prepare_max 0 3 +- f t3_lpx_max 4 7 +cphy_limits_2 0x1666 v1.1 +- f ths_exit_max 0 3 +- f twakeup_max 4 7 +cphy_limits_3 0x1667 v1.1 +- f tinit_max 0 3 + +# binning capability registers +min_frame_length_lines_bin 0x1700 16 +max_frame_length_lines_bin 0x1702 16 +min_line_length_pck_bin 0x1704 16 +max_line_length_pck_bin 0x1706 16 +min_line_blanking_pck_bin 0x1708 16 +fine_integration_time_min_bin 0x170a 16 +fine_integration_time_max_margin_bin 0x170c 16 +binning_capability 0x1710 +- e unsupported 0 +- e binning_then_subsampling 1 +- e subsampling_then_binning 2 +binning_weighting_capability 0x1711 +- b averaged 0 +- b summed 1 +- b bayer_corrected 2 +- b module_specific_weight 3 +binning_sub_types 0x1712 +binning_sub_type(n) 0x1713 +- l n 0 63 1 +- f row 0 3 +- f column 4 7 +binning_weighting_mono_capability 0x1771 v1.1 +- b averaged 0 +- b summed 1 +- b bayer_corrected 2 +- b module_specific_weight 3 +binning_sub_types_mono 0x1772 v1.1 +binning_sub_type_mono(n) 0x1773 v1.1 f +- l n 0 63 1 + +# data transfer interface capability registers +data_transfer_if_capability 0x1800 +- b supported 0 +- b polling 2 + +# sensor correction capability registers +shading_correction_capability 0x1900 +- b color_shading 0 +- b luminance_correction 1 +green_imbalance_capability 0x1901 +- b supported 0 +module_specific_correction_capability 0x1903 +defect_correction_capability 0x1904 16 +- b mapped_defect 0 +- b dynamic_couplet 2 +- b dynamic_single 5 +- b combined_dynamic 8 +defect_correction_capability_2 0x1906 16 +- b dynamic_triplet 3 +nf_capability 0x1908 +- b luma 0 +- b chroma 1 +- b combined 2 + +# optical black readout capability registers +ob_readout_capability 0x1980 +- b controllable_readout 0 +- b visible_pixel_readout 1 +- b different_vc_readout 2 +- b different_dt_readout 3 +- b prog_data_format 4 + +# color feedback capability registers +color_feedback_capability 0x1987 +- b kelvin 0 +- b awb_gain 1 + +# cfa pattern capability registers +CFA_pattern_capability 0x1990 v1.1 +- e bayer 0 +- e monochrome 1 +- e 4x4_quad_bayer 2 +- e vendor_specific 3 +CFA_pattern_conversion_capability 0x1991 v1.1 +- b bayer 0 + +# timer capability registers +flash_mode_capability 0x1a02 +- b single_strobe 0 +sa_strobe_mode_capability 0x1a03 +- b fixed_width 0 +- b edge_ctrl 1 + +# soft reset capability registers +reset_max_delay 0x1a10 v1.1 +reset_min_time 0x1a11 v1.1 + +# pdaf capability registers +pdaf_capability_1 0x1b80 +- b supported 0 +- b processed_bottom_embedded 1 +- b processed_interleaved 2 +- b raw_bottom_embedded 3 +- b raw_interleaved 4 +- b visible_pdaf_correction 5 +- b vc_interleaving 6 +- b dt_interleaving 7 +pdaf_capability_2 0x1b81 +- b ROI 0 +- b after_digital_crop 1 +- b ctrl_retimed 2 + +# bracketing interface capability registers +bracketing_lut_capability_1 0x1c00 +- b coarse_integration 0 +- b global_analog_gain 1 +- b flash 4 +- b global_digital_gain 5 +- b alternate_global_analog_gain 6 +bracketing_lut_capability_2 0x1c01 +- b single_bracketing_mode 0 +- b looped_bracketing_mode 1 +bracketing_lut_size 0x1c02
Documentation/driver-api/media/drivers/ccs/mk-ccs-regs new file +410 -0
410 lines not on this page · raw message
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 2/29 Documentation: ccs: Add CCS driver documentation
In reply to Sakari AilusDocument the MIPI CCS driver and the C register definition generator.
--- .../driver-api/media/drivers/ccs/ccs.rst | 82 +++++++++++++++++++ .../driver-api/media/drivers/index.rst | 1 + 2 files changed, 83 insertions(+) create mode 100644 Documentation/driver-api/media/drivers/ccs/ccs.rst
Documentation/driver-api/media/drivers/ccs/ccs.rst new file +82 -0
@@ -0,0 +1,82 @@ +.. SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause + +.. include:: <isonum.txt> + +MIPI CCS camera sensor driver +============================= + +The MIPI CCS camera sensor driver is a generic driver for `MIPI CCS +<https://www.mipi.org/specifications/camera-command-set>`_ compliant +camera sensors. It exposes three sub-devices representing the pixel array, +the binner and the scaler. + +As the capabilities of individual devices vary, the driver exposes +interfaces based on the capabilities that exist in hardware. + +Pixel Array sub-device +---------------------- + +The pixel array sub-device represents the camera sensor's pixel matrix, as well +as analogue crop functionality present in many compliant devices. The analogue +crop is configured using the ``V4L2_SEL_TGT_CROP`` on the source pad (0) of the +entity. The size of the pixel matrix can be obtained by getting the +``V4L2_SEL_TGT_NATIVE_SIZE`` target. + +Binner +------ + +The binner sub-device represents the binning functionality on the sensor. For +that purpose, selection target ``V4L2_SEL_TGT_COMPOSE`` is supported on the +sink pad (0). + +Additionally, if a device has no scaler or digital crop functionality, the +source pad (1) expses another digital crop selection rectangle that can only +crop at the end of the lines and frames. + +Scaler +------ + +The scaler sub-device represents the digital crop and scaling functionality of +the sensor. The V4L2 selection target ``V4L2_SEL_TGT_CROP`` is used to +configure the digital crop on the sink pad (0) when digital crop is supported. +Scaling is configured using selection target ``V4L2_SEL_TGT_COMPOSE`` on the +sink pad (0) as well. + +Additionally, if the scaler sub-device exists, its source pad (1) exposes +another digital crop selection rectangle that can only crop at the end of the +lines and frames. + +Digital and analogue crop +------------------------- + +Digital crop functionality is referred to as cropping that effectively works by +dropping some data on the floor. Analogue crop, on the other hand, means that +the cropped information is never retrieved. In case of camera sensors, the +analogue data is never read from the pixel matrix that are outside the +configured selection rectangle that designates crop. The difference has an +effect in device timing and likely also in power consumption. + +Register definition generator +----------------------------- + +The ccs-regs.txt file contains MIPI CCS register definitions that are used +to produce C source code files for definitions that can be better used by +programs written in C language. As there are many dependencies between the +produced files, please do not modify them manually as it's error-prone and +in vain, but instead change the script producing them. + +Usage +~~~~~ + +Conventionally the script is called this way to update the CCS driver +definitions: + +.. code-block:: none + + $ Documentation/driver-api/media/drivers/ccs/mk-ccs-regs \ + -e drivers/media/i2c/ccs/ccs-regs.h \ + -L drivers/media/i2c/ccs/ccs-limits.h \ + -l drivers/media/i2c/ccs/ccs-limits.c \ + -c Documentation/driver-api/media/drivers/ccs/ccs-regs.txt + +**Copyright** |copy| 2020 Intel Corporation
Documentation/driver-api/media/drivers/index.rst +1 -0
@@ -26,6 +26,7 @@ Video4Linux (V4L) drivers tuners vimc-devel zoran + ccs/ccs Digital TV drivers
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 3/29 smiapp: Import CCS definitions
In reply to Sakari AilusImport CCS register and limit definitions. These files are generated by a Perl script based on a text-based register definition file. The generator is added later in the series.
--- drivers/media/i2c/smiapp/ccs-limits.c | 239 +++++++ drivers/media/i2c/smiapp/ccs-limits.h | 258 +++++++ drivers/media/i2c/smiapp/ccs-regs.h | 953 ++++++++++++++++++++++++++ 3 files changed, 1450 insertions(+) create mode 100644 drivers/media/i2c/smiapp/ccs-limits.c create mode 100644 drivers/media/i2c/smiapp/ccs-limits.h create mode 100644 drivers/media/i2c/smiapp/ccs-regs.h
drivers/media/i2c/smiapp/ccs-limits.c new file +239 -0
@@ -0,0 +1,239 @@ +// SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause +/* Copyright (C) 2019--2020 Intel Corporation */ + +#include "ccs-limits.h" +#include "ccs-regs.h" + +const struct ccs_limit ccs_limits[] = { + {CCS_R_FRAME_FORMAT_MODEL_TYPE ,1 ,0 ,"frame_format_model_type" }, + {CCS_R_FRAME_FORMAT_MODEL_SUBTYPE ,1 ,0 ,"frame_format_model_subtype" }, + {CCS_R_FRAME_FORMAT_DESCRIPTOR (0 ),30 ,0 ,"frame_format_descriptor" }, + {CCS_R_FRAME_FORMAT_DESCRIPTOR_4 (0 ),32 ,0 ,"frame_format_descriptor_4" }, + {CCS_R_ANALOG_GAIN_CAPABILITY ,2 ,0 ,"analog_gain_capability" }, + {CCS_R_ANALOG_GAIN_CODE_MIN ,2 ,0 ,"analog_gain_code_min" }, + {CCS_R_ANALOG_GAIN_CODE_MAX ,2 ,0 ,"analog_gain_code_max" }, + {CCS_R_ANALOG_GAIN_CODE_STEP ,2 ,0 ,"analog_gain_code_step" }, + {CCS_R_ANALOG_GAIN_TYPE ,2 ,0 ,"analog_gain_type" }, + {CCS_R_ANALOG_GAIN_M0 ,2 ,0 ,"analog_gain_m0" }, + {CCS_R_ANALOG_GAIN_C0 ,2 ,0 ,"analog_gain_c0" }, + {CCS_R_ANALOG_GAIN_M1 ,2 ,0 ,"analog_gain_m1" }, + {CCS_R_ANALOG_GAIN_C1 ,2 ,0 ,"analog_gain_c1" }, + {CCS_R_ANALOG_LINEAR_GAIN_MIN ,2 ,0 ,"analog_linear_gain_min" }, + {CCS_R_ANALOG_LINEAR_GAIN_MAX ,2 ,0 ,"analog_linear_gain_max" }, + {CCS_R_ANALOG_LINEAR_GAIN_STEP_SIZE ,2 ,0 ,"analog_linear_gain_step_size" }, + {CCS_R_ANALOG_EXPONENTIAL_GAIN_MIN ,2 ,0 ,"analog_exponential_gain_min" }, + {CCS_R_ANALOG_EXPONENTIAL_GAIN_MAX ,2 ,0 ,"analog_exponential_gain_max" }, + {CCS_R_ANALOG_EXPONENTIAL_GAIN_STEP_SIZE ,2 ,0 ,"analog_exponential_gain_step_size" }, + {CCS_R_DATA_FORMAT_MODEL_TYPE ,1 ,0 ,"data_format_model_type" }, + {CCS_R_DATA_FORMAT_MODEL_SUBTYPE ,1 ,0 ,"data_format_model_subtype" }, + {CCS_R_DATA_FORMAT_DESCRIPTOR (0 ),32 ,0 ,"data_format_descriptor" }, + {CCS_R_INTEGRATION_TIME_CAPABILITY ,2 ,0 ,"integration_time_capability" }, + {CCS_R_COARSE_INTEGRATION_TIME_MIN ,2 ,0 ,"coarse_integration_time_min" }, + {CCS_R_COARSE_INTEGRATION_TIME_MAX_MARGIN ,2 ,0 ,"coarse_integration_time_max_margin" }, + {CCS_R_FINE_INTEGRATION_TIME_MIN ,2 ,0 ,"fine_integration_time_min" }, + {CCS_R_FINE_INTEGRATION_TIME_MAX_MARGIN ,2 ,0 ,"fine_integration_time_max_margin" }, + {CCS_R_DIGITAL_GAIN_CAPABILITY ,1 ,0 ,"digital_gain_capability" }, + {CCS_R_DIGITAL_GAIN_MIN ,2 ,0 ,"digital_gain_min" }, + {CCS_R_DIGITAL_GAIN_MAX ,2 ,0 ,"digital_gain_max" }, + {CCS_R_DIGITAL_GAIN_STEP_SIZE ,2 ,0 ,"digital_gain_step_size" }, + {CCS_R_PEDESTAL_CAPABILITY ,1 ,0 ,"Pedestal_capability" }, + {CCS_R_ADC_CAPABILITY ,1 ,0 ,"ADC_capability" }, + {CCS_R_ADC_BIT_DEPTH_CAPABILITY ,4 ,0 ,"ADC_bit_depth_capability" }, + {CCS_R_MIN_EXT_CLK_FREQ_MHZ ,4 ,0 ,"min_ext_clk_freq_mhz" }, + {CCS_R_MAX_EXT_CLK_FREQ_MHZ ,4 ,0 ,"max_ext_clk_freq_mhz" }, + {CCS_R_MIN_PRE_PLL_CLK_DIV ,2 ,0 ,"min_pre_pll_clk_div" }, + {CCS_R_MAX_PRE_PLL_CLK_DIV ,2 ,0 ,"max_pre_pll_clk_div" }, + {CCS_R_MIN_PLL_IP_CLK_FREQ_MHZ ,4 ,0 ,"min_pll_ip_clk_freq_mhz" }, + {CCS_R_MAX_PLL_IP_CLK_FREQ_MHZ ,4 ,0 ,"max_pll_ip_clk_freq_mhz" }, + {CCS_R_MIN_PLL_MULTIPLIER ,2 ,0 ,"min_pll_multiplier" }, + {CCS_R_MAX_PLL_MULTIPLIER ,2 ,0 ,"max_pll_multiplier" }, + {CCS_R_MIN_PLL_OP_CLK_FREQ_MHZ ,4 ,0 ,"min_pll_op_clk_freq_mhz" }, + {CCS_R_MAX_PLL_OP_CLK_FREQ_MHZ ,4 ,0 ,"max_pll_op_clk_freq_mhz" }, + {CCS_R_MIN_VT_SYS_CLK_DIV ,2 ,0 ,"min_vt_sys_clk_div" }, + {CCS_R_MAX_VT_SYS_CLK_DIV ,2 ,0 ,"max_vt_sys_clk_div" }, + {CCS_R_MIN_VT_SYS_CLK_FREQ_MHZ ,4 ,0 ,"min_vt_sys_clk_freq_mhz" }, + {CCS_R_MAX_VT_SYS_CLK_FREQ_MHZ ,4 ,0 ,"max_vt_sys_clk_freq_mhz" }, + {CCS_R_MIN_VT_PIX_CLK_FREQ_MHZ ,4 ,0 ,"min_vt_pix_clk_freq_mhz" }, + {CCS_R_MAX_VT_PIX_CLK_FREQ_MHZ ,4 ,0 ,"max_vt_pix_clk_freq_mhz" }, + {CCS_R_MIN_VT_PIX_CLK_DIV ,2 ,0 ,"min_vt_pix_clk_div" }, + {CCS_R_MAX_VT_PIX_CLK_DIV ,2 ,0 ,"max_vt_pix_clk_div" }, + {CCS_R_CLOCK_CALCULATION ,1 ,0 ,"clock_calculation" }, + {CCS_R_NUM_OF_VT_LANES ,1 ,0 ,"num_of_vt_lanes" }, + {CCS_R_NUM_OF_OP_LANES ,1 ,0 ,"num_of_op_lanes" }, + {CCS_R_OP_BITS_PER_LANE ,1 ,0 ,"op_bits_per_lane" }, + {CCS_R_MIN_FRAME_LENGTH_LINES ,2 ,0 ,"min_frame_length_lines" }, + {CCS_R_MAX_FRAME_LENGTH_LINES ,2 ,0 ,"max_frame_length_lines" }, + {CCS_R_MIN_LINE_LENGTH_PCK ,2 ,0 ,"min_line_length_pck" }, + {CCS_R_MAX_LINE_LENGTH_PCK ,2 ,0 ,"max_line_length_pck" }, + {CCS_R_MIN_LINE_BLANKING_PCK ,2 ,0 ,"min_line_blanking_pck" }, + {CCS_R_MIN_FRAME_BLANKING_LINES ,2 ,0 ,"min_frame_blanking_lines" }, + {CCS_R_MIN_LINE_LENGTH_PCK_STEP_SIZE ,1 ,0 ,"min_line_length_pck_step_size" }, + {CCS_R_TIMING_MODE_CAPABILITY ,1 ,0 ,"timing_mode_capability" }, + {CCS_R_FRAME_MARGIN_MAX_VALUE ,2 ,0 ,"frame_margin_max_value" }, + {CCS_R_FRAME_MARGIN_MIN_VALUE ,1 ,0 ,"frame_margin_min_value" }, + {CCS_R_GAIN_DELAY_TYPE ,1 ,0 ,"gain_delay_type" }, + {CCS_R_MIN_OP_SYS_CLK_DIV ,2 ,0 ,"min_op_sys_clk_div" }, + {CCS_R_MAX_OP_SYS_CLK_DIV ,2 ,0 ,"max_op_sys_clk_div" }, + {CCS_R_MIN_OP_SYS_CLK_FREQ_MHZ ,4 ,0 ,"min_op_sys_clk_freq_mhz" }, + {CCS_R_MAX_OP_SYS_CLK_FREQ_MHZ ,4 ,0 ,"max_op_sys_clk_freq_mhz" }, + {CCS_R_MIN_OP_PIX_CLK_DIV ,2 ,0 ,"min_op_pix_clk_div" }, + {CCS_R_MAX_OP_PIX_CLK_DIV ,2 ,0 ,"max_op_pix_clk_div" }, + {CCS_R_MIN_OP_PIX_CLK_FREQ_MHZ ,4 ,0 ,"min_op_pix_clk_freq_mhz" }, + {CCS_R_MAX_OP_PIX_CLK_FREQ_MHZ ,4 ,0 ,"max_op_pix_clk_freq_mhz" }, + {CCS_R_X_ADDR_MIN ,2 ,0 ,"x_addr_min" }, + {CCS_R_Y_ADDR_MIN ,2 ,0 ,"y_addr_min" }, + {CCS_R_X_ADDR_MAX ,2 ,0 ,"x_addr_max" }, + {CCS_R_Y_ADDR_MAX ,2 ,0 ,"y_addr_max" }, + {CCS_R_MIN_X_OUTPUT_SIZE ,2 ,0 ,"min_x_output_size" }, + {CCS_R_MIN_Y_OUTPUT_SIZE ,2 ,0 ,"min_y_output_size" }, + {CCS_R_MAX_X_OUTPUT_SIZE ,2 ,0 ,"max_x_output_size" }, + {CCS_R_MAX_Y_OUTPUT_SIZE ,2 ,0 ,"max_y_output_size" }, + {CCS_R_X_ADDR_START_DIV_CONSTANT ,1 ,0 ,"x_addr_start_div_constant" }, + {CCS_R_Y_ADDR_START_DIV_CONSTANT ,1 ,0 ,"y_addr_start_div_constant" }, + {CCS_R_X_ADDR_END_DIV_CONSTANT ,1 ,0 ,"x_addr_end_div_constant" }, + {CCS_R_Y_ADDR_END_DIV_CONSTANT ,1 ,0 ,"y_addr_end_div_constant" }, + {CCS_R_X_SIZE_DIV ,1 ,0 ,"x_size_div" }, + {CCS_R_Y_SIZE_DIV ,1 ,0 ,"y_size_div" }, + {CCS_R_X_OUTPUT_DIV ,1 ,0 ,"x_output_div" }, + {CCS_R_Y_OUTPUT_DIV ,1 ,0 ,"y_output_div" }, + {CCS_R_NON_FLEXIBLE_RESOLUTION_SUPPORT ,1 ,0 ,"non_flexible_resolution_support" }, + {CCS_R_MIN_OP_PRE_PLL_CLK_DIV ,2 ,0 ,"min_op_pre_pll_clk_div" }, + {CCS_R_MAX_OP_PRE_PLL_CLK_DIV ,2 ,0 ,"max_op_pre_pll_clk_div" }, + {CCS_R_MIN_OP_PLL_IP_CLK_FREQ_MHZ ,4 ,0 ,"min_op_pll_ip_clk_freq_mhz" }, + {CCS_R_MAX_OP_PLL_IP_CLK_FREQ_MHZ ,4 ,0 ,"max_op_pll_ip_clk_freq_mhz" }, + {CCS_R_MIN_OP_PLL_MULTIPLIER ,2 ,0 ,"min_op_pll_multiplier" }, + {CCS_R_MAX_OP_PLL_MULTIPLIER ,2 ,0 ,"max_op_pll_multiplier" }, + {CCS_R_MIN_OP_PLL_OP_CLK_FREQ_MHZ ,4 ,0 ,"min_op_pll_op_clk_freq_mhz" }, + {CCS_R_MAX_OP_PLL_OP_CLK_FREQ_MHZ ,4 ,0 ,"max_op_pll_op_clk_freq_mhz" }, + {CCS_R_CLOCK_TREE_PLL_CAPABILITY ,1 ,0 ,"clock_tree_pll_capability" }, + {CCS_R_CLOCK_CAPA_TYPE_CAPABILITY ,1 ,0 ,"clock_capa_type_capability" }, + {CCS_R_MIN_EVEN_INC ,2 ,0 ,"min_even_inc" }, + {CCS_R_MIN_ODD_INC ,2 ,0 ,"min_odd_inc" }, + {CCS_R_MAX_EVEN_INC ,2 ,0 ,"max_even_inc" }, + {CCS_R_MAX_ODD_INC ,2 ,0 ,"max_odd_inc" }, + {CCS_R_AUX_SUBSAMP_CAPABILITY ,1 ,0 ,"aux_subsamp_capability" }, + {CCS_R_AUX_SUBSAMP_MONO_CAPABILITY ,1 ,0 ,"aux_subsamp_mono_capability" }, + {CCS_R_MONOCHROME_CAPABILITY ,1 ,0 ,"monochrome_capability" }, + {CCS_R_PIXEL_READOUT_CAPABILITY ,1 ,0 ,"pixel_readout_capability" }, + {CCS_R_MIN_EVEN_INC_MONO ,2 ,0 ,"min_even_inc_mono" }, + {CCS_R_MAX_EVEN_INC_MONO ,2 ,0 ,"max_even_inc_mono" }, + {CCS_R_MIN_ODD_INC_MONO ,2 ,0 ,"min_odd_inc_mono" }, + {CCS_R_MAX_ODD_INC_MONO ,2 ,0 ,"max_odd_inc_mono" }, + {CCS_R_MIN_EVEN_INC_BC2 ,2 ,0 ,"min_even_inc_bc2" }, + {CCS_R_MAX_EVEN_INC_BC2 ,2 ,0 ,"max_even_inc_bc2" }, + {CCS_R_MIN_ODD_INC_BC2 ,2 ,0 ,"min_odd_inc_bc2" }, + {CCS_R_MAX_ODD_INC_BC2 ,2 ,0 ,"max_odd_inc_bc2" }, + {CCS_R_MIN_EVEN_INC_MONO_BC2 ,2 ,0 ,"min_even_inc_mono_bc2" }, + {CCS_R_MAX_EVEN_INC_MONO_BC2 ,2 ,0 ,"max_even_inc_mono_bc2" }, + {CCS_R_MIN_ODD_INC_MONO_BC2 ,2 ,0 ,"min_odd_inc_mono_bc2" }, + {CCS_R_MAX_ODD_INC_MONO_BC2 ,2 ,0 ,"max_odd_inc_mono_bc2" }, + {CCS_R_SCALING_CAPABILITY ,2 ,0 ,"scaling_capability" }, + {CCS_R_SCALER_M_MIN ,2 ,0 ,"scaler_m_min" }, + {CCS_R_SCALER_M_MAX ,2 ,0 ,"scaler_m_max" }, + {CCS_R_SCALER_N_MIN ,2 ,0 ,"scaler_n_min" }, + {CCS_R_SCALER_N_MAX ,2 ,0 ,"scaler_n_max" }, + {CCS_R_DIGITAL_CROP_CAPABILITY ,1 ,0 ,"digital_crop_capability" }, + {CCS_R_HDR_CAPABILITY_1 ,1 ,0 ,"hdr_capability_1" }, + {CCS_R_MIN_HDR_BIT_DEPTH ,1 ,0 ,"min_hdr_bit_depth" }, + {CCS_R_HDR_RESOLUTION_SUB_TYPES ,1 ,0 ,"hdr_resolution_sub_types" }, + {CCS_R_HDR_RESOLUTION_SUB_TYPE (0 ),2 ,0 ,"hdr_resolution_sub_type" }, + {CCS_R_HDR_CAPABILITY_2 ,1 ,0 ,"hdr_capability_2" }, + {CCS_R_MAX_HDR_BIT_DEPTH ,1 ,0 ,"max_hdr_bit_depth" }, + {CCS_R_USL_SUPPORT_CAPABILITY ,1 ,0 ,"usl_support_capability" }, + {CCS_R_USL_CLOCK_MODE_D_CAPABILITY ,1 ,0 ,"usl_clock_mode_d_capability" }, + {CCS_R_MIN_OP_SYS_CLK_DIV_REV ,1 ,0 ,"min_op_sys_clk_div_rev" }, + {CCS_R_MAX_OP_SYS_CLK_DIV_REV ,1 ,0 ,"max_op_sys_clk_div_rev" }, + {CCS_R_MIN_OP_PIX_CLK_DIV_REV ,1 ,0 ,"min_op_pix_clk_div_rev" }, + {CCS_R_MAX_OP_PIX_CLK_DIV_REV ,1 ,0 ,"max_op_pix_clk_div_rev" }, + {CCS_R_MIN_OP_SYS_CLK_FREQ_REV_MHZ ,4 ,0 ,"min_op_sys_clk_freq_rev_mhz" }, + {CCS_R_MAX_OP_SYS_CLK_FREQ_REV_MHZ ,4 ,0 ,"max_op_sys_clk_freq_rev_mhz" }, + {CCS_R_MIN_OP_PIX_CLK_FREQ_REV_MHZ ,4 ,0 ,"min_op_pix_clk_freq_rev_mhz" }, + {CCS_R_MAX_OP_PIX_CLK_FREQ_REV_MHZ ,4 ,0 ,"max_op_pix_clk_freq_rev_mhz" }, + {CCS_R_MAX_BITRATE_REV_D_MODE_MBPS ,4 ,0 ,"max_bitrate_rev_d_mode_mbps" }, + {CCS_R_MAX_SYMRATE_REV_C_MODE_MSPS ,4 ,0 ,"max_symrate_rev_c_mode_msps" }, + {CCS_R_COMPRESSION_CAPABILITY ,1 ,0 ,"compression_capability" }, + {CCS_R_TEST_MODE_CAPABILITY ,2 ,0 ,"test_mode_capability" }, + {CCS_R_PN9_DATA_FORMAT1 ,1 ,0 ,"pn9_data_format1" }, + {CCS_R_PN9_DATA_FORMAT2 ,1 ,0 ,"pn9_data_format2" }, + {CCS_R_PN9_DATA_FORMAT3 ,1 ,0 ,"pn9_data_format3" }, + {CCS_R_PN9_DATA_FORMAT4 ,1 ,0 ,"pn9_data_format4" }, + {CCS_R_PN9_MISC_CAPABILITY ,1 ,0 ,"pn9_misc_capability" }, + {CCS_R_TEST_PATTERN_CAPABILITY ,1 ,0 ,"test_pattern_capability" }, + {CCS_R_PATTERN_SIZE_DIV_M1 ,1 ,0 ,"pattern_size_div_m1" }, + {CCS_R_FIFO_SUPPORT_CAPABILITY ,1 ,0 ,"fifo_support_capability" }, + {CCS_R_PHY_CTRL_CAPABILITY ,1 ,0 ,"phy_ctrl_capability" }, + {CCS_R_CSI_DPHY_LANE_MODE_CAPABILITY ,1 ,0 ,"csi_dphy_lane_mode_capability" }, + {CCS_R_CSI_SIGNALING_MODE_CAPABILITY ,1 ,0 ,"csi_signaling_mode_capability" }, + {CCS_R_FAST_STANDBY_CAPABILITY ,1 ,0 ,"fast_standby_capability" }, + {CCS_R_CSI_ADDRESS_CONTROL_CAPABILITY ,1 ,0 ,"csi_address_control_capability" }, + {CCS_R_DATA_TYPE_CAPABILITY ,1 ,0 ,"data_type_capability" }, + {CCS_R_CSI_CPHY_LANE_MODE_CAPABILITY ,1 ,0 ,"csi_cphy_lane_mode_capability" }, + {CCS_R_EMB_DATA_CAPABILITY ,1 ,0 ,"emb_data_capability" }, + {CCS_R_MAX_PER_LANE_BITRATE_LANE_D_MODE_MBPS (0 ),16 ,0 ,"max_per_lane_bitrate_lane_d_mode_mbps 0" }, + {CCS_R_MAX_PER_LANE_BITRATE_LANE_D_MODE_MBPS (4 ),16 ,CCS_L_FL_SAME_REG ,"max_per_lane_bitrate_lane_d_mode_mbps 4" }, + {CCS_R_TEMP_SENSOR_CAPABILITY ,1 ,0 ,"temp_sensor_capability" }, + {CCS_R_MAX_PER_LANE_BITRATE_LANE_C_MODE_MBPS (0 ),16 ,0 ,"max_per_lane_bitrate_lane_c_mode_mbps 0" }, + {CCS_R_MAX_PER_LANE_BITRATE_LANE_C_MODE_MBPS (4 ),16 ,CCS_L_FL_SAME_REG ,"max_per_lane_bitrate_lane_c_mode_mbps 4" }, + {CCS_R_DPHY_EQUALIZATION_CAPABILITY ,1 ,0 ,"dphy_equalization_capability" }, + {CCS_R_CPHY_EQUALIZATION_CAPABILITY ,1 ,0 ,"cphy_equalization_capability" }, + {CCS_R_DPHY_PREAMBLE_CAPABILITY ,1 ,0 ,"dphy_preamble_capability" }, + {CCS_R_DPHY_SSC_CAPABILITY ,1 ,0 ,"dphy_ssc_capability" }, + {CCS_R_CPHY_CALIBRATION_CAPABILITY ,1 ,0 ,"cphy_calibration_capability" }, + {CCS_R_DPHY_CALIBRATION_CAPABILITY ,1 ,0 ,"dphy_calibration_capability" }, + {CCS_R_PHY_CTRL_CAPABILITY_2 ,1 ,0 ,"phy_ctrl_capability_2" }, + {CCS_R_LRTE_CPHY_CAPABILITY ,1 ,0 ,"lrte_cphy_capability" }, + {CCS_R_LRTE_DPHY_CAPABILITY ,1 ,0 ,"lrte_dphy_capability" }, + {CCS_R_ALPS_CAPABILITY_DPHY ,1 ,0 ,"alps_capability_dphy" }, + {CCS_R_ALPS_CAPABILITY_CPHY ,1 ,0 ,"alps_capability_cphy" }, + {CCS_R_SCRAMBLING_CAPABILITY ,1 ,0 ,"scrambling_capability" }, + {CCS_R_DPHY_MANUAL_CONSTANT ,1 ,0 ,"dphy_manual_constant" }, + {CCS_R_CPHY_MANUAL_CONSTANT ,1 ,0 ,"cphy_manual_constant" }, + {CCS_R_CSI2_INTERFACE_CAPABILITY_MISC ,1 ,0 ,"CSI2_interface_capability_misc" }, + {CCS_R_PHY_CTRL_CAPABILITY_3 ,1 ,0 ,"PHY_ctrl_capability_3" }, + {CCS_R_DPHY_SF ,1 ,0 ,"dphy_sf" }, + {CCS_R_CPHY_SF ,1 ,0 ,"cphy_sf" }, + {CCS_R_DPHY_LIMITS_1 ,1 ,0 ,"dphy_limits_1" }, + {CCS_R_DPHY_LIMITS_2 ,1 ,0 ,"dphy_limits_2" }, + {CCS_R_DPHY_LIMITS_3 ,1 ,0 ,"dphy_limits_3" }, + {CCS_R_DPHY_LIMITS_4 ,1 ,0 ,"dphy_limits_4" }, + {CCS_R_DPHY_LIMITS_5 ,1 ,0 ,"dphy_limits_5" }, + {CCS_R_DPHY_LIMITS_6 ,1 ,0 ,"dphy_limits_6" }, + {CCS_R_CPHY_LIMITS_1 ,1 ,0 ,"cphy_limits_1" }, + {CCS_R_CPHY_LIMITS_2 ,1 ,0 ,"cphy_limits_2" }, + {CCS_R_CPHY_LIMITS_3 ,1 ,0 ,"cphy_limits_3" }, + {CCS_R_MIN_FRAME_LENGTH_LINES_BIN ,2 ,0 ,"min_frame_length_lines_bin" }, + {CCS_R_MAX_FRAME_LENGTH_LINES_BIN ,2 ,0 ,"max_frame_length_lines_bin" }, + {CCS_R_MIN_LINE_LENGTH_PCK_BIN ,2 ,0 ,"min_line_length_pck_bin" }, + {CCS_R_MAX_LINE_LENGTH_PCK_BIN ,2 ,0 ,"max_line_length_pck_bin" }, + {CCS_R_MIN_LINE_BLANKING_PCK_BIN ,2 ,0 ,"min_line_blanking_pck_bin" }, + {CCS_R_FINE_INTEGRATION_TIME_MIN_BIN ,2 ,0 ,"fine_integration_time_min_bin" }, + {CCS_R_FINE_INTEGRATION_TIME_MAX_MARGIN_BIN ,2 ,0 ,"fine_integration_time_max_margin_bin" }, + {CCS_R_BINNING_CAPABILITY ,1 ,0 ,"binning_capability" }, + {CCS_R_BINNING_WEIGHTING_CAPABILITY ,1 ,0 ,"binning_weighting_capability" }, + {CCS_R_BINNING_SUB_TYPES ,1 ,0 ,"binning_sub_types" }, + {CCS_R_BINNING_SUB_TYPE (0 ),64 ,0 ,"binning_sub_type" }, + {CCS_R_BINNING_WEIGHTING_MONO_CAPABILITY ,1 ,0 ,"binning_weighting_mono_capability" }, + {CCS_R_BINNING_SUB_TYPES_MONO ,1 ,0 ,"binning_sub_types_mono" }, + {CCS_R_BINNING_SUB_TYPE_MONO (0 ),64 ,0 ,"binning_sub_type_mono" }, + {CCS_R_DATA_TRANSFER_IF_CAPABILITY ,1 ,0 ,"data_transfer_if_capability" }, + {CCS_R_SHADING_CORRECTION_CAPABILITY ,1 ,0 ,"shading_correction_capability" }, + {CCS_R_GREEN_IMBALANCE_CAPABILITY ,1 ,0 ,"green_imbalance_capability" }, + {CCS_R_MODULE_SPECIFIC_CORRECTION_CAPABILITY ,1 ,0 ,"module_specific_correction_capability" }, + {CCS_R_DEFECT_CORRECTION_CAPABILITY ,2 ,0 ,"defect_correction_capability" }, + {CCS_R_DEFECT_CORRECTION_CAPABILITY_2 ,2 ,0 ,"defect_correction_capability_2" }, + {CCS_R_NF_CAPABILITY ,1 ,0 ,"nf_capability" }, + {CCS_R_OB_READOUT_CAPABILITY ,1 ,0 ,"ob_readout_capability" }, + {CCS_R_COLOR_FEEDBACK_CAPABILITY ,1 ,0 ,"color_feedback_capability" }, + {CCS_R_CFA_PATTERN_CAPABILITY ,1 ,0 ,"CFA_pattern_capability" }, + {CCS_R_CFA_PATTERN_CONVERSION_CAPABILITY ,1 ,0 ,"CFA_pattern_conversion_capability" }, + {CCS_R_FLASH_MODE_CAPABILITY ,1 ,0 ,"flash_mode_capability" }, + {CCS_R_SA_STROBE_MODE_CAPABILITY ,1 ,0 ,"sa_strobe_mode_capability" }, + {CCS_R_RESET_MAX_DELAY ,1 ,0 ,"reset_max_delay" }, + {CCS_R_RESET_MIN_TIME ,1 ,0 ,"reset_min_time" }, + {CCS_R_PDAF_CAPABILITY_1 ,1 ,0 ,"pdaf_capability_1" }, + {CCS_R_PDAF_CAPABILITY_2 ,1 ,0 ,"pdaf_capability_2" }, + {CCS_R_BRACKETING_LUT_CAPABILITY_1 ,1 ,0 ,"bracketing_lut_capability_1" }, + {CCS_R_BRACKETING_LUT_CAPABILITY_2 ,1 ,0 ,"bracketing_lut_capability_2" }, + {CCS_R_BRACKETING_LUT_SIZE ,1 ,0 ,"bracketing_lut_size" }, + {0 }/* Guardian */ +};
drivers/media/i2c/smiapp/ccs-limits.h new file +258 -0
258 lines not on this page · raw message
drivers/media/i2c/smiapp/ccs-regs.h new file +953 -0
953 lines not on this page · raw message
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 4/29 smiapp: Use CCS register flags
In reply to Sakari AilusUse the CCS register flags instead of the old smia flags. The new flags include the register width information that was separate from the register flags previously.
--- drivers/media/i2c/smiapp/smiapp-reg-defs.h | 8 ++++---- drivers/media/i2c/smiapp/smiapp-regs.c | 20 +++++++++++++------- drivers/media/i2c/smiapp/smiapp-regs.h | 13 ++++--------- 3 files changed, 21 insertions(+), 20 deletions(-)
drivers/media/i2c/smiapp/smiapp-reg-defs.h +4 -4
@@ -7,11 +7,11 @@* Copyright (C) 2011--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */ -#define SMIAPP_REG_MK_U8 (r) ((SMIAPP_REG_8BIT << 16) | (r)) -#define SMIAPP_REG_MK_U16 (r) ((SMIAPP_REG_16BIT << 16) | (r)) -#define SMIAPP_REG_MK_U32 (r) ((SMIAPP_REG_32BIT << 16) | (r)) +#define SMIAPP_REG_MK_U8 (r) (r) +#define SMIAPP_REG_MK_U16 (r) (CCS_FL_16BIT | (r)) +#define SMIAPP_REG_MK_U32 (r) (CCS_FL_32BIT | (r)) -#define SMIAPP_REG_MK_F32 (r) (SMIAPP_REG_FLAG_FLOAT | (SMIAPP_REG_32BIT << 16) | (r)) +#define SMIAPP_REG_MK_F32 (r) (CCS_FL_FLOAT_IREAL | CCS_FL_32BIT | (r))#define SMIAPP_REG_U16_MODEL_ID SMIAPP_REG_MK_U16(0x0000)#define SMIAPP_REG_U8_REVISION_NUMBER_MAJOR SMIAPP_REG_MK_U8(0x0002)
drivers/media/i2c/smiapp/smiapp-regs.c +13 -7
@@ -133,6 +133,16 @@ static int ____smiapp_read_8only(struct smiapp_sensor *sensor, u16 reg,return 0 ; } +unsigned int ccs_reg_width (u32 reg) +{ +if (reg &CCS_FL_16BIT ) +return sizeof (uint16_t ); +if (reg &CCS_FL_32BIT ) +return sizeof (uint32_t ); + +return sizeof (uint8_t ); +} +/* * Read a 8/16/32-bit i2c register. The value is returned in 'val'. * Returns zero if successful, or non-zero otherwise.
@@ -141,13 +151,9 @@ static int __smiapp_read(struct smiapp_sensor *sensor, u32 reg, u32 *val, bool only8) {struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd); -u8 len =SMIAPP_REG_WIDTH (reg); +unsigned int len =ccs_reg_width (reg);int rval; -if (len !=SMIAPP_REG_8BIT && len !=SMIAPP_REG_16BIT - && len !=SMIAPP_REG_32BIT ) -return -EINVAL ; -if (!only8) rval =____smiapp_read (sensor,SMIAPP_REG_ADDR (reg), len, val);else
@@ -156,7 +162,7 @@ static int __smiapp_read(struct smiapp_sensor *sensor, u32 reg, u32 *val,if (rval <0 )return rval; -if (reg &SMIAPP_REG_FLAG_FLOAT ) +if (reg &CCS_FL_FLOAT_IREAL ) *val =float_to_u32_mul_1000000 (client, *val);return 0 ;
@@ -204,7 +210,7 @@ int smiapp_write_no_quirk(struct smiapp_sensor *sensor, u32 reg, u32 val)struct i2c_msg msg;unsigned char data[6 ];unsigned int retries; -u8 len =SMIAPP_REG_WIDTH (reg); +unsigned int len =ccs_reg_width (reg);int r;if (len >sizeof (data) -2 )
drivers/media/i2c/smiapp/smiapp-regs.h +4 -9
@@ -14,16 +14,9 @@#include <linux/i2c.h> #include <linux/types.h> -#define SMIAPP_REG_ADDR (reg) ((u16)reg) -#define SMIAPP_REG_WIDTH (reg) ((u8)(reg >> 16)) -#define SMIAPP_REG_FLAGS (reg) ((u8)(reg >> 24)) - -/* Use upper 8 bits of the type field for flags */ -#define SMIAPP_REG_FLAG_FLOAT (1 << 24) +#include "ccs-regs.h" -#define SMIAPP_REG_8BIT 1 -#define SMIAPP_REG_16BIT 2 -#define SMIAPP_REG_32BIT 4 +#define SMIAPP_REG_ADDR (reg) ((u16)reg)struct smiapp_sensor ;
@@ -33,4 +26,6 @@ int smiapp_read_8only(struct smiapp_sensor *sensor, u32 reg, u32 *val);int smiapp_write_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 val);int smiapp_write (struct smiapp_sensor *sensor,u32 reg,u32 val); +unsigned int ccs_reg_width (u32 reg); +#endif
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 5/29 smiapp: Calculate CCS limit offsets and limit buffer size
In reply to Sakari AilusCalculate the limit offsets and the size of the limit buffer. CCS limits are read into this buffer, and the offsets are helpful in accessing the information in it.
--- drivers/media/i2c/smiapp/smiapp-core.c | 40 +++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-)
drivers/media/i2c/smiapp/smiapp-core.c +39 -1
@@ -27,6 +27,7 @@#include <media/v4l2-fwnode.h> #include <media/v4l2-device.h> +#include "ccs-limits.h" #include "smiapp.h" #define SMIAPP_ALIGN_DIM (dim, flags) \
@@ -34,6 +35,11 @@ ? ALIGN((dim), 2) \ : (dim) & ~1) +static struct ccs_limit_offset { +u16 lim; +u16 info; +} ccs_limit_offsets[CCS_L_LAST +1 ]; +/* * smiapp_module_idents - supported camera modules */
@@ -3166,7 +3172,39 @@ static struct i2c_driver smiapp_i2c_driver = { .id_table = smiapp_id_table, }; -module_i2c_driver (smiapp_i2c_driver); +static int smiapp_module_init (void ) +{ +unsigned int i, l; + +for (i =0 , l =0 ; ccs_limits[i].size && l <CCS_L_LAST ; i++) { +if (!(ccs_limits[i].flags &CCS_L_FL_SAME_REG )) { + ccs_limit_offsets[l +1 ].lim = +ALIGN (ccs_limit_offsets[l].lim + + ccs_limits[i].size, +ccs_reg_width (ccs_limits[i +1 ].reg)); + ccs_limit_offsets[l].info = i; + l++; + }else { + ccs_limit_offsets[l].lim += ccs_limits[i].size; + } + } + +if (WARN_ON (ccs_limits[i].size)) +return -EINVAL ; + +if (WARN_ON (l !=CCS_L_LAST )) +return -EINVAL ; + +return i2c_register_driver (THIS_MODULE , &smiapp_i2c_driver); +} + +static void smiapp_module_cleanup (void ) +{ +i2c_del_driver (&smiapp_i2c_driver); +} + +module_init (smiapp_module_init); +module_exit (smiapp_module_cleanup);MODULE_AUTHOR ("Sakari Ailus <[email protected]>" );MODULE_DESCRIPTION ("Generic SMIA/SMIA++ camera module driver" );
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 6/29 smiapp: Remove macros for defining registers, merge definitions
In reply to Sakari AilusRemove macros for defining new SMIA registers, instead put the register flags to the register definition itself. Also move the register flags to the same file.
This is not expected to be updated but rather left there as a reference.
--- drivers/media/i2c/smiapp/smiapp-quirk.c | 2 +- drivers/media/i2c/smiapp/smiapp-reg-defs.h | 1046 +++++++++++--------- drivers/media/i2c/smiapp/smiapp-reg.h | 116 --- drivers/media/i2c/smiapp/smiapp.h | 2 +- 4 files changed, 570 insertions(+), 596 deletions(-) delete mode 100644 drivers/media/i2c/smiapp/smiapp-reg.h
drivers/media/i2c/smiapp/smiapp-quirk.c +1 -1
@@ -14,7 +14,7 @@static int smiapp_write_8 (struct smiapp_sensor *sensor,u16 reg,u8 val) { -return smiapp_write (sensor,SMIAPP_REG_MK_U8 (reg), val); +return smiapp_write (sensor, reg, val); } static int smiapp_write_8s(struct smiapp_sensor *sensor,
drivers/media/i2c/smiapp/smiapp-reg-defs.h +568 -478
1,051 lines not on this page · raw message
drivers/media/i2c/smiapp/smiapp-reg.h deleted +0 -116
116 lines not on this page · raw message
drivers/media/i2c/smiapp/smiapp.h +1 -1
@@ -16,7 +16,7 @@#include <media/v4l2-subdev.h> #include "smiapp-pll.h" -#include "smiapp-reg.h" +#include "smiapp-reg-defs.h" #include "smiapp-regs.h" #include "smiapp-quirk.h"
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 7/29 smiapp: Add macros for accessing CCS registers
In reply to Sakari AilusAdd two helper macros for reading and writing the CCS registers as defined in ccs-regs.h.
--- drivers/media/i2c/smiapp/smiapp-regs.h | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/media/i2c/smiapp/smiapp-regs.h +6 -0
@@ -28,4 +28,10 @@ int smiapp_write(struct smiapp_sensor *sensor, u32 reg, u32 val);unsigned int ccs_reg_width (u32 reg); +#define ccs_read (sensor, reg_name, val) \ + smiapp_read(sensor, CCS_R_##reg_name, val) + +#define ccs_write (sensor, reg_name, val) \ + smiapp_write(sensor, CCS_R_##reg_name, val) +#endif
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 8/29 smiapp: Use MIPI CCS version and manufacturer ID information
In reply to Sakari AilusRead MIPI CCS manufacturer and version information, and use the CCS IDs over SMIA whenever they are set.
--- drivers/media/i2c/smiapp/smiapp-core.c | 76 +++++++++++++++++++------- drivers/media/i2c/smiapp/smiapp.h | 20 ++++--- 2 files changed, 68 insertions(+), 28 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +56 -20
@@ -2356,9 +2356,14 @@ smiapp_sysfs_ident_read(struct device *dev, struct device_attribute *attr,struct smiapp_sensor *sensor =to_smiapp_sensor (subdev);struct smiapp_module_info *minfo = &sensor->minfo; -return snprintf (buf,PAGE_SIZE ,"%2.2x%4.4x%2.2x\n" , - minfo->manufacturer_id, minfo->model_id, - minfo->revision_number_major) +1 ; +if (minfo->mipi_manufacturer_id) +return snprintf (buf,PAGE_SIZE ,"%4.4x%4.4x%2.2x\n" , + minfo->mipi_manufacturer_id, minfo->model_id, + minfo->revision_number_major) +1 ; +else +return snprintf (buf,PAGE_SIZE ,"%2.2x%4.4x%2.2x\n" , + minfo->smia_manufacturer_id, minfo->model_id, + minfo->revision_number_major) +1 ; } static DEVICE_ATTR(ident, S_IRUGO, smiapp_sysfs_ident_read, NULL);
@@ -2377,8 +2382,11 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor) minfo->name =SMIAPP_NAME ;/* Module info */ - rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_MANUFACTURER_ID , - &minfo->manufacturer_id); + rval =ccs_read (sensor,MODULE_MANUFACTURER_ID , + &minfo->mipi_manufacturer_id); +if (!rval && !minfo->mipi_manufacturer_id) + rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_MANUFACTURER_ID , + &minfo->smia_manufacturer_id);if (!rval) rval =smiapp_read_8only (sensor,SMIAPP_REG_U16_MODEL_ID , &minfo->model_id);
@@ -2404,9 +2412,12 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor)/* Sensor info */ if (!rval) + rval =ccs_read (sensor,SENSOR_MANUFACTURER_ID , + &minfo->sensor_mipi_manufacturer_id); +if (!rval && !minfo->sensor_mipi_manufacturer_id) rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_SENSOR_MANUFACTURER_ID , - &minfo->sensor_manufacturer_id); + &minfo->sensor_smia_manufacturer_id);if (!rval) rval = smiapp_read_8only(sensor, SMIAPP_REG_U16_SENSOR_MODEL_ID,
@@ -2422,9 +2433,11 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor)/* SMIA */ if (!rval) + rval =ccs_read (sensor,MIPI_CCS_VERSION , &minfo->ccs_version); +if (!rval && !minfo->ccs_version) rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_SMIA_VERSION , &minfo->smia_version); -if (!rval) +if (!rval && !minfo->ccs_version) rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_SMIAPP_VERSION , &minfo->smiapp_version);
@@ -2433,38 +2446,62 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor)return -ENODEV ; } -dev_dbg (&client->dev,"module 0x%2.2x-0x%4.4x\n" , - minfo->manufacturer_id, minfo->model_id); +if (minfo->mipi_manufacturer_id) +dev_dbg (&client->dev,"MIPI CCS module 0x%4.4x-0x%4.4x\n" , + minfo->mipi_manufacturer_id, minfo->model_id); +else +dev_dbg (&client->dev,"SMIA module 0x%2.2x-0x%4.4x\n" , + minfo->smia_manufacturer_id, minfo->model_id);dev_dbg (&client->dev,"module revision 0x%2.2x-0x%2.2x date %2.2d-%2.2d-%2.2d\n" , minfo->revision_number_major, minfo->revision_number_minor, minfo->module_year, minfo->module_month, minfo->module_day); -dev_dbg (&client->dev,"sensor 0x%2.2x-0x%4.4x\n" , - minfo->sensor_manufacturer_id, minfo->sensor_model_id); +if (minfo->sensor_mipi_manufacturer_id) +dev_dbg (&client->dev,"MIPI CCS sensor 0x%4.4x-0x%4.4x\n" , + minfo->sensor_mipi_manufacturer_id, + minfo->sensor_model_id); +else +dev_dbg (&client->dev,"SMIA sensor 0x%2.2x-0x%4.4x\n" , + minfo->sensor_smia_manufacturer_id, + minfo->sensor_model_id);dev_dbg (&client->dev,"sensor revision 0x%2.2x firmware version 0x%2.2x\n" , minfo->sensor_revision_number, minfo->sensor_firmware_version); -dev_dbg (&client->dev,"smia version %2.2d smiapp version %2.2d\n" , - minfo->smia_version, minfo->smiapp_version); +if (minfo->ccs_version) +dev_dbg (&client->dev,"MIPI CCS version %u.%u" , + (minfo->ccs_version &CCS_MIPI_CCS_VERSION_MAJOR_MASK ) + >>CCS_MIPI_CCS_VERSION_MAJOR_SHIFT , + (minfo->ccs_version &CCS_MIPI_CCS_VERSION_MINOR_MASK )); +else +dev_dbg (&client->dev, +"smia version %2.2d smiapp version %2.2d\n" , + minfo->smia_version, minfo->smiapp_version);/* * Some modules have bad data in the lvalues below. Hope the * rvalues have better stuff. The lvalues are module * parameters whereas the rvalues are sensor parameters. */ -if (!minfo->manufacturer_id && !minfo->model_id) { - minfo->manufacturer_id = minfo->sensor_manufacturer_id; +if (minfo->sensor_smia_manufacturer_id && + !minfo->smia_manufacturer_id && !minfo->model_id) { + minfo->smia_manufacturer_id = + minfo->sensor_smia_manufacturer_id; minfo->model_id = minfo->sensor_model_id; minfo->revision_number_major = minfo->sensor_revision_number; }for (i =0 ; i <ARRAY_SIZE (smiapp_module_idents); i++) { -if (smiapp_module_idents[i].manufacturer_id - != minfo->manufacturer_id) +if (smiapp_module_idents[i].mipi_manufacturer_id && + smiapp_module_idents[i].mipi_manufacturer_id + != minfo->mipi_manufacturer_id) +continue ; +if (smiapp_module_idents[i].smia_manufacturer_id && + smiapp_module_idents[i].smia_manufacturer_id + != minfo->smia_manufacturer_id)continue ;if (smiapp_module_idents[i].model_id != minfo->model_id)continue ;
@@ -2488,9 +2525,8 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor)dev_warn (&client->dev,"no quirks for this module; let's hope it's fully compliant\n" ); -dev_dbg (&client->dev,"the sensor is called %s, ident %2.2x%4.4x%2.2x\n" , - minfo->name, minfo->manufacturer_id, minfo->model_id, - minfo->revision_number_major); +dev_dbg (&client->dev,"the sensor is called %s\n" , + minfo->name);return 0 ; }
drivers/media/i2c/smiapp/smiapp.h +12 -8
@@ -91,8 +91,9 @@ struct smiapp_quirk;#define SMIAPP_MODULE_IDENT_FLAG_REV_LE (1 << 0)struct smiapp_module_ident { -u8 manufacturer_id; +u16 mipi_manufacturer_id;u16 model_id; +u8 smia_manufacturer_id;u8 revision_number_major;u8 flags;
@@ -102,7 +103,8 @@ struct smiapp_module_ident { };struct smiapp_module_info { -u32 manufacturer_id; +u32 smia_manufacturer_id; +u32 mipi_manufacturer_id;u32 model_id;u32 revision_number_major;u32 revision_number_minor;
@@ -111,13 +113,15 @@ struct smiapp_module_info {u32 module_month;u32 module_day; -u32 sensor_manufacturer_id; +u32 sensor_smia_manufacturer_id; +u32 sensor_mipi_manufacturer_id;u32 sensor_model_id;u32 sensor_revision_number;u32 sensor_firmware_version;u32 smia_version;u32 smiapp_version; +u32 ccs_version;u32 smiapp_profile;
@@ -126,7 +130,7 @@ struct smiapp_module_info { };#define SMIAPP_IDENT_FQ (manufacturer, model, rev, fl, _name, _quirk) \ - { .manufacturer_id = manufacturer, \ + { .smia_manufacturer_id = manufacturer, \ .model_id = model, \ .revision_number_major = rev, \ .flags = fl, \
@@ -134,7 +138,7 @@ struct smiapp_module_info { .quirk = _quirk, }#define SMIAPP_IDENT_LQ (manufacturer, model, rev, _name, _quirk) \ - { .manufacturer_id = manufacturer, \ + { .smia_manufacturer_id = manufacturer, \ .model_id = model, \ .revision_number_major = rev, \ .flags = SMIAPP_MODULE_IDENT_FLAG_REV_LE, \
@@ -142,14 +146,14 @@ struct smiapp_module_info { .quirk = _quirk, }#define SMIAPP_IDENT_L (manufacturer, model, rev, _name) \ - { .manufacturer_id = manufacturer, \ + { .smia_manufacturer_id = manufacturer, \ .model_id = model, \ .revision_number_major = rev, \ .flags = SMIAPP_MODULE_IDENT_FLAG_REV_LE, \ .name = _name, }#define SMIAPP_IDENT_Q (manufacturer, model, rev, _name, _quirk) \ - { .manufacturer_id = manufacturer, \ + { .smia_manufacturer_id = manufacturer, \ .model_id = model, \ .revision_number_major = rev, \ .flags = 0, \
@@ -157,7 +161,7 @@ struct smiapp_module_info { .quirk = _quirk, }#define SMIAPP_IDENT (manufacturer, model, rev, _name) \ - { .manufacturer_id = manufacturer, \ + { .smia_manufacturer_id = manufacturer, \ .model_id = model, \ .revision_number_major = rev, \ .flags = 0, \
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 9/29 smiapp: Read CCS limit values
In reply to Sakari AilusRead limit and capability values into a driver allocated buffer. This will later replace (most of) the existing SMIA limits.
--- drivers/media/i2c/smiapp/smiapp-core.c | 177 ++++++++++++++++++++++++- drivers/media/i2c/smiapp/smiapp.h | 4 + 2 files changed, 176 insertions(+), 5 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +172 -5
@@ -28,6 +28,7 @@#include <media/v4l2-device.h> #include "ccs-limits.h" +#include "ccs-regs.h" #include "smiapp.h" #define SMIAPP_ALIGN_DIM (dim, flags) \
@@ -102,6 +103,164 @@ static int smiapp_read_all_smia_limits(struct smiapp_sensor *sensor)return 0 ; } +static void ccs_assign_limit (void *ptr,unsigned int width,u32 val) +{ +switch (width) { +case sizeof (u8): + *(u8 *)ptr = val; +break ; +case sizeof (u16): + *(u16 *)ptr = val; +break ; +case sizeof (u32): + *(u32 *)ptr = val; +break ; + } +} + +static int ccs_limit_ptr (struct smiapp_sensor *sensor,unsigned int limit, +unsigned int offset,void **__ptr) +{ +const struct ccs_limit *linfo; + +if (WARN_ON (limit >=CCS_L_LAST )) +return -EINVAL ; + + linfo = &ccs_limits[ccs_limit_offsets[limit].info]; + +if (WARN_ON (!sensor->ccs_limits) || +WARN_ON (offset +ccs_reg_width (linfo->reg) > + ccs_limit_offsets[limit +1 ].lim)) +return -EINVAL ; + + *__ptr = sensor->ccs_limits + ccs_limit_offsets[limit].lim + offset; + +return 0 ; +} + +void ccs_replace_limit (struct smiapp_sensor *sensor, +unsigned int limit,unsigned int offset,u32 val) +{ +struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd); +const struct ccs_limit *linfo; +void *ptr; +int ret; + + ret =ccs_limit_ptr (sensor, limit, offset, &ptr); +if (ret) +return ; + + linfo = &ccs_limits[ccs_limit_offsets[limit].info]; + +dev_dbg (&client->dev,"quirk: 0x%8.8x \"%s\" %u = %d, 0x%x\n" , + linfo->reg, linfo->name, offset, val, val); + +ccs_assign_limit (ptr,ccs_reg_width (linfo->reg), val); +} + +static u32 ccs_get_limit (struct smiapp_sensor *sensor, +unsigned int limit,unsigned int offset) +{ +void *ptr; +int ret; + + ret =ccs_limit_ptr (sensor, limit, offset, &ptr); +if (ret) +return 0 ; + +switch (ccs_reg_width (ccs_limits[ccs_limit_offsets[limit].info].reg)) { +case sizeof (u8): +return *(u8 *)ptr; +case sizeof (u16): +return *(u16 *)ptr; +case sizeof (u32): +return *(u32 *)ptr; + } + +WARN_ON (1 ); + +return 0 ; +} + +#define CCS_LIM (sensor, limit) \ + ccs_get_limit(sensor, CCS_L_##limit, 0) + +#define CCS_LIM_AT (sensor, limit, offset) \ + ccs_get_limit(sensor, CCS_L_##limit, CCS_L_##limit##_OFFSET(offset)) + +static int ccs_read_all_limits (struct smiapp_sensor *sensor) +{ +struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd); +void *ptr, *alloc, *end; +unsigned int i, l; +int ret; + +kfree (sensor->ccs_limits); + sensor->ccs_limits =NULL ; + + alloc =kzalloc (ccs_limit_offsets[CCS_L_LAST ].lim,GFP_KERNEL ); +if (!alloc) +return -ENOMEM ; + + end = alloc + ccs_limit_offsets[CCS_L_LAST ].lim; + +for (i =0 , l =0 , ptr = alloc; ccs_limits[i].size; i++) { +u32 reg = ccs_limits[i].reg; +unsigned int width =ccs_reg_width (reg); +unsigned int j; + +if (l ==CCS_L_LAST ) { +dev_err (&client->dev, +"internal error --- end of limit array\n" ); + ret = -EINVAL ; + goto out_err; + } + +for (j =0 ; j < ccs_limits[i].size / width; + j++, reg += width, ptr += width) { +u32 val; + + ret =smiapp_read (sensor, reg, &val); +if (ret) + goto out_err; + +if (ptr + width > end) { +dev_err (&client->dev, +"internal error --- no room for regs\n" ); + ret = -EINVAL ; + goto out_err; + } + +ccs_assign_limit (ptr, width, val); + +dev_dbg (&client->dev,"0x%8.8x \"%s\" = %u, 0x%x\n" , + reg, ccs_limits[i].name, val, val); + } + +if (ccs_limits[i].flags &CCS_L_FL_SAME_REG ) +continue ; + + l++; + ptr = alloc + ccs_limit_offsets[l].lim; + } + +if (l !=CCS_L_LAST ) { +dev_err (&client->dev, +"internal error --- insufficient limits\n" ); + ret = -EINVAL ; + goto out_err; + } + + sensor->ccs_limits = alloc; + +return 0 ; + +out_err: +kfree (alloc); + +return ret; +} +static int smiapp_read_frame_fmt (struct smiapp_sensor *sensor) {struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd);
@@ -2970,10 +3129,14 @@ static int smiapp_probe(struct i2c_client *client) goto out_power_off; } + rval =ccs_read_all_limits (sensor); +if (rval) + goto out_power_off; + rval =smiapp_read_frame_fmt (sensor);if (rval) { rval = -ENODEV ; - goto out_power_off; + goto out_free_ccs_limits; }/*
@@ -2997,7 +3160,7 @@ static int smiapp_probe(struct i2c_client *client) rval =smiapp_call_quirk (sensor, limits);if (rval) {dev_err (&client->dev,"limits quirks failed\n" ); - goto out_power_off; + goto out_free_ccs_limits; }if (SMIA_LIM (sensor,BINNING_CAPABILITY )) {
@@ -3007,7 +3170,7 @@ static int smiapp_probe(struct i2c_client *client) SMIAPP_REG_U8_BINNING_SUBTYPES, &val);if (rval <0 ) { rval = -ENODEV ; - goto out_power_off; + goto out_free_ccs_limits; } sensor->nbinning_subtypes =min_t (u8, val,SMIAPP_BINNING_SUBTYPES );
@@ -3017,7 +3180,7 @@ static int smiapp_probe(struct i2c_client *client) sensor, SMIAPP_REG_U8_BINNING_TYPE_n(i), &val);if (rval <0 ) { rval = -ENODEV ; - goto out_power_off; + goto out_free_ccs_limits; } sensor->binning_subtypes[i] = *(struct smiapp_binning_subtype *)&val;
@@ -3033,7 +3196,7 @@ static int smiapp_probe(struct i2c_client *client)if (device_create_file (&client->dev, &dev_attr_ident) !=0 ) {dev_err (&client->dev,"sysfs ident entry creation failed\n" ); rval = -ENOENT ; - goto out_power_off; + goto out_free_ccs_limits; } if (sensor->minfo.smiapp_version &&
@@ -3150,6 +3313,9 @@ static int smiapp_probe(struct i2c_client *client) out_cleanup:smiapp_cleanup (sensor); +out_free_ccs_limits: +kfree (sensor->ccs_limits); + out_power_off:smiapp_power_off (&client->dev);mutex_destroy (&sensor->mutex);
@@ -3176,6 +3342,7 @@ static int smiapp_remove(struct i2c_client *client) }smiapp_cleanup (sensor);mutex_destroy (&sensor->mutex); +kfree (sensor->ccs_limits);return 0 ; }
drivers/media/i2c/smiapp/smiapp.h +4 -0
@@ -228,6 +228,7 @@ struct smiapp_sensor {struct clk *ext_clk;struct gpio_desc *xshutdown;u32 limits[SMIAPP_LIMIT_LAST ]; +void *ccs_limits;u8 nbinning_subtypes;struct smiapp_binning_subtype binning_subtypes[SMIAPP_BINNING_SUBTYPES ];u32 mbus_frame_fmts;
@@ -281,4 +282,7 @@ struct smiapp_sensor {#define to_smiapp_sensor (_sd) \ (to_smiapp_subdev(_sd)->sensor) +void ccs_replace_limit (struct smiapp_sensor *sensor, +unsigned int limit,unsigned int offset,u32 val); +#endif /* __SMIAPP_PRIV_H_ */
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 10/29 smiapp: Switch to CCS limits
In reply to Sakari AilusUse the CCS limit definitions instead of the SMIA ones. This allows accessing CCS capabilities where needed as well as dropping the old SMIA limits.
--- drivers/media/i2c/smiapp/Makefile | 2 +- drivers/media/i2c/smiapp/smiapp-core.c | 255 ++++++++++------------- drivers/media/i2c/smiapp/smiapp-limits.c | 118 ----------- drivers/media/i2c/smiapp/smiapp-limits.h | 114 ---------- drivers/media/i2c/smiapp/smiapp-quirk.c | 25 +-- drivers/media/i2c/smiapp/smiapp-quirk.h | 3 - drivers/media/i2c/smiapp/smiapp.h | 10 - 7 files changed, 113 insertions(+), 414 deletions(-) delete mode 100644 drivers/media/i2c/smiapp/smiapp-limits.c delete mode 100644 drivers/media/i2c/smiapp/smiapp-limits.h
drivers/media/i2c/smiapp/Makefile +1 -1
@@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only smiapp-objs += smiapp-core.o smiapp-regs.o \ - smiapp-quirk.o smiapp-limits.o + smiapp-quirk.o ccs-limits.o obj-$(CONFIG_VIDEO_SMIAPP) += smiapp.o ccflags-y += -I $(srctree)/drivers/media/i2c
drivers/media/i2c/smiapp/smiapp-core.c +105 -150
451 lines not on this page · raw message
drivers/media/i2c/smiapp/smiapp-limits.c deleted +0 -118
118 lines not on this page · raw message
drivers/media/i2c/smiapp/smiapp-limits.h deleted +0 -114
114 lines not on this page · raw message
drivers/media/i2c/smiapp/smiapp-quirk.c +7 -18
@@ -10,6 +10,8 @@#include <linux/delay.h> +#include "ccs-limits.h" +#include "smiapp.h" static int smiapp_write_8 (struct smiapp_sensor *sensor,u16 reg,u8 val)
@@ -36,17 +38,6 @@ static int smiapp_write_8s(struct smiapp_sensor *sensor,return 0 ; } -void smiapp_replace_limit (struct smiapp_sensor *sensor, -u32 limit,u32 val) -{ -struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd); - -dev_dbg (&client->dev,"quirk: 0x%8.8x \"%s\" = %d, 0x%x\n" , - smiapp_reg_limits[limit].addr, - smiapp_reg_limits[limit].what, val, val); - sensor->limits[limit] = val; -} -static int jt8ew9_limits (struct smiapp_sensor *sensor) {if (sensor->minfo.revision_number_major <0x03 )
@@ -54,9 +45,8 @@ static int jt8ew9_limits(struct smiapp_sensor *sensor)/* Below 24 gain doesn't have effect at all, */ /* but ~59 is needed for full dynamic range */ -smiapp_replace_limit (sensor,SMIAPP_LIMIT_ANALOGUE_GAIN_CODE_MIN ,59 ); -smiapp_replace_limit ( - sensor,SMIAPP_LIMIT_ANALOGUE_GAIN_CODE_MAX ,6000 ); +ccs_replace_limit (sensor,CCS_L_ANALOG_GAIN_CODE_MIN ,0 ,59 ); +ccs_replace_limit (sensor,CCS_L_ANALOG_GAIN_CODE_MAX ,0 ,6000 );return 0 ; }
@@ -126,9 +116,8 @@ const struct smiapp_quirk smiapp_imx125es_quirk = {static int jt8ev1_limits (struct smiapp_sensor *sensor) { -smiapp_replace_limit (sensor,SMIAPP_LIMIT_X_ADDR_MAX ,4271 ); -smiapp_replace_limit (sensor, -SMIAPP_LIMIT_MIN_LINE_BLANKING_PCK_BIN ,184 ); +ccs_replace_limit (sensor,CCS_L_X_ADDR_MAX ,0 ,4271 ); +ccs_replace_limit (sensor,CCS_L_MIN_LINE_BLANKING_PCK_BIN ,0 ,184 );return 0 ; }
@@ -221,7 +210,7 @@ const struct smiapp_quirk smiapp_jt8ev1_quirk = {static int tcm8500md_limits (struct smiapp_sensor *sensor) { -smiapp_replace_limit (sensor,SMIAPP_LIMIT_MIN_PLL_IP_FREQ_HZ ,2700000 ); +ccs_replace_limit (sensor,CCS_L_MIN_PLL_IP_CLK_FREQ_MHZ ,0 ,2700000 );return 0 ; }
drivers/media/i2c/smiapp/smiapp-quirk.h +0 -3
@@ -55,9 +55,6 @@ struct smiapp_reg_8 {u8 val; }; -void smiapp_replace_limit (struct smiapp_sensor *sensor, -u32 limit,u32 val); -#define SMIAPP_MK_QUIRK_REG_8 (_reg, _val) \ { \ .reg = (u16)_reg, \
drivers/media/i2c/smiapp/smiapp.h +0 -10
@@ -84,8 +84,6 @@ struct smiapp_hwconfig {struct smiapp_flash_strobe_parms *strobe_setup; }; -#include "smiapp-limits.h" -struct smiapp_quirk ;#define SMIAPP_MODULE_IDENT_FLAG_REV_LE (1 << 0)
@@ -167,13 +165,6 @@ struct smiapp_module_info { .flags = 0, \ .name = _name, } -struct smiapp_reg_limits { -u32 addr; -char *what; -}; - -extern struct smiapp_reg_limits smiapp_reg_limits[]; -struct smiapp_csi_data_format {u32 code;u8 width;
@@ -227,7 +218,6 @@ struct smiapp_sensor {struct regulator *vana;struct clk *ext_clk;struct gpio_desc *xshutdown; -u32 limits[SMIAPP_LIMIT_LAST ];void *ccs_limits;u8 nbinning_subtypes;struct smiapp_binning_subtype binning_subtypes[SMIAPP_BINNING_SUBTYPES ];
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 11/29 smiapp: Obtain frame descriptor from CCS limits
In reply to Sakari AilusObtain the frame descriptor from the CCS limits, instead of reading them directly from the frame descriptor registers.
--- drivers/media/i2c/smiapp/smiapp-core.c | 70 +++++++++++--------------- 1 file changed, 30 insertions(+), 40 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +30 -40
@@ -228,34 +228,29 @@ static int ccs_read_all_limits(struct smiapp_sensor *sensor)static int smiapp_read_frame_fmt (struct smiapp_sensor *sensor) {struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd); -u32 fmt_model_type, fmt_model_subtype, ncol_desc, nrow_desc; +u8 fmt_model_type, fmt_model_subtype, ncol_desc, nrow_desc;unsigned int i;int pixel_count =0 ;int line_count =0 ; -int rval; - - rval =smiapp_read (sensor,SMIAPP_REG_U8_FRAME_FORMAT_MODEL_TYPE , - &fmt_model_type); -if (rval) -return rval; - rval =smiapp_read (sensor,SMIAPP_REG_U8_FRAME_FORMAT_MODEL_SUBTYPE , - &fmt_model_subtype); -if (rval) -return rval; + fmt_model_type =CCS_LIM (sensor,FRAME_FORMAT_MODEL_TYPE ); + fmt_model_subtype =CCS_LIM (sensor,FRAME_FORMAT_MODEL_SUBTYPE ); ncol_desc = (fmt_model_subtype - &SMIAPP_FRAME_FORMAT_MODEL_SUBTYPE_NCOLS_MASK ) - >>SMIAPP_FRAME_FORMAT_MODEL_SUBTYPE_NCOLS_SHIFT ; + &CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_MASK ) + >>CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_SHIFT ; nrow_desc = fmt_model_subtype - &SMIAPP_FRAME_FORMAT_MODEL_SUBTYPE_NROWS_MASK ; + &CCS_FRAME_FORMAT_MODEL_SUBTYPE_ROWS_MASK ;dev_dbg (&client->dev,"format_model_type %s\n" , - fmt_model_type ==SMIAPP_FRAME_FORMAT_MODEL_TYPE_2BYTE + fmt_model_type ==CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE ?"2 byte" : - fmt_model_type ==SMIAPP_FRAME_FORMAT_MODEL_TYPE_4BYTE + fmt_model_type ==CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE ?"4 byte" :"is simply bad" ); +dev_dbg (&client->dev,"%u column and %u row descriptors\n" , + ncol_desc, nrow_desc); +for (i =0 ; i < ncol_desc + nrow_desc; i++) {u32 desc;u32 pixelcode;
@@ -264,29 +259,24 @@ static int smiapp_read_frame_fmt(struct smiapp_sensor *sensor)char *what;u32 reg; -if (fmt_model_type ==SMIAPP_FRAME_FORMAT_MODEL_TYPE_2BYTE ) { - reg =SMIAPP_REG_U16_FRAME_FORMAT_DESCRIPTOR_2 (i); - rval =smiapp_read (sensor, reg, &desc); -if (rval) -return rval; +if (fmt_model_type ==CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE ) { + desc =CCS_LIM_AT (sensor,FRAME_FORMAT_DESCRIPTOR , i); pixelcode = (desc - &SMIAPP_FRAME_FORMAT_DESC_2_PIXELCODE_MASK ) - >>SMIAPP_FRAME_FORMAT_DESC_2_PIXELCODE_SHIFT ; - pixels = desc &SMIAPP_FRAME_FORMAT_DESC_2_PIXELS_MASK ; + &CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_MASK ) + >>CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_SHIFT ; + pixels = desc &CCS_FRAME_FORMAT_DESCRIPTOR_PIXELS_MASK ; }else if (fmt_model_type - ==SMIAPP_FRAME_FORMAT_MODEL_TYPE_4BYTE ) { - reg =SMIAPP_REG_U32_FRAME_FORMAT_DESCRIPTOR_4 (i); - rval =smiapp_read (sensor, reg, &desc); -if (rval) -return rval; + ==CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE ) { + desc =CCS_LIM_AT (sensor,FRAME_FORMAT_DESCRIPTOR_4 , i); pixelcode = (desc - &SMIAPP_FRAME_FORMAT_DESC_4_PIXELCODE_MASK ) - >>SMIAPP_FRAME_FORMAT_DESC_4_PIXELCODE_SHIFT ; - pixels = desc &SMIAPP_FRAME_FORMAT_DESC_4_PIXELS_MASK ; + &CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_MASK ) + >>CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_SHIFT ; + pixels = desc & +CCS_FRAME_FORMAT_DESCRIPTOR_4_PIXELS_MASK ; }else { dev_dbg(&client->dev, "invalid frame format model type %d\n",
@@ -300,19 +290,19 @@ static int smiapp_read_frame_fmt(struct smiapp_sensor *sensor) which ="rows" ;switch (pixelcode) { -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_EMBEDDED : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED : what ="embedded" ;break ; -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_DUMMY : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DUMMY_PIXEL : what ="dummy" ;break ; -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_BLACK : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_BLACK_PIXEL : what ="black" ;break ; -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_DARK : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DARK_PIXEL : what ="dark" ;break ; -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_VISIBLE : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL : what ="visible" ;break ;default :
@@ -326,7 +316,7 @@ static int smiapp_read_frame_fmt(struct smiapp_sensor *sensor)if (i < ncol_desc) {if (pixelcode == -SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_VISIBLE ) +CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL ) sensor->visible_pixel_start = pixel_count; pixel_count += pixels;continue ;
@@ -334,13 +324,13 @@ static int smiapp_read_frame_fmt(struct smiapp_sensor *sensor)/* Handle row descriptors */ switch (pixelcode) { -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_EMBEDDED : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED :if (sensor->embedded_end)break ; sensor->embedded_start = line_count; sensor->embedded_end = line_count + pixels;break ; -case SMIAPP_FRAME_FORMAT_DESC_PIXELCODE_VISIBLE : +case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL : sensor->image_start = line_count;break ; }
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 12/29 smiapp: Use CCS limits in reading data format descriptors
In reply to Sakari AilusThe CCS limits have the information so use it instead.
--- drivers/media/i2c/smiapp/smiapp-core.c | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +9 -13
@@ -842,10 +842,7 @@ static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)unsigned int i, pixel_order;int rval; - rval =smiapp_read ( - sensor,SMIAPP_REG_U8_DATA_FORMAT_MODEL_TYPE , &type); -if (rval) -return rval; + type =CCS_LIM (sensor,DATA_FORMAT_MODEL_TYPE );dev_dbg (&client->dev,"data_format_model_type %d\n" , type);
@@ -863,11 +860,11 @@ static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor) pixel_order_str[pixel_order]);switch (type) { -case SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL : +case CCS_DATA_FORMAT_MODEL_TYPE_NORMAL : n =SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL_N ;break ; -case SMIAPP_DATA_FORMAT_MODEL_TYPE_EXTENDED : - n =SMIAPP_DATA_FORMAT_MODEL_TYPE_EXTENDED_N ; +case CCS_DATA_FORMAT_MODEL_TYPE_EXTENDED : + n =CCS_LIM_DATA_FORMAT_DESCRIPTOR_MAX_N +1 ;break ;default :return -EINVAL ;
@@ -879,11 +876,7 @@ static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)for (i =0 ; i < n; i++) {unsigned int fmt, j; - rval =smiapp_read ( - sensor, -SMIAPP_REG_U16_DATA_FORMAT_DESCRIPTOR (i), &fmt); -if (rval) -return rval; + fmt =CCS_LIM_AT (sensor,DATA_FORMAT_DESCRIPTOR , i);dev_dbg (&client->dev,"%u: bpp %u, compressed %u\n" , i, fmt >>8 , (u8 )fmt);
@@ -895,7 +888,10 @@ static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)if (f->pixel_order !=SMIAPP_PIXEL_ORDER_GRBG )continue ; -if (f->width != fmt >>8 || f->compressed != (u8 )fmt) +if (f->width != fmt >> +CCS_DATA_FORMAT_DESCRIPTOR_UNCOMPRESSED_SHIFT || + f->compressed != + (fmt &CCS_DATA_FORMAT_DESCRIPTOR_COMPRESSED_MASK ))continue ;dev_dbg (&client->dev,"jolly good! %d\n" , j);
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 13/29 smiapp: Use CCS limits in reading binning capabilities
In reply to Sakari AilusUse CCS limits for obtaining binning capabilities and subtypes.
--- drivers/media/i2c/smiapp/smiapp-core.c | 27 +++++++++----------------- 1 file changed, 9 insertions(+), 18 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +9 -18
@@ -3105,26 +3105,17 @@ static int smiapp_probe(struct i2c_client *client) }if (CCS_LIM (sensor,BINNING_CAPABILITY )) { -u32 val; - - rval =smiapp_read (sensor, -SMIAPP_REG_U8_BINNING_SUBTYPES , &val); -if (rval <0 ) { - rval = -ENODEV ; - goto out_free_ccs_limits; - } - sensor->nbinning_subtypes =min_t (u8, val, -SMIAPP_BINNING_SUBTYPES ); + sensor->nbinning_subtypes = +min_t (u8,CCS_LIM (sensor,BINNING_SUB_TYPES ), +CCS_LIM_BINNING_SUB_TYPE_MAX_N );for (i =0 ; i < sensor->nbinning_subtypes; i++) { - rval =smiapp_read ( - sensor,SMIAPP_REG_U8_BINNING_TYPE_n (i), &val); -if (rval <0 ) { - rval = -ENODEV ; - goto out_free_ccs_limits; - } - sensor->binning_subtypes[i] = - *(struct smiapp_binning_subtype *)&val; + sensor->binning_subtypes[i].horizontal = +CCS_LIM_AT (sensor,BINNING_SUB_TYPE , i) >> +CCS_BINNING_SUB_TYPE_COLUMN_SHIFT ; + sensor->binning_subtypes[i].vertical = +CCS_LIM_AT (sensor,BINNING_SUB_TYPE , i) & +CCS_BINNING_SUB_TYPE_ROW_MASK ; dev_dbg(&client->dev, "binning %xx%x\n", sensor->binning_subtypes[i].horizontal,
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 14/29 smiapp: Use CCS registers
In reply to Sakari AilusSwitch to CCS standard registers where they exist. The still relevant SMIA registers are left as-is and the redundant ones are removed.
--- drivers/media/i2c/smiapp/smiapp-core.c | 272 +++++++++++-------------- drivers/media/i2c/smiapp/smiapp.h | 4 +- 2 files changed, 118 insertions(+), 158 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +115 -157
@@ -28,7 +28,6 @@#include <media/v4l2-device.h> #include "ccs-limits.h" -#include "ccs-regs.h" #include "smiapp.h" #define SMIAPP_ALIGN_DIM (dim, flags) \
@@ -357,40 +356,34 @@ static int smiapp_pll_configure(struct smiapp_sensor *sensor)struct smiapp_pll *pll = &sensor->pll;int rval; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_VT_PIX_CLK_DIV , pll->vt.pix_clk_div); + rval =ccs_write (sensor,VT_PIX_CLK_DIV , pll->vt.pix_clk_div);if (rval <0 )return rval; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_VT_SYS_CLK_DIV , pll->vt.sys_clk_div); + rval =ccs_write (sensor,VT_SYS_CLK_DIV , pll->vt.sys_clk_div);if (rval <0 )return rval; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_PRE_PLL_CLK_DIV , pll->pre_pll_clk_div); + rval =ccs_write (sensor,PRE_PLL_CLK_DIV , pll->pre_pll_clk_div);if (rval <0 )return rval; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_PLL_MULTIPLIER , pll->pll_multiplier); + rval =ccs_write (sensor,PLL_MULTIPLIER , pll->pll_multiplier);if (rval <0 )return rval;/* Lane op clock ratio does not apply here. */ - rval =smiapp_write ( - sensor,SMIAPP_REG_U32_REQUESTED_LINK_BIT_RATE_MBPS , -DIV_ROUND_UP (pll->op.sys_clk_freq_hz,1000000 /256 /256 )); + rval =ccs_write (sensor,REQUESTED_LINK_RATE , +DIV_ROUND_UP (pll->op.sys_clk_freq_hz, +1000000 /256 /256 ));if (rval <0 || sensor->minfo.smiapp_profile ==SMIAPP_PROFILE_0 )return rval; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_OP_PIX_CLK_DIV , pll->op.pix_clk_div); + rval =ccs_write (sensor,OP_PIX_CLK_DIV , pll->op.pix_clk_div);if (rval <0 )return rval; -return smiapp_write ( - sensor,SMIAPP_REG_U16_OP_SYS_CLK_DIV , pll->op.sys_clk_div); +return ccs_write (sensor,OP_SYS_CLK_DIV , pll->op.sys_clk_div); } static int smiapp_pll_try(struct smiapp_sensor *sensor,
@@ -522,10 +515,10 @@ static u32 smiapp_pixel_order(struct smiapp_sensor *sensor)if (sensor->hflip) {if (sensor->hflip->val) - flip |=SMIAPP_IMAGE_ORIENTATION_HFLIP ; + flip |=CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR ;if (sensor->vflip->val) - flip |=SMIAPP_IMAGE_ORIENTATION_VFLIP ; + flip |=CCS_IMAGE_ORIENTATION_VERTICAL_FLIP ; } flip ^= sensor->hvflip_inv_mask;
@@ -585,10 +578,10 @@ static int smiapp_set_ctrl(struct v4l2_ctrl *ctrl)return -EBUSY ;if (sensor->hflip->val) - orient |=SMIAPP_IMAGE_ORIENTATION_HFLIP ; + orient |=CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR ;if (sensor->vflip->val) - orient |=SMIAPP_IMAGE_ORIENTATION_VFLIP ; + orient |=CCS_IMAGE_ORIENTATION_VERTICAL_FLIP ; orient ^= sensor->hvflip_inv_mask;
@@ -633,60 +626,50 @@ static int smiapp_set_ctrl(struct v4l2_ctrl *ctrl)switch (ctrl->id) {case V4L2_CID_ANALOGUE_GAIN : - rval =smiapp_write ( - sensor, -SMIAPP_REG_U16_ANALOGUE_GAIN_CODE_GLOBAL , ctrl->val); + rval =ccs_write (sensor,ANALOG_GAIN_CODE_GLOBAL , ctrl->val);break ;case V4L2_CID_EXPOSURE : - rval =smiapp_write ( - sensor, -SMIAPP_REG_U16_COARSE_INTEGRATION_TIME , ctrl->val); + rval =ccs_write (sensor,COARSE_INTEGRATION_TIME , ctrl->val);break ;case V4L2_CID_HFLIP :case V4L2_CID_VFLIP : - rval =smiapp_write (sensor,SMIAPP_REG_U8_IMAGE_ORIENTATION , - orient); + rval =ccs_write (sensor,IMAGE_ORIENTATION , orient);break ;case V4L2_CID_VBLANK : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_FRAME_LENGTH_LINES , - sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].height - + ctrl->val); + rval =ccs_write (sensor,FRAME_LENGTH_LINES , + sensor->pixel_array->crop[ +SMIAPP_PA_PAD_SRC ].height + + ctrl->val);break ;case V4L2_CID_HBLANK : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_LINE_LENGTH_PCK , - sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].width - + ctrl->val); + rval =ccs_write (sensor,LINE_LENGTH_PCK , + sensor->pixel_array->crop[ +SMIAPP_PA_PAD_SRC ].width + + ctrl->val);break ;case V4L2_CID_TEST_PATTERN : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_TEST_PATTERN_MODE , ctrl->val); + rval =ccs_write (sensor,TEST_PATTERN_MODE , ctrl->val);break ;case V4L2_CID_TEST_PATTERN_RED : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_TEST_DATA_RED , ctrl->val); + rval =ccs_write (sensor,TEST_DATA_RED , ctrl->val);break ;case V4L2_CID_TEST_PATTERN_GREENR : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_TEST_DATA_GREENR , ctrl->val); + rval =ccs_write (sensor,TEST_DATA_GREENR , ctrl->val);break ;case V4L2_CID_TEST_PATTERN_BLUE : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_TEST_DATA_BLUE , ctrl->val); + rval =ccs_write (sensor,TEST_DATA_BLUE , ctrl->val);break ;case V4L2_CID_TEST_PATTERN_GREENB : - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_TEST_DATA_GREENB , ctrl->val); + rval =ccs_write (sensor,TEST_DATA_GREENB , ctrl->val);break ;case V4L2_CID_PIXEL_RATE :
@@ -846,8 +829,7 @@ static int smiapp_get_mbus_formats(struct smiapp_sensor *sensor)dev_dbg (&client->dev,"data_format_model_type %d\n" , type); - rval =smiapp_read (sensor,SMIAPP_REG_U8_PIXEL_ORDER , - &pixel_order); + rval =ccs_read (sensor,PIXEL_ORDER , &pixel_order);if (rval)return rval;
@@ -1054,22 +1036,20 @@ static int smiapp_read_nvm_page(struct smiapp_sensor *sensor, u32 p, u8 *nvm, *status =0 ; - rval =smiapp_write (sensor, -SMIAPP_REG_U8_DATA_TRANSFER_IF_1_PAGE_SELECT , p); + rval =ccs_write (sensor,DATA_TRANSFER_IF_1_PAGE_SELECT , p);if (rval)return rval; - rval =smiapp_write (sensor,SMIAPP_REG_U8_DATA_TRANSFER_IF_1_CTRL , -SMIAPP_DATA_TRANSFER_IF_1_CTRL_EN ); + rval =ccs_write (sensor,DATA_TRANSFER_IF_1_CTRL , +CCS_DATA_TRANSFER_IF_1_CTRL_ENABLE );if (rval)return rval; - rval =smiapp_read (sensor,SMIAPP_REG_U8_DATA_TRANSFER_IF_1_STATUS , - &s); + rval =ccs_read (sensor,DATA_TRANSFER_IF_1_STATUS , &s);if (rval)return rval; -if (s &SMIAPP_DATA_TRANSFER_IF_1_STATUS_EUSAGE ) { +if (s &CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE ) { *status = s;return -ENODATA ; }
@@ -1077,14 +1057,10 @@ static int smiapp_read_nvm_page(struct smiapp_sensor *sensor, u32 p, u8 *nvm,if (CCS_LIM (sensor,DATA_TRANSFER_IF_CAPABILITY ) &CCS_DATA_TRANSFER_IF_CAPABILITY_POLLING ) {for (i =1000 ; i >0 ; i--) { -if (s &SMIAPP_DATA_TRANSFER_IF_1_STATUS_RD_READY ) +if (s &CCS_DATA_TRANSFER_IF_1_STATUS_READ_IF_READY )break ; - rval =smiapp_read ( - sensor, -SMIAPP_REG_U8_DATA_TRANSFER_IF_1_STATUS , - &s); - + rval =ccs_read (sensor,DATA_TRANSFER_IF_1_STATUS , &s);if (rval)return rval; }
@@ -1093,12 +1069,10 @@ static int smiapp_read_nvm_page(struct smiapp_sensor *sensor, u32 p, u8 *nvm,return -ETIMEDOUT ; } -for (i =0 ; i <SMIAPP_NVM_PAGE_SIZE ; i++) { +for (i =0 ; i <=CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P ; i++) {u32 v; - rval =smiapp_read (sensor, -SMIAPP_REG_U8_DATA_TRANSFER_IF_1_DATA_0 + i, - &v); + rval =ccs_read (sensor,DATA_TRANSFER_IF_1_DATA (i), &v);if (rval)return rval;
@@ -1115,20 +1089,21 @@ static int smiapp_read_nvm(struct smiapp_sensor *sensor, unsigned char *nvm,u32 p;int rval =0 , rval2; -for (p =0 ; p < nvm_size /SMIAPP_NVM_PAGE_SIZE && !rval; p++) { +for (p =0 ; p < nvm_size / (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P +1 ) + && !rval; p++) { rval =smiapp_read_nvm_page (sensor, p, nvm, &status); - nvm +=SMIAPP_NVM_PAGE_SIZE ; + nvm +=CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P +1 ; }if (rval == -ENODATA && - status &SMIAPP_DATA_TRANSFER_IF_1_STATUS_EUSAGE ) + status &CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE ) rval =0 ; - rval2 =smiapp_write (sensor,SMIAPP_REG_U8_DATA_TRANSFER_IF_1_CTRL ,0 ); + rval2 =ccs_write (sensor,DATA_TRANSFER_IF_1_CTRL ,0 );if (rval <0 )return rval;else -return rval2 ?: p *SMIAPP_NVM_PAGE_SIZE ; +return rval2 ?: p * (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P +1 ); }/*
@@ -1144,16 +1119,15 @@ static int smiapp_change_cci_addr(struct smiapp_sensor *sensor) client->addr = sensor->hwcfg->i2c_addr_dfl; - rval =smiapp_write (sensor, -SMIAPP_REG_U8_CCI_ADDRESS_CONTROL , - sensor->hwcfg->i2c_addr_alt <<1 ); + rval =ccs_write (sensor,CCI_ADDRESS_CTRL , + sensor->hwcfg->i2c_addr_alt <<1 );if (rval)return rval; client->addr = sensor->hwcfg->i2c_addr_alt;/* verify addr change went ok */ - rval =smiapp_read (sensor,SMIAPP_REG_U8_CCI_ADDRESS_CONTROL , &val); + rval =ccs_read (sensor,CCI_ADDRESS_CTRL , &val);if (rval)return rval;
@@ -1259,34 +1233,30 @@ static int smiapp_setup_flash_strobe(struct smiapp_sensor *sensor) strobe_width_high_rs = (tmp + strobe_adjustment -1 ) / strobe_adjustment; - rval =smiapp_write (sensor,SMIAPP_REG_U8_FLASH_MODE_RS , - strobe_setup->mode); + rval =ccs_write (sensor,FLASH_MODE_RS , strobe_setup->mode);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U8_FLASH_STROBE_ADJUSTMENT , - strobe_adjustment); + rval =ccs_write (sensor,FLASH_STROBE_ADJUSTMENT , strobe_adjustment);if (rval <0 ) goto out; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_TFLASH_STROBE_WIDTH_HIGH_RS_CTRL , - strobe_width_high_rs); + rval =ccs_write (sensor,TFLASH_STROBE_WIDTH_HIGH_RS_CTRL , + strobe_width_high_rs);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U16_TFLASH_STROBE_DELAY_RS_CTRL , - strobe_setup->strobe_delay); + rval =ccs_write (sensor,TFLASH_STROBE_DELAY_RS_CTRL , + strobe_setup->strobe_delay);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U16_FLASH_STROBE_START_POINT , - strobe_setup->stobe_start_point); + rval =ccs_write (sensor,FLASH_STROBE_START_POINT , + strobe_setup->stobe_start_point);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U8_FLASH_TRIGGER_RS , - strobe_setup->trigger); + rval =ccs_write (sensor,FLASH_TRIGGER_RS , strobe_setup->trigger); out: sensor->hwcfg->strobe_setup->trigger =0 ;
@@ -1349,8 +1319,7 @@ static int smiapp_power_on(struct device *dev) } } - rval =smiapp_write (sensor,SMIAPP_REG_U8_SOFTWARE_RESET , -SMIAPP_SOFTWARE_RESET ); + rval =ccs_write (sensor,SOFTWARE_RESET ,CCS_SOFTWARE_RESET_ON );if (rval <0 ) {dev_err (dev,"software reset failed\n" ); goto out_cci_addr_fail;
@@ -1364,45 +1333,42 @@ static int smiapp_power_on(struct device *dev) } } - rval =smiapp_write (sensor,SMIAPP_REG_U16_COMPRESSION_MODE , -SMIAPP_COMPRESSION_MODE_SIMPLE_PREDICTOR ); + rval =ccs_write (sensor,COMPRESSION_MODE , +CCS_COMPRESSION_MODE_DPCM_PCM_SIMPLE );if (rval) {dev_err (dev,"compression mode set failed\n" ); goto out_cci_addr_fail; } - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_EXTCLK_FREQUENCY_MHZ , - sensor->hwcfg->ext_clk / (1000000 / (1 <<8 ))); + rval =ccs_write (sensor,EXTCLK_FREQUENCY_MHZ , + sensor->hwcfg->ext_clk / (1000000 / (1 <<8 )));if (rval) {dev_err (dev,"extclk frequency set failed\n" ); goto out_cci_addr_fail; } - rval =smiapp_write (sensor,SMIAPP_REG_U8_CSI_LANE_MODE , - sensor->hwcfg->lanes -1 ); + rval =ccs_write (sensor,CSI_LANE_MODE , sensor->hwcfg->lanes -1 );if (rval) {dev_err (dev,"csi lane mode set failed\n" ); goto out_cci_addr_fail; } - rval =smiapp_write (sensor,SMIAPP_REG_U8_FAST_STANDBY_CTRL , -SMIAPP_FAST_STANDBY_CTRL_IMMEDIATE ); + rval =ccs_write (sensor,FAST_STANDBY_CTRL , +CCS_FAST_STANDBY_CTRL_FRAME_TRUNCATION );if (rval) {dev_err (dev,"fast standby set failed\n" ); goto out_cci_addr_fail; } - rval =smiapp_write (sensor,SMIAPP_REG_U8_CSI_SIGNALLING_MODE , - sensor->hwcfg->csi_signalling_mode); + rval =ccs_write (sensor,CSI_SIGNALING_MODE , + sensor->hwcfg->csi_signalling_mode);if (rval) {dev_err (dev,"csi signalling mode set failed\n" ); goto out_cci_addr_fail; }/* DPHY control done by sensor based on requested link rate */ - rval =smiapp_write (sensor,SMIAPP_REG_U8_DPHY_CTRL , -SMIAPP_DPHY_CTRL_UI ); + rval =ccs_write (sensor,PHY_CTRL ,CCS_PHY_CTRL_UI );if (rval <0 ) goto out_cci_addr_fail;
@@ -1439,9 +1405,7 @@ static int smiapp_power_off(struct device *dev)* will fail. So do a soft reset explicitly here. */ if (sensor->hwcfg->i2c_addr_alt) -smiapp_write (sensor, -SMIAPP_REG_U8_SOFTWARE_RESET , -SMIAPP_SOFTWARE_RESET ); +ccs_write (sensor,SOFTWARE_RESET ,CCS_SOFTWARE_RESET_ON );gpiod_set_value (sensor->xshutdown,0 );clk_disable_unprepare (sensor->ext_clk);
@@ -1464,9 +1428,9 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor)mutex_lock (&sensor->mutex); - rval =smiapp_write (sensor,SMIAPP_REG_U16_CSI_DATA_FORMAT , - (sensor->csi_format->width <<8 ) | - sensor->csi_format->compressed); + rval =ccs_write (sensor,CSI_DATA_FORMAT , + (sensor->csi_format->width <<8 ) | + sensor->csi_format->compressed);if (rval) goto out;
@@ -1479,14 +1443,13 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor) (sensor->binning_horizontal <<4 ) | sensor->binning_vertical; - rval =smiapp_write ( - sensor,SMIAPP_REG_U8_BINNING_TYPE , binning_type); + rval =ccs_write (sensor,BINNING_TYPE , binning_type);if (rval <0 ) goto out; binning_mode =1 ; } - rval =smiapp_write (sensor,SMIAPP_REG_U8_BINNING_MODE , binning_mode); + rval =ccs_write (sensor,BINNING_MODE , binning_mode);if (rval <0 ) goto out;
@@ -1496,26 +1459,26 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor) goto out;/* Analog crop start coordinates */ - rval =smiapp_write (sensor,SMIAPP_REG_U16_X_ADDR_START , - sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].left); + rval =ccs_write (sensor,X_ADDR_START , + sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].left);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U16_Y_ADDR_START , - sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].top); + rval =ccs_write (sensor,Y_ADDR_START , + sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].top);if (rval <0 ) goto out;/* Analog crop end coordinates */ - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_X_ADDR_END , + rval =ccs_write ( + sensor,X_ADDR_END , sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].left + sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].width -1 );if (rval <0 ) goto out; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_Y_ADDR_END , + rval =ccs_write ( + sensor,Y_ADDR_END , sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].top + sensor->pixel_array->crop[SMIAPP_PA_PAD_SRC ].height -1 );if (rval <0 )
@@ -1529,26 +1492,26 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor)/* Digital crop */ if (CCS_LIM (sensor,DIGITAL_CROP_CAPABILITY ) ==CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP ) { - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_DIGITAL_CROP_X_OFFSET , + rval =ccs_write ( + sensor,DIGITAL_CROP_X_OFFSET , sensor->scaler->crop[SMIAPP_PAD_SINK ].left);if (rval <0 ) goto out; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_DIGITAL_CROP_Y_OFFSET , + rval =ccs_write ( + sensor,DIGITAL_CROP_Y_OFFSET , sensor->scaler->crop[SMIAPP_PAD_SINK ].top);if (rval <0 ) goto out; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_DIGITAL_CROP_IMAGE_WIDTH , + rval =ccs_write ( + sensor,DIGITAL_CROP_IMAGE_WIDTH , sensor->scaler->crop[SMIAPP_PAD_SINK ].width);if (rval <0 ) goto out; - rval =smiapp_write ( - sensor,SMIAPP_REG_U16_DIGITAL_CROP_IMAGE_HEIGHT , + rval =ccs_write ( + sensor,DIGITAL_CROP_IMAGE_HEIGHT , sensor->scaler->crop[SMIAPP_PAD_SINK ].height);if (rval <0 ) goto out;
@@ -1557,24 +1520,22 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor)/* Scaling */ if (CCS_LIM (sensor,SCALING_CAPABILITY ) !=CCS_SCALING_CAPABILITY_NONE ) { - rval =smiapp_write (sensor,SMIAPP_REG_U16_SCALING_MODE , - sensor->scaling_mode); + rval =ccs_write (sensor,SCALING_MODE , sensor->scaling_mode);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U16_SCALE_M , - sensor->scale_m); + rval =ccs_write (sensor,SCALE_M , sensor->scale_m);if (rval <0 ) goto out; }/* Output size from sensor */ - rval =smiapp_write (sensor,SMIAPP_REG_U16_X_OUTPUT_SIZE , - sensor->src->crop[SMIAPP_PAD_SRC ].width); + rval =ccs_write (sensor,X_OUTPUT_SIZE , + sensor->src->crop[SMIAPP_PAD_SRC ].width);if (rval <0 ) goto out; - rval =smiapp_write (sensor,SMIAPP_REG_U16_Y_OUTPUT_SIZE , - sensor->src->crop[SMIAPP_PAD_SRC ].height); + rval =ccs_write (sensor,Y_OUTPUT_SIZE , + sensor->src->crop[SMIAPP_PAD_SRC ].height);if (rval <0 ) goto out;
@@ -1594,8 +1555,7 @@ static int smiapp_start_streaming(struct smiapp_sensor *sensor) goto out; } - rval =smiapp_write (sensor,SMIAPP_REG_U8_MODE_SELECT , -SMIAPP_MODE_SELECT_STREAMING ); + rval =ccs_write (sensor,MODE_SELECT ,CCS_MODE_SELECT_STREAMING ); out:mutex_unlock (&sensor->mutex);
@@ -1609,8 +1569,7 @@ static int smiapp_stop_streaming(struct smiapp_sensor *sensor)int rval;mutex_lock (&sensor->mutex); - rval =smiapp_write (sensor,SMIAPP_REG_U8_MODE_SELECT , -SMIAPP_MODE_SELECT_SOFTWARE_STANDBY ); + rval =ccs_write (sensor,MODE_SELECT ,CCS_MODE_SELECT_SOFTWARE_STANDBY );if (rval) goto out;
@@ -1828,7 +1787,7 @@ static void smiapp_propagate(struct v4l2_subdev *subdev, sensor->scale_m =CCS_LIM (sensor,SCALER_N_MIN ); sensor->scaling_mode = -SMIAPP_SCALING_MODE_NONE ; +CCS_SCALING_MODE_NO_SCALING ; }else if (ssd == sensor->binner) { sensor->binning_horizontal =1 ; sensor->binning_vertical =1 ;
@@ -2063,7 +2022,7 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev,struct smiapp_sensor *sensor =to_smiapp_sensor (subdev);u32 min, max, a, b, max_m;u32 scale_m =CCS_LIM (sensor,SCALER_N_MIN ); -int mode =SMIAPP_SCALING_MODE_HORIZONTAL ; +int mode =CCS_SCALING_MODE_HORIZONTAL ;u32 try[4 ];u32 ntry =0 ;unsigned int i;
@@ -2123,7 +2082,7 @@ static void smiapp_set_compose_scaler(struct v4l2_subdev *subdev,if (this > best) { scale_m = try[i]; - mode =SMIAPP_SCALING_MODE_HORIZONTAL ; + mode =CCS_SCALING_MODE_HORIZONTAL ; best = this; }
@@ -2494,26 +2453,24 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor) rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_MANUFACTURER_ID , &minfo->smia_manufacturer_id);if (!rval) - rval =smiapp_read_8only (sensor,SMIAPP_REG_U16_MODEL_ID , + rval =smiapp_read_8only (sensor,CCS_R_MODULE_MODEL_ID , &minfo->model_id);if (!rval) rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_REVISION_NUMBER_MAJOR , +CCS_R_MODULE_REVISION_NUMBER_MAJOR , &minfo->revision_number_major);if (!rval) rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_REVISION_NUMBER_MINOR , +CCS_R_MODULE_REVISION_NUMBER_MINOR , &minfo->revision_number_minor);if (!rval) - rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_MODULE_DATE_YEAR , + rval =smiapp_read_8only (sensor,CCS_R_MODULE_DATE_YEAR , &minfo->module_year);if (!rval) - rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_MODULE_DATE_MONTH , + rval =smiapp_read_8only (sensor,CCS_R_MODULE_DATE_MONTH , &minfo->module_month);if (!rval) - rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_MODULE_DATE_DAY , + rval =smiapp_read_8only (sensor,CCS_R_MODULE_DATE_DAY , &minfo->module_day);/* Sensor info */
@@ -2522,19 +2479,19 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor) &minfo->sensor_mipi_manufacturer_id);if (!rval && !minfo->sensor_mipi_manufacturer_id) rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_SENSOR_MANUFACTURER_ID , +CCS_R_SENSOR_MANUFACTURER_ID , &minfo->sensor_smia_manufacturer_id);if (!rval) rval =smiapp_read_8only (sensor, -SMIAPP_REG_U16_SENSOR_MODEL_ID , +CCS_R_SENSOR_MODEL_ID , &minfo->sensor_model_id);if (!rval) rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_SENSOR_REVISION_NUMBER , +CCS_R_SENSOR_REVISION_NUMBER , &minfo->sensor_revision_number);if (!rval) rval =smiapp_read_8only (sensor, -SMIAPP_REG_U8_SENSOR_FIRMWARE_VERSION , +CCS_R_SENSOR_FIRMWARE_VERSION , &minfo->sensor_firmware_version);/* SMIA */
@@ -2919,7 +2876,7 @@ static struct smiapp_hwconfig *smiapp_get_hwconfig(struct device *dev)switch (bus_cfg.bus_type) {case V4L2_MBUS_CSI2_DPHY : - hwcfg->csi_signalling_mode =SMIAPP_CSI_SIGNALLING_MODE_CSI2 ; + hwcfg->csi_signalling_mode =CCS_CSI_SIGNALING_MODE_CSI_2_DPHY ; hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;break ;case V4L2_MBUS_CCP2 :
@@ -3095,8 +3052,9 @@ static int smiapp_probe(struct i2c_client *client)*/ if (sensor->hwcfg->module_board_orient ==SMIAPP_MODULE_BOARD_ORIENT_180 ) - sensor->hvflip_inv_mask =SMIAPP_IMAGE_ORIENTATION_HFLIP | -SMIAPP_IMAGE_ORIENTATION_VFLIP ; + sensor->hvflip_inv_mask = +CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR | +CCS_IMAGE_ORIENTATION_VERTICAL_FLIP ; rval =smiapp_call_quirk (sensor, limits);if (rval) {
drivers/media/i2c/smiapp/smiapp.h +3 -1
@@ -15,6 +15,8 @@#include <media/v4l2-ctrls.h> #include <media/v4l2-subdev.h> +#include "ccs-regs.h" +#include "smiapp-pll.h" #include "smiapp-reg-defs.h" #include "smiapp-regs.h"
@@ -220,7 +222,7 @@ struct smiapp_sensor {struct gpio_desc *xshutdown;void *ccs_limits;u8 nbinning_subtypes; -struct smiapp_binning_subtype binning_subtypes[SMIAPP_BINNING_SUBTYPES ]; +struct smiapp_binning_subtype binning_subtypes[CCS_LIM_BINNING_SUB_TYPE_MAX_N +1 ];u32 mbus_frame_fmts;const struct smiapp_csi_data_format *csi_format;const struct smiapp_csi_data_format *internal_csi_format;
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 15/29 smiapp: Remove quirk function for writing a single 8-bit register
In reply to Sakari AilusThis function is no longer needed as the smiapp_write() function can be used to write 8-bit registers with plain register addresses.
--- drivers/media/i2c/smiapp/smiapp-quirk.c | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-)
drivers/media/i2c/smiapp/smiapp-quirk.c +5 -10
@@ -14,11 +14,6 @@#include "smiapp.h" -static int smiapp_write_8 (struct smiapp_sensor *sensor,u16 reg,u8 val) -{ -return smiapp_write (sensor, reg, val); -} -static int smiapp_write_8s (struct smiapp_sensor *sensor,const struct smiapp_reg_8 *regs,int len) {
@@ -26,7 +21,7 @@ static int smiapp_write_8s(struct smiapp_sensor *sensor,int rval;for (; len >0 ; len--, regs++) { - rval =smiapp_write_8 (sensor, regs->reg, regs->val); + rval =smiapp_write (sensor, regs->reg, regs->val);if (rval <0 ) { dev_err(&client->dev, "error %d writing reg 0x%4.4x, val 0x%2.2x",
@@ -170,7 +165,7 @@ static int jt8ev1_post_poweron(struct smiapp_sensor *sensor)static int jt8ev1_pre_streamon (struct smiapp_sensor *sensor) { -return smiapp_write_8 (sensor,0x3328 ,0x00 ); +return smiapp_write (sensor,0x3328 ,0x00 ); }static int jt8ev1_post_streamoff (struct smiapp_sensor *sensor)
@@ -178,7 +173,7 @@ static int jt8ev1_post_streamoff(struct smiapp_sensor *sensor)int rval;/* Workaround: allows fast standby to work properly */ - rval =smiapp_write_8 (sensor,0x3205 ,0x04 ); + rval =smiapp_write (sensor,0x3205 ,0x04 );if (rval <0 )return rval;
@@ -186,11 +181,11 @@ static int jt8ev1_post_streamoff(struct smiapp_sensor *sensor)usleep_range (2000 ,2050 );/* Restore it */ - rval =smiapp_write_8 (sensor,0x3205 ,0x00 ); + rval =smiapp_write (sensor,0x3205 ,0x00 );if (rval <0 )return rval; -return smiapp_write_8 (sensor,0x3328 ,0x80 ); +return smiapp_write (sensor,0x3328 ,0x80 ); }static int jt8ev1_init (struct smiapp_sensor *sensor)
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 16/29 smiapp: Rename register access functions
In reply to Sakari AilusRename register access functions by changing smiapp to ccs.
The functions operating on register addresses have "addr" appended to the name.
--- drivers/media/i2c/smiapp/smiapp-core.c | 67 +++++++++++++------------ drivers/media/i2c/smiapp/smiapp-quirk.c | 22 ++++---- drivers/media/i2c/smiapp/smiapp-regs.c | 47 ++++++++--------- drivers/media/i2c/smiapp/smiapp-regs.h | 14 +++--- 4 files changed, 76 insertions(+), 74 deletions(-)
drivers/media/i2c/smiapp/smiapp-core.c +34 -33
@@ -180,7 +180,7 @@ static int ccs_read_all_limits(struct smiapp_sensor *sensor) j++, reg += width, ptr += width) {u32 val; - ret =smiapp_read (sensor, reg, &val); + ret =ccs_read_addr (sensor, reg, &val);if (ret) goto out_err;
@@ -2450,59 +2450,60 @@ static int smiapp_identify_module(struct smiapp_sensor *sensor) rval =ccs_read (sensor,MODULE_MANUFACTURER_ID , &minfo->mipi_manufacturer_id);if (!rval && !minfo->mipi_manufacturer_id) - rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_MANUFACTURER_ID , - &minfo->smia_manufacturer_id); + rval =ccs_read_addr_8only (sensor, +SMIAPP_REG_U8_MANUFACTURER_ID , + &minfo->smia_manufacturer_id);if (!rval) - rval =smiapp_read_8only (sensor,CCS_R_MODULE_MODEL_ID , - &minfo->model_id); + rval =ccs_read_addr_8only (sensor,CCS_R_MODULE_MODEL_ID , + &minfo->model_id);if (!rval) - rval =smiapp_read_8only (sensor, -CCS_R_MODULE_REVISION_NUMBER_MAJOR , - &minfo->revision_number_major); + rval =ccs_read_addr_8only (sensor, +CCS_R_MODULE_REVISION_NUMBER_MAJOR , + &minfo->revision_number_major);if (!rval) - rval =smiapp_read_8only (sensor, -CCS_R_MODULE_REVISION_NUMBER_MINOR , - &minfo->revision_number_minor); + rval =ccs_read_addr_8only (sensor, +CCS_R_MODULE_REVISION_NUMBER_MINOR , + &minfo->revision_number_minor);if (!rval) - rval =smiapp_read_8only (sensor,CCS_R_MODULE_DATE_YEAR , - &minfo->module_year); + rval =ccs_read_addr_8only (sensor,CCS_R_MODULE_DATE_YEAR , + &minfo->module_year);if (!rval) - rval =smiapp_read_8only (sensor,CCS_R_MODULE_DATE_MONTH , - &minfo->module_month); + rval =ccs_read_addr_8only (sensor,CCS_R_MODULE_DATE_MONTH , + &minfo->module_month);if (!rval) - rval =smiapp_read_8only (sensor,CCS_R_MODULE_DATE_DAY , - &minfo->module_day); + rval =ccs_read_addr_8only (sensor,CCS_R_MODULE_DATE_DAY , + &minfo->module_day);/* Sensor info */ if (!rval) rval =ccs_read (sensor,SENSOR_MANUFACTURER_ID , &minfo->sensor_mipi_manufacturer_id);if (!rval && !minfo->sensor_mipi_manufacturer_id) - rval =smiapp_read_8only (sensor, -CCS_R_SENSOR_MANUFACTURER_ID , - &minfo->sensor_smia_manufacturer_id); + rval =ccs_read_addr_8only (sensor, +CCS_R_SENSOR_MANUFACTURER_ID , + &minfo->sensor_smia_manufacturer_id);if (!rval) - rval =smiapp_read_8only (sensor, -CCS_R_SENSOR_MODEL_ID , - &minfo->sensor_model_id); + rval =ccs_read_addr_8only (sensor, +CCS_R_SENSOR_MODEL_ID , + &minfo->sensor_model_id);if (!rval) - rval =smiapp_read_8only (sensor, -CCS_R_SENSOR_REVISION_NUMBER , - &minfo->sensor_revision_number); + rval =ccs_read_addr_8only (sensor, +CCS_R_SENSOR_REVISION_NUMBER , + &minfo->sensor_revision_number);if (!rval) - rval =smiapp_read_8only (sensor, -CCS_R_SENSOR_FIRMWARE_VERSION , - &minfo->sensor_firmware_version); + rval =ccs_read_addr_8only (sensor, +CCS_R_SENSOR_FIRMWARE_VERSION , + &minfo->sensor_firmware_version);/* SMIA */ if (!rval) rval =ccs_read (sensor,MIPI_CCS_VERSION , &minfo->ccs_version);if (!rval && !minfo->ccs_version) - rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_SMIA_VERSION , - &minfo->smia_version); + rval =ccs_read_addr_8only (sensor,SMIAPP_REG_U8_SMIA_VERSION , + &minfo->smia_version);if (!rval && !minfo->ccs_version) - rval =smiapp_read_8only (sensor,SMIAPP_REG_U8_SMIAPP_VERSION , - &minfo->smiapp_version); + rval =ccs_read_addr_8only (sensor,SMIAPP_REG_U8_SMIAPP_VERSION , + &minfo->smiapp_version);if (rval) {dev_err (&client->dev,"sensor detection failed\n" );
drivers/media/i2c/smiapp/smiapp-quirk.c +11 -11
@@ -14,14 +14,14 @@#include "smiapp.h" -static int smiapp_write_8s (struct smiapp_sensor *sensor, -const struct smiapp_reg_8 *regs,int len) +static int ccs_write_addr_8s (struct smiapp_sensor *sensor, +const struct smiapp_reg_8 *regs,int len) {struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd);int rval;for (; len >0 ; len--, regs++) { - rval =smiapp_write (sensor, regs->reg, regs->val); + rval =ccs_write_addr (sensor, regs->reg, regs->val);if (rval <0 ) { dev_err(&client->dev, "error %d writing reg 0x%4.4x, val 0x%2.2x",
@@ -81,7 +81,7 @@ static int jt8ew9_post_poweron(struct smiapp_sensor *sensor) }; -return smiapp_write_8s (sensor, regs,ARRAY_SIZE (regs)); +return ccs_write_addr_8s (sensor, regs,ARRAY_SIZE (regs)); }const struct smiapp_quirk smiapp_jt8ew9_quirk = {
@@ -102,7 +102,7 @@ static int imx125es_post_poweron(struct smiapp_sensor *sensor) { 0x3b08, 0x8c }, }; -return smiapp_write_8s (sensor, regs,ARRAY_SIZE (regs)); +return ccs_write_addr_8s (sensor, regs,ARRAY_SIZE (regs)); }const struct smiapp_quirk smiapp_imx125es_quirk = {
@@ -148,13 +148,13 @@ static int jt8ev1_post_poweron(struct smiapp_sensor *sensor) { 0x30b0, 0x01 }, }; - rval =smiapp_write_8s (sensor, regs,ARRAY_SIZE (regs)); + rval =ccs_write_addr_8s (sensor, regs,ARRAY_SIZE (regs));if (rval <0 )return rval;switch (sensor->hwcfg->ext_clk) {case 9600000 : -return smiapp_write_8s (sensor, regs_96, +return ccs_write_addr_8s (sensor, regs_96,ARRAY_SIZE (regs_96));default : dev_warn(&client->dev, "no MSRs for %d Hz ext_clk\n",
@@ -165,7 +165,7 @@ static int jt8ev1_post_poweron(struct smiapp_sensor *sensor)static int jt8ev1_pre_streamon (struct smiapp_sensor *sensor) { -return smiapp_write (sensor,0x3328 ,0x00 ); +return ccs_write_addr (sensor,0x3328 ,0x00 ); }static int jt8ev1_post_streamoff (struct smiapp_sensor *sensor)
@@ -173,7 +173,7 @@ static int jt8ev1_post_streamoff(struct smiapp_sensor *sensor)int rval;/* Workaround: allows fast standby to work properly */ - rval =smiapp_write (sensor,0x3205 ,0x04 ); + rval =ccs_write_addr (sensor,0x3205 ,0x04 );if (rval <0 )return rval;
@@ -181,11 +181,11 @@ static int jt8ev1_post_streamoff(struct smiapp_sensor *sensor)usleep_range (2000 ,2050 );/* Restore it */ - rval =smiapp_write (sensor,0x3205 ,0x00 ); + rval =ccs_write_addr (sensor,0x3205 ,0x00 );if (rval <0 )return rval; -return smiapp_write (sensor,0x3328 ,0x80 ); +return ccs_write_addr (sensor,0x3328 ,0x80 ); }static int jt8ev1_init (struct smiapp_sensor *sensor)
drivers/media/i2c/smiapp/smiapp-regs.c +24 -23
115 lines not on this page · raw message
drivers/media/i2c/smiapp/smiapp-regs.h +7 -7
@@ -20,18 +20,18 @@struct smiapp_sensor ; -int smiapp_read_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 *val); -int smiapp_read (struct smiapp_sensor *sensor,u32 reg,u32 *val); -int smiapp_read_8only (struct smiapp_sensor *sensor,u32 reg,u32 *val); -int smiapp_write_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 val); -int smiapp_write (struct smiapp_sensor *sensor,u32 reg,u32 val); +int ccs_read_addr_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 *val); +int ccs_read_addr (struct smiapp_sensor *sensor,u32 reg,u32 *val); +int ccs_read_addr_8only (struct smiapp_sensor *sensor,u32 reg,u32 *val); +int ccs_write_addr_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 val); +int ccs_write_addr (struct smiapp_sensor *sensor,u32 reg,u32 val);unsigned int ccs_reg_width (u32 reg);#define ccs_read (sensor, reg_name, val) \ - smiapp_read(sensor, CCS_R_##reg_name, val) + ccs_read_addr(sensor, CCS_R_##reg_name, val)#define ccs_write (sensor, reg_name, val) \ - smiapp_write(sensor, CCS_R_##reg_name, val) + ccs_write_addr(sensor, CCS_R_##reg_name, val)#endif
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 17/29 smiapp: Internal rename to CCS
In reply to Sakari AilusRename internal names to reflect the driver's new reference. The module name remains the same.
Also fix trivial coding style issues on the way related to e.g. alignment changes due to the rename.
---
drivers/media/i2c/smiapp/Makefile | 4 +-
.../i2c/smiapp/{smiapp-core.c => ccs-core.c} | 888 +++++++++---------
.../smiapp/{smiapp-quirk.c => ccs-quirk.c} | 43 +-
.../smiapp/{smiapp-quirk.h => ccs-quirk.h} | 46 +-
.../{smiapp-regs.c => ccs-reg-access.c} | 41 +-
.../{smiapp-regs.h => ccs-reg-access.h} | 16 +-
drivers/media/i2c/smiapp/{smiapp.h => ccs.h} | 124 +--
7 files changed, 576 insertions(+), 586 deletions(-)
rename drivers/media/i2c/smiapp/{smiapp-core.c => ccs-core.c} (75%)
rename drivers/media/i2c/smiapp/{smiapp-quirk.c => ccs-quirk.c} (83%)
rename drivers/media/i2c/smiapp/{smiapp-quirk.h => ccs-quirk.h} (59%)
rename drivers/media/i2c/smiapp/{smiapp-regs.c => ccs-reg-access.c} (79%)
rename drivers/media/i2c/smiapp/{smiapp-regs.h => ccs-reg-access.h} (55%)
rename drivers/media/i2c/smiapp/{smiapp.h => ccs.h} (65%)drivers/media/i2c/smiapp/Makefile +2 -2
@@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only -smiapp-objs += smiapp-core.o smiapp-regs.o \ - smiapp-quirk.o ccs-limits.o +smiapp-objs += ccs-core.o ccs-reg-access.o \ + ccs-quirk.o ccs-limits.o obj-$(CONFIG_VIDEO_SMIAPP) += smiapp.o ccflags-y += -I $(srctree)/drivers/media/i2c
drivers/media/i2c/smiapp/ccs-core.c renamed from drivers/media/i2c/smiapp/smiapp-core.c +441 -447
2,057 lines not on this page · raw message
drivers/media/i2c/smiapp/ccs-quirk.c renamed from drivers/media/i2c/smiapp/smiapp-quirk.c +21 -22
138 lines not on this page · raw message
drivers/media/i2c/smiapp/ccs-quirk.h renamed from drivers/media/i2c/smiapp/smiapp-quirk.h +23 -23
85 lines not on this page · raw message
drivers/media/i2c/smiapp/ccs-reg-access.c renamed from drivers/media/i2c/smiapp/smiapp-regs.c +19 -22
128 lines not on this page · raw message
drivers/media/i2c/smiapp/ccs-reg-access.h renamed from drivers/media/i2c/smiapp/smiapp-regs.h +8 -8
@@ -1,6 +1,6 @@/* SPDX-License-Identifier: GPL-2.0-only */ /* -* include/media/smiapp/smiapp-regs.h +* include/media/smiapp/ccs-regs.h * * Generic driver for SMIA/SMIA++ compliant camera modules *
@@ -16,15 +16,15 @@#include "ccs-regs.h" -#define SMIAPP_REG_ADDR (reg) ((u16)reg) +#define CCS_REG_ADDR (reg) ((u16)reg) -struct smiapp_sensor ; +struct ccs_sensor ; -int ccs_read_addr_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 *val); -int ccs_read_addr (struct smiapp_sensor *sensor,u32 reg,u32 *val); -int ccs_read_addr_8only (struct smiapp_sensor *sensor,u32 reg,u32 *val); -int ccs_write_addr_no_quirk (struct smiapp_sensor *sensor,u32 reg,u32 val); -int ccs_write_addr (struct smiapp_sensor *sensor,u32 reg,u32 val); +int ccs_read_addr_no_quirk (struct ccs_sensor *sensor,u32 reg,u32 *val); +int ccs_read_addr (struct ccs_sensor *sensor,u32 reg,u32 *val); +int ccs_read_addr_8only (struct ccs_sensor *sensor,u32 reg,u32 *val); +int ccs_write_addr_no_quirk (struct ccs_sensor *sensor,u32 reg,u32 val); +int ccs_write_addr (struct ccs_sensor *sensor,u32 reg,u32 val);unsigned int ccs_reg_width (u32 reg);
drivers/media/i2c/smiapp/ccs.h renamed from drivers/media/i2c/smiapp/smiapp.h +62 -62
273 lines not on this page · raw message
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 18/29 smiapp: Differentiate CCS sensors from SMIA in subdev naming
In reply to Sakari AilusCall CCS compliant sensors as "ccs" instead of "smiapp" in absence of a device specific name. This is done based on the value of the manufacturer ID register that is only present in CCS.
--- drivers/media/i2c/smiapp/ccs-core.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
drivers/media/i2c/smiapp/ccs-core.c +5 -4
@@ -2437,8 +2437,6 @@ static int ccs_identify_module(struct ccs_sensor *sensor)unsigned int i;int rval =0 ; - minfo->name =SMIAPP_NAME ; -/* Module info */ rval =ccs_read (sensor,MODULE_MANUFACTURER_ID , &minfo->mipi_manufacturer_id);
@@ -2528,15 +2526,18 @@ static int ccs_identify_module(struct ccs_sensor *sensor)"sensor revision 0x%2.2x firmware version 0x%2.2x\n" , minfo->sensor_revision_number, minfo->sensor_firmware_version); -if (minfo->ccs_version) +if (minfo->ccs_version) {dev_dbg (&client->dev,"MIPI CCS version %u.%u" , (minfo->ccs_version &CCS_MIPI_CCS_VERSION_MAJOR_MASK ) >>CCS_MIPI_CCS_VERSION_MAJOR_SHIFT , (minfo->ccs_version &CCS_MIPI_CCS_VERSION_MINOR_MASK )); -else + minfo->name =CCS_NAME ; + }else {dev_dbg (&client->dev,"smia version %2.2d smiapp version %2.2d\n" , minfo->smia_version, minfo->smiapp_version); + minfo->name =SMIAPP_NAME ; + }/* * Some modules have bad data in the lvalues below. Hope the
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 19/29 smiapp: Rename as "ccs"
In reply to Sakari AilusRename the "smiapp" driver as "ccs". MIPI CCS is the contemporary standard for raw Bayer camera sensors. The driver retains support for the SMIA++ and SMIA compliant camera sensors. A module alias is added for old user space using "smiapp" module name.
Add Intel copyright while at it.
---
MAINTAINERS | 20 +++++++++----------
drivers/media/i2c/Kconfig | 2 +-
drivers/media/i2c/Makefile | 2 +-
drivers/media/i2c/{smiapp => ccs}/Kconfig | 7 ++++---
drivers/media/i2c/{smiapp => ccs}/Makefile | 4 ++--
drivers/media/i2c/{smiapp => ccs}/ccs-core.c | 6 ++++--
.../media/i2c/{smiapp => ccs}/ccs-limits.c | 0
.../media/i2c/{smiapp => ccs}/ccs-limits.h | 0
drivers/media/i2c/{smiapp => ccs}/ccs-quirk.c | 5 +++--
drivers/media/i2c/{smiapp => ccs}/ccs-quirk.h | 5 +++--
.../i2c/{smiapp => ccs}/ccs-reg-access.c | 5 +++--
.../i2c/{smiapp => ccs}/ccs-reg-access.h | 5 +++--
drivers/media/i2c/{smiapp => ccs}/ccs-regs.h | 0
drivers/media/i2c/{smiapp => ccs}/ccs.h | 3 ++-
.../i2c/{smiapp => ccs}/smiapp-reg-defs.h | 3 ++-
15 files changed, 38 insertions(+), 29 deletions(-)
rename drivers/media/i2c/{smiapp => ccs}/Kconfig (55%)
rename drivers/media/i2c/{smiapp => ccs}/Makefile (57%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-core.c (99%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-limits.c (100%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-limits.h (100%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-quirk.c (97%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-quirk.h (94%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-reg-access.c (97%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-reg-access.h (86%)
rename drivers/media/i2c/{smiapp => ccs}/ccs-regs.h (100%)
rename drivers/media/i2c/{smiapp => ccs}/ccs.h (98%)
rename drivers/media/i2c/{smiapp => ccs}/smiapp-reg-defs.h (99%)MAINTAINERS +10 -10
@@ -11662,6 +11662,16 @@ M: Oliver Neukum <[email protected]> S: Maintained F: drivers/usb/image/microtek.* +MIPI CCS, SMIA AND SMIA++ IMAGE SENSOR DRIVER +M: Sakari Ailus <[email protected]> +L: [email protected] +S: Maintained +F: Documentation/devicetree/bindings/media/i2c/nokia,smia.txt +F: drivers/media/i2c/ccs/ +F: drivers/media/i2c/smiapp-pll.c +F: drivers/media/i2c/smiapp-pll.h +F: include/uapi/linux/smiapp.h + MIPS M: Thomas Bogendoerfer <[email protected]> L: [email protected]
@@ -16130,16 +16140,6 @@ S: Maintained F: drivers/firmware/smccc/ F: include/linux/arm-smccc.h -SMIA AND SMIA++ IMAGE SENSOR DRIVER -M: Sakari Ailus <[email protected]> -L: [email protected] -S: Maintained -F: Documentation/devicetree/bindings/media/i2c/nokia,smia.txt -F: drivers/media/i2c/smiapp-pll.c -F: drivers/media/i2c/smiapp-pll.h -F: drivers/media/i2c/smiapp/ -F: include/uapi/linux/smiapp.h - SMM665 HARDWARE MONITOR DRIVER M: Guenter Roeck <[email protected]> L: [email protected]
drivers/media/i2c/Kconfig +1 -1
@@ -1233,7 +1233,7 @@ config VIDEO_S5K5BAF This is a V4L2 sensor driver for Samsung S5K5BAF 2M camera sensor with an embedded SoC image signal processor. -source "drivers/media/i2c/smiapp/Kconfig" +source "drivers/media/i2c/ccs/Kconfig" source "drivers/media/i2c/et8ek8/Kconfig" config VIDEO_S5C73M3
drivers/media/i2c/Makefile +1 -1
@@ -2,7 +2,7 @@ msp3400-objs := msp3400-driver.o msp3400-kthreads.o obj-$(CONFIG_VIDEO_MSP3400) += msp3400.o -obj-$(CONFIG_VIDEO_SMIAPP) += smiapp/ +obj-$(CONFIG_VIDEO_CCS) += ccs/ obj-$(CONFIG_VIDEO_ET8EK8) += et8ek8/ obj-$(CONFIG_VIDEO_CX25840) += cx25840/ obj-$(CONFIG_VIDEO_M5MOLS) += m5mols/
drivers/media/i2c/ccs/Kconfig renamed from drivers/media/i2c/smiapp/Kconfig +4 -3
@@ -1,10 +1,11 @@ # SPDX-License-Identifier: GPL-2.0-only -config VIDEO_SMIAPP - tristate "SMIA++/SMIA sensor support" +config VIDEO_CCS + tristate "MIPI CCS/SMIA++/SMIA sensor support" depends on I2C && VIDEO_V4L2 && HAVE_CLK select MEDIA_CONTROLLER select VIDEO_V4L2_SUBDEV_API select VIDEO_SMIAPP_PLL select V4L2_FWNODE help - This is a generic driver for SMIA++/SMIA camera modules. + This is a generic driver for MIPI CCS, SMIA++ and SMIA compliant + camera sensors.
drivers/media/i2c/ccs/Makefile renamed from drivers/media/i2c/smiapp/Makefile +2 -2
@@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only -smiapp-objs += ccs-core.o ccs-reg-access.o \ +ccs-objs += ccs-core.o ccs-reg-access.o \ ccs-quirk.o ccs-limits.o -obj-$(CONFIG_VIDEO_SMIAPP) += smiapp.o +obj-$(CONFIG_VIDEO_CCS) += ccs.o ccflags-y += -I $(srctree)/drivers/media/i2c
drivers/media/i2c/ccs/ccs-core.c renamed from drivers/media/i2c/smiapp/ccs-core.c +4 -2
@@ -1,9 +1,10 @@// SPDX-License-Identifier: GPL-2.0-only /* -* drivers/media/i2c/smiapp/ccs-core.c +* drivers/media/i2c/ccs/ccs-core.c * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2010--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> *
@@ -3298,3 +3299,4 @@ module_exit(ccs_module_cleanup);MODULE_AUTHOR ("Sakari Ailus <[email protected]>" );MODULE_DESCRIPTION ("Generic MIPI CCS/SMIA/SMIA++ camera sensor driver" );MODULE_LICENSE ("GPL v2" ); +MODULE_ALIAS ("smiapp" );
drivers/media/i2c/ccs/ccs-limits.c renamed from drivers/media/i2c/smiapp/ccs-limits.c +0 -0
drivers/media/i2c/ccs/ccs-limits.h renamed from drivers/media/i2c/smiapp/ccs-limits.h +0 -0
drivers/media/i2c/ccs/ccs-quirk.c renamed from drivers/media/i2c/smiapp/ccs-quirk.c +3 -2
@@ -1,9 +1,10 @@// SPDX-License-Identifier: GPL-2.0-only /* -* drivers/media/i2c/smiapp/ccs-quirk.c +* drivers/media/i2c/ccs/ccs-quirk.c * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2011--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */
drivers/media/i2c/ccs/ccs-quirk.h renamed from drivers/media/i2c/smiapp/ccs-quirk.h +3 -2
@@ -1,9 +1,10 @@/* SPDX-License-Identifier: GPL-2.0-only */ /* -* drivers/media/i2c/smiapp/ccs-quirk.h +* drivers/media/i2c/ccs/ccs-quirk.h * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2011--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */
drivers/media/i2c/ccs/ccs-reg-access.c renamed from drivers/media/i2c/smiapp/ccs-reg-access.c +3 -2
@@ -1,9 +1,10 @@// SPDX-License-Identifier: GPL-2.0-only /* -* drivers/media/i2c/smiapp/ccs-regs.c +* drivers/media/i2c/ccs/ccs-reg-access.c * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2011--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */
drivers/media/i2c/ccs/ccs-reg-access.h renamed from drivers/media/i2c/smiapp/ccs-reg-access.h +3 -2
@@ -1,9 +1,10 @@/* SPDX-License-Identifier: GPL-2.0-only */ /* -* include/media/smiapp/ccs-regs.h +* include/media/ccs/ccs-reg-access.h * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2011--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */
drivers/media/i2c/ccs/ccs-regs.h renamed from drivers/media/i2c/smiapp/ccs-regs.h +0 -0
drivers/media/i2c/ccs/ccs.h renamed from drivers/media/i2c/smiapp/ccs.h +2 -1
@@ -2,8 +2,9 @@/* * drivers/media/i2c/smiapp/ccs.h * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2010--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */
drivers/media/i2c/ccs/smiapp-reg-defs.h renamed from drivers/media/i2c/smiapp/smiapp-reg-defs.h +2 -1
@@ -2,8 +2,9 @@/* * drivers/media/i2c/smiapp/smiapp-reg-defs.h * -* Generic driver for SMIA/SMIA++ compliant camera modules +* Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors * +* Copyright (C) 2020 Intel Corporation * Copyright (C) 2011--2012 Nokia Corporation * Contact: Sakari Ailus <[email protected]> */
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 20/29 ccs: Remove profile concept
In reply to Sakari AilusThe driver doesn't do anything tangible with profiles. Remove the notion, and use the capabilities directly.
--- drivers/media/i2c/ccs/ccs-core.c | 23 ++++++----------------- drivers/media/i2c/ccs/ccs.h | 2 -- 2 files changed, 6 insertions(+), 19 deletions(-)
drivers/media/i2c/ccs/ccs-core.c +6 -17
@@ -377,7 +377,7 @@ static int ccs_pll_configure(struct ccs_sensor *sensor) rval =ccs_write (sensor,REQUESTED_LINK_RATE ,DIV_ROUND_UP (pll->op.sys_clk_freq_hz,1000000 /256 /256 )); -if (rval <0 || sensor->minfo.smiapp_profile ==SMIAPP_PROFILE_0 ) +if (rval <0 || sensor->pll.flags &SMIAPP_PLL_FLAG_NO_OP_CLOCKS )return rval; rval =ccs_write (sensor,OP_PIX_CLK_DIV , pll->op.pix_clk_div);
@@ -3096,23 +3096,17 @@ static int ccs_probe(struct i2c_client *client) } } -/* We consider this as profile 0 sensor if any of these are zero. */ if (!CCS_LIM (sensor,MIN_OP_SYS_CLK_DIV ) || !CCS_LIM (sensor,MAX_OP_SYS_CLK_DIV ) || !CCS_LIM (sensor,MIN_OP_PIX_CLK_DIV ) || !CCS_LIM (sensor,MAX_OP_PIX_CLK_DIV )) { - sensor->minfo.smiapp_profile =SMIAPP_PROFILE_0 ; +/* No OP clock branch */ + sensor->pll.flags |=SMIAPP_PLL_FLAG_NO_OP_CLOCKS ; }else if (CCS_LIM (sensor,SCALING_CAPABILITY ) - !=CCS_SCALING_CAPABILITY_NONE ) { -if (CCS_LIM (sensor,SCALING_CAPABILITY ) - ==CCS_SCALING_CAPABILITY_HORIZONTAL ) - sensor->minfo.smiapp_profile =SMIAPP_PROFILE_1 ; -else - sensor->minfo.smiapp_profile =SMIAPP_PROFILE_2 ; - sensor->scaler = &sensor->ssds[sensor->ssds_used]; - sensor->ssds_used++; - }else if (CCS_LIM (sensor,DIGITAL_CROP_CAPABILITY ) + !=CCS_SCALING_CAPABILITY_NONE || +CCS_LIM (sensor,DIGITAL_CROP_CAPABILITY ) ==CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP ) { +/* We have a scaler or digital crop. */ sensor->scaler = &sensor->ssds[sensor->ssds_used]; sensor->ssds_used++; }
@@ -3128,16 +3122,11 @@ static int ccs_probe(struct i2c_client *client) sensor->pll.csi2.lanes = sensor->hwcfg->lanes; sensor->pll.ext_clk_freq_hz = sensor->hwcfg->ext_clk; sensor->pll.scale_n =CCS_LIM (sensor,SCALER_N_MIN ); -/* Profile 0 sensors have no separate OP clock branch. */ -if (sensor->minfo.smiapp_profile ==SMIAPP_PROFILE_0 ) - sensor->pll.flags |=SMIAPP_PLL_FLAG_NO_OP_CLOCKS ;ccs_create_subdev (sensor, sensor->scaler," scaler" ,2 );ccs_create_subdev (sensor, sensor->binner," binner" ,2 );ccs_create_subdev (sensor, sensor->pixel_array," pixel_array" ,1 ); -dev_dbg (&client->dev,"profile %d\n" , sensor->minfo.smiapp_profile); - sensor->pixel_array->sd.entity.function =MEDIA_ENT_F_CAM_SENSOR ; rval =ccs_init_controls (sensor);
drivers/media/i2c/ccs/ccs.h +0 -2
@@ -124,8 +124,6 @@ struct ccs_module_info {u32 smiapp_version;u32 ccs_version; -u32 smiapp_profile; -char *name;const struct ccs_quirk *quirk; };
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 21/29 ccs: Give all subdevs a function
In reply to Sakari AilusThis removes a warning at driver probe time telling that one or two entities have no function set. The function used for both the binner and scaler is the scaler.
--- drivers/media/i2c/ccs/ccs-core.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-)
drivers/media/i2c/ccs/ccs-core.c +8 -6
@@ -2685,7 +2685,7 @@ static void ccs_cleanup(struct ccs_sensor *sensor)static void ccs_create_subdev (struct ccs_sensor *sensor,struct ccs_subdev *ssd,const char *name, -unsigned short num_pads) +unsigned short num_pads,u32 function) {struct i2c_client *client =v4l2_get_subdevdata (&sensor->src->sd);
@@ -2696,6 +2696,7 @@ static void ccs_create_subdev(struct ccs_sensor *sensor,v4l2_subdev_init (&ssd->sd, &ccs_ops); ssd->sd.flags |=V4L2_SUBDEV_FL_HAS_DEVNODE ; + ssd->sd.entity.function = function; ssd->sensor = sensor; ssd->npads = num_pads;
@@ -3123,11 +3124,12 @@ static int ccs_probe(struct i2c_client *client) sensor->pll.ext_clk_freq_hz = sensor->hwcfg->ext_clk; sensor->pll.scale_n =CCS_LIM (sensor,SCALER_N_MIN ); -ccs_create_subdev (sensor, sensor->scaler," scaler" ,2 ); -ccs_create_subdev (sensor, sensor->binner," binner" ,2 ); -ccs_create_subdev (sensor, sensor->pixel_array," pixel_array" ,1 ); - - sensor->pixel_array->sd.entity.function =MEDIA_ENT_F_CAM_SENSOR ; +ccs_create_subdev (sensor, sensor->scaler," scaler" ,2 , +MEDIA_ENT_F_CAM_SENSOR ); +ccs_create_subdev (sensor, sensor->binner," binner" ,2 , +MEDIA_ENT_F_PROC_VIDEO_SCALER ); +ccs_create_subdev (sensor, sensor->pixel_array," pixel_array" ,1 , +MEDIA_ENT_F_PROC_VIDEO_SCALER ); rval =ccs_init_controls (sensor);if (rval <0 )
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 22/29 dt-bindings: nokia,smia: Fix link-frequencies documentation
In reply to Sakari AilusThe link-frequencies property belongs to the endpoint, not to the node representing the device.
--- .../devicetree/bindings/media/i2c/nokia,smia.txt | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
Documentation/devicetree/bindings/media/i2c/nokia,smia.txt +5 -3
@@ -20,8 +20,6 @@ Mandatory properties dependent). - clocks: External clock to the sensor - clock-frequency: Frequency of the external clock to the sensor -- link-frequencies: List of allowed data link frequencies. An array of - 64-bit elements. Optional properties
@@ -39,6 +37,8 @@ Endpoint node mandatory properties ---------------------------------- - data-lanes: <1..n> +- link-frequencies: List of allowed data link frequencies. An array of + 64-bit elements. Example
@@ -55,11 +55,13 @@ Example clocks = <&omap3_isp 0>; clock-frequency = <9600000>; nokia,nvm-size = <512>; /* 8 * 64 */ - link-frequencies = /bits/ 64 <199200000 210000000 499200000>; port { smiapp_ep: endpoint { data-lanes = <1 2>; remote-endpoint = <&csi2a_ep>; + link-frequencies = + /bits/ 64 <199200000 210000000 + 499200000>; }; }; };
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 23/29 dt-bindings: nokia,smia: Make vana-supply optional
In reply to Sakari Ailusvana-supply is optional in the spec, therefore make it optional in bindings, too.
--- Documentation/devicetree/bindings/media/i2c/nokia,smia.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
Documentation/devicetree/bindings/media/i2c/nokia,smia.txt +2 -2
@@ -16,8 +16,6 @@ Mandatory properties - compatible: "nokia,smia" - reg: I2C address (0x10, or an alternative address) -- vana-supply: Analogue voltage supply (VANA), typically 2,8 volts (sensor - dependent). - clocks: External clock to the sensor - clock-frequency: Frequency of the external clock to the sensor
@@ -31,6 +29,8 @@ Optional properties - rotation: Integer property; valid values are 0 (sensor mounted upright) and 180 (sensor mounted upside down). See ../video-interfaces.txt . +- vana-supply: Analogue voltage supply (VANA), typically 2,8 volts (sensor + dependent). Endpoint node mandatory properties
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 24/29 dt-bindings: nokia,smia: Remove nokia,nvm-size property
In reply to Sakari Ailusnokia,nvm-size property was removed from the bindings but it was left in the example. Remove it from the example, too.
--- Documentation/devicetree/bindings/media/i2c/nokia,smia.txt | 1 - 1 file changed, 1 deletion(-)
Documentation/devicetree/bindings/media/i2c/nokia,smia.txt +0 -1
@@ -54,7 +54,6 @@ Example vana-supply = <&vaux3>; clocks = <&omap3_isp 0>; clock-frequency = <9600000>; - nokia,nvm-size = <512>; /* 8 * 64 */ port { smiapp_ep: endpoint { data-lanes = <1 2>;
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 25/29 dt-bindings: nokia,smia: Convert to YAML
In reply to Sakari AilusConvert nokia,smia DT bindings to YAML.
Also add explicit license to bindings.
--- .../bindings/media/i2c/nokia,smia.txt | 67 ----------- .../bindings/media/i2c/nokia,smia.yaml | 106 ++++++++++++++++++ MAINTAINERS | 2 +- 3 files changed, 107 insertions(+), 68 deletions(-) delete mode 100644 Documentation/devicetree/bindings/media/i2c/nokia,smia.txt create mode 100644 Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml
Documentation/devicetree/bindings/media/i2c/nokia,smia.txt deleted +0 -67
@@ -1,67 +0,0 @@ -SMIA/SMIA++ sensor - -SMIA (Standard Mobile Imaging Architecture) is an image sensor standard -defined jointly by Nokia and ST. SMIA++, defined by Nokia, is an extension -of that. These definitions are valid for both types of sensors. - -More detailed documentation can be found in -Documentation/devicetree/bindings/media/video-interfaces.txt . - -The device node should contain a "port" node which may contain one or more -endpoint nodes, in accordance with video interface bindings defined in -Documentation/devicetree/bindings/media/video-interfaces.txt . - -Mandatory properties --------------------- - -- compatible: "nokia,smia" -- reg: I2C address (0x10, or an alternative address) -- clocks: External clock to the sensor -- clock-frequency: Frequency of the external clock to the sensor - - -Optional properties -------------------- - -- reset-gpios: XSHUTDOWN GPIO -- flash-leds: See ../video-interfaces.txt -- lens-focus: See ../video-interfaces.txt -- rotation: Integer property; valid values are 0 (sensor mounted upright) - and 180 (sensor mounted upside down). See - ../video-interfaces.txt . -- vana-supply: Analogue voltage supply (VANA), typically 2,8 volts (sensor - dependent). - - -Endpoint node mandatory properties ----------------------------------- - -- data-lanes: <1..n> -- link-frequencies: List of allowed data link frequencies. An array of - 64-bit elements. - - -Example -------- - -&i2c2 { - clock-frequency = <400000>; - - camera-sensor@10 { - compatible = "nokia,smia"; - reg = <0x10>; - reset-gpios = <&gpio3 20 0>; - vana-supply = <&vaux3>; - clocks = <&omap3_isp 0>; - clock-frequency = <9600000>; - port { - smiapp_ep: endpoint { - data-lanes = <1 2>; - remote-endpoint = <&csi2a_ep>; - link-frequencies = - /bits/ 64 <199200000 210000000 - 499200000>; - }; - }; - }; -};
Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml new file +106 -0
106 lines not on this page · raw message
MAINTAINERS +1 -1
@@ -11666,7 +11666,7 @@ MIPI CCS, SMIA AND SMIA++ IMAGE SENSOR DRIVER M: Sakari Ailus <[email protected]> L: [email protected] S: Maintained -F: Documentation/devicetree/bindings/media/i2c/nokia,smia.txt +F: Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml F: drivers/media/i2c/ccs/ F: drivers/media/i2c/smiapp-pll.c F: drivers/media/i2c/smiapp-pll.h
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 26/29 dt-bindings: nokia,smia: Use better active polarity for reset
In reply to Sakari AilusGenerally reset signal is active low on camera sensors. The example had it high. Make it low, and use GPIO_ACTIVE_LOW in gpio.h for that.
--- Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml +3 -1
@@ -80,6 +80,8 @@ additionalProperties: false examples: - | + #include <dt-bindings/gpio/gpio.h> + i2c2 { #address-cells = <1>; #size-cells = <0>;
@@ -89,7 +91,7 @@ examples: camera-sensor@10 { compatible = "nokia,smia"; reg = <0x10>; - reset-gpios = <&gpio3 20 0>; + reset-gpios = <&gpio3 20 GPIO_ACTIVE_LOW>; vana-supply = <&vaux3>; clocks = <&omap3_isp 0>; clock-frequency = <9600000>;
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 27/29 dt-bindings: nokia,smia: Amend SMIA bindings with MIPI CCS support
In reply to Sakari AilusAmend the existing SMIA bindings by adding MIPI CCS support, with separate compatible strings for CCS 1.0 and CCS 1.1. Rename the old bindings accordingly as CCS is the current standard.
---
.../i2c/{nokia,smia.yaml => mipi-ccs.yaml} | 23 ++++++++++++++-----
MAINTAINERS | 2 +-
2 files changed, 18 insertions(+), 7 deletions(-)
rename Documentation/devicetree/bindings/media/i2c/{nokia,smia.yaml => mipi-ccs.yaml} (81%)Documentation/devicetree/bindings/media/i2c/mipi-ccs.yaml renamed from Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml +17 -6
@@ -1,26 +1,37 @@ # SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) # Copyright (C) 2014--2020 Intel Corporation -$id: http://devicetree.org/schemas/media/i2c/nokia,smia.yaml# +$id: http://devicetree.org/schemas/media/i2c/mipi-ccs.yaml# $schema: http://devicetree.org/meta-schemas/core.yaml# -title: SMIA/SMIA++ sensor +title: MIPI CCS, SMIA++ and SMIA compliant camera sensors maintainers: - Sakari Ailus <[email protected]> description: + CCS (Camera Command Set) is a raw Bayer camera sensor standard defined by the + MIPI Alliance; see + <URL:https://www.mipi.org/specifications/camera-command-set>. + SMIA (Standard Mobile Imaging Architecture) is an image sensor standard defined jointly by Nokia and ST. SMIA++, defined by Nokia, is an extension of - that. These definitions are valid for both types of sensors. + that. More detailed documentation can be found in Documentation/devicetree/bindings/media/video-interfaces.txt . properties: compatible: - const: nokia,smia + oneOf: + - items: + - const: mipi-ccs-1.1 + - const: mipi-ccs + - items: + - const: mipi-ccs-1.0 + - const: mipi-ccs + - const: nokia,smia reg: maxItems: 1
@@ -89,14 +100,14 @@ examples: clock-frequency = <400000>; camera-sensor@10 { - compatible = "nokia,smia"; + compatible = "mipi-ccs-1.0", "mipi-ccs"; reg = <0x10>; reset-gpios = <&gpio3 20 GPIO_ACTIVE_LOW>; vana-supply = <&vaux3>; clocks = <&omap3_isp 0>; clock-frequency = <9600000>; port { - smiapp_ep: endpoint { + ccs_ep: endpoint { data-lanes = <1 2>; remote-endpoint = <&csi2a_ep>; link-frequencies = /bits/ 64 <199200000 210000000
MAINTAINERS +1 -1
@@ -11666,7 +11666,7 @@ MIPI CCS, SMIA AND SMIA++ IMAGE SENSOR DRIVER M: Sakari Ailus <[email protected]> L: [email protected] S: Maintained -F: Documentation/devicetree/bindings/media/i2c/nokia,smia.yaml +F: Documentation/devicetree/bindings/media/i2c/mipi-ccs.yaml F: drivers/media/i2c/ccs/ F: drivers/media/i2c/smiapp-pll.c F: drivers/media/i2c/smiapp-pll.h
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 28/29 dt-bindings: mipi-ccs: Add bus-type for C-PHY support
In reply to Sakari AilusThe bus-type property is required for C-PHY support. Add it, including values for CCP2 and CSI-2 D-PHY.
Also require the bus-type property. Effectively all new sensors are MIPI D-PHY or C-PHY that cannot be told apart without the bus-type property.
--- .../devicetree/bindings/media/i2c/mipi-ccs.yaml | 9 +++++++++ 1 file changed, 9 insertions(+)
Documentation/devicetree/bindings/media/i2c/mipi-ccs.yaml +9 -0
@@ -77,9 +77,17 @@ properties: data-lanes: minItems: 1 maxItems: 8 + bus-type: + description: The type of the data bus. + oneOf: + - const: 1 # CSI-2 C-PHY + - const: 3 # CCP2 + - const: 4 # CSI-2 D-PHY + required: - link-frequencies - data-lanes + - bus-type required: - compatible
@@ -112,6 +120,7 @@ examples: remote-endpoint = <&csi2a_ep>; link-frequencies = /bits/ 64 <199200000 210000000 499200000>; + bus-type = <4>; }; }; };
Signature · 1 line
2.27.0
Sakari Ailus
maintainerPATCH 29/29 ccs: Request for "reset" GPIO
In reply to Sakari AilusThe DT bindings documented "reset-gpios" property but the driver never made use of it. Instead it used a GPIO called "xshutdown", with apprently wrong polarity.
Fix this by requesting "reset" GPIO with the right polarity first, and if that fails, then request "xshutdown" GPIO with the old polarity. This way it works for new users as expected while if someone, somewhere, depended on "xshutdown" GPIO, that continues to work as well.
--- drivers/media/i2c/ccs/ccs-core.c | 14 ++++++++++++-- drivers/media/i2c/ccs/ccs.h | 1 + 2 files changed, 13 insertions(+), 2 deletions(-)
drivers/media/i2c/ccs/ccs-core.c +12 -2
@@ -1295,6 +1295,7 @@ static int ccs_power_on(struct device *dev) }usleep_range (1000 ,1000 ); +gpiod_set_value (sensor->reset,0 );gpiod_set_value (sensor->xshutdown,1 ); sleep =SMIAPP_RESET_DELAY (sensor->hwcfg->ext_clk);
@@ -1381,6 +1382,7 @@ static int ccs_power_on(struct device *dev)return 0 ; out_cci_addr_fail: +gpiod_set_value (sensor->reset,1 );gpiod_set_value (sensor->xshutdown,0 );clk_disable_unprepare (sensor->ext_clk);
@@ -1407,6 +1409,7 @@ static int ccs_power_off(struct device *dev)if (sensor->hwcfg->i2c_addr_alt)ccs_write (sensor,SOFTWARE_RESET ,CCS_SOFTWARE_RESET_ON ); +gpiod_set_value (sensor->reset,1 );gpiod_set_value (sensor->xshutdown,0 );clk_disable_unprepare (sensor->ext_clk);usleep_range (5000 ,5000 );
@@ -3008,8 +3011,15 @@ static int ccs_probe(struct i2c_client *client)return -EINVAL ; } - sensor->xshutdown =devm_gpiod_get_optional (&client->dev,"xshutdown" , -GPIOD_OUT_LOW ); + sensor->reset =devm_gpiod_get_optional (&client->dev,"reset" , +GPIOD_OUT_HIGH ); +if (IS_ERR (sensor->reset)) +return PTR_ERR (sensor->reset); +/* Support old users that may have used "xshutdown" property. */ +if (!sensor->reset) + sensor->xshutdown =devm_gpiod_get_optional (&client->dev, +"xshutdown" , +GPIOD_OUT_LOW );if (IS_ERR (sensor->xshutdown))return PTR_ERR (sensor->xshutdown);
drivers/media/i2c/ccs/ccs.h +1 -0
@@ -219,6 +219,7 @@ struct ccs_sensor {struct regulator *vana;struct clk *ext_clk;struct gpio_desc *xshutdown; +struct gpio_desc *reset;void *ccs_limits;u8 nbinning_subtypes;struct ccs_binning_subtype binning_subtypes[CCS_LIM_BINNING_SUB_TYPE_MAX_N +1 ];
Signature · 1 line
2.27.0