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