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