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