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