1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2018 Intel Corporation 3 4 #include <linux/acpi.h> 5 #include <linux/clk.h> 6 #include <linux/delay.h> 7 #include <linux/i2c.h> 8 #include <linux/module.h> 9 #include <linux/pm_runtime.h> 10 #include <linux/regulator/consumer.h> 11 #include <linux/unaligned.h> 12 13 #include <media/v4l2-cci.h> 14 #include <media/v4l2-ctrls.h> 15 #include <media/v4l2-device.h> 16 #include <media/v4l2-fwnode.h> 17 18 #define IMX258_REG_MODE_SELECT CCI_REG8(0x0100) 19 #define IMX258_MODE_STANDBY 0x00 20 #define IMX258_MODE_STREAMING 0x01 21 22 #define IMX258_REG_RESET CCI_REG8(0x0103) 23 24 /* Chip ID */ 25 #define IMX258_REG_CHIP_ID CCI_REG16(0x0016) 26 #define IMX258_CHIP_ID 0x0258 27 28 /* V_TIMING internal */ 29 #define IMX258_VTS_30FPS 0x0c50 30 #define IMX258_VTS_30FPS_2K 0x0638 31 #define IMX258_VTS_30FPS_VGA 0x034c 32 #define IMX258_VTS_MAX 65525 33 34 /* HBLANK control - read only */ 35 #define IMX258_PPL_DEFAULT 5352 36 37 /* Exposure control */ 38 #define IMX258_REG_EXPOSURE CCI_REG16(0x0202) 39 #define IMX258_EXPOSURE_OFFSET 10 40 #define IMX258_EXPOSURE_MIN 4 41 #define IMX258_EXPOSURE_STEP 1 42 #define IMX258_EXPOSURE_DEFAULT 0x640 43 #define IMX258_EXPOSURE_MAX (IMX258_VTS_MAX - IMX258_EXPOSURE_OFFSET) 44 45 /* Analog gain control */ 46 #define IMX258_REG_ANALOG_GAIN CCI_REG16(0x0204) 47 #define IMX258_ANA_GAIN_MIN 0 48 #define IMX258_ANA_GAIN_MAX 480 49 #define IMX258_ANA_GAIN_STEP 1 50 #define IMX258_ANA_GAIN_DEFAULT 0x0 51 52 /* Digital gain control */ 53 #define IMX258_REG_GR_DIGITAL_GAIN CCI_REG16(0x020e) 54 #define IMX258_REG_R_DIGITAL_GAIN CCI_REG16(0x0210) 55 #define IMX258_REG_B_DIGITAL_GAIN CCI_REG16(0x0212) 56 #define IMX258_REG_GB_DIGITAL_GAIN CCI_REG16(0x0214) 57 #define IMX258_DGTL_GAIN_MIN 0 58 #define IMX258_DGTL_GAIN_MAX 4096 /* Max = 0xFFF */ 59 #define IMX258_DGTL_GAIN_DEFAULT 1024 60 #define IMX258_DGTL_GAIN_STEP 1 61 62 /* HDR control */ 63 #define IMX258_REG_HDR CCI_REG8(0x0220) 64 #define IMX258_HDR_ON BIT(0) 65 #define IMX258_REG_HDR_RATIO CCI_REG8(0x0222) 66 #define IMX258_HDR_RATIO_MIN 0 67 #define IMX258_HDR_RATIO_MAX 5 68 #define IMX258_HDR_RATIO_STEP 1 69 #define IMX258_HDR_RATIO_DEFAULT 0x0 70 71 /* Test Pattern Control */ 72 #define IMX258_REG_TEST_PATTERN CCI_REG16(0x0600) 73 74 #define IMX258_CLK_BLANK_STOP CCI_REG8(0x4040) 75 76 /* Orientation */ 77 #define REG_MIRROR_FLIP_CONTROL CCI_REG8(0x0101) 78 #define REG_CONFIG_MIRROR_HFLIP 0x01 79 #define REG_CONFIG_MIRROR_VFLIP 0x02 80 81 /* IMX258 native and active pixel array size. */ 82 #define IMX258_NATIVE_WIDTH 4224U 83 #define IMX258_NATIVE_HEIGHT 3192U 84 #define IMX258_PIXEL_ARRAY_LEFT 8U 85 #define IMX258_PIXEL_ARRAY_TOP 16U 86 #define IMX258_PIXEL_ARRAY_WIDTH 4208U 87 #define IMX258_PIXEL_ARRAY_HEIGHT 3120U 88 89 /* regs */ 90 #define IMX258_REG_PLL_MULT_DRIV CCI_REG8(0x0310) 91 #define IMX258_REG_IVTPXCK_DIV CCI_REG8(0x0301) 92 #define IMX258_REG_IVTSYCK_DIV CCI_REG8(0x0303) 93 #define IMX258_REG_PREPLLCK_VT_DIV CCI_REG8(0x0305) 94 #define IMX258_REG_IOPPXCK_DIV CCI_REG8(0x0309) 95 #define IMX258_REG_IOPSYCK_DIV CCI_REG8(0x030b) 96 #define IMX258_REG_PREPLLCK_OP_DIV CCI_REG8(0x030d) 97 #define IMX258_REG_PHASE_PIX_OUTEN CCI_REG8(0x3030) 98 #define IMX258_REG_PDPIX_DATA_RATE CCI_REG8(0x3032) 99 #define IMX258_REG_SCALE_MODE CCI_REG8(0x0401) 100 #define IMX258_REG_SCALE_MODE_EXT CCI_REG8(0x3038) 101 #define IMX258_REG_AF_WINDOW_MODE CCI_REG8(0x7bcd) 102 #define IMX258_REG_FRM_LENGTH_CTL CCI_REG8(0x0350) 103 #define IMX258_REG_CSI_LANE_MODE CCI_REG8(0x0114) 104 #define IMX258_REG_X_EVN_INC CCI_REG8(0x0381) 105 #define IMX258_REG_X_ODD_INC CCI_REG8(0x0383) 106 #define IMX258_REG_Y_EVN_INC CCI_REG8(0x0385) 107 #define IMX258_REG_Y_ODD_INC CCI_REG8(0x0387) 108 #define IMX258_REG_BINNING_MODE CCI_REG8(0x0900) 109 #define IMX258_REG_BINNING_TYPE_V CCI_REG8(0x0901) 110 #define IMX258_REG_FORCE_FD_SUM CCI_REG8(0x300d) 111 #define IMX258_REG_DIG_CROP_X_OFFSET CCI_REG16(0x0408) 112 #define IMX258_REG_DIG_CROP_Y_OFFSET CCI_REG16(0x040a) 113 #define IMX258_REG_DIG_CROP_IMAGE_WIDTH CCI_REG16(0x040c) 114 #define IMX258_REG_DIG_CROP_IMAGE_HEIGHT CCI_REG16(0x040e) 115 #define IMX258_REG_SCALE_M CCI_REG16(0x0404) 116 #define IMX258_REG_X_OUT_SIZE CCI_REG16(0x034c) 117 #define IMX258_REG_Y_OUT_SIZE CCI_REG16(0x034e) 118 #define IMX258_REG_X_ADD_STA CCI_REG16(0x0344) 119 #define IMX258_REG_Y_ADD_STA CCI_REG16(0x0346) 120 #define IMX258_REG_X_ADD_END CCI_REG16(0x0348) 121 #define IMX258_REG_Y_ADD_END CCI_REG16(0x034a) 122 #define IMX258_REG_EXCK_FREQ CCI_REG16(0x0136) 123 #define IMX258_REG_CSI_DT_FMT CCI_REG16(0x0112) 124 #define IMX258_REG_LINE_LENGTH_PCK CCI_REG16(0x0342) 125 #define IMX258_REG_SCALE_M_EXT CCI_REG16(0x303a) 126 #define IMX258_REG_FRM_LENGTH_LINES CCI_REG16(0x0340) 127 #define IMX258_REG_FINE_INTEG_TIME CCI_REG8(0x0200) 128 #define IMX258_REG_PLL_IVT_MPY CCI_REG16(0x0306) 129 #define IMX258_REG_PLL_IOP_MPY CCI_REG16(0x030e) 130 #define IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H CCI_REG16(0x0820) 131 #define IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L CCI_REG16(0x0822) 132 133 struct imx258_reg_list { 134 u32 num_of_regs; 135 const struct cci_reg_sequence *regs; 136 }; 137 138 struct imx258_link_cfg { 139 unsigned int lf_to_pix_rate_factor; 140 struct imx258_reg_list reg_list; 141 }; 142 143 enum { 144 IMX258_2_LANE_MODE, 145 IMX258_4_LANE_MODE, 146 IMX258_LANE_CONFIGS, 147 }; 148 149 /* Link frequency config */ 150 struct imx258_link_freq_config { 151 u32 pixels_per_line; 152 153 /* Configuration for this link frequency / num lanes selection */ 154 struct imx258_link_cfg link_cfg[IMX258_LANE_CONFIGS]; 155 }; 156 157 /* Mode : resolution and related config&values */ 158 struct imx258_mode { 159 /* Frame width */ 160 u32 width; 161 /* Frame height */ 162 u32 height; 163 164 /* V-timing */ 165 u32 vts_def; 166 u32 vts_min; 167 168 /* Index of Link frequency config to be used */ 169 u32 link_freq_index; 170 /* Default register values */ 171 struct imx258_reg_list reg_list; 172 173 /* Analog crop rectangle */ 174 struct v4l2_rect crop; 175 }; 176 177 /* 178 * 4208x3120 @ 30 fps needs 1267Mbps/lane, 4 lanes. 179 * To avoid further computation of clock settings, adopt the same per 180 * lane data rate when using 2 lanes, thus allowing a maximum of 15fps. 181 */ 182 static const struct cci_reg_sequence mipi_1267mbps_19_2mhz_2l[] = { 183 { IMX258_REG_EXCK_FREQ, 0x1333 }, 184 { IMX258_REG_IVTPXCK_DIV, 10 }, 185 { IMX258_REG_IVTSYCK_DIV, 2 }, 186 { IMX258_REG_PREPLLCK_VT_DIV, 3 }, 187 { IMX258_REG_PLL_IVT_MPY, 198 }, 188 { IMX258_REG_IOPPXCK_DIV, 10 }, 189 { IMX258_REG_IOPSYCK_DIV, 1 }, 190 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 191 { IMX258_REG_PLL_IOP_MPY, 216 }, 192 { IMX258_REG_PLL_MULT_DRIV, 0 }, 193 194 { IMX258_REG_CSI_LANE_MODE, 1 }, 195 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 1267 * 2 }, 196 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 197 }; 198 199 static const struct cci_reg_sequence mipi_1267mbps_19_2mhz_4l[] = { 200 { IMX258_REG_EXCK_FREQ, 0x1333 }, 201 { IMX258_REG_IVTPXCK_DIV, 5 }, 202 { IMX258_REG_IVTSYCK_DIV, 2 }, 203 { IMX258_REG_PREPLLCK_VT_DIV, 3 }, 204 { IMX258_REG_PLL_IVT_MPY, 198 }, 205 { IMX258_REG_IOPPXCK_DIV, 10 }, 206 { IMX258_REG_IOPSYCK_DIV, 1 }, 207 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 208 { IMX258_REG_PLL_IOP_MPY, 216 }, 209 { IMX258_REG_PLL_MULT_DRIV, 0 }, 210 211 { IMX258_REG_CSI_LANE_MODE, 3 }, 212 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 1267 * 4 }, 213 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 214 }; 215 216 static const struct cci_reg_sequence mipi_1272mbps_24mhz_2l[] = { 217 { IMX258_REG_EXCK_FREQ, 0x1800 }, 218 { IMX258_REG_IVTPXCK_DIV, 10 }, 219 { IMX258_REG_IVTSYCK_DIV, 2 }, 220 { IMX258_REG_PREPLLCK_VT_DIV, 4 }, 221 { IMX258_REG_PLL_IVT_MPY, 212 }, 222 { IMX258_REG_IOPPXCK_DIV, 10 }, 223 { IMX258_REG_IOPSYCK_DIV, 1 }, 224 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 225 { IMX258_REG_PLL_IOP_MPY, 216 }, 226 { IMX258_REG_PLL_MULT_DRIV, 0 }, 227 228 { IMX258_REG_CSI_LANE_MODE, 1 }, 229 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 1272 * 2 }, 230 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 231 }; 232 233 static const struct cci_reg_sequence mipi_1272mbps_24mhz_4l[] = { 234 { IMX258_REG_EXCK_FREQ, 0x1800 }, 235 { IMX258_REG_IVTPXCK_DIV, 5 }, 236 { IMX258_REG_IVTSYCK_DIV, 2 }, 237 { IMX258_REG_PREPLLCK_VT_DIV, 4 }, 238 { IMX258_REG_PLL_IVT_MPY, 212 }, 239 { IMX258_REG_IOPPXCK_DIV, 10 }, 240 { IMX258_REG_IOPSYCK_DIV, 1 }, 241 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 242 { IMX258_REG_PLL_IOP_MPY, 216 }, 243 { IMX258_REG_PLL_MULT_DRIV, 0 }, 244 245 { IMX258_REG_CSI_LANE_MODE, 3 }, 246 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 1272 * 4 }, 247 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 248 }; 249 250 static const struct cci_reg_sequence mipi_640mbps_19_2mhz_2l[] = { 251 { IMX258_REG_EXCK_FREQ, 0x1333 }, 252 { IMX258_REG_IVTPXCK_DIV, 5 }, 253 { IMX258_REG_IVTSYCK_DIV, 2 }, 254 { IMX258_REG_PREPLLCK_VT_DIV, 3 }, 255 { IMX258_REG_PLL_IVT_MPY, 100 }, 256 { IMX258_REG_IOPPXCK_DIV, 10 }, 257 { IMX258_REG_IOPSYCK_DIV, 1 }, 258 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 259 { IMX258_REG_PLL_IOP_MPY, 216 }, 260 { IMX258_REG_PLL_MULT_DRIV, 0 }, 261 262 { IMX258_REG_CSI_LANE_MODE, 1 }, 263 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 640 * 2 }, 264 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 265 }; 266 267 static const struct cci_reg_sequence mipi_640mbps_19_2mhz_4l[] = { 268 { IMX258_REG_EXCK_FREQ, 0x1333 }, 269 { IMX258_REG_IVTPXCK_DIV, 5 }, 270 { IMX258_REG_IVTSYCK_DIV, 2 }, 271 { IMX258_REG_PREPLLCK_VT_DIV, 3 }, 272 { IMX258_REG_PLL_IVT_MPY, 100 }, 273 { IMX258_REG_IOPPXCK_DIV, 10 }, 274 { IMX258_REG_IOPSYCK_DIV, 1 }, 275 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 276 { IMX258_REG_PLL_IOP_MPY, 216 }, 277 { IMX258_REG_PLL_MULT_DRIV, 0 }, 278 279 { IMX258_REG_CSI_LANE_MODE, 3 }, 280 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 640 * 4 }, 281 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 282 }; 283 284 static const struct cci_reg_sequence mipi_642mbps_24mhz_2l[] = { 285 { IMX258_REG_EXCK_FREQ, 0x1800 }, 286 { IMX258_REG_IVTPXCK_DIV, 5 }, 287 { IMX258_REG_IVTSYCK_DIV, 2 }, 288 { IMX258_REG_PREPLLCK_VT_DIV, 4 }, 289 { IMX258_REG_PLL_IVT_MPY, 107 }, 290 { IMX258_REG_IOPPXCK_DIV, 10 }, 291 { IMX258_REG_IOPSYCK_DIV, 1 }, 292 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 293 { IMX258_REG_PLL_IOP_MPY, 216 }, 294 { IMX258_REG_PLL_MULT_DRIV, 0 }, 295 296 { IMX258_REG_CSI_LANE_MODE, 1 }, 297 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 642 * 2 }, 298 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 299 }; 300 301 static const struct cci_reg_sequence mipi_642mbps_24mhz_4l[] = { 302 { IMX258_REG_EXCK_FREQ, 0x1800 }, 303 { IMX258_REG_IVTPXCK_DIV, 5 }, 304 { IMX258_REG_IVTSYCK_DIV, 2 }, 305 { IMX258_REG_PREPLLCK_VT_DIV, 4 }, 306 { IMX258_REG_PLL_IVT_MPY, 107 }, 307 { IMX258_REG_IOPPXCK_DIV, 10 }, 308 { IMX258_REG_IOPSYCK_DIV, 1 }, 309 { IMX258_REG_PREPLLCK_OP_DIV, 2 }, 310 { IMX258_REG_PLL_IOP_MPY, 216 }, 311 { IMX258_REG_PLL_MULT_DRIV, 0 }, 312 313 { IMX258_REG_CSI_LANE_MODE, 3 }, 314 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_H, 642 * 4 }, 315 { IMX258_REG_REQ_LINK_BIT_RATE_MBPS_L, 0 }, 316 }; 317 318 static const struct cci_reg_sequence mode_common_regs[] = { 319 { CCI_REG8(0x3051), 0x00 }, 320 { CCI_REG8(0x6B11), 0xCF }, 321 { CCI_REG8(0x7FF0), 0x08 }, 322 { CCI_REG8(0x7FF1), 0x0F }, 323 { CCI_REG8(0x7FF2), 0x08 }, 324 { CCI_REG8(0x7FF3), 0x1B }, 325 { CCI_REG8(0x7FF4), 0x23 }, 326 { CCI_REG8(0x7FF5), 0x60 }, 327 { CCI_REG8(0x7FF6), 0x00 }, 328 { CCI_REG8(0x7FF7), 0x01 }, 329 { CCI_REG8(0x7FF8), 0x00 }, 330 { CCI_REG8(0x7FF9), 0x78 }, 331 { CCI_REG8(0x7FFA), 0x00 }, 332 { CCI_REG8(0x7FFB), 0x00 }, 333 { CCI_REG8(0x7FFC), 0x00 }, 334 { CCI_REG8(0x7FFD), 0x00 }, 335 { CCI_REG8(0x7FFE), 0x00 }, 336 { CCI_REG8(0x7FFF), 0x03 }, 337 { CCI_REG8(0x7F76), 0x03 }, 338 { CCI_REG8(0x7F77), 0xFE }, 339 { CCI_REG8(0x7FA8), 0x03 }, 340 { CCI_REG8(0x7FA9), 0xFE }, 341 { CCI_REG8(0x7B24), 0x81 }, 342 { CCI_REG8(0x6564), 0x07 }, 343 { CCI_REG8(0x6B0D), 0x41 }, 344 { CCI_REG8(0x653D), 0x04 }, 345 { CCI_REG8(0x6B05), 0x8C }, 346 { CCI_REG8(0x6B06), 0xF9 }, 347 { CCI_REG8(0x6B08), 0x65 }, 348 { CCI_REG8(0x6B09), 0xFC }, 349 { CCI_REG8(0x6B0A), 0xCF }, 350 { CCI_REG8(0x6B0B), 0xD2 }, 351 { CCI_REG8(0x6700), 0x0E }, 352 { CCI_REG8(0x6707), 0x0E }, 353 { CCI_REG8(0x9104), 0x00 }, 354 { CCI_REG8(0x4648), 0x7F }, 355 { CCI_REG8(0x7420), 0x00 }, 356 { CCI_REG8(0x7421), 0x1C }, 357 { CCI_REG8(0x7422), 0x00 }, 358 { CCI_REG8(0x7423), 0xD7 }, 359 { CCI_REG8(0x5F04), 0x00 }, 360 { CCI_REG8(0x5F05), 0xED }, 361 {IMX258_REG_CSI_DT_FMT, 0x0a0a}, 362 {IMX258_REG_LINE_LENGTH_PCK, 5352}, 363 {IMX258_REG_X_ADD_STA, 0}, 364 {IMX258_REG_Y_ADD_STA, 0}, 365 {IMX258_REG_X_ADD_END, 4207}, 366 {IMX258_REG_Y_ADD_END, 3119}, 367 {IMX258_REG_X_EVN_INC, 1}, 368 {IMX258_REG_X_ODD_INC, 1}, 369 {IMX258_REG_Y_EVN_INC, 1}, 370 {IMX258_REG_Y_ODD_INC, 1}, 371 {IMX258_REG_DIG_CROP_X_OFFSET, 0}, 372 {IMX258_REG_DIG_CROP_Y_OFFSET, 0}, 373 {IMX258_REG_DIG_CROP_IMAGE_WIDTH, 4208}, 374 {IMX258_REG_SCALE_MODE_EXT, 0}, 375 {IMX258_REG_SCALE_M_EXT, 16}, 376 {IMX258_REG_FORCE_FD_SUM, 0}, 377 {IMX258_REG_FRM_LENGTH_CTL, 0}, 378 {IMX258_REG_ANALOG_GAIN, 0}, 379 {IMX258_REG_GR_DIGITAL_GAIN, 256}, 380 {IMX258_REG_R_DIGITAL_GAIN, 256}, 381 {IMX258_REG_B_DIGITAL_GAIN, 256}, 382 {IMX258_REG_GB_DIGITAL_GAIN, 256}, 383 {IMX258_REG_AF_WINDOW_MODE, 0}, 384 { CCI_REG8(0x94DC), 0x20 }, 385 { CCI_REG8(0x94DD), 0x20 }, 386 { CCI_REG8(0x94DE), 0x20 }, 387 { CCI_REG8(0x95DC), 0x20 }, 388 { CCI_REG8(0x95DD), 0x20 }, 389 { CCI_REG8(0x95DE), 0x20 }, 390 { CCI_REG8(0x7FB0), 0x00 }, 391 { CCI_REG8(0x9010), 0x3E }, 392 { CCI_REG8(0x9419), 0x50 }, 393 { CCI_REG8(0x941B), 0x50 }, 394 { CCI_REG8(0x9519), 0x50 }, 395 { CCI_REG8(0x951B), 0x50 }, 396 {IMX258_REG_PHASE_PIX_OUTEN, 0}, 397 {IMX258_REG_PDPIX_DATA_RATE, 0}, 398 {IMX258_REG_HDR, 0}, 399 }; 400 401 static const struct cci_reg_sequence mode_4208x3120_regs[] = { 402 {IMX258_REG_BINNING_MODE, 0}, 403 {IMX258_REG_BINNING_TYPE_V, 0x11}, 404 {IMX258_REG_SCALE_MODE, 0}, 405 {IMX258_REG_SCALE_M, 16}, 406 {IMX258_REG_DIG_CROP_IMAGE_HEIGHT, 3120}, 407 {IMX258_REG_X_OUT_SIZE, 4208}, 408 {IMX258_REG_Y_OUT_SIZE, 3120}, 409 }; 410 411 static const struct cci_reg_sequence mode_2104_1560_regs[] = { 412 {IMX258_REG_BINNING_MODE, 1}, 413 {IMX258_REG_BINNING_TYPE_V, 0x12}, 414 {IMX258_REG_SCALE_MODE, 1}, 415 {IMX258_REG_SCALE_M, 32}, 416 {IMX258_REG_DIG_CROP_IMAGE_HEIGHT, 1560}, 417 {IMX258_REG_X_OUT_SIZE, 2104}, 418 {IMX258_REG_Y_OUT_SIZE, 1560}, 419 }; 420 421 static const struct cci_reg_sequence mode_1048_780_regs[] = { 422 {IMX258_REG_BINNING_MODE, 1}, 423 {IMX258_REG_BINNING_TYPE_V, 0x14}, 424 {IMX258_REG_SCALE_MODE, 1}, 425 {IMX258_REG_SCALE_M, 64}, 426 {IMX258_REG_DIG_CROP_IMAGE_HEIGHT, 780}, 427 {IMX258_REG_X_OUT_SIZE, 1048}, 428 {IMX258_REG_Y_OUT_SIZE, 780}, 429 }; 430 431 struct imx258_variant_cfg { 432 const struct cci_reg_sequence *regs; 433 unsigned int num_regs; 434 }; 435 436 static const struct cci_reg_sequence imx258_cfg_regs[] = { 437 { CCI_REG8(0x3052), 0x00 }, 438 { CCI_REG8(0x4E21), 0x14 }, 439 { CCI_REG8(0x7B25), 0x00 }, 440 }; 441 442 static const struct imx258_variant_cfg imx258_cfg = { 443 .regs = imx258_cfg_regs, 444 .num_regs = ARRAY_SIZE(imx258_cfg_regs), 445 }; 446 447 static const struct cci_reg_sequence imx258_pdaf_cfg_regs[] = { 448 { CCI_REG8(0x3052), 0x01 }, 449 { CCI_REG8(0x4E21), 0x10 }, 450 { CCI_REG8(0x7B25), 0x01 }, 451 }; 452 453 static const struct imx258_variant_cfg imx258_pdaf_cfg = { 454 .regs = imx258_pdaf_cfg_regs, 455 .num_regs = ARRAY_SIZE(imx258_pdaf_cfg_regs), 456 }; 457 458 /* 459 * The supported formats. 460 * This table MUST contain 4 entries per format, to cover the various flip 461 * combinations in the order 462 * - no flip 463 * - h flip 464 * - v flip 465 * - h&v flips 466 */ 467 static const u32 codes[] = { 468 /* 10-bit modes. */ 469 MEDIA_BUS_FMT_SRGGB10_1X10, 470 MEDIA_BUS_FMT_SGRBG10_1X10, 471 MEDIA_BUS_FMT_SGBRG10_1X10, 472 MEDIA_BUS_FMT_SBGGR10_1X10 473 }; 474 475 static const char * const imx258_test_pattern_menu[] = { 476 "Disabled", 477 "Solid Colour", 478 "Eight Vertical Colour Bars", 479 "Colour Bars With Fade to Grey", 480 "Pseudorandom Sequence (PN9)", 481 }; 482 483 /* regulator supplies */ 484 static const char * const imx258_supply_name[] = { 485 /* Supplies can be enabled in any order */ 486 "vana", /* Analog (2.8V) supply */ 487 "vdig", /* Digital Core (1.2V) supply */ 488 "vif", /* IF (1.8V) supply */ 489 }; 490 491 #define IMX258_NUM_SUPPLIES ARRAY_SIZE(imx258_supply_name) 492 493 enum { 494 IMX258_LINK_FREQ_1267MBPS, 495 IMX258_LINK_FREQ_640MBPS, 496 }; 497 498 /* 499 * Pixel rate does not necessarily relate to link frequency on this sensor as 500 * there is a FIFO between the pixel array pipeline and the MIPI serializer. 501 * The recommendation from Sony is that the pixel array is always run with a 502 * line length of 5352 pixels, which means that there is a large amount of 503 * blanking time for the 1048x780 mode. There is no need to replicate this 504 * blanking on the CSI2 bus, and the configuration of register 0x0301 allows the 505 * divider to be altered. 506 * 507 * The actual factor between link frequency and pixel rate is in the 508 * imx258_link_cfg, so use this to convert between the two. 509 * bits per pixel being 10, and D-PHY being DDR is assumed by this function, so 510 * the value is only the combination of number of lanes and pixel clock divider. 511 */ 512 static u64 link_freq_to_pixel_rate(u64 f, const struct imx258_link_cfg *link_cfg) 513 { 514 f *= 2 * link_cfg->lf_to_pix_rate_factor; 515 do_div(f, 10); 516 517 return f; 518 } 519 520 /* Menu items for LINK_FREQ V4L2 control */ 521 /* Configurations for supported link frequencies */ 522 static const s64 link_freq_menu_items_19_2[] = { 523 633600000ULL, 524 320000000ULL, 525 }; 526 527 static const s64 link_freq_menu_items_24[] = { 528 636000000ULL, 529 321000000ULL, 530 }; 531 532 #define REGS(_list) { .num_of_regs = ARRAY_SIZE(_list), .regs = _list, } 533 534 /* Link frequency configs */ 535 static const struct imx258_link_freq_config link_freq_configs_19_2[] = { 536 [IMX258_LINK_FREQ_1267MBPS] = { 537 .pixels_per_line = IMX258_PPL_DEFAULT, 538 .link_cfg = { 539 [IMX258_2_LANE_MODE] = { 540 .lf_to_pix_rate_factor = 2 * 2, 541 .reg_list = REGS(mipi_1267mbps_19_2mhz_2l), 542 }, 543 [IMX258_4_LANE_MODE] = { 544 .lf_to_pix_rate_factor = 4, 545 .reg_list = REGS(mipi_1267mbps_19_2mhz_4l), 546 }, 547 } 548 }, 549 [IMX258_LINK_FREQ_640MBPS] = { 550 .pixels_per_line = IMX258_PPL_DEFAULT, 551 .link_cfg = { 552 [IMX258_2_LANE_MODE] = { 553 .lf_to_pix_rate_factor = 2, 554 .reg_list = REGS(mipi_640mbps_19_2mhz_2l), 555 }, 556 [IMX258_4_LANE_MODE] = { 557 .lf_to_pix_rate_factor = 4, 558 .reg_list = REGS(mipi_640mbps_19_2mhz_4l), 559 }, 560 } 561 }, 562 }; 563 564 static const struct imx258_link_freq_config link_freq_configs_24[] = { 565 [IMX258_LINK_FREQ_1267MBPS] = { 566 .pixels_per_line = IMX258_PPL_DEFAULT, 567 .link_cfg = { 568 [IMX258_2_LANE_MODE] = { 569 .lf_to_pix_rate_factor = 2, 570 .reg_list = REGS(mipi_1272mbps_24mhz_2l), 571 }, 572 [IMX258_4_LANE_MODE] = { 573 .lf_to_pix_rate_factor = 4, 574 .reg_list = REGS(mipi_1272mbps_24mhz_4l), 575 }, 576 } 577 }, 578 [IMX258_LINK_FREQ_640MBPS] = { 579 .pixels_per_line = IMX258_PPL_DEFAULT, 580 .link_cfg = { 581 [IMX258_2_LANE_MODE] = { 582 .lf_to_pix_rate_factor = 2 * 2, 583 .reg_list = REGS(mipi_642mbps_24mhz_2l), 584 }, 585 [IMX258_4_LANE_MODE] = { 586 .lf_to_pix_rate_factor = 4, 587 .reg_list = REGS(mipi_642mbps_24mhz_4l), 588 }, 589 } 590 }, 591 }; 592 593 /* Mode configs */ 594 static const struct imx258_mode supported_modes[] = { 595 { 596 .width = 4208, 597 .height = 3120, 598 .vts_def = IMX258_VTS_30FPS, 599 .vts_min = IMX258_VTS_30FPS, 600 .reg_list = { 601 .num_of_regs = ARRAY_SIZE(mode_4208x3120_regs), 602 .regs = mode_4208x3120_regs, 603 }, 604 .link_freq_index = IMX258_LINK_FREQ_1267MBPS, 605 .crop = { 606 .left = IMX258_PIXEL_ARRAY_LEFT, 607 .top = IMX258_PIXEL_ARRAY_TOP, 608 .width = 4208, 609 .height = 3120, 610 }, 611 }, 612 { 613 .width = 2104, 614 .height = 1560, 615 .vts_def = IMX258_VTS_30FPS_2K, 616 .vts_min = IMX258_VTS_30FPS_2K, 617 .reg_list = { 618 .num_of_regs = ARRAY_SIZE(mode_2104_1560_regs), 619 .regs = mode_2104_1560_regs, 620 }, 621 .link_freq_index = IMX258_LINK_FREQ_640MBPS, 622 .crop = { 623 .left = IMX258_PIXEL_ARRAY_LEFT, 624 .top = IMX258_PIXEL_ARRAY_TOP, 625 .width = 4208, 626 .height = 3120, 627 }, 628 }, 629 { 630 .width = 1048, 631 .height = 780, 632 .vts_def = IMX258_VTS_30FPS_VGA, 633 .vts_min = IMX258_VTS_30FPS_VGA, 634 .reg_list = { 635 .num_of_regs = ARRAY_SIZE(mode_1048_780_regs), 636 .regs = mode_1048_780_regs, 637 }, 638 .link_freq_index = IMX258_LINK_FREQ_640MBPS, 639 .crop = { 640 .left = IMX258_PIXEL_ARRAY_LEFT, 641 .top = IMX258_PIXEL_ARRAY_TOP, 642 .width = 4208, 643 .height = 3120, 644 }, 645 }, 646 }; 647 648 struct imx258 { 649 struct device *dev; 650 651 struct v4l2_subdev sd; 652 struct media_pad pad; 653 struct regmap *regmap; 654 655 const struct imx258_variant_cfg *variant_cfg; 656 657 struct v4l2_ctrl_handler ctrl_handler; 658 /* V4L2 Controls */ 659 struct v4l2_ctrl *link_freq; 660 struct v4l2_ctrl *pixel_rate; 661 struct v4l2_ctrl *vblank; 662 struct v4l2_ctrl *hblank; 663 struct v4l2_ctrl *exposure; 664 struct v4l2_ctrl *hflip; 665 struct v4l2_ctrl *vflip; 666 667 /* Current mode */ 668 const struct imx258_mode *cur_mode; 669 670 unsigned long link_freq_bitmap; 671 const struct imx258_link_freq_config *link_freq_configs; 672 const s64 *link_freq_menu_items; 673 unsigned int lane_mode_idx; 674 unsigned int csi2_flags; 675 676 /* 677 * Mutex for serialized access: 678 * Protect sensor module set pad format and start/stop streaming safely. 679 */ 680 struct mutex mutex; 681 682 struct clk *clk; 683 struct regulator_bulk_data supplies[IMX258_NUM_SUPPLIES]; 684 }; 685 686 static inline struct imx258 *to_imx258(struct v4l2_subdev *_sd) 687 { 688 return container_of(_sd, struct imx258, sd); 689 } 690 691 /* Get bayer order based on flip setting. */ 692 static u32 imx258_get_format_code(const struct imx258 *imx258) 693 { 694 unsigned int i; 695 696 lockdep_assert_held(&imx258->mutex); 697 698 i = (imx258->vflip->val ? 2 : 0) | 699 (imx258->hflip->val ? 1 : 0); 700 701 return codes[i]; 702 } 703 704 /* Open sub-device */ 705 static int imx258_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 706 { 707 struct imx258 *imx258 = to_imx258(sd); 708 struct v4l2_mbus_framefmt *try_fmt = 709 v4l2_subdev_state_get_format(fh->state, 0); 710 struct v4l2_rect *try_crop; 711 712 mutex_lock(&imx258->mutex); 713 714 /* Initialize try_fmt */ 715 try_fmt->width = supported_modes[0].width; 716 try_fmt->height = supported_modes[0].height; 717 try_fmt->code = imx258_get_format_code(imx258); 718 try_fmt->field = V4L2_FIELD_NONE; 719 720 mutex_unlock(&imx258->mutex); 721 722 /* Initialize try_crop */ 723 try_crop = v4l2_subdev_state_get_crop(fh->state, 0); 724 try_crop->left = IMX258_PIXEL_ARRAY_LEFT; 725 try_crop->top = IMX258_PIXEL_ARRAY_TOP; 726 try_crop->width = IMX258_PIXEL_ARRAY_WIDTH; 727 try_crop->height = IMX258_PIXEL_ARRAY_HEIGHT; 728 729 return 0; 730 } 731 732 static int imx258_update_digital_gain(struct imx258 *imx258, u32 val) 733 { 734 int ret = 0; 735 736 cci_write(imx258->regmap, IMX258_REG_GR_DIGITAL_GAIN, val, &ret); 737 cci_write(imx258->regmap, IMX258_REG_GB_DIGITAL_GAIN, val, &ret); 738 cci_write(imx258->regmap, IMX258_REG_R_DIGITAL_GAIN, val, &ret); 739 cci_write(imx258->regmap, IMX258_REG_B_DIGITAL_GAIN, val, &ret); 740 741 return ret; 742 } 743 744 static void imx258_adjust_exposure_range(struct imx258 *imx258) 745 { 746 int exposure_max, exposure_def; 747 748 /* Honour the VBLANK limits when setting exposure. */ 749 exposure_max = imx258->cur_mode->height + imx258->vblank->val - 750 IMX258_EXPOSURE_OFFSET; 751 exposure_def = min(exposure_max, imx258->exposure->val); 752 __v4l2_ctrl_modify_range(imx258->exposure, imx258->exposure->minimum, 753 exposure_max, imx258->exposure->step, 754 exposure_def); 755 } 756 757 static int imx258_set_ctrl(struct v4l2_ctrl *ctrl) 758 { 759 struct imx258 *imx258 = 760 container_of(ctrl->handler, struct imx258, ctrl_handler); 761 int ret = 0; 762 763 /* 764 * The VBLANK control may change the limits of usable exposure, so check 765 * and adjust if necessary. 766 */ 767 if (ctrl->id == V4L2_CID_VBLANK) 768 imx258_adjust_exposure_range(imx258); 769 770 /* 771 * Applying V4L2 control value only happens 772 * when power is up for streaming 773 */ 774 if (pm_runtime_get_if_in_use(imx258->dev) == 0) 775 return 0; 776 777 switch (ctrl->id) { 778 case V4L2_CID_ANALOGUE_GAIN: 779 ret = cci_write(imx258->regmap, IMX258_REG_ANALOG_GAIN, 780 ctrl->val, NULL); 781 break; 782 case V4L2_CID_EXPOSURE: 783 ret = cci_write(imx258->regmap, IMX258_REG_EXPOSURE, 784 ctrl->val, NULL); 785 break; 786 case V4L2_CID_DIGITAL_GAIN: 787 ret = imx258_update_digital_gain(imx258, ctrl->val); 788 break; 789 case V4L2_CID_TEST_PATTERN: 790 ret = cci_write(imx258->regmap, IMX258_REG_TEST_PATTERN, 791 ctrl->val, NULL); 792 break; 793 case V4L2_CID_WIDE_DYNAMIC_RANGE: 794 if (!ctrl->val) { 795 ret = cci_write(imx258->regmap, IMX258_REG_HDR, 796 IMX258_HDR_RATIO_MIN, NULL); 797 } else { 798 ret = cci_write(imx258->regmap, IMX258_REG_HDR, 799 IMX258_HDR_ON, NULL); 800 if (ret) 801 break; 802 ret = cci_write(imx258->regmap, IMX258_REG_HDR_RATIO, 803 BIT(IMX258_HDR_RATIO_MAX), NULL); 804 } 805 break; 806 case V4L2_CID_VBLANK: 807 ret = cci_write(imx258->regmap, IMX258_REG_FRM_LENGTH_LINES, 808 imx258->cur_mode->height + ctrl->val, NULL); 809 break; 810 case V4L2_CID_VFLIP: 811 case V4L2_CID_HFLIP: 812 ret = cci_write(imx258->regmap, REG_MIRROR_FLIP_CONTROL, 813 (imx258->hflip->val ? 814 REG_CONFIG_MIRROR_HFLIP : 0) | 815 (imx258->vflip->val ? 816 REG_CONFIG_MIRROR_VFLIP : 0), 817 NULL); 818 break; 819 default: 820 dev_info(imx258->dev, 821 "ctrl(id:0x%x,val:0x%x) is not handled\n", 822 ctrl->id, ctrl->val); 823 ret = -EINVAL; 824 break; 825 } 826 827 pm_runtime_put(imx258->dev); 828 829 return ret; 830 } 831 832 static const struct v4l2_ctrl_ops imx258_ctrl_ops = { 833 .s_ctrl = imx258_set_ctrl, 834 }; 835 836 static int imx258_enum_mbus_code(struct v4l2_subdev *sd, 837 struct v4l2_subdev_state *sd_state, 838 struct v4l2_subdev_mbus_code_enum *code) 839 { 840 struct imx258 *imx258 = to_imx258(sd); 841 842 /* Only one bayer format (10 bit) is supported */ 843 if (code->index > 0) 844 return -EINVAL; 845 846 mutex_lock(&imx258->mutex); 847 code->code = imx258_get_format_code(imx258); 848 mutex_unlock(&imx258->mutex); 849 850 return 0; 851 } 852 853 static int imx258_enum_frame_size(struct v4l2_subdev *sd, 854 struct v4l2_subdev_state *sd_state, 855 struct v4l2_subdev_frame_size_enum *fse) 856 { 857 struct imx258 *imx258 = to_imx258(sd); 858 u32 code; 859 860 if (fse->index >= ARRAY_SIZE(supported_modes)) 861 return -EINVAL; 862 863 mutex_lock(&imx258->mutex); 864 code = imx258_get_format_code(imx258); 865 mutex_unlock(&imx258->mutex); 866 867 if (fse->code != code) 868 return -EINVAL; 869 870 fse->min_width = supported_modes[fse->index].width; 871 fse->max_width = fse->min_width; 872 fse->min_height = supported_modes[fse->index].height; 873 fse->max_height = fse->min_height; 874 875 return 0; 876 } 877 878 static void imx258_update_pad_format(struct imx258 *imx258, 879 const struct imx258_mode *mode, 880 struct v4l2_subdev_format *fmt) 881 { 882 fmt->format.width = mode->width; 883 fmt->format.height = mode->height; 884 fmt->format.code = imx258_get_format_code(imx258); 885 fmt->format.field = V4L2_FIELD_NONE; 886 } 887 888 static int __imx258_get_pad_format(struct imx258 *imx258, 889 struct v4l2_subdev_state *sd_state, 890 struct v4l2_subdev_format *fmt) 891 { 892 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) 893 fmt->format = *v4l2_subdev_state_get_format(sd_state, 894 fmt->pad); 895 else 896 imx258_update_pad_format(imx258, imx258->cur_mode, fmt); 897 898 return 0; 899 } 900 901 static int imx258_get_pad_format(struct v4l2_subdev *sd, 902 struct v4l2_subdev_state *sd_state, 903 struct v4l2_subdev_format *fmt) 904 { 905 struct imx258 *imx258 = to_imx258(sd); 906 int ret; 907 908 mutex_lock(&imx258->mutex); 909 ret = __imx258_get_pad_format(imx258, sd_state, fmt); 910 mutex_unlock(&imx258->mutex); 911 912 return ret; 913 } 914 915 static int imx258_set_pad_format(struct v4l2_subdev *sd, 916 struct v4l2_subdev_state *sd_state, 917 struct v4l2_subdev_format *fmt) 918 { 919 struct imx258 *imx258 = to_imx258(sd); 920 const struct imx258_link_freq_config *link_freq_cfgs; 921 const struct imx258_link_cfg *link_cfg; 922 struct v4l2_mbus_framefmt *framefmt; 923 const struct imx258_mode *mode; 924 s32 vblank_def; 925 s32 vblank_min; 926 s64 h_blank; 927 s64 pixel_rate; 928 s64 link_freq; 929 930 mutex_lock(&imx258->mutex); 931 932 fmt->format.code = imx258_get_format_code(imx258); 933 934 mode = v4l2_find_nearest_size(supported_modes, 935 ARRAY_SIZE(supported_modes), width, height, 936 fmt->format.width, fmt->format.height); 937 imx258_update_pad_format(imx258, mode, fmt); 938 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 939 framefmt = v4l2_subdev_state_get_format(sd_state, fmt->pad); 940 *framefmt = fmt->format; 941 } else { 942 imx258->cur_mode = mode; 943 __v4l2_ctrl_s_ctrl(imx258->link_freq, mode->link_freq_index); 944 945 link_freq = imx258->link_freq_menu_items[mode->link_freq_index]; 946 link_freq_cfgs = 947 &imx258->link_freq_configs[mode->link_freq_index]; 948 949 link_cfg = &link_freq_cfgs->link_cfg[imx258->lane_mode_idx]; 950 pixel_rate = link_freq_to_pixel_rate(link_freq, link_cfg); 951 __v4l2_ctrl_modify_range(imx258->pixel_rate, pixel_rate, 952 pixel_rate, 1, pixel_rate); 953 /* Update limits and set FPS to default */ 954 vblank_def = imx258->cur_mode->vts_def - 955 imx258->cur_mode->height; 956 vblank_min = imx258->cur_mode->vts_min - 957 imx258->cur_mode->height; 958 __v4l2_ctrl_modify_range( 959 imx258->vblank, vblank_min, 960 IMX258_VTS_MAX - imx258->cur_mode->height, 1, 961 vblank_def); 962 __v4l2_ctrl_s_ctrl(imx258->vblank, vblank_def); 963 h_blank = 964 imx258->link_freq_configs[mode->link_freq_index].pixels_per_line 965 - imx258->cur_mode->width; 966 __v4l2_ctrl_modify_range(imx258->hblank, h_blank, 967 h_blank, 1, h_blank); 968 } 969 970 mutex_unlock(&imx258->mutex); 971 972 return 0; 973 } 974 975 static const struct v4l2_rect * 976 __imx258_get_pad_crop(struct imx258 *imx258, 977 struct v4l2_subdev_state *sd_state, 978 unsigned int pad, enum v4l2_subdev_format_whence which) 979 { 980 switch (which) { 981 case V4L2_SUBDEV_FORMAT_TRY: 982 return v4l2_subdev_state_get_crop(sd_state, pad); 983 case V4L2_SUBDEV_FORMAT_ACTIVE: 984 return &imx258->cur_mode->crop; 985 } 986 987 return NULL; 988 } 989 990 static int imx258_get_selection(struct v4l2_subdev *sd, 991 struct v4l2_subdev_state *sd_state, 992 struct v4l2_subdev_selection *sel) 993 { 994 switch (sel->target) { 995 case V4L2_SEL_TGT_CROP: { 996 struct imx258 *imx258 = to_imx258(sd); 997 998 mutex_lock(&imx258->mutex); 999 sel->r = *__imx258_get_pad_crop(imx258, sd_state, sel->pad, 1000 sel->which); 1001 mutex_unlock(&imx258->mutex); 1002 1003 return 0; 1004 } 1005 1006 case V4L2_SEL_TGT_NATIVE_SIZE: 1007 sel->r.left = 0; 1008 sel->r.top = 0; 1009 sel->r.width = IMX258_NATIVE_WIDTH; 1010 sel->r.height = IMX258_NATIVE_HEIGHT; 1011 1012 return 0; 1013 1014 case V4L2_SEL_TGT_CROP_DEFAULT: 1015 case V4L2_SEL_TGT_CROP_BOUNDS: 1016 sel->r.left = IMX258_PIXEL_ARRAY_LEFT; 1017 sel->r.top = IMX258_PIXEL_ARRAY_TOP; 1018 sel->r.width = IMX258_PIXEL_ARRAY_WIDTH; 1019 sel->r.height = IMX258_PIXEL_ARRAY_HEIGHT; 1020 1021 return 0; 1022 } 1023 1024 return -EINVAL; 1025 } 1026 1027 /* Start streaming */ 1028 static int imx258_start_streaming(struct imx258 *imx258) 1029 { 1030 const struct imx258_reg_list *reg_list; 1031 const struct imx258_link_freq_config *link_freq_cfg; 1032 int ret, link_freq_index; 1033 1034 ret = cci_write(imx258->regmap, IMX258_REG_RESET, 0x01, NULL); 1035 if (ret) { 1036 dev_err(imx258->dev, "%s failed to reset sensor\n", __func__); 1037 return ret; 1038 } 1039 1040 /* 12ms is required from poweron to standby */ 1041 fsleep(12000); 1042 1043 /* Setup PLL */ 1044 link_freq_index = imx258->cur_mode->link_freq_index; 1045 link_freq_cfg = &imx258->link_freq_configs[link_freq_index]; 1046 1047 reg_list = &link_freq_cfg->link_cfg[imx258->lane_mode_idx].reg_list; 1048 ret = cci_multi_reg_write(imx258->regmap, reg_list->regs, reg_list->num_of_regs, NULL); 1049 if (ret) { 1050 dev_err(imx258->dev, "%s failed to set plls\n", __func__); 1051 return ret; 1052 } 1053 1054 ret = cci_multi_reg_write(imx258->regmap, mode_common_regs, 1055 ARRAY_SIZE(mode_common_regs), NULL); 1056 if (ret) { 1057 dev_err(imx258->dev, "%s failed to set common regs\n", __func__); 1058 return ret; 1059 } 1060 1061 ret = cci_multi_reg_write(imx258->regmap, imx258->variant_cfg->regs, 1062 imx258->variant_cfg->num_regs, NULL); 1063 if (ret) { 1064 dev_err(imx258->dev, "%s failed to set variant config\n", 1065 __func__); 1066 return ret; 1067 } 1068 1069 ret = cci_write(imx258->regmap, IMX258_CLK_BLANK_STOP, 1070 !!(imx258->csi2_flags & V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK), 1071 NULL); 1072 if (ret) { 1073 dev_err(imx258->dev, "%s failed to set clock lane mode\n", __func__); 1074 return ret; 1075 } 1076 1077 /* Apply default values of current mode */ 1078 reg_list = &imx258->cur_mode->reg_list; 1079 ret = cci_multi_reg_write(imx258->regmap, reg_list->regs, reg_list->num_of_regs, NULL); 1080 if (ret) { 1081 dev_err(imx258->dev, "%s failed to set mode\n", __func__); 1082 return ret; 1083 } 1084 1085 /* Apply customized values from user */ 1086 ret = __v4l2_ctrl_handler_setup(imx258->sd.ctrl_handler); 1087 if (ret) 1088 return ret; 1089 1090 /* set stream on register */ 1091 return cci_write(imx258->regmap, IMX258_REG_MODE_SELECT, 1092 IMX258_MODE_STREAMING, NULL); 1093 } 1094 1095 /* Stop streaming */ 1096 static int imx258_stop_streaming(struct imx258 *imx258) 1097 { 1098 int ret; 1099 1100 /* set stream off register */ 1101 ret = cci_write(imx258->regmap, IMX258_REG_MODE_SELECT, 1102 IMX258_MODE_STANDBY, NULL); 1103 if (ret) 1104 dev_err(imx258->dev, "%s failed to set stream\n", __func__); 1105 1106 /* 1107 * Return success even if it was an error, as there is nothing the 1108 * caller can do about it. 1109 */ 1110 return 0; 1111 } 1112 1113 static int imx258_power_on(struct device *dev) 1114 { 1115 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1116 struct imx258 *imx258 = to_imx258(sd); 1117 int ret; 1118 1119 ret = regulator_bulk_enable(IMX258_NUM_SUPPLIES, 1120 imx258->supplies); 1121 if (ret) { 1122 dev_err(dev, "%s: failed to enable regulators\n", 1123 __func__); 1124 return ret; 1125 } 1126 1127 ret = clk_prepare_enable(imx258->clk); 1128 if (ret) { 1129 dev_err(dev, "failed to enable clock\n"); 1130 regulator_bulk_disable(IMX258_NUM_SUPPLIES, imx258->supplies); 1131 } 1132 1133 return ret; 1134 } 1135 1136 static int imx258_power_off(struct device *dev) 1137 { 1138 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1139 struct imx258 *imx258 = to_imx258(sd); 1140 1141 clk_disable_unprepare(imx258->clk); 1142 regulator_bulk_disable(IMX258_NUM_SUPPLIES, imx258->supplies); 1143 1144 return 0; 1145 } 1146 1147 static int imx258_set_stream(struct v4l2_subdev *sd, int enable) 1148 { 1149 struct imx258 *imx258 = to_imx258(sd); 1150 int ret = 0; 1151 1152 mutex_lock(&imx258->mutex); 1153 1154 if (enable) { 1155 ret = pm_runtime_resume_and_get(imx258->dev); 1156 if (ret < 0) 1157 goto err_unlock; 1158 1159 /* 1160 * Apply default & customized values 1161 * and then start streaming. 1162 */ 1163 ret = imx258_start_streaming(imx258); 1164 if (ret) 1165 goto err_rpm_put; 1166 } else { 1167 imx258_stop_streaming(imx258); 1168 pm_runtime_put(imx258->dev); 1169 } 1170 1171 mutex_unlock(&imx258->mutex); 1172 1173 return ret; 1174 1175 err_rpm_put: 1176 pm_runtime_put(imx258->dev); 1177 err_unlock: 1178 mutex_unlock(&imx258->mutex); 1179 1180 return ret; 1181 } 1182 1183 /* Verify chip ID */ 1184 static int imx258_identify_module(struct imx258 *imx258) 1185 { 1186 int ret; 1187 u64 val; 1188 1189 ret = cci_read(imx258->regmap, IMX258_REG_CHIP_ID, 1190 &val, NULL); 1191 if (ret) { 1192 dev_err(imx258->dev, "failed to read chip id %x\n", 1193 IMX258_CHIP_ID); 1194 return ret; 1195 } 1196 1197 if (val != IMX258_CHIP_ID) { 1198 dev_err(imx258->dev, "chip id mismatch: %x!=%llx\n", 1199 IMX258_CHIP_ID, val); 1200 return -EIO; 1201 } 1202 1203 return 0; 1204 } 1205 1206 static const struct v4l2_subdev_video_ops imx258_video_ops = { 1207 .s_stream = imx258_set_stream, 1208 }; 1209 1210 static const struct v4l2_subdev_pad_ops imx258_pad_ops = { 1211 .enum_mbus_code = imx258_enum_mbus_code, 1212 .get_fmt = imx258_get_pad_format, 1213 .set_fmt = imx258_set_pad_format, 1214 .enum_frame_size = imx258_enum_frame_size, 1215 .get_selection = imx258_get_selection, 1216 }; 1217 1218 static const struct v4l2_subdev_ops imx258_subdev_ops = { 1219 .video = &imx258_video_ops, 1220 .pad = &imx258_pad_ops, 1221 }; 1222 1223 static const struct v4l2_subdev_internal_ops imx258_internal_ops = { 1224 .open = imx258_open, 1225 }; 1226 1227 /* Initialize control handlers */ 1228 static int imx258_init_controls(struct imx258 *imx258) 1229 { 1230 const struct imx258_link_freq_config *link_freq_cfgs; 1231 struct v4l2_fwnode_device_properties props; 1232 struct v4l2_ctrl_handler *ctrl_hdlr; 1233 const struct imx258_link_cfg *link_cfg; 1234 s64 vblank_def; 1235 s64 vblank_min; 1236 s64 pixel_rate; 1237 int ret; 1238 1239 ctrl_hdlr = &imx258->ctrl_handler; 1240 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 13); 1241 if (ret) 1242 return ret; 1243 1244 mutex_init(&imx258->mutex); 1245 ctrl_hdlr->lock = &imx258->mutex; 1246 imx258->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, 1247 &imx258_ctrl_ops, 1248 V4L2_CID_LINK_FREQ, 1249 ARRAY_SIZE(link_freq_menu_items_19_2) - 1, 1250 0, 1251 imx258->link_freq_menu_items); 1252 1253 if (imx258->link_freq) 1254 imx258->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; 1255 1256 imx258->hflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, 1257 V4L2_CID_HFLIP, 0, 1, 1, 1); 1258 if (imx258->hflip) 1259 imx258->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; 1260 1261 imx258->vflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, 1262 V4L2_CID_VFLIP, 0, 1, 1, 1); 1263 if (imx258->vflip) 1264 imx258->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; 1265 1266 link_freq_cfgs = &imx258->link_freq_configs[0]; 1267 link_cfg = link_freq_cfgs[imx258->lane_mode_idx].link_cfg; 1268 pixel_rate = link_freq_to_pixel_rate(imx258->link_freq_menu_items[0], 1269 link_cfg); 1270 1271 /* By default, PIXEL_RATE is read only */ 1272 imx258->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, 1273 V4L2_CID_PIXEL_RATE, 1274 pixel_rate, pixel_rate, 1275 1, pixel_rate); 1276 1277 vblank_def = imx258->cur_mode->vts_def - imx258->cur_mode->height; 1278 vblank_min = imx258->cur_mode->vts_min - imx258->cur_mode->height; 1279 imx258->vblank = v4l2_ctrl_new_std( 1280 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_VBLANK, 1281 vblank_min, 1282 IMX258_VTS_MAX - imx258->cur_mode->height, 1, 1283 vblank_def); 1284 1285 imx258->hblank = v4l2_ctrl_new_std( 1286 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_HBLANK, 1287 IMX258_PPL_DEFAULT - imx258->cur_mode->width, 1288 IMX258_PPL_DEFAULT - imx258->cur_mode->width, 1289 1, 1290 IMX258_PPL_DEFAULT - imx258->cur_mode->width); 1291 1292 if (imx258->hblank) 1293 imx258->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY; 1294 1295 imx258->exposure = v4l2_ctrl_new_std( 1296 ctrl_hdlr, &imx258_ctrl_ops, 1297 V4L2_CID_EXPOSURE, IMX258_EXPOSURE_MIN, 1298 IMX258_EXPOSURE_MAX, IMX258_EXPOSURE_STEP, 1299 IMX258_EXPOSURE_DEFAULT); 1300 1301 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, 1302 IMX258_ANA_GAIN_MIN, IMX258_ANA_GAIN_MAX, 1303 IMX258_ANA_GAIN_STEP, IMX258_ANA_GAIN_DEFAULT); 1304 1305 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_DIGITAL_GAIN, 1306 IMX258_DGTL_GAIN_MIN, IMX258_DGTL_GAIN_MAX, 1307 IMX258_DGTL_GAIN_STEP, 1308 IMX258_DGTL_GAIN_DEFAULT); 1309 1310 v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_WIDE_DYNAMIC_RANGE, 1311 0, 1, 1, IMX258_HDR_RATIO_DEFAULT); 1312 1313 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx258_ctrl_ops, 1314 V4L2_CID_TEST_PATTERN, 1315 ARRAY_SIZE(imx258_test_pattern_menu) - 1, 1316 0, 0, imx258_test_pattern_menu); 1317 1318 if (ctrl_hdlr->error) { 1319 ret = ctrl_hdlr->error; 1320 dev_err(imx258->dev, "%s control init failed (%d)\n", 1321 __func__, ret); 1322 goto error; 1323 } 1324 1325 ret = v4l2_fwnode_device_parse(imx258->dev, &props); 1326 if (ret) 1327 goto error; 1328 1329 ret = v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &imx258_ctrl_ops, 1330 &props); 1331 if (ret) 1332 goto error; 1333 1334 imx258->sd.ctrl_handler = ctrl_hdlr; 1335 1336 return 0; 1337 1338 error: 1339 v4l2_ctrl_handler_free(ctrl_hdlr); 1340 mutex_destroy(&imx258->mutex); 1341 1342 return ret; 1343 } 1344 1345 static void imx258_free_controls(struct imx258 *imx258) 1346 { 1347 v4l2_ctrl_handler_free(imx258->sd.ctrl_handler); 1348 mutex_destroy(&imx258->mutex); 1349 } 1350 1351 static int imx258_get_regulators(struct imx258 *imx258) 1352 { 1353 unsigned int i; 1354 1355 for (i = 0; i < IMX258_NUM_SUPPLIES; i++) 1356 imx258->supplies[i].supply = imx258_supply_name[i]; 1357 1358 return devm_regulator_bulk_get(imx258->dev, 1359 IMX258_NUM_SUPPLIES, imx258->supplies); 1360 } 1361 1362 static int imx258_probe(struct i2c_client *client) 1363 { 1364 struct imx258 *imx258; 1365 struct fwnode_handle *endpoint; 1366 struct v4l2_fwnode_endpoint ep = { 1367 .bus_type = V4L2_MBUS_CSI2_DPHY 1368 }; 1369 int ret; 1370 u32 val = 0; 1371 1372 imx258 = devm_kzalloc(&client->dev, sizeof(*imx258), GFP_KERNEL); 1373 if (!imx258) 1374 return -ENOMEM; 1375 1376 imx258->dev = &client->dev; 1377 1378 imx258->regmap = devm_cci_regmap_init_i2c(client, 16); 1379 if (IS_ERR(imx258->regmap)) { 1380 ret = PTR_ERR(imx258->regmap); 1381 dev_err(imx258->dev, "failed to initialize CCI: %d\n", ret); 1382 return ret; 1383 } 1384 1385 ret = imx258_get_regulators(imx258); 1386 if (ret) 1387 return dev_err_probe(imx258->dev, ret, 1388 "failed to get regulators\n"); 1389 1390 imx258->clk = devm_v4l2_sensor_clk_get_legacy(imx258->dev, NULL, false, 1391 0); 1392 if (IS_ERR(imx258->clk)) 1393 return dev_err_probe(imx258->dev, PTR_ERR(imx258->clk), 1394 "error getting clock\n"); 1395 1396 val = clk_get_rate(imx258->clk); 1397 1398 switch (val) { 1399 case 19200000: 1400 imx258->link_freq_configs = link_freq_configs_19_2; 1401 imx258->link_freq_menu_items = link_freq_menu_items_19_2; 1402 break; 1403 case 24000000: 1404 imx258->link_freq_configs = link_freq_configs_24; 1405 imx258->link_freq_menu_items = link_freq_menu_items_24; 1406 break; 1407 default: 1408 dev_err(imx258->dev, "input clock frequency of %u not supported\n", 1409 val); 1410 return -EINVAL; 1411 } 1412 1413 endpoint = fwnode_graph_get_next_endpoint(dev_fwnode(imx258->dev), NULL); 1414 if (!endpoint) { 1415 dev_err(imx258->dev, "Endpoint node not found\n"); 1416 return -EINVAL; 1417 } 1418 1419 ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &ep); 1420 fwnode_handle_put(endpoint); 1421 if (ret) { 1422 dev_err(imx258->dev, "Parsing endpoint node failed\n"); 1423 return ret; 1424 } 1425 1426 ret = v4l2_link_freq_to_bitmap(imx258->dev, 1427 ep.link_frequencies, 1428 ep.nr_of_link_frequencies, 1429 imx258->link_freq_menu_items, 1430 ARRAY_SIZE(link_freq_menu_items_19_2), 1431 &imx258->link_freq_bitmap); 1432 if (ret) { 1433 dev_err(imx258->dev, "Link frequency not supported\n"); 1434 goto error_endpoint_free; 1435 } 1436 1437 /* Get number of data lanes */ 1438 switch (ep.bus.mipi_csi2.num_data_lanes) { 1439 case 2: 1440 imx258->lane_mode_idx = IMX258_2_LANE_MODE; 1441 break; 1442 case 4: 1443 imx258->lane_mode_idx = IMX258_4_LANE_MODE; 1444 break; 1445 default: 1446 dev_err(imx258->dev, "Invalid data lanes: %u\n", 1447 ep.bus.mipi_csi2.num_data_lanes); 1448 ret = -EINVAL; 1449 goto error_endpoint_free; 1450 } 1451 1452 imx258->csi2_flags = ep.bus.mipi_csi2.flags; 1453 1454 imx258->variant_cfg = device_get_match_data(imx258->dev); 1455 if (!imx258->variant_cfg) 1456 imx258->variant_cfg = &imx258_cfg; 1457 1458 /* Initialize subdev */ 1459 v4l2_i2c_subdev_init(&imx258->sd, client, &imx258_subdev_ops); 1460 1461 /* Will be powered off via pm_runtime_idle */ 1462 ret = imx258_power_on(imx258->dev); 1463 if (ret) 1464 goto error_endpoint_free; 1465 1466 /* Check module identity */ 1467 ret = imx258_identify_module(imx258); 1468 if (ret) 1469 goto error_identify; 1470 1471 /* Set default mode to max resolution */ 1472 imx258->cur_mode = &supported_modes[0]; 1473 1474 ret = imx258_init_controls(imx258); 1475 if (ret) 1476 goto error_identify; 1477 1478 /* Initialize subdev */ 1479 imx258->sd.internal_ops = &imx258_internal_ops; 1480 imx258->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1481 imx258->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1482 1483 /* Initialize source pad */ 1484 imx258->pad.flags = MEDIA_PAD_FL_SOURCE; 1485 1486 ret = media_entity_pads_init(&imx258->sd.entity, 1, &imx258->pad); 1487 if (ret) 1488 goto error_handler_free; 1489 1490 ret = v4l2_async_register_subdev_sensor(&imx258->sd); 1491 if (ret < 0) 1492 goto error_media_entity; 1493 1494 pm_runtime_set_active(imx258->dev); 1495 pm_runtime_enable(imx258->dev); 1496 pm_runtime_idle(imx258->dev); 1497 v4l2_fwnode_endpoint_free(&ep); 1498 1499 return 0; 1500 1501 error_media_entity: 1502 media_entity_cleanup(&imx258->sd.entity); 1503 1504 error_handler_free: 1505 imx258_free_controls(imx258); 1506 1507 error_identify: 1508 imx258_power_off(imx258->dev); 1509 1510 error_endpoint_free: 1511 v4l2_fwnode_endpoint_free(&ep); 1512 1513 return ret; 1514 } 1515 1516 static void imx258_remove(struct i2c_client *client) 1517 { 1518 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1519 struct imx258 *imx258 = to_imx258(sd); 1520 1521 v4l2_async_unregister_subdev(sd); 1522 media_entity_cleanup(&sd->entity); 1523 imx258_free_controls(imx258); 1524 1525 pm_runtime_disable(imx258->dev); 1526 if (!pm_runtime_status_suspended(imx258->dev)) 1527 imx258_power_off(imx258->dev); 1528 pm_runtime_set_suspended(imx258->dev); 1529 } 1530 1531 static const struct dev_pm_ops imx258_pm_ops = { 1532 SET_RUNTIME_PM_OPS(imx258_power_off, imx258_power_on, NULL) 1533 }; 1534 1535 #ifdef CONFIG_ACPI 1536 static const struct acpi_device_id imx258_acpi_ids[] = { 1537 { "SONY258A" }, 1538 { /* sentinel */ } 1539 }; 1540 1541 MODULE_DEVICE_TABLE(acpi, imx258_acpi_ids); 1542 #endif 1543 1544 static const struct of_device_id imx258_dt_ids[] = { 1545 { .compatible = "sony,imx258", .data = &imx258_cfg }, 1546 { .compatible = "sony,imx258-pdaf", .data = &imx258_pdaf_cfg }, 1547 { /* sentinel */ } 1548 }; 1549 MODULE_DEVICE_TABLE(of, imx258_dt_ids); 1550 1551 static struct i2c_driver imx258_i2c_driver = { 1552 .driver = { 1553 .name = "imx258", 1554 .pm = &imx258_pm_ops, 1555 .acpi_match_table = ACPI_PTR(imx258_acpi_ids), 1556 .of_match_table = imx258_dt_ids, 1557 }, 1558 .probe = imx258_probe, 1559 .remove = imx258_remove, 1560 }; 1561 1562 module_i2c_driver(imx258_i2c_driver); 1563 1564 MODULE_AUTHOR("Yeh, Andy <andy.yeh@intel.com>"); 1565 MODULE_AUTHOR("Chiang, Alan"); 1566 MODULE_AUTHOR("Chen, Jason"); 1567 MODULE_DESCRIPTION("Sony IMX258 sensor driver"); 1568 MODULE_LICENSE("GPL v2"); 1569