1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * drivers/media/i2c/ccs/ccs-core.c 4 * 5 * Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors 6 * 7 * Copyright (C) 2020 Intel Corporation 8 * Copyright (C) 2010--2012 Nokia Corporation 9 * Contact: Sakari Ailus <sakari.ailus@linux.intel.com> 10 * 11 * Based on smiapp driver by Vimarsh Zutshi 12 * Based on jt8ev1.c by Vimarsh Zutshi 13 * Based on smia-sensor.c by Tuukka Toivonen <tuukkat76@gmail.com> 14 */ 15 16 #include <linux/clk.h> 17 #include <linux/delay.h> 18 #include <linux/device.h> 19 #include <linux/firmware.h> 20 #include <linux/gpio.h> 21 #include <linux/gpio/consumer.h> 22 #include <linux/module.h> 23 #include <linux/pm_runtime.h> 24 #include <linux/property.h> 25 #include <linux/regulator/consumer.h> 26 #include <linux/slab.h> 27 #include <linux/smiapp.h> 28 #include <linux/v4l2-mediabus.h> 29 #include <media/v4l2-fwnode.h> 30 #include <media/v4l2-device.h> 31 #include <uapi/linux/ccs.h> 32 33 #include "ccs.h" 34 35 #define CCS_ALIGN_DIM(dim, flags) \ 36 ((flags) & V4L2_SEL_FLAG_GE \ 37 ? ALIGN((dim), 2) \ 38 : (dim) & ~1) 39 40 static struct ccs_limit_offset { 41 u16 lim; 42 u16 info; 43 } ccs_limit_offsets[CCS_L_LAST + 1]; 44 45 /* 46 * ccs_module_idents - supported camera modules 47 */ 48 static const struct ccs_module_ident ccs_module_idents[] = { 49 CCS_IDENT_L(0x01, 0x022b, -1, "vs6555"), 50 CCS_IDENT_L(0x01, 0x022e, -1, "vw6558"), 51 CCS_IDENT_L(0x07, 0x7698, -1, "ovm7698"), 52 CCS_IDENT_L(0x0b, 0x4242, -1, "smiapp-003"), 53 CCS_IDENT_L(0x0c, 0x208a, -1, "tcm8330md"), 54 CCS_IDENT_LQ(0x0c, 0x2134, -1, "tcm8500md", &smiapp_tcm8500md_quirk), 55 CCS_IDENT_L(0x0c, 0x213e, -1, "et8en2"), 56 CCS_IDENT_L(0x0c, 0x2184, -1, "tcm8580md"), 57 CCS_IDENT_LQ(0x0c, 0x560f, -1, "jt8ew9", &smiapp_jt8ew9_quirk), 58 CCS_IDENT_LQ(0x10, 0x4141, -1, "jt8ev1", &smiapp_jt8ev1_quirk), 59 CCS_IDENT_LQ(0x10, 0x4241, -1, "imx125es", &smiapp_imx125es_quirk), 60 }; 61 62 #define CCS_DEVICE_FLAG_IS_SMIA BIT(0) 63 64 struct ccs_device { 65 unsigned char flags; 66 }; 67 68 static const char * const ccs_regulators[] = { "vcore", "vio", "vana" }; 69 70 /* 71 * 72 * Dynamic Capability Identification 73 * 74 */ 75 76 static void ccs_assign_limit(void *ptr, unsigned int width, u32 val) 77 { 78 switch (width) { 79 case sizeof(u8): 80 *(u8 *)ptr = val; 81 break; 82 case sizeof(u16): 83 *(u16 *)ptr = val; 84 break; 85 case sizeof(u32): 86 *(u32 *)ptr = val; 87 break; 88 } 89 } 90 91 static int ccs_limit_ptr(struct ccs_sensor *sensor, unsigned int limit, 92 unsigned int offset, void **__ptr) 93 { 94 const struct ccs_limit *linfo; 95 96 if (WARN_ON(limit >= CCS_L_LAST)) 97 return -EINVAL; 98 99 linfo = &ccs_limits[ccs_limit_offsets[limit].info]; 100 101 if (WARN_ON(!sensor->ccs_limits) || 102 WARN_ON(offset + ccs_reg_width(linfo->reg) > 103 ccs_limit_offsets[limit + 1].lim)) 104 return -EINVAL; 105 106 *__ptr = sensor->ccs_limits + ccs_limit_offsets[limit].lim + offset; 107 108 return 0; 109 } 110 111 void ccs_replace_limit(struct ccs_sensor *sensor, 112 unsigned int limit, unsigned int offset, u32 val) 113 { 114 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 115 const struct ccs_limit *linfo; 116 void *ptr; 117 int ret; 118 119 ret = ccs_limit_ptr(sensor, limit, offset, &ptr); 120 if (ret) 121 return; 122 123 linfo = &ccs_limits[ccs_limit_offsets[limit].info]; 124 125 dev_dbg(&client->dev, "quirk: 0x%8.8x \"%s\" %u = %d, 0x%x\n", 126 linfo->reg, linfo->name, offset, val, val); 127 128 ccs_assign_limit(ptr, ccs_reg_width(linfo->reg), val); 129 } 130 131 u32 ccs_get_limit(struct ccs_sensor *sensor, unsigned int limit, 132 unsigned int offset) 133 { 134 void *ptr; 135 u32 val; 136 int ret; 137 138 ret = ccs_limit_ptr(sensor, limit, offset, &ptr); 139 if (ret) 140 return 0; 141 142 switch (ccs_reg_width(ccs_limits[ccs_limit_offsets[limit].info].reg)) { 143 case sizeof(u8): 144 val = *(u8 *)ptr; 145 break; 146 case sizeof(u16): 147 val = *(u16 *)ptr; 148 break; 149 case sizeof(u32): 150 val = *(u32 *)ptr; 151 break; 152 default: 153 WARN_ON(1); 154 return 0; 155 } 156 157 return ccs_reg_conv(sensor, ccs_limits[limit].reg, val); 158 } 159 160 static int ccs_read_all_limits(struct ccs_sensor *sensor) 161 { 162 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 163 void *ptr, *alloc, *end; 164 unsigned int i, l; 165 int ret; 166 167 kfree(sensor->ccs_limits); 168 sensor->ccs_limits = NULL; 169 170 alloc = kzalloc(ccs_limit_offsets[CCS_L_LAST].lim, GFP_KERNEL); 171 if (!alloc) 172 return -ENOMEM; 173 174 end = alloc + ccs_limit_offsets[CCS_L_LAST].lim; 175 176 for (i = 0, l = 0, ptr = alloc; ccs_limits[i].size; i++) { 177 u32 reg = ccs_limits[i].reg; 178 unsigned int width = ccs_reg_width(reg); 179 unsigned int j; 180 181 if (l == CCS_L_LAST) { 182 dev_err(&client->dev, 183 "internal error --- end of limit array\n"); 184 ret = -EINVAL; 185 goto out_err; 186 } 187 188 for (j = 0; j < ccs_limits[i].size / width; 189 j++, reg += width, ptr += width) { 190 u32 val; 191 192 ret = ccs_read_addr_noconv(sensor, reg, &val); 193 if (ret) 194 goto out_err; 195 196 if (ptr + width > end) { 197 dev_err(&client->dev, 198 "internal error --- no room for regs\n"); 199 ret = -EINVAL; 200 goto out_err; 201 } 202 203 if (!val && j) 204 break; 205 206 ccs_assign_limit(ptr, width, val); 207 208 dev_dbg(&client->dev, "0x%8.8x \"%s\" = %u, 0x%x\n", 209 reg, ccs_limits[i].name, val, val); 210 } 211 212 if (ccs_limits[i].flags & CCS_L_FL_SAME_REG) 213 continue; 214 215 l++; 216 ptr = alloc + ccs_limit_offsets[l].lim; 217 } 218 219 if (l != CCS_L_LAST) { 220 dev_err(&client->dev, 221 "internal error --- insufficient limits\n"); 222 ret = -EINVAL; 223 goto out_err; 224 } 225 226 sensor->ccs_limits = alloc; 227 228 if (CCS_LIM(sensor, SCALER_N_MIN) < 16) 229 ccs_replace_limit(sensor, CCS_L_SCALER_N_MIN, 0, 16); 230 231 return 0; 232 233 out_err: 234 kfree(alloc); 235 236 return ret; 237 } 238 239 static int ccs_read_frame_fmt(struct ccs_sensor *sensor) 240 { 241 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 242 u8 fmt_model_type, fmt_model_subtype, ncol_desc, nrow_desc; 243 unsigned int i; 244 int pixel_count = 0; 245 int line_count = 0; 246 247 fmt_model_type = CCS_LIM(sensor, FRAME_FORMAT_MODEL_TYPE); 248 fmt_model_subtype = CCS_LIM(sensor, FRAME_FORMAT_MODEL_SUBTYPE); 249 250 ncol_desc = (fmt_model_subtype 251 & CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_MASK) 252 >> CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_SHIFT; 253 nrow_desc = fmt_model_subtype 254 & CCS_FRAME_FORMAT_MODEL_SUBTYPE_ROWS_MASK; 255 256 dev_dbg(&client->dev, "format_model_type %s\n", 257 fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE 258 ? "2 byte" : 259 fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE 260 ? "4 byte" : "is simply bad"); 261 262 dev_dbg(&client->dev, "%u column and %u row descriptors\n", 263 ncol_desc, nrow_desc); 264 265 for (i = 0; i < ncol_desc + nrow_desc; i++) { 266 u32 desc; 267 u32 pixelcode; 268 u32 pixels; 269 char *which; 270 char *what; 271 272 if (fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE) { 273 desc = CCS_LIM_AT(sensor, FRAME_FORMAT_DESCRIPTOR, i); 274 275 pixelcode = 276 (desc 277 & CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_MASK) 278 >> CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_SHIFT; 279 pixels = desc & CCS_FRAME_FORMAT_DESCRIPTOR_PIXELS_MASK; 280 } else if (fmt_model_type 281 == CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE) { 282 desc = CCS_LIM_AT(sensor, FRAME_FORMAT_DESCRIPTOR_4, i); 283 284 pixelcode = 285 (desc 286 & CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_MASK) 287 >> CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_SHIFT; 288 pixels = desc & 289 CCS_FRAME_FORMAT_DESCRIPTOR_4_PIXELS_MASK; 290 } else { 291 dev_dbg(&client->dev, 292 "invalid frame format model type %d\n", 293 fmt_model_type); 294 return -EINVAL; 295 } 296 297 if (i < ncol_desc) 298 which = "columns"; 299 else 300 which = "rows"; 301 302 switch (pixelcode) { 303 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED: 304 what = "embedded"; 305 break; 306 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DUMMY_PIXEL: 307 what = "dummy"; 308 break; 309 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_BLACK_PIXEL: 310 what = "black"; 311 break; 312 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DARK_PIXEL: 313 what = "dark"; 314 break; 315 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL: 316 what = "visible"; 317 break; 318 default: 319 what = "invalid"; 320 break; 321 } 322 323 dev_dbg(&client->dev, 324 "%s pixels: %d %s (pixelcode %u)\n", 325 what, pixels, which, pixelcode); 326 327 if (i < ncol_desc) { 328 if (pixelcode == 329 CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL) 330 sensor->visible_pixel_start = pixel_count; 331 pixel_count += pixels; 332 continue; 333 } 334 335 /* Handle row descriptors */ 336 switch (pixelcode) { 337 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED: 338 if (sensor->embedded_end) 339 break; 340 sensor->embedded_start = line_count; 341 sensor->embedded_end = line_count + pixels; 342 break; 343 case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL: 344 sensor->image_start = line_count; 345 break; 346 } 347 line_count += pixels; 348 } 349 350 if (sensor->embedded_end > sensor->image_start) { 351 dev_dbg(&client->dev, 352 "adjusting image start line to %u (was %u)\n", 353 sensor->embedded_end, sensor->image_start); 354 sensor->image_start = sensor->embedded_end; 355 } 356 357 dev_dbg(&client->dev, "embedded data from lines %d to %d\n", 358 sensor->embedded_start, sensor->embedded_end); 359 dev_dbg(&client->dev, "image data starts at line %d\n", 360 sensor->image_start); 361 362 return 0; 363 } 364 365 static int ccs_pll_configure(struct ccs_sensor *sensor) 366 { 367 struct ccs_pll *pll = &sensor->pll; 368 int rval; 369 370 rval = ccs_write(sensor, VT_PIX_CLK_DIV, pll->vt_bk.pix_clk_div); 371 if (rval < 0) 372 return rval; 373 374 rval = ccs_write(sensor, VT_SYS_CLK_DIV, pll->vt_bk.sys_clk_div); 375 if (rval < 0) 376 return rval; 377 378 rval = ccs_write(sensor, PRE_PLL_CLK_DIV, pll->vt_fr.pre_pll_clk_div); 379 if (rval < 0) 380 return rval; 381 382 rval = ccs_write(sensor, PLL_MULTIPLIER, pll->vt_fr.pll_multiplier); 383 if (rval < 0) 384 return rval; 385 386 if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY) & 387 CCS_PHY_CTRL_CAPABILITY_AUTO_PHY_CTL)) { 388 /* Lane op clock ratio does not apply here. */ 389 rval = ccs_write(sensor, REQUESTED_LINK_RATE, 390 DIV_ROUND_UP(pll->op_bk.sys_clk_freq_hz, 391 1000000 / 256 / 256) * 392 (pll->flags & CCS_PLL_FLAG_LANE_SPEED_MODEL ? 393 sensor->pll.csi2.lanes : 1) << 394 (pll->flags & CCS_PLL_FLAG_OP_SYS_DDR ? 395 1 : 0)); 396 if (rval < 0) 397 return rval; 398 } 399 400 if (sensor->pll.flags & CCS_PLL_FLAG_NO_OP_CLOCKS) 401 return 0; 402 403 rval = ccs_write(sensor, OP_PIX_CLK_DIV, pll->op_bk.pix_clk_div); 404 if (rval < 0) 405 return rval; 406 407 rval = ccs_write(sensor, OP_SYS_CLK_DIV, pll->op_bk.sys_clk_div); 408 if (rval < 0) 409 return rval; 410 411 if (!(pll->flags & CCS_PLL_FLAG_DUAL_PLL)) 412 return 0; 413 414 rval = ccs_write(sensor, PLL_MODE, CCS_PLL_MODE_DUAL); 415 if (rval < 0) 416 return rval; 417 418 rval = ccs_write(sensor, OP_PRE_PLL_CLK_DIV, 419 pll->op_fr.pre_pll_clk_div); 420 if (rval < 0) 421 return rval; 422 423 return ccs_write(sensor, OP_PLL_MULTIPLIER, pll->op_fr.pll_multiplier); 424 } 425 426 static int ccs_pll_try(struct ccs_sensor *sensor, struct ccs_pll *pll) 427 { 428 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 429 struct ccs_pll_limits lim = { 430 .vt_fr = { 431 .min_pre_pll_clk_div = CCS_LIM(sensor, MIN_PRE_PLL_CLK_DIV), 432 .max_pre_pll_clk_div = CCS_LIM(sensor, MAX_PRE_PLL_CLK_DIV), 433 .min_pll_ip_clk_freq_hz = CCS_LIM(sensor, MIN_PLL_IP_CLK_FREQ_MHZ), 434 .max_pll_ip_clk_freq_hz = CCS_LIM(sensor, MAX_PLL_IP_CLK_FREQ_MHZ), 435 .min_pll_multiplier = CCS_LIM(sensor, MIN_PLL_MULTIPLIER), 436 .max_pll_multiplier = CCS_LIM(sensor, MAX_PLL_MULTIPLIER), 437 .min_pll_op_clk_freq_hz = CCS_LIM(sensor, MIN_PLL_OP_CLK_FREQ_MHZ), 438 .max_pll_op_clk_freq_hz = CCS_LIM(sensor, MAX_PLL_OP_CLK_FREQ_MHZ), 439 }, 440 .op_fr = { 441 .min_pre_pll_clk_div = CCS_LIM(sensor, MIN_OP_PRE_PLL_CLK_DIV), 442 .max_pre_pll_clk_div = CCS_LIM(sensor, MAX_OP_PRE_PLL_CLK_DIV), 443 .min_pll_ip_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PLL_IP_CLK_FREQ_MHZ), 444 .max_pll_ip_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PLL_IP_CLK_FREQ_MHZ), 445 .min_pll_multiplier = CCS_LIM(sensor, MIN_OP_PLL_MULTIPLIER), 446 .max_pll_multiplier = CCS_LIM(sensor, MAX_OP_PLL_MULTIPLIER), 447 .min_pll_op_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PLL_OP_CLK_FREQ_MHZ), 448 .max_pll_op_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PLL_OP_CLK_FREQ_MHZ), 449 }, 450 .op_bk = { 451 .min_sys_clk_div = CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV), 452 .max_sys_clk_div = CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV), 453 .min_pix_clk_div = CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV), 454 .max_pix_clk_div = CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV), 455 .min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_OP_SYS_CLK_FREQ_MHZ), 456 .max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_OP_SYS_CLK_FREQ_MHZ), 457 .min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PIX_CLK_FREQ_MHZ), 458 .max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PIX_CLK_FREQ_MHZ), 459 }, 460 .vt_bk = { 461 .min_sys_clk_div = CCS_LIM(sensor, MIN_VT_SYS_CLK_DIV), 462 .max_sys_clk_div = CCS_LIM(sensor, MAX_VT_SYS_CLK_DIV), 463 .min_pix_clk_div = CCS_LIM(sensor, MIN_VT_PIX_CLK_DIV), 464 .max_pix_clk_div = CCS_LIM(sensor, MAX_VT_PIX_CLK_DIV), 465 .min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_VT_SYS_CLK_FREQ_MHZ), 466 .max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_VT_SYS_CLK_FREQ_MHZ), 467 .min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_VT_PIX_CLK_FREQ_MHZ), 468 .max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_VT_PIX_CLK_FREQ_MHZ), 469 }, 470 .min_line_length_pck_bin = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN), 471 .min_line_length_pck = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK), 472 }; 473 474 return ccs_pll_calculate(&client->dev, &lim, pll); 475 } 476 477 static int ccs_pll_update(struct ccs_sensor *sensor) 478 { 479 struct ccs_pll *pll = &sensor->pll; 480 int rval; 481 482 pll->binning_horizontal = sensor->binning_horizontal; 483 pll->binning_vertical = sensor->binning_vertical; 484 pll->link_freq = 485 sensor->link_freq->qmenu_int[sensor->link_freq->val]; 486 pll->scale_m = sensor->scale_m; 487 pll->bits_per_pixel = sensor->csi_format->compressed; 488 489 rval = ccs_pll_try(sensor, pll); 490 if (rval < 0) 491 return rval; 492 493 __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_parray, 494 pll->pixel_rate_pixel_array); 495 __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_csi, pll->pixel_rate_csi); 496 497 return 0; 498 } 499 500 501 /* 502 * 503 * V4L2 Controls handling 504 * 505 */ 506 507 static void __ccs_update_exposure_limits(struct ccs_sensor *sensor) 508 { 509 struct v4l2_ctrl *ctrl = sensor->exposure; 510 int max; 511 512 max = sensor->pixel_array->crop[CCS_PA_PAD_SRC].height 513 + sensor->vblank->val 514 - CCS_LIM(sensor, COARSE_INTEGRATION_TIME_MAX_MARGIN); 515 516 __v4l2_ctrl_modify_range(ctrl, ctrl->minimum, max, ctrl->step, max); 517 } 518 519 /* 520 * Order matters. 521 * 522 * 1. Bits-per-pixel, descending. 523 * 2. Bits-per-pixel compressed, descending. 524 * 3. Pixel order, same as in pixel_order_str. Formats for all four pixel 525 * orders must be defined. 526 */ 527 static const struct ccs_csi_data_format ccs_csi_data_formats[] = { 528 { MEDIA_BUS_FMT_SGRBG16_1X16, 16, 16, CCS_PIXEL_ORDER_GRBG, }, 529 { MEDIA_BUS_FMT_SRGGB16_1X16, 16, 16, CCS_PIXEL_ORDER_RGGB, }, 530 { MEDIA_BUS_FMT_SBGGR16_1X16, 16, 16, CCS_PIXEL_ORDER_BGGR, }, 531 { MEDIA_BUS_FMT_SGBRG16_1X16, 16, 16, CCS_PIXEL_ORDER_GBRG, }, 532 { MEDIA_BUS_FMT_SGRBG14_1X14, 14, 14, CCS_PIXEL_ORDER_GRBG, }, 533 { MEDIA_BUS_FMT_SRGGB14_1X14, 14, 14, CCS_PIXEL_ORDER_RGGB, }, 534 { MEDIA_BUS_FMT_SBGGR14_1X14, 14, 14, CCS_PIXEL_ORDER_BGGR, }, 535 { MEDIA_BUS_FMT_SGBRG14_1X14, 14, 14, CCS_PIXEL_ORDER_GBRG, }, 536 { MEDIA_BUS_FMT_SGRBG12_1X12, 12, 12, CCS_PIXEL_ORDER_GRBG, }, 537 { MEDIA_BUS_FMT_SRGGB12_1X12, 12, 12, CCS_PIXEL_ORDER_RGGB, }, 538 { MEDIA_BUS_FMT_SBGGR12_1X12, 12, 12, CCS_PIXEL_ORDER_BGGR, }, 539 { MEDIA_BUS_FMT_SGBRG12_1X12, 12, 12, CCS_PIXEL_ORDER_GBRG, }, 540 { MEDIA_BUS_FMT_SGRBG10_1X10, 10, 10, CCS_PIXEL_ORDER_GRBG, }, 541 { MEDIA_BUS_FMT_SRGGB10_1X10, 10, 10, CCS_PIXEL_ORDER_RGGB, }, 542 { MEDIA_BUS_FMT_SBGGR10_1X10, 10, 10, CCS_PIXEL_ORDER_BGGR, }, 543 { MEDIA_BUS_FMT_SGBRG10_1X10, 10, 10, CCS_PIXEL_ORDER_GBRG, }, 544 { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_GRBG, }, 545 { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_RGGB, }, 546 { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_BGGR, }, 547 { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_GBRG, }, 548 { MEDIA_BUS_FMT_SGRBG8_1X8, 8, 8, CCS_PIXEL_ORDER_GRBG, }, 549 { MEDIA_BUS_FMT_SRGGB8_1X8, 8, 8, CCS_PIXEL_ORDER_RGGB, }, 550 { MEDIA_BUS_FMT_SBGGR8_1X8, 8, 8, CCS_PIXEL_ORDER_BGGR, }, 551 { MEDIA_BUS_FMT_SGBRG8_1X8, 8, 8, CCS_PIXEL_ORDER_GBRG, }, 552 }; 553 554 static const char *pixel_order_str[] = { "GRBG", "RGGB", "BGGR", "GBRG" }; 555 556 #define to_csi_format_idx(fmt) (((unsigned long)(fmt) \ 557 - (unsigned long)ccs_csi_data_formats) \ 558 / sizeof(*ccs_csi_data_formats)) 559 560 static u32 ccs_pixel_order(struct ccs_sensor *sensor) 561 { 562 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 563 int flip = 0; 564 565 if (sensor->hflip) { 566 if (sensor->hflip->val) 567 flip |= CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR; 568 569 if (sensor->vflip->val) 570 flip |= CCS_IMAGE_ORIENTATION_VERTICAL_FLIP; 571 } 572 573 flip ^= sensor->hvflip_inv_mask; 574 575 dev_dbg(&client->dev, "flip %d\n", flip); 576 return sensor->default_pixel_order ^ flip; 577 } 578 579 static void ccs_update_mbus_formats(struct ccs_sensor *sensor) 580 { 581 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 582 unsigned int csi_format_idx = 583 to_csi_format_idx(sensor->csi_format) & ~3; 584 unsigned int internal_csi_format_idx = 585 to_csi_format_idx(sensor->internal_csi_format) & ~3; 586 unsigned int pixel_order = ccs_pixel_order(sensor); 587 588 if (WARN_ON_ONCE(max(internal_csi_format_idx, csi_format_idx) + 589 pixel_order >= ARRAY_SIZE(ccs_csi_data_formats))) 590 return; 591 592 sensor->mbus_frame_fmts = 593 sensor->default_mbus_frame_fmts << pixel_order; 594 sensor->csi_format = 595 &ccs_csi_data_formats[csi_format_idx + pixel_order]; 596 sensor->internal_csi_format = 597 &ccs_csi_data_formats[internal_csi_format_idx 598 + pixel_order]; 599 600 dev_dbg(&client->dev, "new pixel order %s\n", 601 pixel_order_str[pixel_order]); 602 } 603 604 static const char * const ccs_test_patterns[] = { 605 "Disabled", 606 "Solid Colour", 607 "Eight Vertical Colour Bars", 608 "Colour Bars With Fade to Grey", 609 "Pseudorandom Sequence (PN9)", 610 }; 611 612 static int ccs_set_ctrl(struct v4l2_ctrl *ctrl) 613 { 614 struct ccs_sensor *sensor = 615 container_of(ctrl->handler, struct ccs_subdev, ctrl_handler) 616 ->sensor; 617 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 618 int pm_status; 619 u32 orient = 0; 620 unsigned int i; 621 int exposure; 622 int rval; 623 624 switch (ctrl->id) { 625 case V4L2_CID_HFLIP: 626 case V4L2_CID_VFLIP: 627 if (sensor->streaming) 628 return -EBUSY; 629 630 if (sensor->hflip->val) 631 orient |= CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR; 632 633 if (sensor->vflip->val) 634 orient |= CCS_IMAGE_ORIENTATION_VERTICAL_FLIP; 635 636 orient ^= sensor->hvflip_inv_mask; 637 638 ccs_update_mbus_formats(sensor); 639 640 break; 641 case V4L2_CID_VBLANK: 642 exposure = sensor->exposure->val; 643 644 __ccs_update_exposure_limits(sensor); 645 646 if (exposure > sensor->exposure->maximum) { 647 sensor->exposure->val = sensor->exposure->maximum; 648 rval = ccs_set_ctrl(sensor->exposure); 649 if (rval < 0) 650 return rval; 651 } 652 653 break; 654 case V4L2_CID_LINK_FREQ: 655 if (sensor->streaming) 656 return -EBUSY; 657 658 rval = ccs_pll_update(sensor); 659 if (rval) 660 return rval; 661 662 return 0; 663 case V4L2_CID_TEST_PATTERN: 664 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++) 665 v4l2_ctrl_activate( 666 sensor->test_data[i], 667 ctrl->val == 668 V4L2_SMIAPP_TEST_PATTERN_MODE_SOLID_COLOUR); 669 670 break; 671 } 672 673 pm_status = pm_runtime_get_if_active(&client->dev, true); 674 if (!pm_status) 675 return 0; 676 677 switch (ctrl->id) { 678 case V4L2_CID_ANALOGUE_GAIN: 679 rval = ccs_write(sensor, ANALOG_GAIN_CODE_GLOBAL, ctrl->val); 680 681 break; 682 683 case V4L2_CID_CCS_ANALOGUE_LINEAR_GAIN: 684 rval = ccs_write(sensor, ANALOG_LINEAR_GAIN_GLOBAL, ctrl->val); 685 686 break; 687 688 case V4L2_CID_CCS_ANALOGUE_EXPONENTIAL_GAIN: 689 rval = ccs_write(sensor, ANALOG_EXPONENTIAL_GAIN_GLOBAL, 690 ctrl->val); 691 692 break; 693 694 case V4L2_CID_DIGITAL_GAIN: 695 if (CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) == 696 CCS_DIGITAL_GAIN_CAPABILITY_GLOBAL) { 697 rval = ccs_write(sensor, DIGITAL_GAIN_GLOBAL, 698 ctrl->val); 699 break; 700 } 701 702 rval = ccs_write_addr(sensor, 703 SMIAPP_REG_U16_DIGITAL_GAIN_GREENR, 704 ctrl->val); 705 if (rval) 706 break; 707 708 rval = ccs_write_addr(sensor, 709 SMIAPP_REG_U16_DIGITAL_GAIN_RED, 710 ctrl->val); 711 if (rval) 712 break; 713 714 rval = ccs_write_addr(sensor, 715 SMIAPP_REG_U16_DIGITAL_GAIN_BLUE, 716 ctrl->val); 717 if (rval) 718 break; 719 720 rval = ccs_write_addr(sensor, 721 SMIAPP_REG_U16_DIGITAL_GAIN_GREENB, 722 ctrl->val); 723 724 break; 725 case V4L2_CID_EXPOSURE: 726 rval = ccs_write(sensor, COARSE_INTEGRATION_TIME, ctrl->val); 727 728 break; 729 case V4L2_CID_HFLIP: 730 case V4L2_CID_VFLIP: 731 rval = ccs_write(sensor, IMAGE_ORIENTATION, orient); 732 733 break; 734 case V4L2_CID_VBLANK: 735 rval = ccs_write(sensor, FRAME_LENGTH_LINES, 736 sensor->pixel_array->crop[ 737 CCS_PA_PAD_SRC].height 738 + ctrl->val); 739 740 break; 741 case V4L2_CID_HBLANK: 742 rval = ccs_write(sensor, LINE_LENGTH_PCK, 743 sensor->pixel_array->crop[CCS_PA_PAD_SRC].width 744 + ctrl->val); 745 746 break; 747 case V4L2_CID_TEST_PATTERN: 748 rval = ccs_write(sensor, TEST_PATTERN_MODE, ctrl->val); 749 750 break; 751 case V4L2_CID_TEST_PATTERN_RED: 752 rval = ccs_write(sensor, TEST_DATA_RED, ctrl->val); 753 754 break; 755 case V4L2_CID_TEST_PATTERN_GREENR: 756 rval = ccs_write(sensor, TEST_DATA_GREENR, ctrl->val); 757 758 break; 759 case V4L2_CID_TEST_PATTERN_BLUE: 760 rval = ccs_write(sensor, TEST_DATA_BLUE, ctrl->val); 761 762 break; 763 case V4L2_CID_TEST_PATTERN_GREENB: 764 rval = ccs_write(sensor, TEST_DATA_GREENB, ctrl->val); 765 766 break; 767 case V4L2_CID_CCS_SHADING_CORRECTION: 768 rval = ccs_write(sensor, SHADING_CORRECTION_EN, 769 ctrl->val ? CCS_SHADING_CORRECTION_EN_ENABLE : 770 0); 771 772 if (!rval && sensor->luminance_level) 773 v4l2_ctrl_activate(sensor->luminance_level, ctrl->val); 774 775 break; 776 case V4L2_CID_CCS_LUMINANCE_CORRECTION_LEVEL: 777 rval = ccs_write(sensor, LUMINANCE_CORRECTION_LEVEL, ctrl->val); 778 779 break; 780 case V4L2_CID_PIXEL_RATE: 781 /* For v4l2_ctrl_s_ctrl_int64() used internally. */ 782 rval = 0; 783 784 break; 785 default: 786 rval = -EINVAL; 787 } 788 789 if (pm_status > 0) { 790 pm_runtime_mark_last_busy(&client->dev); 791 pm_runtime_put_autosuspend(&client->dev); 792 } 793 794 return rval; 795 } 796 797 static const struct v4l2_ctrl_ops ccs_ctrl_ops = { 798 .s_ctrl = ccs_set_ctrl, 799 }; 800 801 static int ccs_init_controls(struct ccs_sensor *sensor) 802 { 803 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 804 int rval; 805 806 rval = v4l2_ctrl_handler_init(&sensor->pixel_array->ctrl_handler, 17); 807 if (rval) 808 return rval; 809 810 sensor->pixel_array->ctrl_handler.lock = &sensor->mutex; 811 812 switch (CCS_LIM(sensor, ANALOG_GAIN_CAPABILITY)) { 813 case CCS_ANALOG_GAIN_CAPABILITY_GLOBAL: { 814 struct { 815 const char *name; 816 u32 id; 817 s32 value; 818 } const gain_ctrls[] = { 819 { "Analogue Gain m0", V4L2_CID_CCS_ANALOGUE_GAIN_M0, 820 CCS_LIM(sensor, ANALOG_GAIN_M0), }, 821 { "Analogue Gain c0", V4L2_CID_CCS_ANALOGUE_GAIN_C0, 822 CCS_LIM(sensor, ANALOG_GAIN_C0), }, 823 { "Analogue Gain m1", V4L2_CID_CCS_ANALOGUE_GAIN_M1, 824 CCS_LIM(sensor, ANALOG_GAIN_M1), }, 825 { "Analogue Gain c1", V4L2_CID_CCS_ANALOGUE_GAIN_C1, 826 CCS_LIM(sensor, ANALOG_GAIN_C1), }, 827 }; 828 struct v4l2_ctrl_config ctrl_cfg = { 829 .type = V4L2_CTRL_TYPE_INTEGER, 830 .ops = &ccs_ctrl_ops, 831 .flags = V4L2_CTRL_FLAG_READ_ONLY, 832 .step = 1, 833 }; 834 unsigned int i; 835 836 for (i = 0; i < ARRAY_SIZE(gain_ctrls); i++) { 837 ctrl_cfg.name = gain_ctrls[i].name; 838 ctrl_cfg.id = gain_ctrls[i].id; 839 ctrl_cfg.min = ctrl_cfg.max = ctrl_cfg.def = 840 gain_ctrls[i].value; 841 842 v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler, 843 &ctrl_cfg, NULL); 844 } 845 846 v4l2_ctrl_new_std(&sensor->pixel_array->ctrl_handler, 847 &ccs_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, 848 CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN), 849 CCS_LIM(sensor, ANALOG_GAIN_CODE_MAX), 850 max(CCS_LIM(sensor, ANALOG_GAIN_CODE_STEP), 851 1U), 852 CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN)); 853 } 854 break; 855 856 case CCS_ANALOG_GAIN_CAPABILITY_ALTERNATE_GLOBAL: { 857 struct { 858 const char *name; 859 u32 id; 860 u16 min, max, step; 861 } const gain_ctrls[] = { 862 { 863 "Analogue Linear Gain", 864 V4L2_CID_CCS_ANALOGUE_LINEAR_GAIN, 865 CCS_LIM(sensor, ANALOG_LINEAR_GAIN_MIN), 866 CCS_LIM(sensor, ANALOG_LINEAR_GAIN_MAX), 867 max(CCS_LIM(sensor, 868 ANALOG_LINEAR_GAIN_STEP_SIZE), 869 1U), 870 }, 871 { 872 "Analogue Exponential Gain", 873 V4L2_CID_CCS_ANALOGUE_EXPONENTIAL_GAIN, 874 CCS_LIM(sensor, ANALOG_EXPONENTIAL_GAIN_MIN), 875 CCS_LIM(sensor, ANALOG_EXPONENTIAL_GAIN_MAX), 876 max(CCS_LIM(sensor, 877 ANALOG_EXPONENTIAL_GAIN_STEP_SIZE), 878 1U), 879 }, 880 }; 881 struct v4l2_ctrl_config ctrl_cfg = { 882 .type = V4L2_CTRL_TYPE_INTEGER, 883 .ops = &ccs_ctrl_ops, 884 }; 885 unsigned int i; 886 887 for (i = 0; i < ARRAY_SIZE(gain_ctrls); i++) { 888 ctrl_cfg.name = gain_ctrls[i].name; 889 ctrl_cfg.min = ctrl_cfg.def = gain_ctrls[i].min; 890 ctrl_cfg.max = gain_ctrls[i].max; 891 ctrl_cfg.step = gain_ctrls[i].step; 892 ctrl_cfg.id = gain_ctrls[i].id; 893 894 v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler, 895 &ctrl_cfg, NULL); 896 } 897 } 898 } 899 900 if (CCS_LIM(sensor, SHADING_CORRECTION_CAPABILITY) & 901 (CCS_SHADING_CORRECTION_CAPABILITY_COLOR_SHADING | 902 CCS_SHADING_CORRECTION_CAPABILITY_LUMINANCE_CORRECTION)) { 903 const struct v4l2_ctrl_config ctrl_cfg = { 904 .name = "Shading Correction", 905 .type = V4L2_CTRL_TYPE_BOOLEAN, 906 .id = V4L2_CID_CCS_SHADING_CORRECTION, 907 .ops = &ccs_ctrl_ops, 908 .max = 1, 909 .step = 1, 910 }; 911 912 v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler, 913 &ctrl_cfg, NULL); 914 } 915 916 if (CCS_LIM(sensor, SHADING_CORRECTION_CAPABILITY) & 917 CCS_SHADING_CORRECTION_CAPABILITY_LUMINANCE_CORRECTION) { 918 const struct v4l2_ctrl_config ctrl_cfg = { 919 .name = "Luminance Correction Level", 920 .type = V4L2_CTRL_TYPE_BOOLEAN, 921 .id = V4L2_CID_CCS_LUMINANCE_CORRECTION_LEVEL, 922 .ops = &ccs_ctrl_ops, 923 .max = 255, 924 .step = 1, 925 .def = 128, 926 }; 927 928 sensor->luminance_level = 929 v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler, 930 &ctrl_cfg, NULL); 931 } 932 933 if (CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) == 934 CCS_DIGITAL_GAIN_CAPABILITY_GLOBAL || 935 CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) == 936 SMIAPP_DIGITAL_GAIN_CAPABILITY_PER_CHANNEL) 937 v4l2_ctrl_new_std(&sensor->pixel_array->ctrl_handler, 938 &ccs_ctrl_ops, V4L2_CID_DIGITAL_GAIN, 939 CCS_LIM(sensor, DIGITAL_GAIN_MIN), 940 CCS_LIM(sensor, DIGITAL_GAIN_MAX), 941 max(CCS_LIM(sensor, DIGITAL_GAIN_STEP_SIZE), 942 1U), 943 0x100); 944 945 /* Exposure limits will be updated soon, use just something here. */ 946 sensor->exposure = v4l2_ctrl_new_std( 947 &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops, 948 V4L2_CID_EXPOSURE, 0, 0, 1, 0); 949 950 sensor->hflip = v4l2_ctrl_new_std( 951 &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops, 952 V4L2_CID_HFLIP, 0, 1, 1, 0); 953 sensor->vflip = v4l2_ctrl_new_std( 954 &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops, 955 V4L2_CID_VFLIP, 0, 1, 1, 0); 956 957 sensor->vblank = v4l2_ctrl_new_std( 958 &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops, 959 V4L2_CID_VBLANK, 0, 1, 1, 0); 960 961 if (sensor->vblank) 962 sensor->vblank->flags |= V4L2_CTRL_FLAG_UPDATE; 963 964 sensor->hblank = v4l2_ctrl_new_std( 965 &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops, 966 V4L2_CID_HBLANK, 0, 1, 1, 0); 967 968 if (sensor->hblank) 969 sensor->hblank->flags |= V4L2_CTRL_FLAG_UPDATE; 970 971 sensor->pixel_rate_parray = v4l2_ctrl_new_std( 972 &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops, 973 V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1); 974 975 v4l2_ctrl_new_std_menu_items(&sensor->pixel_array->ctrl_handler, 976 &ccs_ctrl_ops, V4L2_CID_TEST_PATTERN, 977 ARRAY_SIZE(ccs_test_patterns) - 1, 978 0, 0, ccs_test_patterns); 979 980 if (sensor->pixel_array->ctrl_handler.error) { 981 dev_err(&client->dev, 982 "pixel array controls initialization failed (%d)\n", 983 sensor->pixel_array->ctrl_handler.error); 984 return sensor->pixel_array->ctrl_handler.error; 985 } 986 987 sensor->pixel_array->sd.ctrl_handler = 988 &sensor->pixel_array->ctrl_handler; 989 990 v4l2_ctrl_cluster(2, &sensor->hflip); 991 992 rval = v4l2_ctrl_handler_init(&sensor->src->ctrl_handler, 0); 993 if (rval) 994 return rval; 995 996 sensor->src->ctrl_handler.lock = &sensor->mutex; 997 998 sensor->pixel_rate_csi = v4l2_ctrl_new_std( 999 &sensor->src->ctrl_handler, &ccs_ctrl_ops, 1000 V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1); 1001 1002 if (sensor->src->ctrl_handler.error) { 1003 dev_err(&client->dev, 1004 "src controls initialization failed (%d)\n", 1005 sensor->src->ctrl_handler.error); 1006 return sensor->src->ctrl_handler.error; 1007 } 1008 1009 sensor->src->sd.ctrl_handler = &sensor->src->ctrl_handler; 1010 1011 return 0; 1012 } 1013 1014 /* 1015 * For controls that require information on available media bus codes 1016 * and linke frequencies. 1017 */ 1018 static int ccs_init_late_controls(struct ccs_sensor *sensor) 1019 { 1020 unsigned long *valid_link_freqs = &sensor->valid_link_freqs[ 1021 sensor->csi_format->compressed - sensor->compressed_min_bpp]; 1022 unsigned int i; 1023 1024 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++) { 1025 int max_value = (1 << sensor->csi_format->width) - 1; 1026 1027 sensor->test_data[i] = v4l2_ctrl_new_std( 1028 &sensor->pixel_array->ctrl_handler, 1029 &ccs_ctrl_ops, V4L2_CID_TEST_PATTERN_RED + i, 1030 0, max_value, 1, max_value); 1031 } 1032 1033 sensor->link_freq = v4l2_ctrl_new_int_menu( 1034 &sensor->src->ctrl_handler, &ccs_ctrl_ops, 1035 V4L2_CID_LINK_FREQ, __fls(*valid_link_freqs), 1036 __ffs(*valid_link_freqs), sensor->hwcfg.op_sys_clock); 1037 1038 return sensor->src->ctrl_handler.error; 1039 } 1040 1041 static void ccs_free_controls(struct ccs_sensor *sensor) 1042 { 1043 unsigned int i; 1044 1045 for (i = 0; i < sensor->ssds_used; i++) 1046 v4l2_ctrl_handler_free(&sensor->ssds[i].ctrl_handler); 1047 } 1048 1049 static int ccs_get_mbus_formats(struct ccs_sensor *sensor) 1050 { 1051 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1052 struct ccs_pll *pll = &sensor->pll; 1053 u8 compressed_max_bpp = 0; 1054 unsigned int type, n; 1055 unsigned int i, pixel_order; 1056 int rval; 1057 1058 type = CCS_LIM(sensor, DATA_FORMAT_MODEL_TYPE); 1059 1060 dev_dbg(&client->dev, "data_format_model_type %d\n", type); 1061 1062 rval = ccs_read(sensor, PIXEL_ORDER, &pixel_order); 1063 if (rval) 1064 return rval; 1065 1066 if (pixel_order >= ARRAY_SIZE(pixel_order_str)) { 1067 dev_dbg(&client->dev, "bad pixel order %d\n", pixel_order); 1068 return -EINVAL; 1069 } 1070 1071 dev_dbg(&client->dev, "pixel order %d (%s)\n", pixel_order, 1072 pixel_order_str[pixel_order]); 1073 1074 switch (type) { 1075 case CCS_DATA_FORMAT_MODEL_TYPE_NORMAL: 1076 n = SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL_N; 1077 break; 1078 case CCS_DATA_FORMAT_MODEL_TYPE_EXTENDED: 1079 n = CCS_LIM_DATA_FORMAT_DESCRIPTOR_MAX_N + 1; 1080 break; 1081 default: 1082 return -EINVAL; 1083 } 1084 1085 sensor->default_pixel_order = pixel_order; 1086 sensor->mbus_frame_fmts = 0; 1087 1088 for (i = 0; i < n; i++) { 1089 unsigned int fmt, j; 1090 1091 fmt = CCS_LIM_AT(sensor, DATA_FORMAT_DESCRIPTOR, i); 1092 1093 dev_dbg(&client->dev, "%u: bpp %u, compressed %u\n", 1094 i, fmt >> 8, (u8)fmt); 1095 1096 for (j = 0; j < ARRAY_SIZE(ccs_csi_data_formats); j++) { 1097 const struct ccs_csi_data_format *f = 1098 &ccs_csi_data_formats[j]; 1099 1100 if (f->pixel_order != CCS_PIXEL_ORDER_GRBG) 1101 continue; 1102 1103 if (f->width != fmt >> 1104 CCS_DATA_FORMAT_DESCRIPTOR_UNCOMPRESSED_SHIFT || 1105 f->compressed != 1106 (fmt & CCS_DATA_FORMAT_DESCRIPTOR_COMPRESSED_MASK)) 1107 continue; 1108 1109 dev_dbg(&client->dev, "jolly good! %d\n", j); 1110 1111 sensor->default_mbus_frame_fmts |= 1 << j; 1112 } 1113 } 1114 1115 /* Figure out which BPP values can be used with which formats. */ 1116 pll->binning_horizontal = 1; 1117 pll->binning_vertical = 1; 1118 pll->scale_m = sensor->scale_m; 1119 1120 for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) { 1121 sensor->compressed_min_bpp = 1122 min(ccs_csi_data_formats[i].compressed, 1123 sensor->compressed_min_bpp); 1124 compressed_max_bpp = 1125 max(ccs_csi_data_formats[i].compressed, 1126 compressed_max_bpp); 1127 } 1128 1129 sensor->valid_link_freqs = devm_kcalloc( 1130 &client->dev, 1131 compressed_max_bpp - sensor->compressed_min_bpp + 1, 1132 sizeof(*sensor->valid_link_freqs), GFP_KERNEL); 1133 if (!sensor->valid_link_freqs) 1134 return -ENOMEM; 1135 1136 for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) { 1137 const struct ccs_csi_data_format *f = 1138 &ccs_csi_data_formats[i]; 1139 unsigned long *valid_link_freqs = 1140 &sensor->valid_link_freqs[ 1141 f->compressed - sensor->compressed_min_bpp]; 1142 unsigned int j; 1143 1144 if (!(sensor->default_mbus_frame_fmts & 1 << i)) 1145 continue; 1146 1147 pll->bits_per_pixel = f->compressed; 1148 1149 for (j = 0; sensor->hwcfg.op_sys_clock[j]; j++) { 1150 pll->link_freq = sensor->hwcfg.op_sys_clock[j]; 1151 1152 rval = ccs_pll_try(sensor, pll); 1153 dev_dbg(&client->dev, "link freq %u Hz, bpp %u %s\n", 1154 pll->link_freq, pll->bits_per_pixel, 1155 rval ? "not ok" : "ok"); 1156 if (rval) 1157 continue; 1158 1159 set_bit(j, valid_link_freqs); 1160 } 1161 1162 if (!*valid_link_freqs) { 1163 dev_info(&client->dev, 1164 "no valid link frequencies for %u bpp\n", 1165 f->compressed); 1166 sensor->default_mbus_frame_fmts &= ~BIT(i); 1167 continue; 1168 } 1169 1170 if (!sensor->csi_format 1171 || f->width > sensor->csi_format->width 1172 || (f->width == sensor->csi_format->width 1173 && f->compressed > sensor->csi_format->compressed)) { 1174 sensor->csi_format = f; 1175 sensor->internal_csi_format = f; 1176 } 1177 } 1178 1179 if (!sensor->csi_format) { 1180 dev_err(&client->dev, "no supported mbus code found\n"); 1181 return -EINVAL; 1182 } 1183 1184 ccs_update_mbus_formats(sensor); 1185 1186 return 0; 1187 } 1188 1189 static void ccs_update_blanking(struct ccs_sensor *sensor) 1190 { 1191 struct v4l2_ctrl *vblank = sensor->vblank; 1192 struct v4l2_ctrl *hblank = sensor->hblank; 1193 u16 min_fll, max_fll, min_llp, max_llp, min_lbp; 1194 int min, max; 1195 1196 if (sensor->binning_vertical > 1 || sensor->binning_horizontal > 1) { 1197 min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES_BIN); 1198 max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES_BIN); 1199 min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN); 1200 max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK_BIN); 1201 min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK_BIN); 1202 } else { 1203 min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES); 1204 max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES); 1205 min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK); 1206 max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK); 1207 min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK); 1208 } 1209 1210 min = max_t(int, 1211 CCS_LIM(sensor, MIN_FRAME_BLANKING_LINES), 1212 min_fll - sensor->pixel_array->crop[CCS_PA_PAD_SRC].height); 1213 max = max_fll - sensor->pixel_array->crop[CCS_PA_PAD_SRC].height; 1214 1215 __v4l2_ctrl_modify_range(vblank, min, max, vblank->step, min); 1216 1217 min = max_t(int, 1218 min_llp - sensor->pixel_array->crop[CCS_PA_PAD_SRC].width, 1219 min_lbp); 1220 max = max_llp - sensor->pixel_array->crop[CCS_PA_PAD_SRC].width; 1221 1222 __v4l2_ctrl_modify_range(hblank, min, max, hblank->step, min); 1223 1224 __ccs_update_exposure_limits(sensor); 1225 } 1226 1227 static int ccs_pll_blanking_update(struct ccs_sensor *sensor) 1228 { 1229 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1230 int rval; 1231 1232 rval = ccs_pll_update(sensor); 1233 if (rval < 0) 1234 return rval; 1235 1236 /* Output from pixel array, including blanking */ 1237 ccs_update_blanking(sensor); 1238 1239 dev_dbg(&client->dev, "vblank\t\t%d\n", sensor->vblank->val); 1240 dev_dbg(&client->dev, "hblank\t\t%d\n", sensor->hblank->val); 1241 1242 dev_dbg(&client->dev, "real timeperframe\t100/%d\n", 1243 sensor->pll.pixel_rate_pixel_array / 1244 ((sensor->pixel_array->crop[CCS_PA_PAD_SRC].width 1245 + sensor->hblank->val) * 1246 (sensor->pixel_array->crop[CCS_PA_PAD_SRC].height 1247 + sensor->vblank->val) / 100)); 1248 1249 return 0; 1250 } 1251 1252 /* 1253 * 1254 * SMIA++ NVM handling 1255 * 1256 */ 1257 1258 static int ccs_read_nvm_page(struct ccs_sensor *sensor, u32 p, u8 *nvm, 1259 u8 *status) 1260 { 1261 unsigned int i; 1262 int rval; 1263 u32 s; 1264 1265 *status = 0; 1266 1267 rval = ccs_write(sensor, DATA_TRANSFER_IF_1_PAGE_SELECT, p); 1268 if (rval) 1269 return rval; 1270 1271 rval = ccs_write(sensor, DATA_TRANSFER_IF_1_CTRL, 1272 CCS_DATA_TRANSFER_IF_1_CTRL_ENABLE); 1273 if (rval) 1274 return rval; 1275 1276 rval = ccs_read(sensor, DATA_TRANSFER_IF_1_STATUS, &s); 1277 if (rval) 1278 return rval; 1279 1280 if (s & CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE) { 1281 *status = s; 1282 return -ENODATA; 1283 } 1284 1285 if (CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) & 1286 CCS_DATA_TRANSFER_IF_CAPABILITY_POLLING) { 1287 for (i = 1000; i > 0; i--) { 1288 if (s & CCS_DATA_TRANSFER_IF_1_STATUS_READ_IF_READY) 1289 break; 1290 1291 rval = ccs_read(sensor, DATA_TRANSFER_IF_1_STATUS, &s); 1292 if (rval) 1293 return rval; 1294 } 1295 1296 if (!i) 1297 return -ETIMEDOUT; 1298 } 1299 1300 for (i = 0; i <= CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P; i++) { 1301 u32 v; 1302 1303 rval = ccs_read(sensor, DATA_TRANSFER_IF_1_DATA(i), &v); 1304 if (rval) 1305 return rval; 1306 1307 *nvm++ = v; 1308 } 1309 1310 return 0; 1311 } 1312 1313 static int ccs_read_nvm(struct ccs_sensor *sensor, unsigned char *nvm, 1314 size_t nvm_size) 1315 { 1316 u8 status = 0; 1317 u32 p; 1318 int rval = 0, rval2; 1319 1320 for (p = 0; p < nvm_size / (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1) 1321 && !rval; p++) { 1322 rval = ccs_read_nvm_page(sensor, p, nvm, &status); 1323 nvm += CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1; 1324 } 1325 1326 if (rval == -ENODATA && 1327 status & CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE) 1328 rval = 0; 1329 1330 rval2 = ccs_write(sensor, DATA_TRANSFER_IF_1_CTRL, 0); 1331 if (rval < 0) 1332 return rval; 1333 else 1334 return rval2 ?: p * (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1); 1335 } 1336 1337 /* 1338 * 1339 * SMIA++ CCI address control 1340 * 1341 */ 1342 static int ccs_change_cci_addr(struct ccs_sensor *sensor) 1343 { 1344 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1345 int rval; 1346 u32 val; 1347 1348 client->addr = sensor->hwcfg.i2c_addr_dfl; 1349 1350 rval = ccs_write(sensor, CCI_ADDRESS_CTRL, 1351 sensor->hwcfg.i2c_addr_alt << 1); 1352 if (rval) 1353 return rval; 1354 1355 client->addr = sensor->hwcfg.i2c_addr_alt; 1356 1357 /* verify addr change went ok */ 1358 rval = ccs_read(sensor, CCI_ADDRESS_CTRL, &val); 1359 if (rval) 1360 return rval; 1361 1362 if (val != sensor->hwcfg.i2c_addr_alt << 1) 1363 return -ENODEV; 1364 1365 return 0; 1366 } 1367 1368 /* 1369 * 1370 * SMIA++ Mode Control 1371 * 1372 */ 1373 static int ccs_setup_flash_strobe(struct ccs_sensor *sensor) 1374 { 1375 struct ccs_flash_strobe_parms *strobe_setup; 1376 unsigned int ext_freq = sensor->hwcfg.ext_clk; 1377 u32 tmp; 1378 u32 strobe_adjustment; 1379 u32 strobe_width_high_rs; 1380 int rval; 1381 1382 strobe_setup = sensor->hwcfg.strobe_setup; 1383 1384 /* 1385 * How to calculate registers related to strobe length. Please 1386 * do not change, or if you do at least know what you're 1387 * doing. :-) 1388 * 1389 * Sakari Ailus <sakari.ailus@linux.intel.com> 2010-10-25 1390 * 1391 * flash_strobe_length [us] / 10^6 = (tFlash_strobe_width_ctrl 1392 * / EXTCLK freq [Hz]) * flash_strobe_adjustment 1393 * 1394 * tFlash_strobe_width_ctrl E N, [1 - 0xffff] 1395 * flash_strobe_adjustment E N, [1 - 0xff] 1396 * 1397 * The formula above is written as below to keep it on one 1398 * line: 1399 * 1400 * l / 10^6 = w / e * a 1401 * 1402 * Let's mark w * a by x: 1403 * 1404 * x = w * a 1405 * 1406 * Thus, we get: 1407 * 1408 * x = l * e / 10^6 1409 * 1410 * The strobe width must be at least as long as requested, 1411 * thus rounding upwards is needed. 1412 * 1413 * x = (l * e + 10^6 - 1) / 10^6 1414 * ----------------------------- 1415 * 1416 * Maximum possible accuracy is wanted at all times. Thus keep 1417 * a as small as possible. 1418 * 1419 * Calculate a, assuming maximum w, with rounding upwards: 1420 * 1421 * a = (x + (2^16 - 1) - 1) / (2^16 - 1) 1422 * ------------------------------------- 1423 * 1424 * Thus, we also get w, with that a, with rounding upwards: 1425 * 1426 * w = (x + a - 1) / a 1427 * ------------------- 1428 * 1429 * To get limits: 1430 * 1431 * x E [1, (2^16 - 1) * (2^8 - 1)] 1432 * 1433 * Substituting maximum x to the original formula (with rounding), 1434 * the maximum l is thus 1435 * 1436 * (2^16 - 1) * (2^8 - 1) * 10^6 = l * e + 10^6 - 1 1437 * 1438 * l = (10^6 * (2^16 - 1) * (2^8 - 1) - 10^6 + 1) / e 1439 * -------------------------------------------------- 1440 * 1441 * flash_strobe_length must be clamped between 1 and 1442 * (10^6 * (2^16 - 1) * (2^8 - 1) - 10^6 + 1) / EXTCLK freq. 1443 * 1444 * Then, 1445 * 1446 * flash_strobe_adjustment = ((flash_strobe_length * 1447 * EXTCLK freq + 10^6 - 1) / 10^6 + (2^16 - 1) - 1) / (2^16 - 1) 1448 * 1449 * tFlash_strobe_width_ctrl = ((flash_strobe_length * 1450 * EXTCLK freq + 10^6 - 1) / 10^6 + 1451 * flash_strobe_adjustment - 1) / flash_strobe_adjustment 1452 */ 1453 tmp = div_u64(1000000ULL * ((1 << 16) - 1) * ((1 << 8) - 1) - 1454 1000000 + 1, ext_freq); 1455 strobe_setup->strobe_width_high_us = 1456 clamp_t(u32, strobe_setup->strobe_width_high_us, 1, tmp); 1457 1458 tmp = div_u64(((u64)strobe_setup->strobe_width_high_us * (u64)ext_freq + 1459 1000000 - 1), 1000000ULL); 1460 strobe_adjustment = (tmp + (1 << 16) - 1 - 1) / ((1 << 16) - 1); 1461 strobe_width_high_rs = (tmp + strobe_adjustment - 1) / 1462 strobe_adjustment; 1463 1464 rval = ccs_write(sensor, FLASH_MODE_RS, strobe_setup->mode); 1465 if (rval < 0) 1466 goto out; 1467 1468 rval = ccs_write(sensor, FLASH_STROBE_ADJUSTMENT, strobe_adjustment); 1469 if (rval < 0) 1470 goto out; 1471 1472 rval = ccs_write(sensor, TFLASH_STROBE_WIDTH_HIGH_RS_CTRL, 1473 strobe_width_high_rs); 1474 if (rval < 0) 1475 goto out; 1476 1477 rval = ccs_write(sensor, TFLASH_STROBE_DELAY_RS_CTRL, 1478 strobe_setup->strobe_delay); 1479 if (rval < 0) 1480 goto out; 1481 1482 rval = ccs_write(sensor, FLASH_STROBE_START_POINT, 1483 strobe_setup->stobe_start_point); 1484 if (rval < 0) 1485 goto out; 1486 1487 rval = ccs_write(sensor, FLASH_TRIGGER_RS, strobe_setup->trigger); 1488 1489 out: 1490 sensor->hwcfg.strobe_setup->trigger = 0; 1491 1492 return rval; 1493 } 1494 1495 /* ----------------------------------------------------------------------------- 1496 * Power management 1497 */ 1498 1499 static int ccs_write_msr_regs(struct ccs_sensor *sensor) 1500 { 1501 int rval; 1502 1503 rval = ccs_write_data_regs(sensor, 1504 sensor->sdata.sensor_manufacturer_regs, 1505 sensor->sdata.num_sensor_manufacturer_regs); 1506 if (rval) 1507 return rval; 1508 1509 return ccs_write_data_regs(sensor, 1510 sensor->mdata.module_manufacturer_regs, 1511 sensor->mdata.num_module_manufacturer_regs); 1512 } 1513 1514 static int ccs_update_phy_ctrl(struct ccs_sensor *sensor) 1515 { 1516 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1517 u8 val; 1518 1519 if (!sensor->ccs_limits) 1520 return 0; 1521 1522 if (CCS_LIM(sensor, PHY_CTRL_CAPABILITY) & 1523 CCS_PHY_CTRL_CAPABILITY_AUTO_PHY_CTL) { 1524 val = CCS_PHY_CTRL_AUTO; 1525 } else if (CCS_LIM(sensor, PHY_CTRL_CAPABILITY) & 1526 CCS_PHY_CTRL_CAPABILITY_UI_PHY_CTL) { 1527 val = CCS_PHY_CTRL_UI; 1528 } else { 1529 dev_err(&client->dev, "manual PHY control not supported\n"); 1530 return -EINVAL; 1531 } 1532 1533 return ccs_write(sensor, PHY_CTRL, val); 1534 } 1535 1536 static int ccs_power_on(struct device *dev) 1537 { 1538 struct v4l2_subdev *subdev = dev_get_drvdata(dev); 1539 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 1540 /* 1541 * The sub-device related to the I2C device is always the 1542 * source one, i.e. ssds[0]. 1543 */ 1544 struct ccs_sensor *sensor = 1545 container_of(ssd, struct ccs_sensor, ssds[0]); 1546 const struct ccs_device *ccsdev = device_get_match_data(dev); 1547 int rval; 1548 1549 rval = regulator_bulk_enable(ARRAY_SIZE(ccs_regulators), 1550 sensor->regulators); 1551 if (rval) { 1552 dev_err(dev, "failed to enable vana regulator\n"); 1553 return rval; 1554 } 1555 1556 if (sensor->reset || sensor->xshutdown || sensor->ext_clk) { 1557 unsigned int sleep; 1558 1559 rval = clk_prepare_enable(sensor->ext_clk); 1560 if (rval < 0) { 1561 dev_dbg(dev, "failed to enable xclk\n"); 1562 goto out_xclk_fail; 1563 } 1564 1565 gpiod_set_value(sensor->reset, 0); 1566 gpiod_set_value(sensor->xshutdown, 1); 1567 1568 if (ccsdev->flags & CCS_DEVICE_FLAG_IS_SMIA) 1569 sleep = SMIAPP_RESET_DELAY(sensor->hwcfg.ext_clk); 1570 else 1571 sleep = 5000; 1572 1573 usleep_range(sleep, sleep); 1574 } 1575 1576 /* 1577 * Failures to respond to the address change command have been noticed. 1578 * Those failures seem to be caused by the sensor requiring a longer 1579 * boot time than advertised. An additional 10ms delay seems to work 1580 * around the issue, but the SMIA++ I2C write retry hack makes the delay 1581 * unnecessary. The failures need to be investigated to find a proper 1582 * fix, and a delay will likely need to be added here if the I2C write 1583 * retry hack is reverted before the root cause of the boot time issue 1584 * is found. 1585 */ 1586 1587 if (!sensor->reset && !sensor->xshutdown) { 1588 u8 retry = 100; 1589 u32 reset; 1590 1591 rval = ccs_write(sensor, SOFTWARE_RESET, CCS_SOFTWARE_RESET_ON); 1592 if (rval < 0) { 1593 dev_err(dev, "software reset failed\n"); 1594 goto out_cci_addr_fail; 1595 } 1596 1597 do { 1598 rval = ccs_read(sensor, SOFTWARE_RESET, &reset); 1599 reset = !rval && reset == CCS_SOFTWARE_RESET_OFF; 1600 if (reset) 1601 break; 1602 1603 usleep_range(1000, 2000); 1604 } while (--retry); 1605 1606 if (!reset) 1607 return -EIO; 1608 } 1609 1610 if (sensor->hwcfg.i2c_addr_alt) { 1611 rval = ccs_change_cci_addr(sensor); 1612 if (rval) { 1613 dev_err(dev, "cci address change error\n"); 1614 goto out_cci_addr_fail; 1615 } 1616 } 1617 1618 rval = ccs_write(sensor, COMPRESSION_MODE, 1619 CCS_COMPRESSION_MODE_DPCM_PCM_SIMPLE); 1620 if (rval) { 1621 dev_err(dev, "compression mode set failed\n"); 1622 goto out_cci_addr_fail; 1623 } 1624 1625 rval = ccs_write(sensor, EXTCLK_FREQUENCY_MHZ, 1626 sensor->hwcfg.ext_clk / (1000000 / (1 << 8))); 1627 if (rval) { 1628 dev_err(dev, "extclk frequency set failed\n"); 1629 goto out_cci_addr_fail; 1630 } 1631 1632 rval = ccs_write(sensor, CSI_LANE_MODE, sensor->hwcfg.lanes - 1); 1633 if (rval) { 1634 dev_err(dev, "csi lane mode set failed\n"); 1635 goto out_cci_addr_fail; 1636 } 1637 1638 rval = ccs_write(sensor, FAST_STANDBY_CTRL, 1639 CCS_FAST_STANDBY_CTRL_FRAME_TRUNCATION); 1640 if (rval) { 1641 dev_err(dev, "fast standby set failed\n"); 1642 goto out_cci_addr_fail; 1643 } 1644 1645 rval = ccs_write(sensor, CSI_SIGNALING_MODE, 1646 sensor->hwcfg.csi_signalling_mode); 1647 if (rval) { 1648 dev_err(dev, "csi signalling mode set failed\n"); 1649 goto out_cci_addr_fail; 1650 } 1651 1652 rval = ccs_update_phy_ctrl(sensor); 1653 if (rval < 0) 1654 goto out_cci_addr_fail; 1655 1656 rval = ccs_write_msr_regs(sensor); 1657 if (rval) 1658 goto out_cci_addr_fail; 1659 1660 rval = ccs_call_quirk(sensor, post_poweron); 1661 if (rval) { 1662 dev_err(dev, "post_poweron quirks failed\n"); 1663 goto out_cci_addr_fail; 1664 } 1665 1666 return 0; 1667 1668 out_cci_addr_fail: 1669 gpiod_set_value(sensor->reset, 1); 1670 gpiod_set_value(sensor->xshutdown, 0); 1671 clk_disable_unprepare(sensor->ext_clk); 1672 1673 out_xclk_fail: 1674 regulator_bulk_disable(ARRAY_SIZE(ccs_regulators), 1675 sensor->regulators); 1676 1677 return rval; 1678 } 1679 1680 static int ccs_power_off(struct device *dev) 1681 { 1682 struct v4l2_subdev *subdev = dev_get_drvdata(dev); 1683 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 1684 struct ccs_sensor *sensor = 1685 container_of(ssd, struct ccs_sensor, ssds[0]); 1686 1687 /* 1688 * Currently power/clock to lens are enable/disabled separately 1689 * but they are essentially the same signals. So if the sensor is 1690 * powered off while the lens is powered on the sensor does not 1691 * really see a power off and next time the cci address change 1692 * will fail. So do a soft reset explicitly here. 1693 */ 1694 if (sensor->hwcfg.i2c_addr_alt) 1695 ccs_write(sensor, SOFTWARE_RESET, CCS_SOFTWARE_RESET_ON); 1696 1697 gpiod_set_value(sensor->reset, 1); 1698 gpiod_set_value(sensor->xshutdown, 0); 1699 clk_disable_unprepare(sensor->ext_clk); 1700 usleep_range(5000, 5000); 1701 regulator_bulk_disable(ARRAY_SIZE(ccs_regulators), 1702 sensor->regulators); 1703 sensor->streaming = false; 1704 1705 return 0; 1706 } 1707 1708 /* ----------------------------------------------------------------------------- 1709 * Video stream management 1710 */ 1711 1712 static int ccs_start_streaming(struct ccs_sensor *sensor) 1713 { 1714 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1715 unsigned int binning_mode; 1716 int rval; 1717 1718 mutex_lock(&sensor->mutex); 1719 1720 rval = ccs_write(sensor, CSI_DATA_FORMAT, 1721 (sensor->csi_format->width << 8) | 1722 sensor->csi_format->compressed); 1723 if (rval) 1724 goto out; 1725 1726 /* Binning configuration */ 1727 if (sensor->binning_horizontal == 1 && 1728 sensor->binning_vertical == 1) { 1729 binning_mode = 0; 1730 } else { 1731 u8 binning_type = 1732 (sensor->binning_horizontal << 4) 1733 | sensor->binning_vertical; 1734 1735 rval = ccs_write(sensor, BINNING_TYPE, binning_type); 1736 if (rval < 0) 1737 goto out; 1738 1739 binning_mode = 1; 1740 } 1741 rval = ccs_write(sensor, BINNING_MODE, binning_mode); 1742 if (rval < 0) 1743 goto out; 1744 1745 /* Set up PLL */ 1746 rval = ccs_pll_configure(sensor); 1747 if (rval) 1748 goto out; 1749 1750 /* Analog crop start coordinates */ 1751 rval = ccs_write(sensor, X_ADDR_START, 1752 sensor->pixel_array->crop[CCS_PA_PAD_SRC].left); 1753 if (rval < 0) 1754 goto out; 1755 1756 rval = ccs_write(sensor, Y_ADDR_START, 1757 sensor->pixel_array->crop[CCS_PA_PAD_SRC].top); 1758 if (rval < 0) 1759 goto out; 1760 1761 /* Analog crop end coordinates */ 1762 rval = ccs_write( 1763 sensor, X_ADDR_END, 1764 sensor->pixel_array->crop[CCS_PA_PAD_SRC].left 1765 + sensor->pixel_array->crop[CCS_PA_PAD_SRC].width - 1); 1766 if (rval < 0) 1767 goto out; 1768 1769 rval = ccs_write( 1770 sensor, Y_ADDR_END, 1771 sensor->pixel_array->crop[CCS_PA_PAD_SRC].top 1772 + sensor->pixel_array->crop[CCS_PA_PAD_SRC].height - 1); 1773 if (rval < 0) 1774 goto out; 1775 1776 /* 1777 * Output from pixel array, including blanking, is set using 1778 * controls below. No need to set here. 1779 */ 1780 1781 /* Digital crop */ 1782 if (CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY) 1783 == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) { 1784 rval = ccs_write( 1785 sensor, DIGITAL_CROP_X_OFFSET, 1786 sensor->scaler->crop[CCS_PAD_SINK].left); 1787 if (rval < 0) 1788 goto out; 1789 1790 rval = ccs_write( 1791 sensor, DIGITAL_CROP_Y_OFFSET, 1792 sensor->scaler->crop[CCS_PAD_SINK].top); 1793 if (rval < 0) 1794 goto out; 1795 1796 rval = ccs_write( 1797 sensor, DIGITAL_CROP_IMAGE_WIDTH, 1798 sensor->scaler->crop[CCS_PAD_SINK].width); 1799 if (rval < 0) 1800 goto out; 1801 1802 rval = ccs_write( 1803 sensor, DIGITAL_CROP_IMAGE_HEIGHT, 1804 sensor->scaler->crop[CCS_PAD_SINK].height); 1805 if (rval < 0) 1806 goto out; 1807 } 1808 1809 /* Scaling */ 1810 if (CCS_LIM(sensor, SCALING_CAPABILITY) 1811 != CCS_SCALING_CAPABILITY_NONE) { 1812 rval = ccs_write(sensor, SCALING_MODE, sensor->scaling_mode); 1813 if (rval < 0) 1814 goto out; 1815 1816 rval = ccs_write(sensor, SCALE_M, sensor->scale_m); 1817 if (rval < 0) 1818 goto out; 1819 } 1820 1821 /* Output size from sensor */ 1822 rval = ccs_write(sensor, X_OUTPUT_SIZE, 1823 sensor->src->crop[CCS_PAD_SRC].width); 1824 if (rval < 0) 1825 goto out; 1826 rval = ccs_write(sensor, Y_OUTPUT_SIZE, 1827 sensor->src->crop[CCS_PAD_SRC].height); 1828 if (rval < 0) 1829 goto out; 1830 1831 if (CCS_LIM(sensor, FLASH_MODE_CAPABILITY) & 1832 (CCS_FLASH_MODE_CAPABILITY_SINGLE_STROBE | 1833 SMIAPP_FLASH_MODE_CAPABILITY_MULTIPLE_STROBE) && 1834 sensor->hwcfg.strobe_setup != NULL && 1835 sensor->hwcfg.strobe_setup->trigger != 0) { 1836 rval = ccs_setup_flash_strobe(sensor); 1837 if (rval) 1838 goto out; 1839 } 1840 1841 rval = ccs_call_quirk(sensor, pre_streamon); 1842 if (rval) { 1843 dev_err(&client->dev, "pre_streamon quirks failed\n"); 1844 goto out; 1845 } 1846 1847 rval = ccs_write(sensor, MODE_SELECT, CCS_MODE_SELECT_STREAMING); 1848 1849 out: 1850 mutex_unlock(&sensor->mutex); 1851 1852 return rval; 1853 } 1854 1855 static int ccs_stop_streaming(struct ccs_sensor *sensor) 1856 { 1857 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1858 int rval; 1859 1860 mutex_lock(&sensor->mutex); 1861 rval = ccs_write(sensor, MODE_SELECT, CCS_MODE_SELECT_SOFTWARE_STANDBY); 1862 if (rval) 1863 goto out; 1864 1865 rval = ccs_call_quirk(sensor, post_streamoff); 1866 if (rval) 1867 dev_err(&client->dev, "post_streamoff quirks failed\n"); 1868 1869 out: 1870 mutex_unlock(&sensor->mutex); 1871 return rval; 1872 } 1873 1874 /* ----------------------------------------------------------------------------- 1875 * V4L2 subdev video operations 1876 */ 1877 1878 static int ccs_pm_get_init(struct ccs_sensor *sensor) 1879 { 1880 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1881 int rval; 1882 1883 /* 1884 * It can't use pm_runtime_resume_and_get() here, as the driver 1885 * relies at the returned value to detect if the device was already 1886 * active or not. 1887 */ 1888 rval = pm_runtime_get_sync(&client->dev); 1889 if (rval < 0) 1890 goto error; 1891 1892 /* Device was already active, so don't set controls */ 1893 if (rval == 1) 1894 return 0; 1895 1896 /* Restore V4L2 controls to the previously suspended device */ 1897 rval = v4l2_ctrl_handler_setup(&sensor->pixel_array->ctrl_handler); 1898 if (rval) 1899 goto error; 1900 1901 rval = v4l2_ctrl_handler_setup(&sensor->src->ctrl_handler); 1902 if (rval) 1903 goto error; 1904 1905 /* Keep PM runtime usage_count incremented on success */ 1906 return 0; 1907 error: 1908 pm_runtime_put(&client->dev); 1909 return rval; 1910 } 1911 1912 static int ccs_set_stream(struct v4l2_subdev *subdev, int enable) 1913 { 1914 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 1915 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1916 int rval; 1917 1918 if (sensor->streaming == enable) 1919 return 0; 1920 1921 if (!enable) { 1922 ccs_stop_streaming(sensor); 1923 sensor->streaming = false; 1924 pm_runtime_mark_last_busy(&client->dev); 1925 pm_runtime_put_autosuspend(&client->dev); 1926 1927 return 0; 1928 } 1929 1930 rval = ccs_pm_get_init(sensor); 1931 if (rval) 1932 return rval; 1933 1934 sensor->streaming = true; 1935 1936 rval = ccs_start_streaming(sensor); 1937 if (rval < 0) { 1938 sensor->streaming = false; 1939 pm_runtime_mark_last_busy(&client->dev); 1940 pm_runtime_put_autosuspend(&client->dev); 1941 } 1942 1943 return rval; 1944 } 1945 1946 static int ccs_pre_streamon(struct v4l2_subdev *subdev, u32 flags) 1947 { 1948 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 1949 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1950 int rval; 1951 1952 if (flags & V4L2_SUBDEV_PRE_STREAMON_FL_MANUAL_LP) { 1953 switch (sensor->hwcfg.csi_signalling_mode) { 1954 case CCS_CSI_SIGNALING_MODE_CSI_2_DPHY: 1955 if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY_2) & 1956 CCS_PHY_CTRL_CAPABILITY_2_MANUAL_LP_DPHY)) 1957 return -EACCES; 1958 break; 1959 case CCS_CSI_SIGNALING_MODE_CSI_2_CPHY: 1960 if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY_2) & 1961 CCS_PHY_CTRL_CAPABILITY_2_MANUAL_LP_CPHY)) 1962 return -EACCES; 1963 break; 1964 default: 1965 return -EACCES; 1966 } 1967 } 1968 1969 rval = ccs_pm_get_init(sensor); 1970 if (rval) 1971 return rval; 1972 1973 if (flags & V4L2_SUBDEV_PRE_STREAMON_FL_MANUAL_LP) { 1974 rval = ccs_write(sensor, MANUAL_LP_CTRL, 1975 CCS_MANUAL_LP_CTRL_ENABLE); 1976 if (rval) 1977 pm_runtime_put(&client->dev); 1978 } 1979 1980 return rval; 1981 } 1982 1983 static int ccs_post_streamoff(struct v4l2_subdev *subdev) 1984 { 1985 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 1986 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 1987 1988 return pm_runtime_put(&client->dev); 1989 } 1990 1991 static int ccs_enum_mbus_code(struct v4l2_subdev *subdev, 1992 struct v4l2_subdev_state *sd_state, 1993 struct v4l2_subdev_mbus_code_enum *code) 1994 { 1995 struct i2c_client *client = v4l2_get_subdevdata(subdev); 1996 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 1997 unsigned int i; 1998 int idx = -1; 1999 int rval = -EINVAL; 2000 2001 mutex_lock(&sensor->mutex); 2002 2003 dev_err(&client->dev, "subdev %s, pad %d, index %d\n", 2004 subdev->name, code->pad, code->index); 2005 2006 if (subdev != &sensor->src->sd || code->pad != CCS_PAD_SRC) { 2007 if (code->index) 2008 goto out; 2009 2010 code->code = sensor->internal_csi_format->code; 2011 rval = 0; 2012 goto out; 2013 } 2014 2015 for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) { 2016 if (sensor->mbus_frame_fmts & (1 << i)) 2017 idx++; 2018 2019 if (idx == code->index) { 2020 code->code = ccs_csi_data_formats[i].code; 2021 dev_err(&client->dev, "found index %d, i %d, code %x\n", 2022 code->index, i, code->code); 2023 rval = 0; 2024 break; 2025 } 2026 } 2027 2028 out: 2029 mutex_unlock(&sensor->mutex); 2030 2031 return rval; 2032 } 2033 2034 static u32 __ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad) 2035 { 2036 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2037 2038 if (subdev == &sensor->src->sd && pad == CCS_PAD_SRC) 2039 return sensor->csi_format->code; 2040 else 2041 return sensor->internal_csi_format->code; 2042 } 2043 2044 static int __ccs_get_format(struct v4l2_subdev *subdev, 2045 struct v4l2_subdev_state *sd_state, 2046 struct v4l2_subdev_format *fmt) 2047 { 2048 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2049 2050 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 2051 fmt->format = *v4l2_subdev_get_try_format(subdev, sd_state, 2052 fmt->pad); 2053 } else { 2054 struct v4l2_rect *r; 2055 2056 if (fmt->pad == ssd->source_pad) 2057 r = &ssd->crop[ssd->source_pad]; 2058 else 2059 r = &ssd->sink_fmt; 2060 2061 fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad); 2062 fmt->format.width = r->width; 2063 fmt->format.height = r->height; 2064 fmt->format.field = V4L2_FIELD_NONE; 2065 } 2066 2067 return 0; 2068 } 2069 2070 static int ccs_get_format(struct v4l2_subdev *subdev, 2071 struct v4l2_subdev_state *sd_state, 2072 struct v4l2_subdev_format *fmt) 2073 { 2074 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2075 int rval; 2076 2077 mutex_lock(&sensor->mutex); 2078 rval = __ccs_get_format(subdev, sd_state, fmt); 2079 mutex_unlock(&sensor->mutex); 2080 2081 return rval; 2082 } 2083 2084 static void ccs_get_crop_compose(struct v4l2_subdev *subdev, 2085 struct v4l2_subdev_state *sd_state, 2086 struct v4l2_rect **crops, 2087 struct v4l2_rect **comps, int which) 2088 { 2089 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2090 unsigned int i; 2091 2092 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) { 2093 if (crops) 2094 for (i = 0; i < subdev->entity.num_pads; i++) 2095 crops[i] = &ssd->crop[i]; 2096 if (comps) 2097 *comps = &ssd->compose; 2098 } else { 2099 if (crops) { 2100 for (i = 0; i < subdev->entity.num_pads; i++) 2101 crops[i] = v4l2_subdev_get_try_crop(subdev, 2102 sd_state, 2103 i); 2104 } 2105 if (comps) 2106 *comps = v4l2_subdev_get_try_compose(subdev, sd_state, 2107 CCS_PAD_SINK); 2108 } 2109 } 2110 2111 /* Changes require propagation only on sink pad. */ 2112 static void ccs_propagate(struct v4l2_subdev *subdev, 2113 struct v4l2_subdev_state *sd_state, int which, 2114 int target) 2115 { 2116 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2117 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2118 struct v4l2_rect *comp, *crops[CCS_PADS]; 2119 2120 ccs_get_crop_compose(subdev, sd_state, crops, &comp, which); 2121 2122 switch (target) { 2123 case V4L2_SEL_TGT_CROP: 2124 comp->width = crops[CCS_PAD_SINK]->width; 2125 comp->height = crops[CCS_PAD_SINK]->height; 2126 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) { 2127 if (ssd == sensor->scaler) { 2128 sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN); 2129 sensor->scaling_mode = 2130 CCS_SCALING_MODE_NO_SCALING; 2131 } else if (ssd == sensor->binner) { 2132 sensor->binning_horizontal = 1; 2133 sensor->binning_vertical = 1; 2134 } 2135 } 2136 fallthrough; 2137 case V4L2_SEL_TGT_COMPOSE: 2138 *crops[CCS_PAD_SRC] = *comp; 2139 break; 2140 default: 2141 WARN_ON_ONCE(1); 2142 } 2143 } 2144 2145 static const struct ccs_csi_data_format 2146 *ccs_validate_csi_data_format(struct ccs_sensor *sensor, u32 code) 2147 { 2148 unsigned int i; 2149 2150 for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) { 2151 if (sensor->mbus_frame_fmts & (1 << i) && 2152 ccs_csi_data_formats[i].code == code) 2153 return &ccs_csi_data_formats[i]; 2154 } 2155 2156 return sensor->csi_format; 2157 } 2158 2159 static int ccs_set_format_source(struct v4l2_subdev *subdev, 2160 struct v4l2_subdev_state *sd_state, 2161 struct v4l2_subdev_format *fmt) 2162 { 2163 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2164 const struct ccs_csi_data_format *csi_format, 2165 *old_csi_format = sensor->csi_format; 2166 unsigned long *valid_link_freqs; 2167 u32 code = fmt->format.code; 2168 unsigned int i; 2169 int rval; 2170 2171 rval = __ccs_get_format(subdev, sd_state, fmt); 2172 if (rval) 2173 return rval; 2174 2175 /* 2176 * Media bus code is changeable on src subdev's source pad. On 2177 * other source pads we just get format here. 2178 */ 2179 if (subdev != &sensor->src->sd) 2180 return 0; 2181 2182 csi_format = ccs_validate_csi_data_format(sensor, code); 2183 2184 fmt->format.code = csi_format->code; 2185 2186 if (fmt->which != V4L2_SUBDEV_FORMAT_ACTIVE) 2187 return 0; 2188 2189 sensor->csi_format = csi_format; 2190 2191 if (csi_format->width != old_csi_format->width) 2192 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++) 2193 __v4l2_ctrl_modify_range( 2194 sensor->test_data[i], 0, 2195 (1 << csi_format->width) - 1, 1, 0); 2196 2197 if (csi_format->compressed == old_csi_format->compressed) 2198 return 0; 2199 2200 valid_link_freqs = 2201 &sensor->valid_link_freqs[sensor->csi_format->compressed 2202 - sensor->compressed_min_bpp]; 2203 2204 __v4l2_ctrl_modify_range( 2205 sensor->link_freq, 0, 2206 __fls(*valid_link_freqs), ~*valid_link_freqs, 2207 __ffs(*valid_link_freqs)); 2208 2209 return ccs_pll_update(sensor); 2210 } 2211 2212 static int ccs_set_format(struct v4l2_subdev *subdev, 2213 struct v4l2_subdev_state *sd_state, 2214 struct v4l2_subdev_format *fmt) 2215 { 2216 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2217 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2218 struct v4l2_rect *crops[CCS_PADS]; 2219 2220 mutex_lock(&sensor->mutex); 2221 2222 if (fmt->pad == ssd->source_pad) { 2223 int rval; 2224 2225 rval = ccs_set_format_source(subdev, sd_state, fmt); 2226 2227 mutex_unlock(&sensor->mutex); 2228 2229 return rval; 2230 } 2231 2232 /* Sink pad. Width and height are changeable here. */ 2233 fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad); 2234 fmt->format.width &= ~1; 2235 fmt->format.height &= ~1; 2236 fmt->format.field = V4L2_FIELD_NONE; 2237 2238 fmt->format.width = 2239 clamp(fmt->format.width, 2240 CCS_LIM(sensor, MIN_X_OUTPUT_SIZE), 2241 CCS_LIM(sensor, MAX_X_OUTPUT_SIZE)); 2242 fmt->format.height = 2243 clamp(fmt->format.height, 2244 CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE), 2245 CCS_LIM(sensor, MAX_Y_OUTPUT_SIZE)); 2246 2247 ccs_get_crop_compose(subdev, sd_state, crops, NULL, fmt->which); 2248 2249 crops[ssd->sink_pad]->left = 0; 2250 crops[ssd->sink_pad]->top = 0; 2251 crops[ssd->sink_pad]->width = fmt->format.width; 2252 crops[ssd->sink_pad]->height = fmt->format.height; 2253 if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) 2254 ssd->sink_fmt = *crops[ssd->sink_pad]; 2255 ccs_propagate(subdev, sd_state, fmt->which, V4L2_SEL_TGT_CROP); 2256 2257 mutex_unlock(&sensor->mutex); 2258 2259 return 0; 2260 } 2261 2262 /* 2263 * Calculate goodness of scaled image size compared to expected image 2264 * size and flags provided. 2265 */ 2266 #define SCALING_GOODNESS 100000 2267 #define SCALING_GOODNESS_EXTREME 100000000 2268 static int scaling_goodness(struct v4l2_subdev *subdev, int w, int ask_w, 2269 int h, int ask_h, u32 flags) 2270 { 2271 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2272 struct i2c_client *client = v4l2_get_subdevdata(subdev); 2273 int val = 0; 2274 2275 w &= ~1; 2276 ask_w &= ~1; 2277 h &= ~1; 2278 ask_h &= ~1; 2279 2280 if (flags & V4L2_SEL_FLAG_GE) { 2281 if (w < ask_w) 2282 val -= SCALING_GOODNESS; 2283 if (h < ask_h) 2284 val -= SCALING_GOODNESS; 2285 } 2286 2287 if (flags & V4L2_SEL_FLAG_LE) { 2288 if (w > ask_w) 2289 val -= SCALING_GOODNESS; 2290 if (h > ask_h) 2291 val -= SCALING_GOODNESS; 2292 } 2293 2294 val -= abs(w - ask_w); 2295 val -= abs(h - ask_h); 2296 2297 if (w < CCS_LIM(sensor, MIN_X_OUTPUT_SIZE)) 2298 val -= SCALING_GOODNESS_EXTREME; 2299 2300 dev_dbg(&client->dev, "w %d ask_w %d h %d ask_h %d goodness %d\n", 2301 w, ask_w, h, ask_h, val); 2302 2303 return val; 2304 } 2305 2306 static void ccs_set_compose_binner(struct v4l2_subdev *subdev, 2307 struct v4l2_subdev_state *sd_state, 2308 struct v4l2_subdev_selection *sel, 2309 struct v4l2_rect **crops, 2310 struct v4l2_rect *comp) 2311 { 2312 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2313 unsigned int i; 2314 unsigned int binh = 1, binv = 1; 2315 int best = scaling_goodness( 2316 subdev, 2317 crops[CCS_PAD_SINK]->width, sel->r.width, 2318 crops[CCS_PAD_SINK]->height, sel->r.height, sel->flags); 2319 2320 for (i = 0; i < sensor->nbinning_subtypes; i++) { 2321 int this = scaling_goodness( 2322 subdev, 2323 crops[CCS_PAD_SINK]->width 2324 / sensor->binning_subtypes[i].horizontal, 2325 sel->r.width, 2326 crops[CCS_PAD_SINK]->height 2327 / sensor->binning_subtypes[i].vertical, 2328 sel->r.height, sel->flags); 2329 2330 if (this > best) { 2331 binh = sensor->binning_subtypes[i].horizontal; 2332 binv = sensor->binning_subtypes[i].vertical; 2333 best = this; 2334 } 2335 } 2336 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) { 2337 sensor->binning_vertical = binv; 2338 sensor->binning_horizontal = binh; 2339 } 2340 2341 sel->r.width = (crops[CCS_PAD_SINK]->width / binh) & ~1; 2342 sel->r.height = (crops[CCS_PAD_SINK]->height / binv) & ~1; 2343 } 2344 2345 /* 2346 * Calculate best scaling ratio and mode for given output resolution. 2347 * 2348 * Try all of these: horizontal ratio, vertical ratio and smallest 2349 * size possible (horizontally). 2350 * 2351 * Also try whether horizontal scaler or full scaler gives a better 2352 * result. 2353 */ 2354 static void ccs_set_compose_scaler(struct v4l2_subdev *subdev, 2355 struct v4l2_subdev_state *sd_state, 2356 struct v4l2_subdev_selection *sel, 2357 struct v4l2_rect **crops, 2358 struct v4l2_rect *comp) 2359 { 2360 struct i2c_client *client = v4l2_get_subdevdata(subdev); 2361 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2362 u32 min, max, a, b, max_m; 2363 u32 scale_m = CCS_LIM(sensor, SCALER_N_MIN); 2364 int mode = CCS_SCALING_MODE_HORIZONTAL; 2365 u32 try[4]; 2366 u32 ntry = 0; 2367 unsigned int i; 2368 int best = INT_MIN; 2369 2370 sel->r.width = min_t(unsigned int, sel->r.width, 2371 crops[CCS_PAD_SINK]->width); 2372 sel->r.height = min_t(unsigned int, sel->r.height, 2373 crops[CCS_PAD_SINK]->height); 2374 2375 a = crops[CCS_PAD_SINK]->width 2376 * CCS_LIM(sensor, SCALER_N_MIN) / sel->r.width; 2377 b = crops[CCS_PAD_SINK]->height 2378 * CCS_LIM(sensor, SCALER_N_MIN) / sel->r.height; 2379 max_m = crops[CCS_PAD_SINK]->width 2380 * CCS_LIM(sensor, SCALER_N_MIN) 2381 / CCS_LIM(sensor, MIN_X_OUTPUT_SIZE); 2382 2383 a = clamp(a, CCS_LIM(sensor, SCALER_M_MIN), 2384 CCS_LIM(sensor, SCALER_M_MAX)); 2385 b = clamp(b, CCS_LIM(sensor, SCALER_M_MIN), 2386 CCS_LIM(sensor, SCALER_M_MAX)); 2387 max_m = clamp(max_m, CCS_LIM(sensor, SCALER_M_MIN), 2388 CCS_LIM(sensor, SCALER_M_MAX)); 2389 2390 dev_dbg(&client->dev, "scaling: a %d b %d max_m %d\n", a, b, max_m); 2391 2392 min = min(max_m, min(a, b)); 2393 max = min(max_m, max(a, b)); 2394 2395 try[ntry] = min; 2396 ntry++; 2397 if (min != max) { 2398 try[ntry] = max; 2399 ntry++; 2400 } 2401 if (max != max_m) { 2402 try[ntry] = min + 1; 2403 ntry++; 2404 if (min != max) { 2405 try[ntry] = max + 1; 2406 ntry++; 2407 } 2408 } 2409 2410 for (i = 0; i < ntry; i++) { 2411 int this = scaling_goodness( 2412 subdev, 2413 crops[CCS_PAD_SINK]->width 2414 / try[i] * CCS_LIM(sensor, SCALER_N_MIN), 2415 sel->r.width, 2416 crops[CCS_PAD_SINK]->height, 2417 sel->r.height, 2418 sel->flags); 2419 2420 dev_dbg(&client->dev, "trying factor %d (%d)\n", try[i], i); 2421 2422 if (this > best) { 2423 scale_m = try[i]; 2424 mode = CCS_SCALING_MODE_HORIZONTAL; 2425 best = this; 2426 } 2427 2428 if (CCS_LIM(sensor, SCALING_CAPABILITY) 2429 == CCS_SCALING_CAPABILITY_HORIZONTAL) 2430 continue; 2431 2432 this = scaling_goodness( 2433 subdev, crops[CCS_PAD_SINK]->width 2434 / try[i] 2435 * CCS_LIM(sensor, SCALER_N_MIN), 2436 sel->r.width, 2437 crops[CCS_PAD_SINK]->height 2438 / try[i] 2439 * CCS_LIM(sensor, SCALER_N_MIN), 2440 sel->r.height, 2441 sel->flags); 2442 2443 if (this > best) { 2444 scale_m = try[i]; 2445 mode = SMIAPP_SCALING_MODE_BOTH; 2446 best = this; 2447 } 2448 } 2449 2450 sel->r.width = 2451 (crops[CCS_PAD_SINK]->width 2452 / scale_m 2453 * CCS_LIM(sensor, SCALER_N_MIN)) & ~1; 2454 if (mode == SMIAPP_SCALING_MODE_BOTH) 2455 sel->r.height = 2456 (crops[CCS_PAD_SINK]->height 2457 / scale_m 2458 * CCS_LIM(sensor, SCALER_N_MIN)) 2459 & ~1; 2460 else 2461 sel->r.height = crops[CCS_PAD_SINK]->height; 2462 2463 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) { 2464 sensor->scale_m = scale_m; 2465 sensor->scaling_mode = mode; 2466 } 2467 } 2468 /* We're only called on source pads. This function sets scaling. */ 2469 static int ccs_set_compose(struct v4l2_subdev *subdev, 2470 struct v4l2_subdev_state *sd_state, 2471 struct v4l2_subdev_selection *sel) 2472 { 2473 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2474 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2475 struct v4l2_rect *comp, *crops[CCS_PADS]; 2476 2477 ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which); 2478 2479 sel->r.top = 0; 2480 sel->r.left = 0; 2481 2482 if (ssd == sensor->binner) 2483 ccs_set_compose_binner(subdev, sd_state, sel, crops, comp); 2484 else 2485 ccs_set_compose_scaler(subdev, sd_state, sel, crops, comp); 2486 2487 *comp = sel->r; 2488 ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_COMPOSE); 2489 2490 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) 2491 return ccs_pll_blanking_update(sensor); 2492 2493 return 0; 2494 } 2495 2496 static int __ccs_sel_supported(struct v4l2_subdev *subdev, 2497 struct v4l2_subdev_selection *sel) 2498 { 2499 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2500 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2501 2502 /* We only implement crop in three places. */ 2503 switch (sel->target) { 2504 case V4L2_SEL_TGT_CROP: 2505 case V4L2_SEL_TGT_CROP_BOUNDS: 2506 if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC) 2507 return 0; 2508 if (ssd == sensor->src && sel->pad == CCS_PAD_SRC) 2509 return 0; 2510 if (ssd == sensor->scaler && sel->pad == CCS_PAD_SINK && 2511 CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY) 2512 == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) 2513 return 0; 2514 return -EINVAL; 2515 case V4L2_SEL_TGT_NATIVE_SIZE: 2516 if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC) 2517 return 0; 2518 return -EINVAL; 2519 case V4L2_SEL_TGT_COMPOSE: 2520 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 2521 if (sel->pad == ssd->source_pad) 2522 return -EINVAL; 2523 if (ssd == sensor->binner) 2524 return 0; 2525 if (ssd == sensor->scaler && CCS_LIM(sensor, SCALING_CAPABILITY) 2526 != CCS_SCALING_CAPABILITY_NONE) 2527 return 0; 2528 fallthrough; 2529 default: 2530 return -EINVAL; 2531 } 2532 } 2533 2534 static int ccs_set_crop(struct v4l2_subdev *subdev, 2535 struct v4l2_subdev_state *sd_state, 2536 struct v4l2_subdev_selection *sel) 2537 { 2538 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2539 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2540 struct v4l2_rect *src_size, *crops[CCS_PADS]; 2541 struct v4l2_rect _r; 2542 2543 ccs_get_crop_compose(subdev, sd_state, crops, NULL, sel->which); 2544 2545 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) { 2546 if (sel->pad == ssd->sink_pad) 2547 src_size = &ssd->sink_fmt; 2548 else 2549 src_size = &ssd->compose; 2550 } else { 2551 if (sel->pad == ssd->sink_pad) { 2552 _r.left = 0; 2553 _r.top = 0; 2554 _r.width = v4l2_subdev_get_try_format(subdev, 2555 sd_state, 2556 sel->pad) 2557 ->width; 2558 _r.height = v4l2_subdev_get_try_format(subdev, 2559 sd_state, 2560 sel->pad) 2561 ->height; 2562 src_size = &_r; 2563 } else { 2564 src_size = v4l2_subdev_get_try_compose( 2565 subdev, sd_state, ssd->sink_pad); 2566 } 2567 } 2568 2569 if (ssd == sensor->src && sel->pad == CCS_PAD_SRC) { 2570 sel->r.left = 0; 2571 sel->r.top = 0; 2572 } 2573 2574 sel->r.width = min(sel->r.width, src_size->width); 2575 sel->r.height = min(sel->r.height, src_size->height); 2576 2577 sel->r.left = min_t(int, sel->r.left, src_size->width - sel->r.width); 2578 sel->r.top = min_t(int, sel->r.top, src_size->height - sel->r.height); 2579 2580 *crops[sel->pad] = sel->r; 2581 2582 if (ssd != sensor->pixel_array && sel->pad == CCS_PAD_SINK) 2583 ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_CROP); 2584 2585 return 0; 2586 } 2587 2588 static void ccs_get_native_size(struct ccs_subdev *ssd, struct v4l2_rect *r) 2589 { 2590 r->top = 0; 2591 r->left = 0; 2592 r->width = CCS_LIM(ssd->sensor, X_ADDR_MAX) + 1; 2593 r->height = CCS_LIM(ssd->sensor, Y_ADDR_MAX) + 1; 2594 } 2595 2596 static int __ccs_get_selection(struct v4l2_subdev *subdev, 2597 struct v4l2_subdev_state *sd_state, 2598 struct v4l2_subdev_selection *sel) 2599 { 2600 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2601 struct ccs_subdev *ssd = to_ccs_subdev(subdev); 2602 struct v4l2_rect *comp, *crops[CCS_PADS]; 2603 struct v4l2_rect sink_fmt; 2604 int ret; 2605 2606 ret = __ccs_sel_supported(subdev, sel); 2607 if (ret) 2608 return ret; 2609 2610 ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which); 2611 2612 if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) { 2613 sink_fmt = ssd->sink_fmt; 2614 } else { 2615 struct v4l2_mbus_framefmt *fmt = 2616 v4l2_subdev_get_try_format(subdev, sd_state, 2617 ssd->sink_pad); 2618 2619 sink_fmt.left = 0; 2620 sink_fmt.top = 0; 2621 sink_fmt.width = fmt->width; 2622 sink_fmt.height = fmt->height; 2623 } 2624 2625 switch (sel->target) { 2626 case V4L2_SEL_TGT_CROP_BOUNDS: 2627 case V4L2_SEL_TGT_NATIVE_SIZE: 2628 if (ssd == sensor->pixel_array) 2629 ccs_get_native_size(ssd, &sel->r); 2630 else if (sel->pad == ssd->sink_pad) 2631 sel->r = sink_fmt; 2632 else 2633 sel->r = *comp; 2634 break; 2635 case V4L2_SEL_TGT_CROP: 2636 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 2637 sel->r = *crops[sel->pad]; 2638 break; 2639 case V4L2_SEL_TGT_COMPOSE: 2640 sel->r = *comp; 2641 break; 2642 } 2643 2644 return 0; 2645 } 2646 2647 static int ccs_get_selection(struct v4l2_subdev *subdev, 2648 struct v4l2_subdev_state *sd_state, 2649 struct v4l2_subdev_selection *sel) 2650 { 2651 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2652 int rval; 2653 2654 mutex_lock(&sensor->mutex); 2655 rval = __ccs_get_selection(subdev, sd_state, sel); 2656 mutex_unlock(&sensor->mutex); 2657 2658 return rval; 2659 } 2660 2661 static int ccs_set_selection(struct v4l2_subdev *subdev, 2662 struct v4l2_subdev_state *sd_state, 2663 struct v4l2_subdev_selection *sel) 2664 { 2665 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2666 int ret; 2667 2668 ret = __ccs_sel_supported(subdev, sel); 2669 if (ret) 2670 return ret; 2671 2672 mutex_lock(&sensor->mutex); 2673 2674 sel->r.left = max(0, sel->r.left & ~1); 2675 sel->r.top = max(0, sel->r.top & ~1); 2676 sel->r.width = CCS_ALIGN_DIM(sel->r.width, sel->flags); 2677 sel->r.height = CCS_ALIGN_DIM(sel->r.height, sel->flags); 2678 2679 sel->r.width = max_t(unsigned int, CCS_LIM(sensor, MIN_X_OUTPUT_SIZE), 2680 sel->r.width); 2681 sel->r.height = max_t(unsigned int, CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE), 2682 sel->r.height); 2683 2684 switch (sel->target) { 2685 case V4L2_SEL_TGT_CROP: 2686 ret = ccs_set_crop(subdev, sd_state, sel); 2687 break; 2688 case V4L2_SEL_TGT_COMPOSE: 2689 ret = ccs_set_compose(subdev, sd_state, sel); 2690 break; 2691 default: 2692 ret = -EINVAL; 2693 } 2694 2695 mutex_unlock(&sensor->mutex); 2696 return ret; 2697 } 2698 2699 static int ccs_get_skip_frames(struct v4l2_subdev *subdev, u32 *frames) 2700 { 2701 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2702 2703 *frames = sensor->frame_skip; 2704 return 0; 2705 } 2706 2707 static int ccs_get_skip_top_lines(struct v4l2_subdev *subdev, u32 *lines) 2708 { 2709 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2710 2711 *lines = sensor->image_start; 2712 2713 return 0; 2714 } 2715 2716 /* ----------------------------------------------------------------------------- 2717 * sysfs attributes 2718 */ 2719 2720 static ssize_t 2721 nvm_show(struct device *dev, struct device_attribute *attr, char *buf) 2722 { 2723 struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev)); 2724 struct i2c_client *client = v4l2_get_subdevdata(subdev); 2725 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2726 int rval; 2727 2728 if (!sensor->dev_init_done) 2729 return -EBUSY; 2730 2731 rval = ccs_pm_get_init(sensor); 2732 if (rval < 0) 2733 return -ENODEV; 2734 2735 rval = ccs_read_nvm(sensor, buf, PAGE_SIZE); 2736 if (rval < 0) { 2737 pm_runtime_put(&client->dev); 2738 dev_err(&client->dev, "nvm read failed\n"); 2739 return -ENODEV; 2740 } 2741 2742 pm_runtime_mark_last_busy(&client->dev); 2743 pm_runtime_put_autosuspend(&client->dev); 2744 2745 /* 2746 * NVM is still way below a PAGE_SIZE, so we can safely 2747 * assume this for now. 2748 */ 2749 return rval; 2750 } 2751 static DEVICE_ATTR_RO(nvm); 2752 2753 static ssize_t 2754 ident_show(struct device *dev, struct device_attribute *attr, char *buf) 2755 { 2756 struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev)); 2757 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2758 struct ccs_module_info *minfo = &sensor->minfo; 2759 2760 if (minfo->mipi_manufacturer_id) 2761 return snprintf(buf, PAGE_SIZE, "%4.4x%4.4x%2.2x\n", 2762 minfo->mipi_manufacturer_id, minfo->model_id, 2763 minfo->revision_number) + 1; 2764 else 2765 return snprintf(buf, PAGE_SIZE, "%2.2x%4.4x%2.2x\n", 2766 minfo->smia_manufacturer_id, minfo->model_id, 2767 minfo->revision_number) + 1; 2768 } 2769 static DEVICE_ATTR_RO(ident); 2770 2771 /* ----------------------------------------------------------------------------- 2772 * V4L2 subdev core operations 2773 */ 2774 2775 static int ccs_identify_module(struct ccs_sensor *sensor) 2776 { 2777 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 2778 struct ccs_module_info *minfo = &sensor->minfo; 2779 unsigned int i; 2780 u32 rev; 2781 int rval = 0; 2782 2783 /* Module info */ 2784 rval = ccs_read(sensor, MODULE_MANUFACTURER_ID, 2785 &minfo->mipi_manufacturer_id); 2786 if (!rval && !minfo->mipi_manufacturer_id) 2787 rval = ccs_read_addr_8only(sensor, 2788 SMIAPP_REG_U8_MANUFACTURER_ID, 2789 &minfo->smia_manufacturer_id); 2790 if (!rval) 2791 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_MODEL_ID, 2792 &minfo->model_id); 2793 if (!rval) 2794 rval = ccs_read_addr_8only(sensor, 2795 CCS_R_MODULE_REVISION_NUMBER_MAJOR, 2796 &rev); 2797 if (!rval) { 2798 rval = ccs_read_addr_8only(sensor, 2799 CCS_R_MODULE_REVISION_NUMBER_MINOR, 2800 &minfo->revision_number); 2801 minfo->revision_number |= rev << 8; 2802 } 2803 if (!rval) 2804 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_YEAR, 2805 &minfo->module_year); 2806 if (!rval) 2807 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_MONTH, 2808 &minfo->module_month); 2809 if (!rval) 2810 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_DAY, 2811 &minfo->module_day); 2812 2813 /* Sensor info */ 2814 if (!rval) 2815 rval = ccs_read(sensor, SENSOR_MANUFACTURER_ID, 2816 &minfo->sensor_mipi_manufacturer_id); 2817 if (!rval && !minfo->sensor_mipi_manufacturer_id) 2818 rval = ccs_read_addr_8only(sensor, 2819 CCS_R_SENSOR_MANUFACTURER_ID, 2820 &minfo->sensor_smia_manufacturer_id); 2821 if (!rval) 2822 rval = ccs_read_addr_8only(sensor, 2823 CCS_R_SENSOR_MODEL_ID, 2824 &minfo->sensor_model_id); 2825 if (!rval) 2826 rval = ccs_read_addr_8only(sensor, 2827 CCS_R_SENSOR_REVISION_NUMBER, 2828 &minfo->sensor_revision_number); 2829 if (!rval) 2830 rval = ccs_read_addr_8only(sensor, 2831 CCS_R_SENSOR_FIRMWARE_VERSION, 2832 &minfo->sensor_firmware_version); 2833 2834 /* SMIA */ 2835 if (!rval) 2836 rval = ccs_read(sensor, MIPI_CCS_VERSION, &minfo->ccs_version); 2837 if (!rval && !minfo->ccs_version) 2838 rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIA_VERSION, 2839 &minfo->smia_version); 2840 if (!rval && !minfo->ccs_version) 2841 rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIAPP_VERSION, 2842 &minfo->smiapp_version); 2843 2844 if (rval) { 2845 dev_err(&client->dev, "sensor detection failed\n"); 2846 return -ENODEV; 2847 } 2848 2849 if (minfo->mipi_manufacturer_id) 2850 dev_dbg(&client->dev, "MIPI CCS module 0x%4.4x-0x%4.4x\n", 2851 minfo->mipi_manufacturer_id, minfo->model_id); 2852 else 2853 dev_dbg(&client->dev, "SMIA module 0x%2.2x-0x%4.4x\n", 2854 minfo->smia_manufacturer_id, minfo->model_id); 2855 2856 dev_dbg(&client->dev, 2857 "module revision 0x%4.4x date %2.2d-%2.2d-%2.2d\n", 2858 minfo->revision_number, minfo->module_year, minfo->module_month, 2859 minfo->module_day); 2860 2861 if (minfo->sensor_mipi_manufacturer_id) 2862 dev_dbg(&client->dev, "MIPI CCS sensor 0x%4.4x-0x%4.4x\n", 2863 minfo->sensor_mipi_manufacturer_id, 2864 minfo->sensor_model_id); 2865 else 2866 dev_dbg(&client->dev, "SMIA sensor 0x%2.2x-0x%4.4x\n", 2867 minfo->sensor_smia_manufacturer_id, 2868 minfo->sensor_model_id); 2869 2870 dev_dbg(&client->dev, 2871 "sensor revision 0x%2.2x firmware version 0x%2.2x\n", 2872 minfo->sensor_revision_number, minfo->sensor_firmware_version); 2873 2874 if (minfo->ccs_version) { 2875 dev_dbg(&client->dev, "MIPI CCS version %u.%u", 2876 (minfo->ccs_version & CCS_MIPI_CCS_VERSION_MAJOR_MASK) 2877 >> CCS_MIPI_CCS_VERSION_MAJOR_SHIFT, 2878 (minfo->ccs_version & CCS_MIPI_CCS_VERSION_MINOR_MASK)); 2879 minfo->name = CCS_NAME; 2880 } else { 2881 dev_dbg(&client->dev, 2882 "smia version %2.2d smiapp version %2.2d\n", 2883 minfo->smia_version, minfo->smiapp_version); 2884 minfo->name = SMIAPP_NAME; 2885 } 2886 2887 /* 2888 * Some modules have bad data in the lvalues below. Hope the 2889 * rvalues have better stuff. The lvalues are module 2890 * parameters whereas the rvalues are sensor parameters. 2891 */ 2892 if (minfo->sensor_smia_manufacturer_id && 2893 !minfo->smia_manufacturer_id && !minfo->model_id) { 2894 minfo->smia_manufacturer_id = 2895 minfo->sensor_smia_manufacturer_id; 2896 minfo->model_id = minfo->sensor_model_id; 2897 minfo->revision_number = minfo->sensor_revision_number; 2898 } 2899 2900 for (i = 0; i < ARRAY_SIZE(ccs_module_idents); i++) { 2901 if (ccs_module_idents[i].mipi_manufacturer_id && 2902 ccs_module_idents[i].mipi_manufacturer_id 2903 != minfo->mipi_manufacturer_id) 2904 continue; 2905 if (ccs_module_idents[i].smia_manufacturer_id && 2906 ccs_module_idents[i].smia_manufacturer_id 2907 != minfo->smia_manufacturer_id) 2908 continue; 2909 if (ccs_module_idents[i].model_id != minfo->model_id) 2910 continue; 2911 if (ccs_module_idents[i].flags 2912 & CCS_MODULE_IDENT_FLAG_REV_LE) { 2913 if (ccs_module_idents[i].revision_number_major 2914 < (minfo->revision_number >> 8)) 2915 continue; 2916 } else { 2917 if (ccs_module_idents[i].revision_number_major 2918 != (minfo->revision_number >> 8)) 2919 continue; 2920 } 2921 2922 minfo->name = ccs_module_idents[i].name; 2923 minfo->quirk = ccs_module_idents[i].quirk; 2924 break; 2925 } 2926 2927 if (i >= ARRAY_SIZE(ccs_module_idents)) 2928 dev_warn(&client->dev, 2929 "no quirks for this module; let's hope it's fully compliant\n"); 2930 2931 dev_dbg(&client->dev, "the sensor is called %s\n", minfo->name); 2932 2933 return 0; 2934 } 2935 2936 static const struct v4l2_subdev_ops ccs_ops; 2937 static const struct v4l2_subdev_internal_ops ccs_internal_ops; 2938 static const struct media_entity_operations ccs_entity_ops; 2939 2940 static int ccs_register_subdev(struct ccs_sensor *sensor, 2941 struct ccs_subdev *ssd, 2942 struct ccs_subdev *sink_ssd, 2943 u16 source_pad, u16 sink_pad, u32 link_flags) 2944 { 2945 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 2946 int rval; 2947 2948 if (!sink_ssd) 2949 return 0; 2950 2951 rval = media_entity_pads_init(&ssd->sd.entity, ssd->npads, ssd->pads); 2952 if (rval) { 2953 dev_err(&client->dev, "media_entity_pads_init failed\n"); 2954 return rval; 2955 } 2956 2957 rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev, &ssd->sd); 2958 if (rval) { 2959 dev_err(&client->dev, "v4l2_device_register_subdev failed\n"); 2960 return rval; 2961 } 2962 2963 rval = media_create_pad_link(&ssd->sd.entity, source_pad, 2964 &sink_ssd->sd.entity, sink_pad, 2965 link_flags); 2966 if (rval) { 2967 dev_err(&client->dev, "media_create_pad_link failed\n"); 2968 v4l2_device_unregister_subdev(&ssd->sd); 2969 return rval; 2970 } 2971 2972 return 0; 2973 } 2974 2975 static void ccs_unregistered(struct v4l2_subdev *subdev) 2976 { 2977 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2978 unsigned int i; 2979 2980 for (i = 1; i < sensor->ssds_used; i++) 2981 v4l2_device_unregister_subdev(&sensor->ssds[i].sd); 2982 } 2983 2984 static int ccs_registered(struct v4l2_subdev *subdev) 2985 { 2986 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 2987 int rval; 2988 2989 if (sensor->scaler) { 2990 rval = ccs_register_subdev(sensor, sensor->binner, 2991 sensor->scaler, 2992 CCS_PAD_SRC, CCS_PAD_SINK, 2993 MEDIA_LNK_FL_ENABLED | 2994 MEDIA_LNK_FL_IMMUTABLE); 2995 if (rval < 0) 2996 return rval; 2997 } 2998 2999 rval = ccs_register_subdev(sensor, sensor->pixel_array, sensor->binner, 3000 CCS_PA_PAD_SRC, CCS_PAD_SINK, 3001 MEDIA_LNK_FL_ENABLED | 3002 MEDIA_LNK_FL_IMMUTABLE); 3003 if (rval) 3004 goto out_err; 3005 3006 return 0; 3007 3008 out_err: 3009 ccs_unregistered(subdev); 3010 3011 return rval; 3012 } 3013 3014 static void ccs_cleanup(struct ccs_sensor *sensor) 3015 { 3016 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 3017 3018 device_remove_file(&client->dev, &dev_attr_nvm); 3019 device_remove_file(&client->dev, &dev_attr_ident); 3020 3021 ccs_free_controls(sensor); 3022 } 3023 3024 static void ccs_create_subdev(struct ccs_sensor *sensor, 3025 struct ccs_subdev *ssd, const char *name, 3026 unsigned short num_pads, u32 function) 3027 { 3028 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 3029 3030 if (!ssd) 3031 return; 3032 3033 if (ssd != sensor->src) 3034 v4l2_subdev_init(&ssd->sd, &ccs_ops); 3035 3036 ssd->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 3037 ssd->sd.entity.function = function; 3038 ssd->sensor = sensor; 3039 3040 ssd->npads = num_pads; 3041 ssd->source_pad = num_pads - 1; 3042 3043 v4l2_i2c_subdev_set_name(&ssd->sd, client, sensor->minfo.name, name); 3044 3045 ccs_get_native_size(ssd, &ssd->sink_fmt); 3046 3047 ssd->compose.width = ssd->sink_fmt.width; 3048 ssd->compose.height = ssd->sink_fmt.height; 3049 ssd->crop[ssd->source_pad] = ssd->compose; 3050 ssd->pads[ssd->source_pad].flags = MEDIA_PAD_FL_SOURCE; 3051 if (ssd != sensor->pixel_array) { 3052 ssd->crop[ssd->sink_pad] = ssd->compose; 3053 ssd->pads[ssd->sink_pad].flags = MEDIA_PAD_FL_SINK; 3054 } 3055 3056 ssd->sd.entity.ops = &ccs_entity_ops; 3057 3058 if (ssd == sensor->src) 3059 return; 3060 3061 ssd->sd.internal_ops = &ccs_internal_ops; 3062 ssd->sd.owner = THIS_MODULE; 3063 ssd->sd.dev = &client->dev; 3064 v4l2_set_subdevdata(&ssd->sd, client); 3065 } 3066 3067 static int ccs_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 3068 { 3069 struct ccs_subdev *ssd = to_ccs_subdev(sd); 3070 struct ccs_sensor *sensor = ssd->sensor; 3071 unsigned int i; 3072 3073 mutex_lock(&sensor->mutex); 3074 3075 for (i = 0; i < ssd->npads; i++) { 3076 struct v4l2_mbus_framefmt *try_fmt = 3077 v4l2_subdev_get_try_format(sd, fh->state, i); 3078 struct v4l2_rect *try_crop = 3079 v4l2_subdev_get_try_crop(sd, fh->state, i); 3080 struct v4l2_rect *try_comp; 3081 3082 ccs_get_native_size(ssd, try_crop); 3083 3084 try_fmt->width = try_crop->width; 3085 try_fmt->height = try_crop->height; 3086 try_fmt->code = sensor->internal_csi_format->code; 3087 try_fmt->field = V4L2_FIELD_NONE; 3088 3089 if (ssd != sensor->pixel_array) 3090 continue; 3091 3092 try_comp = v4l2_subdev_get_try_compose(sd, fh->state, i); 3093 *try_comp = *try_crop; 3094 } 3095 3096 mutex_unlock(&sensor->mutex); 3097 3098 return 0; 3099 } 3100 3101 static const struct v4l2_subdev_video_ops ccs_video_ops = { 3102 .s_stream = ccs_set_stream, 3103 .pre_streamon = ccs_pre_streamon, 3104 .post_streamoff = ccs_post_streamoff, 3105 }; 3106 3107 static const struct v4l2_subdev_pad_ops ccs_pad_ops = { 3108 .enum_mbus_code = ccs_enum_mbus_code, 3109 .get_fmt = ccs_get_format, 3110 .set_fmt = ccs_set_format, 3111 .get_selection = ccs_get_selection, 3112 .set_selection = ccs_set_selection, 3113 }; 3114 3115 static const struct v4l2_subdev_sensor_ops ccs_sensor_ops = { 3116 .g_skip_frames = ccs_get_skip_frames, 3117 .g_skip_top_lines = ccs_get_skip_top_lines, 3118 }; 3119 3120 static const struct v4l2_subdev_ops ccs_ops = { 3121 .video = &ccs_video_ops, 3122 .pad = &ccs_pad_ops, 3123 .sensor = &ccs_sensor_ops, 3124 }; 3125 3126 static const struct media_entity_operations ccs_entity_ops = { 3127 .link_validate = v4l2_subdev_link_validate, 3128 }; 3129 3130 static const struct v4l2_subdev_internal_ops ccs_internal_src_ops = { 3131 .registered = ccs_registered, 3132 .unregistered = ccs_unregistered, 3133 .open = ccs_open, 3134 }; 3135 3136 static const struct v4l2_subdev_internal_ops ccs_internal_ops = { 3137 .open = ccs_open, 3138 }; 3139 3140 /* ----------------------------------------------------------------------------- 3141 * I2C Driver 3142 */ 3143 3144 static int __maybe_unused ccs_suspend(struct device *dev) 3145 { 3146 struct i2c_client *client = to_i2c_client(dev); 3147 struct v4l2_subdev *subdev = i2c_get_clientdata(client); 3148 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 3149 bool streaming = sensor->streaming; 3150 int rval; 3151 3152 rval = pm_runtime_resume_and_get(dev); 3153 if (rval < 0) 3154 return rval; 3155 3156 if (sensor->streaming) 3157 ccs_stop_streaming(sensor); 3158 3159 /* save state for resume */ 3160 sensor->streaming = streaming; 3161 3162 return 0; 3163 } 3164 3165 static int __maybe_unused ccs_resume(struct device *dev) 3166 { 3167 struct i2c_client *client = to_i2c_client(dev); 3168 struct v4l2_subdev *subdev = i2c_get_clientdata(client); 3169 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 3170 int rval = 0; 3171 3172 pm_runtime_put(dev); 3173 3174 if (sensor->streaming) 3175 rval = ccs_start_streaming(sensor); 3176 3177 return rval; 3178 } 3179 3180 static int ccs_get_hwconfig(struct ccs_sensor *sensor, struct device *dev) 3181 { 3182 struct ccs_hwconfig *hwcfg = &sensor->hwcfg; 3183 struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = V4L2_MBUS_UNKNOWN }; 3184 struct fwnode_handle *ep; 3185 struct fwnode_handle *fwnode = dev_fwnode(dev); 3186 u32 rotation; 3187 int i; 3188 int rval; 3189 3190 ep = fwnode_graph_get_endpoint_by_id(fwnode, 0, 0, 3191 FWNODE_GRAPH_ENDPOINT_NEXT); 3192 if (!ep) 3193 return -ENODEV; 3194 3195 /* 3196 * Note that we do need to rely on detecting the bus type between CSI-2 3197 * D-PHY and CCP2 as the old bindings did not require it. 3198 */ 3199 rval = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); 3200 if (rval) 3201 goto out_err; 3202 3203 switch (bus_cfg.bus_type) { 3204 case V4L2_MBUS_CSI2_DPHY: 3205 hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_DPHY; 3206 hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes; 3207 break; 3208 case V4L2_MBUS_CSI2_CPHY: 3209 hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_CPHY; 3210 hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes; 3211 break; 3212 case V4L2_MBUS_CSI1: 3213 case V4L2_MBUS_CCP2: 3214 hwcfg->csi_signalling_mode = (bus_cfg.bus.mipi_csi1.strobe) ? 3215 SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_STROBE : 3216 SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_CLOCK; 3217 hwcfg->lanes = 1; 3218 break; 3219 default: 3220 dev_err(dev, "unsupported bus %u\n", bus_cfg.bus_type); 3221 rval = -EINVAL; 3222 goto out_err; 3223 } 3224 3225 dev_dbg(dev, "lanes %u\n", hwcfg->lanes); 3226 3227 rval = fwnode_property_read_u32(fwnode, "rotation", &rotation); 3228 if (!rval) { 3229 switch (rotation) { 3230 case 180: 3231 hwcfg->module_board_orient = 3232 CCS_MODULE_BOARD_ORIENT_180; 3233 fallthrough; 3234 case 0: 3235 break; 3236 default: 3237 dev_err(dev, "invalid rotation %u\n", rotation); 3238 rval = -EINVAL; 3239 goto out_err; 3240 } 3241 } 3242 3243 rval = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency", 3244 &hwcfg->ext_clk); 3245 if (rval) 3246 dev_info(dev, "can't get clock-frequency\n"); 3247 3248 dev_dbg(dev, "clk %d, mode %d\n", hwcfg->ext_clk, 3249 hwcfg->csi_signalling_mode); 3250 3251 if (!bus_cfg.nr_of_link_frequencies) { 3252 dev_warn(dev, "no link frequencies defined\n"); 3253 rval = -EINVAL; 3254 goto out_err; 3255 } 3256 3257 hwcfg->op_sys_clock = devm_kcalloc( 3258 dev, bus_cfg.nr_of_link_frequencies + 1 /* guardian */, 3259 sizeof(*hwcfg->op_sys_clock), GFP_KERNEL); 3260 if (!hwcfg->op_sys_clock) { 3261 rval = -ENOMEM; 3262 goto out_err; 3263 } 3264 3265 for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++) { 3266 hwcfg->op_sys_clock[i] = bus_cfg.link_frequencies[i]; 3267 dev_dbg(dev, "freq %d: %lld\n", i, hwcfg->op_sys_clock[i]); 3268 } 3269 3270 v4l2_fwnode_endpoint_free(&bus_cfg); 3271 fwnode_handle_put(ep); 3272 3273 return 0; 3274 3275 out_err: 3276 v4l2_fwnode_endpoint_free(&bus_cfg); 3277 fwnode_handle_put(ep); 3278 3279 return rval; 3280 } 3281 3282 static int ccs_probe(struct i2c_client *client) 3283 { 3284 struct ccs_sensor *sensor; 3285 const struct firmware *fw; 3286 char filename[40]; 3287 unsigned int i; 3288 int rval; 3289 3290 sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL); 3291 if (sensor == NULL) 3292 return -ENOMEM; 3293 3294 rval = ccs_get_hwconfig(sensor, &client->dev); 3295 if (rval) 3296 return rval; 3297 3298 sensor->src = &sensor->ssds[sensor->ssds_used]; 3299 3300 v4l2_i2c_subdev_init(&sensor->src->sd, client, &ccs_ops); 3301 sensor->src->sd.internal_ops = &ccs_internal_src_ops; 3302 3303 sensor->regulators = devm_kcalloc(&client->dev, 3304 ARRAY_SIZE(ccs_regulators), 3305 sizeof(*sensor->regulators), 3306 GFP_KERNEL); 3307 if (!sensor->regulators) 3308 return -ENOMEM; 3309 3310 for (i = 0; i < ARRAY_SIZE(ccs_regulators); i++) 3311 sensor->regulators[i].supply = ccs_regulators[i]; 3312 3313 rval = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(ccs_regulators), 3314 sensor->regulators); 3315 if (rval) { 3316 dev_err(&client->dev, "could not get regulators\n"); 3317 return rval; 3318 } 3319 3320 sensor->ext_clk = devm_clk_get(&client->dev, NULL); 3321 if (PTR_ERR(sensor->ext_clk) == -ENOENT) { 3322 dev_info(&client->dev, "no clock defined, continuing...\n"); 3323 sensor->ext_clk = NULL; 3324 } else if (IS_ERR(sensor->ext_clk)) { 3325 dev_err(&client->dev, "could not get clock (%ld)\n", 3326 PTR_ERR(sensor->ext_clk)); 3327 return -EPROBE_DEFER; 3328 } 3329 3330 if (sensor->ext_clk) { 3331 if (sensor->hwcfg.ext_clk) { 3332 unsigned long rate; 3333 3334 rval = clk_set_rate(sensor->ext_clk, 3335 sensor->hwcfg.ext_clk); 3336 if (rval < 0) { 3337 dev_err(&client->dev, 3338 "unable to set clock freq to %u\n", 3339 sensor->hwcfg.ext_clk); 3340 return rval; 3341 } 3342 3343 rate = clk_get_rate(sensor->ext_clk); 3344 if (rate != sensor->hwcfg.ext_clk) { 3345 dev_err(&client->dev, 3346 "can't set clock freq, asked for %u but got %lu\n", 3347 sensor->hwcfg.ext_clk, rate); 3348 return -EINVAL; 3349 } 3350 } else { 3351 sensor->hwcfg.ext_clk = clk_get_rate(sensor->ext_clk); 3352 dev_dbg(&client->dev, "obtained clock freq %u\n", 3353 sensor->hwcfg.ext_clk); 3354 } 3355 } else if (sensor->hwcfg.ext_clk) { 3356 dev_dbg(&client->dev, "assuming clock freq %u\n", 3357 sensor->hwcfg.ext_clk); 3358 } else { 3359 dev_err(&client->dev, "unable to obtain clock freq\n"); 3360 return -EINVAL; 3361 } 3362 3363 if (!sensor->hwcfg.ext_clk) { 3364 dev_err(&client->dev, "cannot work with xclk frequency 0\n"); 3365 return -EINVAL; 3366 } 3367 3368 sensor->reset = devm_gpiod_get_optional(&client->dev, "reset", 3369 GPIOD_OUT_HIGH); 3370 if (IS_ERR(sensor->reset)) 3371 return PTR_ERR(sensor->reset); 3372 /* Support old users that may have used "xshutdown" property. */ 3373 if (!sensor->reset) 3374 sensor->xshutdown = devm_gpiod_get_optional(&client->dev, 3375 "xshutdown", 3376 GPIOD_OUT_LOW); 3377 if (IS_ERR(sensor->xshutdown)) 3378 return PTR_ERR(sensor->xshutdown); 3379 3380 rval = ccs_power_on(&client->dev); 3381 if (rval < 0) 3382 return rval; 3383 3384 mutex_init(&sensor->mutex); 3385 3386 rval = ccs_identify_module(sensor); 3387 if (rval) { 3388 rval = -ENODEV; 3389 goto out_power_off; 3390 } 3391 3392 rval = snprintf(filename, sizeof(filename), 3393 "ccs/ccs-sensor-%4.4x-%4.4x-%4.4x.fw", 3394 sensor->minfo.sensor_mipi_manufacturer_id, 3395 sensor->minfo.sensor_model_id, 3396 sensor->minfo.sensor_revision_number); 3397 if (rval >= sizeof(filename)) { 3398 rval = -ENOMEM; 3399 goto out_power_off; 3400 } 3401 3402 rval = request_firmware(&fw, filename, &client->dev); 3403 if (!rval) { 3404 ccs_data_parse(&sensor->sdata, fw->data, fw->size, &client->dev, 3405 true); 3406 release_firmware(fw); 3407 } 3408 3409 rval = snprintf(filename, sizeof(filename), 3410 "ccs/ccs-module-%4.4x-%4.4x-%4.4x.fw", 3411 sensor->minfo.mipi_manufacturer_id, 3412 sensor->minfo.model_id, 3413 sensor->minfo.revision_number); 3414 if (rval >= sizeof(filename)) { 3415 rval = -ENOMEM; 3416 goto out_release_sdata; 3417 } 3418 3419 rval = request_firmware(&fw, filename, &client->dev); 3420 if (!rval) { 3421 ccs_data_parse(&sensor->mdata, fw->data, fw->size, &client->dev, 3422 true); 3423 release_firmware(fw); 3424 } 3425 3426 rval = ccs_read_all_limits(sensor); 3427 if (rval) 3428 goto out_release_mdata; 3429 3430 rval = ccs_read_frame_fmt(sensor); 3431 if (rval) { 3432 rval = -ENODEV; 3433 goto out_free_ccs_limits; 3434 } 3435 3436 rval = ccs_update_phy_ctrl(sensor); 3437 if (rval < 0) 3438 goto out_free_ccs_limits; 3439 3440 /* 3441 * Handle Sensor Module orientation on the board. 3442 * 3443 * The application of H-FLIP and V-FLIP on the sensor is modified by 3444 * the sensor orientation on the board. 3445 * 3446 * For CCS_BOARD_SENSOR_ORIENT_180 the default behaviour is to set 3447 * both H-FLIP and V-FLIP for normal operation which also implies 3448 * that a set/unset operation for user space HFLIP and VFLIP v4l2 3449 * controls will need to be internally inverted. 3450 * 3451 * Rotation also changes the bayer pattern. 3452 */ 3453 if (sensor->hwcfg.module_board_orient == 3454 CCS_MODULE_BOARD_ORIENT_180) 3455 sensor->hvflip_inv_mask = 3456 CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR | 3457 CCS_IMAGE_ORIENTATION_VERTICAL_FLIP; 3458 3459 rval = ccs_call_quirk(sensor, limits); 3460 if (rval) { 3461 dev_err(&client->dev, "limits quirks failed\n"); 3462 goto out_free_ccs_limits; 3463 } 3464 3465 if (CCS_LIM(sensor, BINNING_CAPABILITY)) { 3466 sensor->nbinning_subtypes = 3467 min_t(u8, CCS_LIM(sensor, BINNING_SUB_TYPES), 3468 CCS_LIM_BINNING_SUB_TYPE_MAX_N); 3469 3470 for (i = 0; i < sensor->nbinning_subtypes; i++) { 3471 sensor->binning_subtypes[i].horizontal = 3472 CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) >> 3473 CCS_BINNING_SUB_TYPE_COLUMN_SHIFT; 3474 sensor->binning_subtypes[i].vertical = 3475 CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) & 3476 CCS_BINNING_SUB_TYPE_ROW_MASK; 3477 3478 dev_dbg(&client->dev, "binning %xx%x\n", 3479 sensor->binning_subtypes[i].horizontal, 3480 sensor->binning_subtypes[i].vertical); 3481 } 3482 } 3483 sensor->binning_horizontal = 1; 3484 sensor->binning_vertical = 1; 3485 3486 if (device_create_file(&client->dev, &dev_attr_ident) != 0) { 3487 dev_err(&client->dev, "sysfs ident entry creation failed\n"); 3488 rval = -ENOENT; 3489 goto out_free_ccs_limits; 3490 } 3491 3492 if (sensor->minfo.smiapp_version && 3493 CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) & 3494 CCS_DATA_TRANSFER_IF_CAPABILITY_SUPPORTED) { 3495 if (device_create_file(&client->dev, &dev_attr_nvm) != 0) { 3496 dev_err(&client->dev, "sysfs nvm entry failed\n"); 3497 rval = -EBUSY; 3498 goto out_cleanup; 3499 } 3500 } 3501 3502 if (!CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV) || 3503 !CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV) || 3504 !CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV) || 3505 !CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV)) { 3506 /* No OP clock branch */ 3507 sensor->pll.flags |= CCS_PLL_FLAG_NO_OP_CLOCKS; 3508 } else if (CCS_LIM(sensor, SCALING_CAPABILITY) 3509 != CCS_SCALING_CAPABILITY_NONE || 3510 CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY) 3511 == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) { 3512 /* We have a scaler or digital crop. */ 3513 sensor->scaler = &sensor->ssds[sensor->ssds_used]; 3514 sensor->ssds_used++; 3515 } 3516 sensor->binner = &sensor->ssds[sensor->ssds_used]; 3517 sensor->ssds_used++; 3518 sensor->pixel_array = &sensor->ssds[sensor->ssds_used]; 3519 sensor->ssds_used++; 3520 3521 sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN); 3522 3523 /* prepare PLL configuration input values */ 3524 sensor->pll.bus_type = CCS_PLL_BUS_TYPE_CSI2_DPHY; 3525 sensor->pll.csi2.lanes = sensor->hwcfg.lanes; 3526 if (CCS_LIM(sensor, CLOCK_CALCULATION) & 3527 CCS_CLOCK_CALCULATION_LANE_SPEED) { 3528 sensor->pll.flags |= CCS_PLL_FLAG_LANE_SPEED_MODEL; 3529 if (CCS_LIM(sensor, CLOCK_CALCULATION) & 3530 CCS_CLOCK_CALCULATION_LINK_DECOUPLED) { 3531 sensor->pll.vt_lanes = 3532 CCS_LIM(sensor, NUM_OF_VT_LANES) + 1; 3533 sensor->pll.op_lanes = 3534 CCS_LIM(sensor, NUM_OF_OP_LANES) + 1; 3535 sensor->pll.flags |= CCS_PLL_FLAG_LINK_DECOUPLED; 3536 } else { 3537 sensor->pll.vt_lanes = sensor->pll.csi2.lanes; 3538 sensor->pll.op_lanes = sensor->pll.csi2.lanes; 3539 } 3540 } 3541 if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) & 3542 CCS_CLOCK_TREE_PLL_CAPABILITY_EXT_DIVIDER) 3543 sensor->pll.flags |= CCS_PLL_FLAG_EXT_IP_PLL_DIVIDER; 3544 if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) & 3545 CCS_CLOCK_TREE_PLL_CAPABILITY_FLEXIBLE_OP_PIX_CLK_DIV) 3546 sensor->pll.flags |= CCS_PLL_FLAG_FLEXIBLE_OP_PIX_CLK_DIV; 3547 if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) & 3548 CCS_FIFO_SUPPORT_CAPABILITY_DERATING) 3549 sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING; 3550 if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) & 3551 CCS_FIFO_SUPPORT_CAPABILITY_DERATING_OVERRATING) 3552 sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING | 3553 CCS_PLL_FLAG_FIFO_OVERRATING; 3554 if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) & 3555 CCS_CLOCK_TREE_PLL_CAPABILITY_DUAL_PLL) { 3556 if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) & 3557 CCS_CLOCK_TREE_PLL_CAPABILITY_SINGLE_PLL) { 3558 u32 v; 3559 3560 /* Use sensor default in PLL mode selection */ 3561 rval = ccs_read(sensor, PLL_MODE, &v); 3562 if (rval) 3563 goto out_cleanup; 3564 3565 if (v == CCS_PLL_MODE_DUAL) 3566 sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL; 3567 } else { 3568 sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL; 3569 } 3570 if (CCS_LIM(sensor, CLOCK_CALCULATION) & 3571 CCS_CLOCK_CALCULATION_DUAL_PLL_OP_SYS_DDR) 3572 sensor->pll.flags |= CCS_PLL_FLAG_OP_SYS_DDR; 3573 if (CCS_LIM(sensor, CLOCK_CALCULATION) & 3574 CCS_CLOCK_CALCULATION_DUAL_PLL_OP_PIX_DDR) 3575 sensor->pll.flags |= CCS_PLL_FLAG_OP_PIX_DDR; 3576 } 3577 sensor->pll.op_bits_per_lane = CCS_LIM(sensor, OP_BITS_PER_LANE); 3578 sensor->pll.ext_clk_freq_hz = sensor->hwcfg.ext_clk; 3579 sensor->pll.scale_n = CCS_LIM(sensor, SCALER_N_MIN); 3580 3581 ccs_create_subdev(sensor, sensor->scaler, " scaler", 2, 3582 MEDIA_ENT_F_PROC_VIDEO_SCALER); 3583 ccs_create_subdev(sensor, sensor->binner, " binner", 2, 3584 MEDIA_ENT_F_PROC_VIDEO_SCALER); 3585 ccs_create_subdev(sensor, sensor->pixel_array, " pixel_array", 1, 3586 MEDIA_ENT_F_CAM_SENSOR); 3587 3588 rval = ccs_init_controls(sensor); 3589 if (rval < 0) 3590 goto out_cleanup; 3591 3592 rval = ccs_call_quirk(sensor, init); 3593 if (rval) 3594 goto out_cleanup; 3595 3596 rval = ccs_get_mbus_formats(sensor); 3597 if (rval) { 3598 rval = -ENODEV; 3599 goto out_cleanup; 3600 } 3601 3602 rval = ccs_init_late_controls(sensor); 3603 if (rval) { 3604 rval = -ENODEV; 3605 goto out_cleanup; 3606 } 3607 3608 mutex_lock(&sensor->mutex); 3609 rval = ccs_pll_blanking_update(sensor); 3610 mutex_unlock(&sensor->mutex); 3611 if (rval) { 3612 dev_err(&client->dev, "update mode failed\n"); 3613 goto out_cleanup; 3614 } 3615 3616 sensor->streaming = false; 3617 sensor->dev_init_done = true; 3618 3619 rval = media_entity_pads_init(&sensor->src->sd.entity, 2, 3620 sensor->src->pads); 3621 if (rval < 0) 3622 goto out_media_entity_cleanup; 3623 3624 rval = ccs_write_msr_regs(sensor); 3625 if (rval) 3626 goto out_media_entity_cleanup; 3627 3628 pm_runtime_set_active(&client->dev); 3629 pm_runtime_get_noresume(&client->dev); 3630 pm_runtime_enable(&client->dev); 3631 3632 rval = v4l2_async_register_subdev_sensor(&sensor->src->sd); 3633 if (rval < 0) 3634 goto out_disable_runtime_pm; 3635 3636 pm_runtime_set_autosuspend_delay(&client->dev, 1000); 3637 pm_runtime_use_autosuspend(&client->dev); 3638 pm_runtime_put_autosuspend(&client->dev); 3639 3640 return 0; 3641 3642 out_disable_runtime_pm: 3643 pm_runtime_put_noidle(&client->dev); 3644 pm_runtime_disable(&client->dev); 3645 3646 out_media_entity_cleanup: 3647 media_entity_cleanup(&sensor->src->sd.entity); 3648 3649 out_cleanup: 3650 ccs_cleanup(sensor); 3651 3652 out_release_mdata: 3653 kvfree(sensor->mdata.backing); 3654 3655 out_release_sdata: 3656 kvfree(sensor->sdata.backing); 3657 3658 out_free_ccs_limits: 3659 kfree(sensor->ccs_limits); 3660 3661 out_power_off: 3662 ccs_power_off(&client->dev); 3663 mutex_destroy(&sensor->mutex); 3664 3665 return rval; 3666 } 3667 3668 static int ccs_remove(struct i2c_client *client) 3669 { 3670 struct v4l2_subdev *subdev = i2c_get_clientdata(client); 3671 struct ccs_sensor *sensor = to_ccs_sensor(subdev); 3672 unsigned int i; 3673 3674 v4l2_async_unregister_subdev(subdev); 3675 3676 pm_runtime_disable(&client->dev); 3677 if (!pm_runtime_status_suspended(&client->dev)) 3678 ccs_power_off(&client->dev); 3679 pm_runtime_set_suspended(&client->dev); 3680 3681 for (i = 0; i < sensor->ssds_used; i++) { 3682 v4l2_device_unregister_subdev(&sensor->ssds[i].sd); 3683 media_entity_cleanup(&sensor->ssds[i].sd.entity); 3684 } 3685 ccs_cleanup(sensor); 3686 mutex_destroy(&sensor->mutex); 3687 kfree(sensor->ccs_limits); 3688 kvfree(sensor->sdata.backing); 3689 kvfree(sensor->mdata.backing); 3690 3691 return 0; 3692 } 3693 3694 static const struct ccs_device smia_device = { 3695 .flags = CCS_DEVICE_FLAG_IS_SMIA, 3696 }; 3697 3698 static const struct ccs_device ccs_device = {}; 3699 3700 static const struct acpi_device_id ccs_acpi_table[] = { 3701 { .id = "MIPI0200", .driver_data = (unsigned long)&ccs_device }, 3702 { }, 3703 }; 3704 MODULE_DEVICE_TABLE(acpi, ccs_acpi_table); 3705 3706 static const struct of_device_id ccs_of_table[] = { 3707 { .compatible = "mipi-ccs-1.1", .data = &ccs_device }, 3708 { .compatible = "mipi-ccs-1.0", .data = &ccs_device }, 3709 { .compatible = "mipi-ccs", .data = &ccs_device }, 3710 { .compatible = "nokia,smia", .data = &smia_device }, 3711 { }, 3712 }; 3713 MODULE_DEVICE_TABLE(of, ccs_of_table); 3714 3715 static const struct dev_pm_ops ccs_pm_ops = { 3716 SET_SYSTEM_SLEEP_PM_OPS(ccs_suspend, ccs_resume) 3717 SET_RUNTIME_PM_OPS(ccs_power_off, ccs_power_on, NULL) 3718 }; 3719 3720 static struct i2c_driver ccs_i2c_driver = { 3721 .driver = { 3722 .acpi_match_table = ccs_acpi_table, 3723 .of_match_table = ccs_of_table, 3724 .name = CCS_NAME, 3725 .pm = &ccs_pm_ops, 3726 }, 3727 .probe_new = ccs_probe, 3728 .remove = ccs_remove, 3729 }; 3730 3731 static int ccs_module_init(void) 3732 { 3733 unsigned int i, l; 3734 3735 for (i = 0, l = 0; ccs_limits[i].size && l < CCS_L_LAST; i++) { 3736 if (!(ccs_limits[i].flags & CCS_L_FL_SAME_REG)) { 3737 ccs_limit_offsets[l + 1].lim = 3738 ALIGN(ccs_limit_offsets[l].lim + 3739 ccs_limits[i].size, 3740 ccs_reg_width(ccs_limits[i + 1].reg)); 3741 ccs_limit_offsets[l].info = i; 3742 l++; 3743 } else { 3744 ccs_limit_offsets[l].lim += ccs_limits[i].size; 3745 } 3746 } 3747 3748 if (WARN_ON(ccs_limits[i].size)) 3749 return -EINVAL; 3750 3751 if (WARN_ON(l != CCS_L_LAST)) 3752 return -EINVAL; 3753 3754 return i2c_register_driver(THIS_MODULE, &ccs_i2c_driver); 3755 } 3756 3757 static void ccs_module_cleanup(void) 3758 { 3759 i2c_del_driver(&ccs_i2c_driver); 3760 } 3761 3762 module_init(ccs_module_init); 3763 module_exit(ccs_module_cleanup); 3764 3765 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>"); 3766 MODULE_DESCRIPTION("Generic MIPI CCS/SMIA/SMIA++ camera sensor driver"); 3767 MODULE_LICENSE("GPL v2"); 3768 MODULE_ALIAS("smiapp"); 3769