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