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_enum_mbus_code(struct v4l2_subdev *subdev,
1947                               struct v4l2_subdev_state *sd_state,
1948                               struct v4l2_subdev_mbus_code_enum *code)
1949 {
1950         struct i2c_client *client = v4l2_get_subdevdata(subdev);
1951         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1952         unsigned int i;
1953         int idx = -1;
1954         int rval = -EINVAL;
1955
1956         mutex_lock(&sensor->mutex);
1957
1958         dev_err(&client->dev, "subdev %s, pad %d, index %d\n",
1959                 subdev->name, code->pad, code->index);
1960
1961         if (subdev != &sensor->src->sd || code->pad != CCS_PAD_SRC) {
1962                 if (code->index)
1963                         goto out;
1964
1965                 code->code = sensor->internal_csi_format->code;
1966                 rval = 0;
1967                 goto out;
1968         }
1969
1970         for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
1971                 if (sensor->mbus_frame_fmts & (1 << i))
1972                         idx++;
1973
1974                 if (idx == code->index) {
1975                         code->code = ccs_csi_data_formats[i].code;
1976                         dev_err(&client->dev, "found index %d, i %d, code %x\n",
1977                                 code->index, i, code->code);
1978                         rval = 0;
1979                         break;
1980                 }
1981         }
1982
1983 out:
1984         mutex_unlock(&sensor->mutex);
1985
1986         return rval;
1987 }
1988
1989 static u32 __ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad)
1990 {
1991         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1992
1993         if (subdev == &sensor->src->sd && pad == CCS_PAD_SRC)
1994                 return sensor->csi_format->code;
1995         else
1996                 return sensor->internal_csi_format->code;
1997 }
1998
1999 static int __ccs_get_format(struct v4l2_subdev *subdev,
2000                             struct v4l2_subdev_state *sd_state,
2001                             struct v4l2_subdev_format *fmt)
2002 {
2003         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2004
2005         if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
2006                 fmt->format = *v4l2_subdev_get_try_format(subdev, sd_state,
2007                                                           fmt->pad);
2008         } else {
2009                 struct v4l2_rect *r;
2010
2011                 if (fmt->pad == ssd->source_pad)
2012                         r = &ssd->crop[ssd->source_pad];
2013                 else
2014                         r = &ssd->sink_fmt;
2015
2016                 fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);
2017                 fmt->format.width = r->width;
2018                 fmt->format.height = r->height;
2019                 fmt->format.field = V4L2_FIELD_NONE;
2020         }
2021
2022         return 0;
2023 }
2024
2025 static int ccs_get_format(struct v4l2_subdev *subdev,
2026                           struct v4l2_subdev_state *sd_state,
2027                           struct v4l2_subdev_format *fmt)
2028 {
2029         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2030         int rval;
2031
2032         mutex_lock(&sensor->mutex);
2033         rval = __ccs_get_format(subdev, sd_state, fmt);
2034         mutex_unlock(&sensor->mutex);
2035
2036         return rval;
2037 }
2038
2039 static void ccs_get_crop_compose(struct v4l2_subdev *subdev,
2040                                  struct v4l2_subdev_state *sd_state,
2041                                  struct v4l2_rect **crops,
2042                                  struct v4l2_rect **comps, int which)
2043 {
2044         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2045         unsigned int i;
2046
2047         if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2048                 if (crops)
2049                         for (i = 0; i < subdev->entity.num_pads; i++)
2050                                 crops[i] = &ssd->crop[i];
2051                 if (comps)
2052                         *comps = &ssd->compose;
2053         } else {
2054                 if (crops) {
2055                         for (i = 0; i < subdev->entity.num_pads; i++)
2056                                 crops[i] = v4l2_subdev_get_try_crop(subdev,
2057                                                                     sd_state,
2058                                                                     i);
2059                 }
2060                 if (comps)
2061                         *comps = v4l2_subdev_get_try_compose(subdev, sd_state,
2062                                                              CCS_PAD_SINK);
2063         }
2064 }
2065
2066 /* Changes require propagation only on sink pad. */
2067 static void ccs_propagate(struct v4l2_subdev *subdev,
2068                           struct v4l2_subdev_state *sd_state, int which,
2069                           int target)
2070 {
2071         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2072         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2073         struct v4l2_rect *comp, *crops[CCS_PADS];
2074
2075         ccs_get_crop_compose(subdev, sd_state, crops, &comp, which);
2076
2077         switch (target) {
2078         case V4L2_SEL_TGT_CROP:
2079                 comp->width = crops[CCS_PAD_SINK]->width;
2080                 comp->height = crops[CCS_PAD_SINK]->height;
2081                 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2082                         if (ssd == sensor->scaler) {
2083                                 sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);
2084                                 sensor->scaling_mode =
2085                                         CCS_SCALING_MODE_NO_SCALING;
2086                         } else if (ssd == sensor->binner) {
2087                                 sensor->binning_horizontal = 1;
2088                                 sensor->binning_vertical = 1;
2089                         }
2090                 }
2091                 fallthrough;
2092         case V4L2_SEL_TGT_COMPOSE:
2093                 *crops[CCS_PAD_SRC] = *comp;
2094                 break;
2095         default:
2096                 WARN_ON_ONCE(1);
2097         }
2098 }
2099
2100 static const struct ccs_csi_data_format
2101 *ccs_validate_csi_data_format(struct ccs_sensor *sensor, u32 code)
2102 {
2103         unsigned int i;
2104
2105         for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
2106                 if (sensor->mbus_frame_fmts & (1 << i) &&
2107                     ccs_csi_data_formats[i].code == code)
2108                         return &ccs_csi_data_formats[i];
2109         }
2110
2111         return sensor->csi_format;
2112 }
2113
2114 static int ccs_set_format_source(struct v4l2_subdev *subdev,
2115                                  struct v4l2_subdev_state *sd_state,
2116                                  struct v4l2_subdev_format *fmt)
2117 {
2118         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2119         const struct ccs_csi_data_format *csi_format,
2120                 *old_csi_format = sensor->csi_format;
2121         unsigned long *valid_link_freqs;
2122         u32 code = fmt->format.code;
2123         unsigned int i;
2124         int rval;
2125
2126         rval = __ccs_get_format(subdev, sd_state, fmt);
2127         if (rval)
2128                 return rval;
2129
2130         /*
2131          * Media bus code is changeable on src subdev's source pad. On
2132          * other source pads we just get format here.
2133          */
2134         if (subdev != &sensor->src->sd)
2135                 return 0;
2136
2137         csi_format = ccs_validate_csi_data_format(sensor, code);
2138
2139         fmt->format.code = csi_format->code;
2140
2141         if (fmt->which != V4L2_SUBDEV_FORMAT_ACTIVE)
2142                 return 0;
2143
2144         sensor->csi_format = csi_format;
2145
2146         if (csi_format->width != old_csi_format->width)
2147                 for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
2148                         __v4l2_ctrl_modify_range(
2149                                 sensor->test_data[i], 0,
2150                                 (1 << csi_format->width) - 1, 1, 0);
2151
2152         if (csi_format->compressed == old_csi_format->compressed)
2153                 return 0;
2154
2155         valid_link_freqs =
2156                 &sensor->valid_link_freqs[sensor->csi_format->compressed
2157                                           - sensor->compressed_min_bpp];
2158
2159         __v4l2_ctrl_modify_range(
2160                 sensor->link_freq, 0,
2161                 __fls(*valid_link_freqs), ~*valid_link_freqs,
2162                 __ffs(*valid_link_freqs));
2163
2164         return ccs_pll_update(sensor);
2165 }
2166
2167 static int ccs_set_format(struct v4l2_subdev *subdev,
2168                           struct v4l2_subdev_state *sd_state,
2169                           struct v4l2_subdev_format *fmt)
2170 {
2171         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2172         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2173         struct v4l2_rect *crops[CCS_PADS];
2174
2175         mutex_lock(&sensor->mutex);
2176
2177         if (fmt->pad == ssd->source_pad) {
2178                 int rval;
2179
2180                 rval = ccs_set_format_source(subdev, sd_state, fmt);
2181
2182                 mutex_unlock(&sensor->mutex);
2183
2184                 return rval;
2185         }
2186
2187         /* Sink pad. Width and height are changeable here. */
2188         fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);
2189         fmt->format.width &= ~1;
2190         fmt->format.height &= ~1;
2191         fmt->format.field = V4L2_FIELD_NONE;
2192
2193         fmt->format.width =
2194                 clamp(fmt->format.width,
2195                       CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),
2196                       CCS_LIM(sensor, MAX_X_OUTPUT_SIZE));
2197         fmt->format.height =
2198                 clamp(fmt->format.height,
2199                       CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),
2200                       CCS_LIM(sensor, MAX_Y_OUTPUT_SIZE));
2201
2202         ccs_get_crop_compose(subdev, sd_state, crops, NULL, fmt->which);
2203
2204         crops[ssd->sink_pad]->left = 0;
2205         crops[ssd->sink_pad]->top = 0;
2206         crops[ssd->sink_pad]->width = fmt->format.width;
2207         crops[ssd->sink_pad]->height = fmt->format.height;
2208         if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE)
2209                 ssd->sink_fmt = *crops[ssd->sink_pad];
2210         ccs_propagate(subdev, sd_state, fmt->which, V4L2_SEL_TGT_CROP);
2211
2212         mutex_unlock(&sensor->mutex);
2213
2214         return 0;
2215 }
2216
2217 /*
2218  * Calculate goodness of scaled image size compared to expected image
2219  * size and flags provided.
2220  */
2221 #define SCALING_GOODNESS                100000
2222 #define SCALING_GOODNESS_EXTREME        100000000
2223 static int scaling_goodness(struct v4l2_subdev *subdev, int w, int ask_w,
2224                             int h, int ask_h, u32 flags)
2225 {
2226         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2227         struct i2c_client *client = v4l2_get_subdevdata(subdev);
2228         int val = 0;
2229
2230         w &= ~1;
2231         ask_w &= ~1;
2232         h &= ~1;
2233         ask_h &= ~1;
2234
2235         if (flags & V4L2_SEL_FLAG_GE) {
2236                 if (w < ask_w)
2237                         val -= SCALING_GOODNESS;
2238                 if (h < ask_h)
2239                         val -= SCALING_GOODNESS;
2240         }
2241
2242         if (flags & V4L2_SEL_FLAG_LE) {
2243                 if (w > ask_w)
2244                         val -= SCALING_GOODNESS;
2245                 if (h > ask_h)
2246                         val -= SCALING_GOODNESS;
2247         }
2248
2249         val -= abs(w - ask_w);
2250         val -= abs(h - ask_h);
2251
2252         if (w < CCS_LIM(sensor, MIN_X_OUTPUT_SIZE))
2253                 val -= SCALING_GOODNESS_EXTREME;
2254
2255         dev_dbg(&client->dev, "w %d ask_w %d h %d ask_h %d goodness %d\n",
2256                 w, ask_w, h, ask_h, val);
2257
2258         return val;
2259 }
2260
2261 static void ccs_set_compose_binner(struct v4l2_subdev *subdev,
2262                                    struct v4l2_subdev_state *sd_state,
2263                                    struct v4l2_subdev_selection *sel,
2264                                    struct v4l2_rect **crops,
2265                                    struct v4l2_rect *comp)
2266 {
2267         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2268         unsigned int i;
2269         unsigned int binh = 1, binv = 1;
2270         int best = scaling_goodness(
2271                 subdev,
2272                 crops[CCS_PAD_SINK]->width, sel->r.width,
2273                 crops[CCS_PAD_SINK]->height, sel->r.height, sel->flags);
2274
2275         for (i = 0; i < sensor->nbinning_subtypes; i++) {
2276                 int this = scaling_goodness(
2277                         subdev,
2278                         crops[CCS_PAD_SINK]->width
2279                         / sensor->binning_subtypes[i].horizontal,
2280                         sel->r.width,
2281                         crops[CCS_PAD_SINK]->height
2282                         / sensor->binning_subtypes[i].vertical,
2283                         sel->r.height, sel->flags);
2284
2285                 if (this > best) {
2286                         binh = sensor->binning_subtypes[i].horizontal;
2287                         binv = sensor->binning_subtypes[i].vertical;
2288                         best = this;
2289                 }
2290         }
2291         if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2292                 sensor->binning_vertical = binv;
2293                 sensor->binning_horizontal = binh;
2294         }
2295
2296         sel->r.width = (crops[CCS_PAD_SINK]->width / binh) & ~1;
2297         sel->r.height = (crops[CCS_PAD_SINK]->height / binv) & ~1;
2298 }
2299
2300 /*
2301  * Calculate best scaling ratio and mode for given output resolution.
2302  *
2303  * Try all of these: horizontal ratio, vertical ratio and smallest
2304  * size possible (horizontally).
2305  *
2306  * Also try whether horizontal scaler or full scaler gives a better
2307  * result.
2308  */
2309 static void ccs_set_compose_scaler(struct v4l2_subdev *subdev,
2310                                    struct v4l2_subdev_state *sd_state,
2311                                    struct v4l2_subdev_selection *sel,
2312                                    struct v4l2_rect **crops,
2313                                    struct v4l2_rect *comp)
2314 {
2315         struct i2c_client *client = v4l2_get_subdevdata(subdev);
2316         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2317         u32 min, max, a, b, max_m;
2318         u32 scale_m = CCS_LIM(sensor, SCALER_N_MIN);
2319         int mode = CCS_SCALING_MODE_HORIZONTAL;
2320         u32 try[4];
2321         u32 ntry = 0;
2322         unsigned int i;
2323         int best = INT_MIN;
2324
2325         sel->r.width = min_t(unsigned int, sel->r.width,
2326                              crops[CCS_PAD_SINK]->width);
2327         sel->r.height = min_t(unsigned int, sel->r.height,
2328                               crops[CCS_PAD_SINK]->height);
2329
2330         a = crops[CCS_PAD_SINK]->width
2331                 * CCS_LIM(sensor, SCALER_N_MIN) / sel->r.width;
2332         b = crops[CCS_PAD_SINK]->height
2333                 * CCS_LIM(sensor, SCALER_N_MIN) / sel->r.height;
2334         max_m = crops[CCS_PAD_SINK]->width
2335                 * CCS_LIM(sensor, SCALER_N_MIN)
2336                 / CCS_LIM(sensor, MIN_X_OUTPUT_SIZE);
2337
2338         a = clamp(a, CCS_LIM(sensor, SCALER_M_MIN),
2339                   CCS_LIM(sensor, SCALER_M_MAX));
2340         b = clamp(b, CCS_LIM(sensor, SCALER_M_MIN),
2341                   CCS_LIM(sensor, SCALER_M_MAX));
2342         max_m = clamp(max_m, CCS_LIM(sensor, SCALER_M_MIN),
2343                       CCS_LIM(sensor, SCALER_M_MAX));
2344
2345         dev_dbg(&client->dev, "scaling: a %d b %d max_m %d\n", a, b, max_m);
2346
2347         min = min(max_m, min(a, b));
2348         max = min(max_m, max(a, b));
2349
2350         try[ntry] = min;
2351         ntry++;
2352         if (min != max) {
2353                 try[ntry] = max;
2354                 ntry++;
2355         }
2356         if (max != max_m) {
2357                 try[ntry] = min + 1;
2358                 ntry++;
2359                 if (min != max) {
2360                         try[ntry] = max + 1;
2361                         ntry++;
2362                 }
2363         }
2364
2365         for (i = 0; i < ntry; i++) {
2366                 int this = scaling_goodness(
2367                         subdev,
2368                         crops[CCS_PAD_SINK]->width
2369                         / try[i] * CCS_LIM(sensor, SCALER_N_MIN),
2370                         sel->r.width,
2371                         crops[CCS_PAD_SINK]->height,
2372                         sel->r.height,
2373                         sel->flags);
2374
2375                 dev_dbg(&client->dev, "trying factor %d (%d)\n", try[i], i);
2376
2377                 if (this > best) {
2378                         scale_m = try[i];
2379                         mode = CCS_SCALING_MODE_HORIZONTAL;
2380                         best = this;
2381                 }
2382
2383                 if (CCS_LIM(sensor, SCALING_CAPABILITY)
2384                     == CCS_SCALING_CAPABILITY_HORIZONTAL)
2385                         continue;
2386
2387                 this = scaling_goodness(
2388                         subdev, crops[CCS_PAD_SINK]->width
2389                         / try[i]
2390                         * CCS_LIM(sensor, SCALER_N_MIN),
2391                         sel->r.width,
2392                         crops[CCS_PAD_SINK]->height
2393                         / try[i]
2394                         * CCS_LIM(sensor, SCALER_N_MIN),
2395                         sel->r.height,
2396                         sel->flags);
2397
2398                 if (this > best) {
2399                         scale_m = try[i];
2400                         mode = SMIAPP_SCALING_MODE_BOTH;
2401                         best = this;
2402                 }
2403         }
2404
2405         sel->r.width =
2406                 (crops[CCS_PAD_SINK]->width
2407                  / scale_m
2408                  * CCS_LIM(sensor, SCALER_N_MIN)) & ~1;
2409         if (mode == SMIAPP_SCALING_MODE_BOTH)
2410                 sel->r.height =
2411                         (crops[CCS_PAD_SINK]->height
2412                          / scale_m
2413                          * CCS_LIM(sensor, SCALER_N_MIN))
2414                         & ~1;
2415         else
2416                 sel->r.height = crops[CCS_PAD_SINK]->height;
2417
2418         if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2419                 sensor->scale_m = scale_m;
2420                 sensor->scaling_mode = mode;
2421         }
2422 }
2423 /* We're only called on source pads. This function sets scaling. */
2424 static int ccs_set_compose(struct v4l2_subdev *subdev,
2425                            struct v4l2_subdev_state *sd_state,
2426                            struct v4l2_subdev_selection *sel)
2427 {
2428         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2429         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2430         struct v4l2_rect *comp, *crops[CCS_PADS];
2431
2432         ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which);
2433
2434         sel->r.top = 0;
2435         sel->r.left = 0;
2436
2437         if (ssd == sensor->binner)
2438                 ccs_set_compose_binner(subdev, sd_state, sel, crops, comp);
2439         else
2440                 ccs_set_compose_scaler(subdev, sd_state, sel, crops, comp);
2441
2442         *comp = sel->r;
2443         ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_COMPOSE);
2444
2445         if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE)
2446                 return ccs_pll_blanking_update(sensor);
2447
2448         return 0;
2449 }
2450
2451 static int __ccs_sel_supported(struct v4l2_subdev *subdev,
2452                                struct v4l2_subdev_selection *sel)
2453 {
2454         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2455         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2456
2457         /* We only implement crop in three places. */
2458         switch (sel->target) {
2459         case V4L2_SEL_TGT_CROP:
2460         case V4L2_SEL_TGT_CROP_BOUNDS:
2461                 if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC)
2462                         return 0;
2463                 if (ssd == sensor->src && sel->pad == CCS_PAD_SRC)
2464                         return 0;
2465                 if (ssd == sensor->scaler && sel->pad == CCS_PAD_SINK &&
2466                     CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
2467                     == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP)
2468                         return 0;
2469                 return -EINVAL;
2470         case V4L2_SEL_TGT_NATIVE_SIZE:
2471                 if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC)
2472                         return 0;
2473                 return -EINVAL;
2474         case V4L2_SEL_TGT_COMPOSE:
2475         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2476                 if (sel->pad == ssd->source_pad)
2477                         return -EINVAL;
2478                 if (ssd == sensor->binner)
2479                         return 0;
2480                 if (ssd == sensor->scaler && CCS_LIM(sensor, SCALING_CAPABILITY)
2481                     != CCS_SCALING_CAPABILITY_NONE)
2482                         return 0;
2483                 fallthrough;
2484         default:
2485                 return -EINVAL;
2486         }
2487 }
2488
2489 static int ccs_set_crop(struct v4l2_subdev *subdev,
2490                         struct v4l2_subdev_state *sd_state,
2491                         struct v4l2_subdev_selection *sel)
2492 {
2493         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2494         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2495         struct v4l2_rect *src_size, *crops[CCS_PADS];
2496         struct v4l2_rect _r;
2497
2498         ccs_get_crop_compose(subdev, sd_state, crops, NULL, sel->which);
2499
2500         if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2501                 if (sel->pad == ssd->sink_pad)
2502                         src_size = &ssd->sink_fmt;
2503                 else
2504                         src_size = &ssd->compose;
2505         } else {
2506                 if (sel->pad == ssd->sink_pad) {
2507                         _r.left = 0;
2508                         _r.top = 0;
2509                         _r.width = v4l2_subdev_get_try_format(subdev,
2510                                                               sd_state,
2511                                                               sel->pad)
2512                                 ->width;
2513                         _r.height = v4l2_subdev_get_try_format(subdev,
2514                                                                sd_state,
2515                                                                sel->pad)
2516                                 ->height;
2517                         src_size = &_r;
2518                 } else {
2519                         src_size = v4l2_subdev_get_try_compose(
2520                                 subdev, sd_state, ssd->sink_pad);
2521                 }
2522         }
2523
2524         if (ssd == sensor->src && sel->pad == CCS_PAD_SRC) {
2525                 sel->r.left = 0;
2526                 sel->r.top = 0;
2527         }
2528
2529         sel->r.width = min(sel->r.width, src_size->width);
2530         sel->r.height = min(sel->r.height, src_size->height);
2531
2532         sel->r.left = min_t(int, sel->r.left, src_size->width - sel->r.width);
2533         sel->r.top = min_t(int, sel->r.top, src_size->height - sel->r.height);
2534
2535         *crops[sel->pad] = sel->r;
2536
2537         if (ssd != sensor->pixel_array && sel->pad == CCS_PAD_SINK)
2538                 ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_CROP);
2539
2540         return 0;
2541 }
2542
2543 static void ccs_get_native_size(struct ccs_subdev *ssd, struct v4l2_rect *r)
2544 {
2545         r->top = 0;
2546         r->left = 0;
2547         r->width = CCS_LIM(ssd->sensor, X_ADDR_MAX) + 1;
2548         r->height = CCS_LIM(ssd->sensor, Y_ADDR_MAX) + 1;
2549 }
2550
2551 static int __ccs_get_selection(struct v4l2_subdev *subdev,
2552                                struct v4l2_subdev_state *sd_state,
2553                                struct v4l2_subdev_selection *sel)
2554 {
2555         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2556         struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2557         struct v4l2_rect *comp, *crops[CCS_PADS];
2558         struct v4l2_rect sink_fmt;
2559         int ret;
2560
2561         ret = __ccs_sel_supported(subdev, sel);
2562         if (ret)
2563                 return ret;
2564
2565         ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which);
2566
2567         if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2568                 sink_fmt = ssd->sink_fmt;
2569         } else {
2570                 struct v4l2_mbus_framefmt *fmt =
2571                         v4l2_subdev_get_try_format(subdev, sd_state,
2572                                                    ssd->sink_pad);
2573
2574                 sink_fmt.left = 0;
2575                 sink_fmt.top = 0;
2576                 sink_fmt.width = fmt->width;
2577                 sink_fmt.height = fmt->height;
2578         }
2579
2580         switch (sel->target) {
2581         case V4L2_SEL_TGT_CROP_BOUNDS:
2582         case V4L2_SEL_TGT_NATIVE_SIZE:
2583                 if (ssd == sensor->pixel_array)
2584                         ccs_get_native_size(ssd, &sel->r);
2585                 else if (sel->pad == ssd->sink_pad)
2586                         sel->r = sink_fmt;
2587                 else
2588                         sel->r = *comp;
2589                 break;
2590         case V4L2_SEL_TGT_CROP:
2591         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2592                 sel->r = *crops[sel->pad];
2593                 break;
2594         case V4L2_SEL_TGT_COMPOSE:
2595                 sel->r = *comp;
2596                 break;
2597         }
2598
2599         return 0;
2600 }
2601
2602 static int ccs_get_selection(struct v4l2_subdev *subdev,
2603                              struct v4l2_subdev_state *sd_state,
2604                              struct v4l2_subdev_selection *sel)
2605 {
2606         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2607         int rval;
2608
2609         mutex_lock(&sensor->mutex);
2610         rval = __ccs_get_selection(subdev, sd_state, sel);
2611         mutex_unlock(&sensor->mutex);
2612
2613         return rval;
2614 }
2615
2616 static int ccs_set_selection(struct v4l2_subdev *subdev,
2617                              struct v4l2_subdev_state *sd_state,
2618                              struct v4l2_subdev_selection *sel)
2619 {
2620         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2621         int ret;
2622
2623         ret = __ccs_sel_supported(subdev, sel);
2624         if (ret)
2625                 return ret;
2626
2627         mutex_lock(&sensor->mutex);
2628
2629         sel->r.left = max(0, sel->r.left & ~1);
2630         sel->r.top = max(0, sel->r.top & ~1);
2631         sel->r.width = CCS_ALIGN_DIM(sel->r.width, sel->flags);
2632         sel->r.height = CCS_ALIGN_DIM(sel->r.height, sel->flags);
2633
2634         sel->r.width = max_t(unsigned int, CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),
2635                              sel->r.width);
2636         sel->r.height = max_t(unsigned int, CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),
2637                               sel->r.height);
2638
2639         switch (sel->target) {
2640         case V4L2_SEL_TGT_CROP:
2641                 ret = ccs_set_crop(subdev, sd_state, sel);
2642                 break;
2643         case V4L2_SEL_TGT_COMPOSE:
2644                 ret = ccs_set_compose(subdev, sd_state, sel);
2645                 break;
2646         default:
2647                 ret = -EINVAL;
2648         }
2649
2650         mutex_unlock(&sensor->mutex);
2651         return ret;
2652 }
2653
2654 static int ccs_get_skip_frames(struct v4l2_subdev *subdev, u32 *frames)
2655 {
2656         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2657
2658         *frames = sensor->frame_skip;
2659         return 0;
2660 }
2661
2662 static int ccs_get_skip_top_lines(struct v4l2_subdev *subdev, u32 *lines)
2663 {
2664         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2665
2666         *lines = sensor->image_start;
2667
2668         return 0;
2669 }
2670
2671 /* -----------------------------------------------------------------------------
2672  * sysfs attributes
2673  */
2674
2675 static ssize_t
2676 ccs_sysfs_nvm_read(struct device *dev, struct device_attribute *attr,
2677                    char *buf)
2678 {
2679         struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2680         struct i2c_client *client = v4l2_get_subdevdata(subdev);
2681         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2682         int rval;
2683
2684         if (!sensor->dev_init_done)
2685                 return -EBUSY;
2686
2687         rval = ccs_pm_get_init(sensor);
2688         if (rval < 0)
2689                 return -ENODEV;
2690
2691         rval = ccs_read_nvm(sensor, buf, PAGE_SIZE);
2692         if (rval < 0) {
2693                 pm_runtime_put(&client->dev);
2694                 dev_err(&client->dev, "nvm read failed\n");
2695                 return -ENODEV;
2696         }
2697
2698         pm_runtime_mark_last_busy(&client->dev);
2699         pm_runtime_put_autosuspend(&client->dev);
2700
2701         /*
2702          * NVM is still way below a PAGE_SIZE, so we can safely
2703          * assume this for now.
2704          */
2705         return rval;
2706 }
2707 static DEVICE_ATTR(nvm, S_IRUGO, ccs_sysfs_nvm_read, NULL);
2708
2709 static ssize_t
2710 ccs_sysfs_ident_read(struct device *dev, struct device_attribute *attr,
2711                      char *buf)
2712 {
2713         struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2714         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2715         struct ccs_module_info *minfo = &sensor->minfo;
2716
2717         if (minfo->mipi_manufacturer_id)
2718                 return snprintf(buf, PAGE_SIZE, "%4.4x%4.4x%2.2x\n",
2719                                 minfo->mipi_manufacturer_id, minfo->model_id,
2720                                 minfo->revision_number) + 1;
2721         else
2722                 return snprintf(buf, PAGE_SIZE, "%2.2x%4.4x%2.2x\n",
2723                                 minfo->smia_manufacturer_id, minfo->model_id,
2724                                 minfo->revision_number) + 1;
2725 }
2726
2727 static DEVICE_ATTR(ident, S_IRUGO, ccs_sysfs_ident_read, NULL);
2728
2729 /* -----------------------------------------------------------------------------
2730  * V4L2 subdev core operations
2731  */
2732
2733 static int ccs_identify_module(struct ccs_sensor *sensor)
2734 {
2735         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2736         struct ccs_module_info *minfo = &sensor->minfo;
2737         unsigned int i;
2738         u32 rev;
2739         int rval = 0;
2740
2741         /* Module info */
2742         rval = ccs_read(sensor, MODULE_MANUFACTURER_ID,
2743                         &minfo->mipi_manufacturer_id);
2744         if (!rval && !minfo->mipi_manufacturer_id)
2745                 rval = ccs_read_addr_8only(sensor,
2746                                            SMIAPP_REG_U8_MANUFACTURER_ID,
2747                                            &minfo->smia_manufacturer_id);
2748         if (!rval)
2749                 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_MODEL_ID,
2750                                            &minfo->model_id);
2751         if (!rval)
2752                 rval = ccs_read_addr_8only(sensor,
2753                                            CCS_R_MODULE_REVISION_NUMBER_MAJOR,
2754                                            &rev);
2755         if (!rval) {
2756                 rval = ccs_read_addr_8only(sensor,
2757                                            CCS_R_MODULE_REVISION_NUMBER_MINOR,
2758                                            &minfo->revision_number);
2759                 minfo->revision_number |= rev << 8;
2760         }
2761         if (!rval)
2762                 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_YEAR,
2763                                            &minfo->module_year);
2764         if (!rval)
2765                 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_MONTH,
2766                                            &minfo->module_month);
2767         if (!rval)
2768                 rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_DAY,
2769                                            &minfo->module_day);
2770
2771         /* Sensor info */
2772         if (!rval)
2773                 rval = ccs_read(sensor, SENSOR_MANUFACTURER_ID,
2774                                 &minfo->sensor_mipi_manufacturer_id);
2775         if (!rval && !minfo->sensor_mipi_manufacturer_id)
2776                 rval = ccs_read_addr_8only(sensor,
2777                                            CCS_R_SENSOR_MANUFACTURER_ID,
2778                                            &minfo->sensor_smia_manufacturer_id);
2779         if (!rval)
2780                 rval = ccs_read_addr_8only(sensor,
2781                                            CCS_R_SENSOR_MODEL_ID,
2782                                            &minfo->sensor_model_id);
2783         if (!rval)
2784                 rval = ccs_read_addr_8only(sensor,
2785                                            CCS_R_SENSOR_REVISION_NUMBER,
2786                                            &minfo->sensor_revision_number);
2787         if (!rval)
2788                 rval = ccs_read_addr_8only(sensor,
2789                                            CCS_R_SENSOR_FIRMWARE_VERSION,
2790                                            &minfo->sensor_firmware_version);
2791
2792         /* SMIA */
2793         if (!rval)
2794                 rval = ccs_read(sensor, MIPI_CCS_VERSION, &minfo->ccs_version);
2795         if (!rval && !minfo->ccs_version)
2796                 rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIA_VERSION,
2797                                            &minfo->smia_version);
2798         if (!rval && !minfo->ccs_version)
2799                 rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIAPP_VERSION,
2800                                            &minfo->smiapp_version);
2801
2802         if (rval) {
2803                 dev_err(&client->dev, "sensor detection failed\n");
2804                 return -ENODEV;
2805         }
2806
2807         if (minfo->mipi_manufacturer_id)
2808                 dev_dbg(&client->dev, "MIPI CCS module 0x%4.4x-0x%4.4x\n",
2809                         minfo->mipi_manufacturer_id, minfo->model_id);
2810         else
2811                 dev_dbg(&client->dev, "SMIA module 0x%2.2x-0x%4.4x\n",
2812                         minfo->smia_manufacturer_id, minfo->model_id);
2813
2814         dev_dbg(&client->dev,
2815                 "module revision 0x%4.4x date %2.2d-%2.2d-%2.2d\n",
2816                 minfo->revision_number, minfo->module_year, minfo->module_month,
2817                 minfo->module_day);
2818
2819         if (minfo->sensor_mipi_manufacturer_id)
2820                 dev_dbg(&client->dev, "MIPI CCS sensor 0x%4.4x-0x%4.4x\n",
2821                         minfo->sensor_mipi_manufacturer_id,
2822                         minfo->sensor_model_id);
2823         else
2824                 dev_dbg(&client->dev, "SMIA sensor 0x%2.2x-0x%4.4x\n",
2825                         minfo->sensor_smia_manufacturer_id,
2826                         minfo->sensor_model_id);
2827
2828         dev_dbg(&client->dev,
2829                 "sensor revision 0x%2.2x firmware version 0x%2.2x\n",
2830                 minfo->sensor_revision_number, minfo->sensor_firmware_version);
2831
2832         if (minfo->ccs_version) {
2833                 dev_dbg(&client->dev, "MIPI CCS version %u.%u",
2834                         (minfo->ccs_version & CCS_MIPI_CCS_VERSION_MAJOR_MASK)
2835                         >> CCS_MIPI_CCS_VERSION_MAJOR_SHIFT,
2836                         (minfo->ccs_version & CCS_MIPI_CCS_VERSION_MINOR_MASK));
2837                 minfo->name = CCS_NAME;
2838         } else {
2839                 dev_dbg(&client->dev,
2840                         "smia version %2.2d smiapp version %2.2d\n",
2841                         minfo->smia_version, minfo->smiapp_version);
2842                 minfo->name = SMIAPP_NAME;
2843         }
2844
2845         /*
2846          * Some modules have bad data in the lvalues below. Hope the
2847          * rvalues have better stuff. The lvalues are module
2848          * parameters whereas the rvalues are sensor parameters.
2849          */
2850         if (minfo->sensor_smia_manufacturer_id &&
2851             !minfo->smia_manufacturer_id && !minfo->model_id) {
2852                 minfo->smia_manufacturer_id =
2853                         minfo->sensor_smia_manufacturer_id;
2854                 minfo->model_id = minfo->sensor_model_id;
2855                 minfo->revision_number = minfo->sensor_revision_number;
2856         }
2857
2858         for (i = 0; i < ARRAY_SIZE(ccs_module_idents); i++) {
2859                 if (ccs_module_idents[i].mipi_manufacturer_id &&
2860                     ccs_module_idents[i].mipi_manufacturer_id
2861                     != minfo->mipi_manufacturer_id)
2862                         continue;
2863                 if (ccs_module_idents[i].smia_manufacturer_id &&
2864                     ccs_module_idents[i].smia_manufacturer_id
2865                     != minfo->smia_manufacturer_id)
2866                         continue;
2867                 if (ccs_module_idents[i].model_id != minfo->model_id)
2868                         continue;
2869                 if (ccs_module_idents[i].flags
2870                     & CCS_MODULE_IDENT_FLAG_REV_LE) {
2871                         if (ccs_module_idents[i].revision_number_major
2872                             < (minfo->revision_number >> 8))
2873                                 continue;
2874                 } else {
2875                         if (ccs_module_idents[i].revision_number_major
2876                             != (minfo->revision_number >> 8))
2877                                 continue;
2878                 }
2879
2880                 minfo->name = ccs_module_idents[i].name;
2881                 minfo->quirk = ccs_module_idents[i].quirk;
2882                 break;
2883         }
2884
2885         if (i >= ARRAY_SIZE(ccs_module_idents))
2886                 dev_warn(&client->dev,
2887                          "no quirks for this module; let's hope it's fully compliant\n");
2888
2889         dev_dbg(&client->dev, "the sensor is called %s\n", minfo->name);
2890
2891         return 0;
2892 }
2893
2894 static const struct v4l2_subdev_ops ccs_ops;
2895 static const struct v4l2_subdev_internal_ops ccs_internal_ops;
2896 static const struct media_entity_operations ccs_entity_ops;
2897
2898 static int ccs_register_subdev(struct ccs_sensor *sensor,
2899                                struct ccs_subdev *ssd,
2900                                struct ccs_subdev *sink_ssd,
2901                                u16 source_pad, u16 sink_pad, u32 link_flags)
2902 {
2903         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2904         int rval;
2905
2906         if (!sink_ssd)
2907                 return 0;
2908
2909         rval = media_entity_pads_init(&ssd->sd.entity, ssd->npads, ssd->pads);
2910         if (rval) {
2911                 dev_err(&client->dev, "media_entity_pads_init failed\n");
2912                 return rval;
2913         }
2914
2915         rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev, &ssd->sd);
2916         if (rval) {
2917                 dev_err(&client->dev, "v4l2_device_register_subdev failed\n");
2918                 return rval;
2919         }
2920
2921         rval = media_create_pad_link(&ssd->sd.entity, source_pad,
2922                                      &sink_ssd->sd.entity, sink_pad,
2923                                      link_flags);
2924         if (rval) {
2925                 dev_err(&client->dev, "media_create_pad_link failed\n");
2926                 v4l2_device_unregister_subdev(&ssd->sd);
2927                 return rval;
2928         }
2929
2930         return 0;
2931 }
2932
2933 static void ccs_unregistered(struct v4l2_subdev *subdev)
2934 {
2935         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2936         unsigned int i;
2937
2938         for (i = 1; i < sensor->ssds_used; i++)
2939                 v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
2940 }
2941
2942 static int ccs_registered(struct v4l2_subdev *subdev)
2943 {
2944         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2945         int rval;
2946
2947         if (sensor->scaler) {
2948                 rval = ccs_register_subdev(sensor, sensor->binner,
2949                                            sensor->scaler,
2950                                            CCS_PAD_SRC, CCS_PAD_SINK,
2951                                            MEDIA_LNK_FL_ENABLED |
2952                                            MEDIA_LNK_FL_IMMUTABLE);
2953                 if (rval < 0)
2954                         return rval;
2955         }
2956
2957         rval = ccs_register_subdev(sensor, sensor->pixel_array, sensor->binner,
2958                                    CCS_PA_PAD_SRC, CCS_PAD_SINK,
2959                                    MEDIA_LNK_FL_ENABLED |
2960                                    MEDIA_LNK_FL_IMMUTABLE);
2961         if (rval)
2962                 goto out_err;
2963
2964         return 0;
2965
2966 out_err:
2967         ccs_unregistered(subdev);
2968
2969         return rval;
2970 }
2971
2972 static void ccs_cleanup(struct ccs_sensor *sensor)
2973 {
2974         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2975
2976         device_remove_file(&client->dev, &dev_attr_nvm);
2977         device_remove_file(&client->dev, &dev_attr_ident);
2978
2979         ccs_free_controls(sensor);
2980 }
2981
2982 static void ccs_create_subdev(struct ccs_sensor *sensor,
2983                               struct ccs_subdev *ssd, const char *name,
2984                               unsigned short num_pads, u32 function)
2985 {
2986         struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2987
2988         if (!ssd)
2989                 return;
2990
2991         if (ssd != sensor->src)
2992                 v4l2_subdev_init(&ssd->sd, &ccs_ops);
2993
2994         ssd->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
2995         ssd->sd.entity.function = function;
2996         ssd->sensor = sensor;
2997
2998         ssd->npads = num_pads;
2999         ssd->source_pad = num_pads - 1;
3000
3001         v4l2_i2c_subdev_set_name(&ssd->sd, client, sensor->minfo.name, name);
3002
3003         ccs_get_native_size(ssd, &ssd->sink_fmt);
3004
3005         ssd->compose.width = ssd->sink_fmt.width;
3006         ssd->compose.height = ssd->sink_fmt.height;
3007         ssd->crop[ssd->source_pad] = ssd->compose;
3008         ssd->pads[ssd->source_pad].flags = MEDIA_PAD_FL_SOURCE;
3009         if (ssd != sensor->pixel_array) {
3010                 ssd->crop[ssd->sink_pad] = ssd->compose;
3011                 ssd->pads[ssd->sink_pad].flags = MEDIA_PAD_FL_SINK;
3012         }
3013
3014         ssd->sd.entity.ops = &ccs_entity_ops;
3015
3016         if (ssd == sensor->src)
3017                 return;
3018
3019         ssd->sd.internal_ops = &ccs_internal_ops;
3020         ssd->sd.owner = THIS_MODULE;
3021         ssd->sd.dev = &client->dev;
3022         v4l2_set_subdevdata(&ssd->sd, client);
3023 }
3024
3025 static int ccs_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
3026 {
3027         struct ccs_subdev *ssd = to_ccs_subdev(sd);
3028         struct ccs_sensor *sensor = ssd->sensor;
3029         unsigned int i;
3030
3031         mutex_lock(&sensor->mutex);
3032
3033         for (i = 0; i < ssd->npads; i++) {
3034                 struct v4l2_mbus_framefmt *try_fmt =
3035                         v4l2_subdev_get_try_format(sd, fh->state, i);
3036                 struct v4l2_rect *try_crop =
3037                         v4l2_subdev_get_try_crop(sd, fh->state, i);
3038                 struct v4l2_rect *try_comp;
3039
3040                 ccs_get_native_size(ssd, try_crop);
3041
3042                 try_fmt->width = try_crop->width;
3043                 try_fmt->height = try_crop->height;
3044                 try_fmt->code = sensor->internal_csi_format->code;
3045                 try_fmt->field = V4L2_FIELD_NONE;
3046
3047                 if (ssd != sensor->pixel_array)
3048                         continue;
3049
3050                 try_comp = v4l2_subdev_get_try_compose(sd, fh->state, i);
3051                 *try_comp = *try_crop;
3052         }
3053
3054         mutex_unlock(&sensor->mutex);
3055
3056         return 0;
3057 }
3058
3059 static const struct v4l2_subdev_video_ops ccs_video_ops = {
3060         .s_stream = ccs_set_stream,
3061 };
3062
3063 static const struct v4l2_subdev_pad_ops ccs_pad_ops = {
3064         .enum_mbus_code = ccs_enum_mbus_code,
3065         .get_fmt = ccs_get_format,
3066         .set_fmt = ccs_set_format,
3067         .get_selection = ccs_get_selection,
3068         .set_selection = ccs_set_selection,
3069 };
3070
3071 static const struct v4l2_subdev_sensor_ops ccs_sensor_ops = {
3072         .g_skip_frames = ccs_get_skip_frames,
3073         .g_skip_top_lines = ccs_get_skip_top_lines,
3074 };
3075
3076 static const struct v4l2_subdev_ops ccs_ops = {
3077         .video = &ccs_video_ops,
3078         .pad = &ccs_pad_ops,
3079         .sensor = &ccs_sensor_ops,
3080 };
3081
3082 static const struct media_entity_operations ccs_entity_ops = {
3083         .link_validate = v4l2_subdev_link_validate,
3084 };
3085
3086 static const struct v4l2_subdev_internal_ops ccs_internal_src_ops = {
3087         .registered = ccs_registered,
3088         .unregistered = ccs_unregistered,
3089         .open = ccs_open,
3090 };
3091
3092 static const struct v4l2_subdev_internal_ops ccs_internal_ops = {
3093         .open = ccs_open,
3094 };
3095
3096 /* -----------------------------------------------------------------------------
3097  * I2C Driver
3098  */
3099
3100 static int __maybe_unused ccs_suspend(struct device *dev)
3101 {
3102         struct i2c_client *client = to_i2c_client(dev);
3103         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3104         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3105         bool streaming = sensor->streaming;
3106         int rval;
3107
3108         rval = pm_runtime_resume_and_get(dev);
3109         if (rval < 0)
3110                 return rval;
3111
3112         if (sensor->streaming)
3113                 ccs_stop_streaming(sensor);
3114
3115         /* save state for resume */
3116         sensor->streaming = streaming;
3117
3118         return 0;
3119 }
3120
3121 static int __maybe_unused ccs_resume(struct device *dev)
3122 {
3123         struct i2c_client *client = to_i2c_client(dev);
3124         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3125         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3126         int rval = 0;
3127
3128         pm_runtime_put(dev);
3129
3130         if (sensor->streaming)
3131                 rval = ccs_start_streaming(sensor);
3132
3133         return rval;
3134 }
3135
3136 static int ccs_get_hwconfig(struct ccs_sensor *sensor, struct device *dev)
3137 {
3138         struct ccs_hwconfig *hwcfg = &sensor->hwcfg;
3139         struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = V4L2_MBUS_UNKNOWN };
3140         struct fwnode_handle *ep;
3141         struct fwnode_handle *fwnode = dev_fwnode(dev);
3142         u32 rotation;
3143         int i;
3144         int rval;
3145
3146         ep = fwnode_graph_get_endpoint_by_id(fwnode, 0, 0,
3147                                              FWNODE_GRAPH_ENDPOINT_NEXT);
3148         if (!ep)
3149                 return -ENODEV;
3150
3151         /*
3152          * Note that we do need to rely on detecting the bus type between CSI-2
3153          * D-PHY and CCP2 as the old bindings did not require it.
3154          */
3155         rval = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
3156         if (rval)
3157                 goto out_err;
3158
3159         switch (bus_cfg.bus_type) {
3160         case V4L2_MBUS_CSI2_DPHY:
3161                 hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_DPHY;
3162                 hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;
3163                 break;
3164         case V4L2_MBUS_CSI2_CPHY:
3165                 hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_CPHY;
3166                 hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;
3167                 break;
3168         case V4L2_MBUS_CSI1:
3169         case V4L2_MBUS_CCP2:
3170                 hwcfg->csi_signalling_mode = (bus_cfg.bus.mipi_csi1.strobe) ?
3171                 SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_STROBE :
3172                 SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_CLOCK;
3173                 hwcfg->lanes = 1;
3174                 break;
3175         default:
3176                 dev_err(dev, "unsupported bus %u\n", bus_cfg.bus_type);
3177                 rval = -EINVAL;
3178                 goto out_err;
3179         }
3180
3181         dev_dbg(dev, "lanes %u\n", hwcfg->lanes);
3182
3183         rval = fwnode_property_read_u32(fwnode, "rotation", &rotation);
3184         if (!rval) {
3185                 switch (rotation) {
3186                 case 180:
3187                         hwcfg->module_board_orient =
3188                                 CCS_MODULE_BOARD_ORIENT_180;
3189                         fallthrough;
3190                 case 0:
3191                         break;
3192                 default:
3193                         dev_err(dev, "invalid rotation %u\n", rotation);
3194                         rval = -EINVAL;
3195                         goto out_err;
3196                 }
3197         }
3198
3199         rval = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency",
3200                                         &hwcfg->ext_clk);
3201         if (rval)
3202                 dev_info(dev, "can't get clock-frequency\n");
3203
3204         dev_dbg(dev, "clk %d, mode %d\n", hwcfg->ext_clk,
3205                 hwcfg->csi_signalling_mode);
3206
3207         if (!bus_cfg.nr_of_link_frequencies) {
3208                 dev_warn(dev, "no link frequencies defined\n");
3209                 rval = -EINVAL;
3210                 goto out_err;
3211         }
3212
3213         hwcfg->op_sys_clock = devm_kcalloc(
3214                 dev, bus_cfg.nr_of_link_frequencies + 1 /* guardian */,
3215                 sizeof(*hwcfg->op_sys_clock), GFP_KERNEL);
3216         if (!hwcfg->op_sys_clock) {
3217                 rval = -ENOMEM;
3218                 goto out_err;
3219         }
3220
3221         for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++) {
3222                 hwcfg->op_sys_clock[i] = bus_cfg.link_frequencies[i];
3223                 dev_dbg(dev, "freq %d: %lld\n", i, hwcfg->op_sys_clock[i]);
3224         }
3225
3226         v4l2_fwnode_endpoint_free(&bus_cfg);
3227         fwnode_handle_put(ep);
3228
3229         return 0;
3230
3231 out_err:
3232         v4l2_fwnode_endpoint_free(&bus_cfg);
3233         fwnode_handle_put(ep);
3234
3235         return rval;
3236 }
3237
3238 static int ccs_probe(struct i2c_client *client)
3239 {
3240         struct ccs_sensor *sensor;
3241         const struct firmware *fw;
3242         char filename[40];
3243         unsigned int i;
3244         int rval;
3245
3246         sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
3247         if (sensor == NULL)
3248                 return -ENOMEM;
3249
3250         rval = ccs_get_hwconfig(sensor, &client->dev);
3251         if (rval)
3252                 return rval;
3253
3254         sensor->src = &sensor->ssds[sensor->ssds_used];
3255
3256         v4l2_i2c_subdev_init(&sensor->src->sd, client, &ccs_ops);
3257         sensor->src->sd.internal_ops = &ccs_internal_src_ops;
3258
3259         sensor->regulators = devm_kcalloc(&client->dev,
3260                                           ARRAY_SIZE(ccs_regulators),
3261                                           sizeof(*sensor->regulators),
3262                                           GFP_KERNEL);
3263         if (!sensor->regulators)
3264                 return -ENOMEM;
3265
3266         for (i = 0; i < ARRAY_SIZE(ccs_regulators); i++)
3267                 sensor->regulators[i].supply = ccs_regulators[i];
3268
3269         rval = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(ccs_regulators),
3270                                        sensor->regulators);
3271         if (rval) {
3272                 dev_err(&client->dev, "could not get regulators\n");
3273                 return rval;
3274         }
3275
3276         sensor->ext_clk = devm_clk_get(&client->dev, NULL);
3277         if (PTR_ERR(sensor->ext_clk) == -ENOENT) {
3278                 dev_info(&client->dev, "no clock defined, continuing...\n");
3279                 sensor->ext_clk = NULL;
3280         } else if (IS_ERR(sensor->ext_clk)) {
3281                 dev_err(&client->dev, "could not get clock (%ld)\n",
3282                         PTR_ERR(sensor->ext_clk));
3283                 return -EPROBE_DEFER;
3284         }
3285
3286         if (sensor->ext_clk) {
3287                 if (sensor->hwcfg.ext_clk) {
3288                         unsigned long rate;
3289
3290                         rval = clk_set_rate(sensor->ext_clk,
3291                                             sensor->hwcfg.ext_clk);
3292                         if (rval < 0) {
3293                                 dev_err(&client->dev,
3294                                         "unable to set clock freq to %u\n",
3295                                         sensor->hwcfg.ext_clk);
3296                                 return rval;
3297                         }
3298
3299                         rate = clk_get_rate(sensor->ext_clk);
3300                         if (rate != sensor->hwcfg.ext_clk) {
3301                                 dev_err(&client->dev,
3302                                         "can't set clock freq, asked for %u but got %lu\n",
3303                                         sensor->hwcfg.ext_clk, rate);
3304                                 return -EINVAL;
3305                         }
3306                 } else {
3307                         sensor->hwcfg.ext_clk = clk_get_rate(sensor->ext_clk);
3308                         dev_dbg(&client->dev, "obtained clock freq %u\n",
3309                                 sensor->hwcfg.ext_clk);
3310                 }
3311         } else if (sensor->hwcfg.ext_clk) {
3312                 dev_dbg(&client->dev, "assuming clock freq %u\n",
3313                         sensor->hwcfg.ext_clk);
3314         } else {
3315                 dev_err(&client->dev, "unable to obtain clock freq\n");
3316                 return -EINVAL;
3317         }
3318
3319         if (!sensor->hwcfg.ext_clk) {
3320                 dev_err(&client->dev, "cannot work with xclk frequency 0\n");
3321                 return -EINVAL;
3322         }
3323
3324         sensor->reset = devm_gpiod_get_optional(&client->dev, "reset",
3325                                                 GPIOD_OUT_HIGH);
3326         if (IS_ERR(sensor->reset))
3327                 return PTR_ERR(sensor->reset);
3328         /* Support old users that may have used "xshutdown" property. */
3329         if (!sensor->reset)
3330                 sensor->xshutdown = devm_gpiod_get_optional(&client->dev,
3331                                                             "xshutdown",
3332                                                             GPIOD_OUT_LOW);
3333         if (IS_ERR(sensor->xshutdown))
3334                 return PTR_ERR(sensor->xshutdown);
3335
3336         rval = ccs_power_on(&client->dev);
3337         if (rval < 0)
3338                 return rval;
3339
3340         mutex_init(&sensor->mutex);
3341
3342         rval = ccs_identify_module(sensor);
3343         if (rval) {
3344                 rval = -ENODEV;
3345                 goto out_power_off;
3346         }
3347
3348         rval = snprintf(filename, sizeof(filename),
3349                         "ccs/ccs-sensor-%4.4x-%4.4x-%4.4x.fw",
3350                         sensor->minfo.sensor_mipi_manufacturer_id,
3351                         sensor->minfo.sensor_model_id,
3352                         sensor->minfo.sensor_revision_number);
3353         if (rval >= sizeof(filename)) {
3354                 rval = -ENOMEM;
3355                 goto out_power_off;
3356         }
3357
3358         rval = request_firmware(&fw, filename, &client->dev);
3359         if (!rval) {
3360                 ccs_data_parse(&sensor->sdata, fw->data, fw->size, &client->dev,
3361                                true);
3362                 release_firmware(fw);
3363         }
3364
3365         rval = snprintf(filename, sizeof(filename),
3366                         "ccs/ccs-module-%4.4x-%4.4x-%4.4x.fw",
3367                         sensor->minfo.mipi_manufacturer_id,
3368                         sensor->minfo.model_id,
3369                         sensor->minfo.revision_number);
3370         if (rval >= sizeof(filename)) {
3371                 rval = -ENOMEM;
3372                 goto out_release_sdata;
3373         }
3374
3375         rval = request_firmware(&fw, filename, &client->dev);
3376         if (!rval) {
3377                 ccs_data_parse(&sensor->mdata, fw->data, fw->size, &client->dev,
3378                                true);
3379                 release_firmware(fw);
3380         }
3381
3382         rval = ccs_read_all_limits(sensor);
3383         if (rval)
3384                 goto out_release_mdata;
3385
3386         rval = ccs_read_frame_fmt(sensor);
3387         if (rval) {
3388                 rval = -ENODEV;
3389                 goto out_free_ccs_limits;
3390         }
3391
3392         rval = ccs_update_phy_ctrl(sensor);
3393         if (rval < 0)
3394                 goto out_free_ccs_limits;
3395
3396         /*
3397          * Handle Sensor Module orientation on the board.
3398          *
3399          * The application of H-FLIP and V-FLIP on the sensor is modified by
3400          * the sensor orientation on the board.
3401          *
3402          * For CCS_BOARD_SENSOR_ORIENT_180 the default behaviour is to set
3403          * both H-FLIP and V-FLIP for normal operation which also implies
3404          * that a set/unset operation for user space HFLIP and VFLIP v4l2
3405          * controls will need to be internally inverted.
3406          *
3407          * Rotation also changes the bayer pattern.
3408          */
3409         if (sensor->hwcfg.module_board_orient ==
3410             CCS_MODULE_BOARD_ORIENT_180)
3411                 sensor->hvflip_inv_mask =
3412                         CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR |
3413                         CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
3414
3415         rval = ccs_call_quirk(sensor, limits);
3416         if (rval) {
3417                 dev_err(&client->dev, "limits quirks failed\n");
3418                 goto out_free_ccs_limits;
3419         }
3420
3421         if (CCS_LIM(sensor, BINNING_CAPABILITY)) {
3422                 sensor->nbinning_subtypes =
3423                         min_t(u8, CCS_LIM(sensor, BINNING_SUB_TYPES),
3424                               CCS_LIM_BINNING_SUB_TYPE_MAX_N);
3425
3426                 for (i = 0; i < sensor->nbinning_subtypes; i++) {
3427                         sensor->binning_subtypes[i].horizontal =
3428                                 CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) >>
3429                                 CCS_BINNING_SUB_TYPE_COLUMN_SHIFT;
3430                         sensor->binning_subtypes[i].vertical =
3431                                 CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) &
3432                                 CCS_BINNING_SUB_TYPE_ROW_MASK;
3433
3434                         dev_dbg(&client->dev, "binning %xx%x\n",
3435                                 sensor->binning_subtypes[i].horizontal,
3436                                 sensor->binning_subtypes[i].vertical);
3437                 }
3438         }
3439         sensor->binning_horizontal = 1;
3440         sensor->binning_vertical = 1;
3441
3442         if (device_create_file(&client->dev, &dev_attr_ident) != 0) {
3443                 dev_err(&client->dev, "sysfs ident entry creation failed\n");
3444                 rval = -ENOENT;
3445                 goto out_free_ccs_limits;
3446         }
3447
3448         if (sensor->minfo.smiapp_version &&
3449             CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &
3450             CCS_DATA_TRANSFER_IF_CAPABILITY_SUPPORTED) {
3451                 if (device_create_file(&client->dev, &dev_attr_nvm) != 0) {
3452                         dev_err(&client->dev, "sysfs nvm entry failed\n");
3453                         rval = -EBUSY;
3454                         goto out_cleanup;
3455                 }
3456         }
3457
3458         if (!CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV) ||
3459             !CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV) ||
3460             !CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV) ||
3461             !CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV)) {
3462                 /* No OP clock branch */
3463                 sensor->pll.flags |= CCS_PLL_FLAG_NO_OP_CLOCKS;
3464         } else if (CCS_LIM(sensor, SCALING_CAPABILITY)
3465                    != CCS_SCALING_CAPABILITY_NONE ||
3466                    CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
3467                    == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
3468                 /* We have a scaler or digital crop. */
3469                 sensor->scaler = &sensor->ssds[sensor->ssds_used];
3470                 sensor->ssds_used++;
3471         }
3472         sensor->binner = &sensor->ssds[sensor->ssds_used];
3473         sensor->ssds_used++;
3474         sensor->pixel_array = &sensor->ssds[sensor->ssds_used];
3475         sensor->ssds_used++;
3476
3477         sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);
3478
3479         /* prepare PLL configuration input values */
3480         sensor->pll.bus_type = CCS_PLL_BUS_TYPE_CSI2_DPHY;
3481         sensor->pll.csi2.lanes = sensor->hwcfg.lanes;
3482         if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3483             CCS_CLOCK_CALCULATION_LANE_SPEED) {
3484                 sensor->pll.flags |= CCS_PLL_FLAG_LANE_SPEED_MODEL;
3485                 if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3486                     CCS_CLOCK_CALCULATION_LINK_DECOUPLED) {
3487                         sensor->pll.vt_lanes =
3488                                 CCS_LIM(sensor, NUM_OF_VT_LANES) + 1;
3489                         sensor->pll.op_lanes =
3490                                 CCS_LIM(sensor, NUM_OF_OP_LANES) + 1;
3491                         sensor->pll.flags |= CCS_PLL_FLAG_LINK_DECOUPLED;
3492                 } else {
3493                         sensor->pll.vt_lanes = sensor->pll.csi2.lanes;
3494                         sensor->pll.op_lanes = sensor->pll.csi2.lanes;
3495                 }
3496         }
3497         if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3498             CCS_CLOCK_TREE_PLL_CAPABILITY_EXT_DIVIDER)
3499                 sensor->pll.flags |= CCS_PLL_FLAG_EXT_IP_PLL_DIVIDER;
3500         if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3501             CCS_CLOCK_TREE_PLL_CAPABILITY_FLEXIBLE_OP_PIX_CLK_DIV)
3502                 sensor->pll.flags |= CCS_PLL_FLAG_FLEXIBLE_OP_PIX_CLK_DIV;
3503         if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) &
3504             CCS_FIFO_SUPPORT_CAPABILITY_DERATING)
3505                 sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING;
3506         if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) &
3507             CCS_FIFO_SUPPORT_CAPABILITY_DERATING_OVERRATING)
3508                 sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING |
3509                                      CCS_PLL_FLAG_FIFO_OVERRATING;
3510         if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3511             CCS_CLOCK_TREE_PLL_CAPABILITY_DUAL_PLL) {
3512                 if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3513                     CCS_CLOCK_TREE_PLL_CAPABILITY_SINGLE_PLL) {
3514                         u32 v;
3515
3516                         /* Use sensor default in PLL mode selection */
3517                         rval = ccs_read(sensor, PLL_MODE, &v);
3518                         if (rval)
3519                                 goto out_cleanup;
3520
3521                         if (v == CCS_PLL_MODE_DUAL)
3522                                 sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL;
3523                 } else {
3524                         sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL;
3525                 }
3526                 if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3527                     CCS_CLOCK_CALCULATION_DUAL_PLL_OP_SYS_DDR)
3528                         sensor->pll.flags |= CCS_PLL_FLAG_OP_SYS_DDR;
3529                 if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3530                     CCS_CLOCK_CALCULATION_DUAL_PLL_OP_PIX_DDR)
3531                         sensor->pll.flags |= CCS_PLL_FLAG_OP_PIX_DDR;
3532         }
3533         sensor->pll.op_bits_per_lane = CCS_LIM(sensor, OP_BITS_PER_LANE);
3534         sensor->pll.ext_clk_freq_hz = sensor->hwcfg.ext_clk;
3535         sensor->pll.scale_n = CCS_LIM(sensor, SCALER_N_MIN);
3536
3537         ccs_create_subdev(sensor, sensor->scaler, " scaler", 2,
3538                           MEDIA_ENT_F_PROC_VIDEO_SCALER);
3539         ccs_create_subdev(sensor, sensor->binner, " binner", 2,
3540                           MEDIA_ENT_F_PROC_VIDEO_SCALER);
3541         ccs_create_subdev(sensor, sensor->pixel_array, " pixel_array", 1,
3542                           MEDIA_ENT_F_CAM_SENSOR);
3543
3544         rval = ccs_init_controls(sensor);
3545         if (rval < 0)
3546                 goto out_cleanup;
3547
3548         rval = ccs_call_quirk(sensor, init);
3549         if (rval)
3550                 goto out_cleanup;
3551
3552         rval = ccs_get_mbus_formats(sensor);
3553         if (rval) {
3554                 rval = -ENODEV;
3555                 goto out_cleanup;
3556         }
3557
3558         rval = ccs_init_late_controls(sensor);
3559         if (rval) {
3560                 rval = -ENODEV;
3561                 goto out_cleanup;
3562         }
3563
3564         mutex_lock(&sensor->mutex);
3565         rval = ccs_pll_blanking_update(sensor);
3566         mutex_unlock(&sensor->mutex);
3567         if (rval) {
3568                 dev_err(&client->dev, "update mode failed\n");
3569                 goto out_cleanup;
3570         }
3571
3572         sensor->streaming = false;
3573         sensor->dev_init_done = true;
3574
3575         rval = media_entity_pads_init(&sensor->src->sd.entity, 2,
3576                                  sensor->src->pads);
3577         if (rval < 0)
3578                 goto out_media_entity_cleanup;
3579
3580         rval = ccs_write_msr_regs(sensor);
3581         if (rval)
3582                 goto out_media_entity_cleanup;
3583
3584         pm_runtime_set_active(&client->dev);
3585         pm_runtime_get_noresume(&client->dev);
3586         pm_runtime_enable(&client->dev);
3587
3588         rval = v4l2_async_register_subdev_sensor(&sensor->src->sd);
3589         if (rval < 0)
3590                 goto out_disable_runtime_pm;
3591
3592         pm_runtime_set_autosuspend_delay(&client->dev, 1000);
3593         pm_runtime_use_autosuspend(&client->dev);
3594         pm_runtime_put_autosuspend(&client->dev);
3595
3596         return 0;
3597
3598 out_disable_runtime_pm:
3599         pm_runtime_put_noidle(&client->dev);
3600         pm_runtime_disable(&client->dev);
3601
3602 out_media_entity_cleanup:
3603         media_entity_cleanup(&sensor->src->sd.entity);
3604
3605 out_cleanup:
3606         ccs_cleanup(sensor);
3607
3608 out_release_mdata:
3609         kvfree(sensor->mdata.backing);
3610
3611 out_release_sdata:
3612         kvfree(sensor->sdata.backing);
3613
3614 out_free_ccs_limits:
3615         kfree(sensor->ccs_limits);
3616
3617 out_power_off:
3618         ccs_power_off(&client->dev);
3619         mutex_destroy(&sensor->mutex);
3620
3621         return rval;
3622 }
3623
3624 static int ccs_remove(struct i2c_client *client)
3625 {
3626         struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3627         struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3628         unsigned int i;
3629
3630         v4l2_async_unregister_subdev(subdev);
3631
3632         pm_runtime_disable(&client->dev);
3633         if (!pm_runtime_status_suspended(&client->dev))
3634                 ccs_power_off(&client->dev);
3635         pm_runtime_set_suspended(&client->dev);
3636
3637         for (i = 0; i < sensor->ssds_used; i++) {
3638                 v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
3639                 media_entity_cleanup(&sensor->ssds[i].sd.entity);
3640         }
3641         ccs_cleanup(sensor);
3642         mutex_destroy(&sensor->mutex);
3643         kfree(sensor->ccs_limits);
3644         kvfree(sensor->sdata.backing);
3645         kvfree(sensor->mdata.backing);
3646
3647         return 0;
3648 }
3649
3650 static const struct ccs_device smia_device = {
3651         .flags = CCS_DEVICE_FLAG_IS_SMIA,
3652 };
3653
3654 static const struct ccs_device ccs_device = {};
3655
3656 static const struct acpi_device_id ccs_acpi_table[] = {
3657         { .id = "MIPI0200", .driver_data = (unsigned long)&ccs_device },
3658         { },
3659 };
3660 MODULE_DEVICE_TABLE(acpi, ccs_acpi_table);
3661
3662 static const struct of_device_id ccs_of_table[] = {
3663         { .compatible = "mipi-ccs-1.1", .data = &ccs_device },
3664         { .compatible = "mipi-ccs-1.0", .data = &ccs_device },
3665         { .compatible = "mipi-ccs", .data = &ccs_device },
3666         { .compatible = "nokia,smia", .data = &smia_device },
3667         { },
3668 };
3669 MODULE_DEVICE_TABLE(of, ccs_of_table);
3670
3671 static const struct dev_pm_ops ccs_pm_ops = {
3672         SET_SYSTEM_SLEEP_PM_OPS(ccs_suspend, ccs_resume)
3673         SET_RUNTIME_PM_OPS(ccs_power_off, ccs_power_on, NULL)
3674 };
3675
3676 static struct i2c_driver ccs_i2c_driver = {
3677         .driver = {
3678                 .acpi_match_table = ccs_acpi_table,
3679                 .of_match_table = ccs_of_table,
3680                 .name = CCS_NAME,
3681                 .pm = &ccs_pm_ops,
3682         },
3683         .probe_new = ccs_probe,
3684         .remove = ccs_remove,
3685 };
3686
3687 static int ccs_module_init(void)
3688 {
3689         unsigned int i, l;
3690
3691         for (i = 0, l = 0; ccs_limits[i].size && l < CCS_L_LAST; i++) {
3692                 if (!(ccs_limits[i].flags & CCS_L_FL_SAME_REG)) {
3693                         ccs_limit_offsets[l + 1].lim =
3694                                 ALIGN(ccs_limit_offsets[l].lim +
3695                                       ccs_limits[i].size,
3696                                       ccs_reg_width(ccs_limits[i + 1].reg));
3697                         ccs_limit_offsets[l].info = i;
3698                         l++;
3699                 } else {
3700                         ccs_limit_offsets[l].lim += ccs_limits[i].size;
3701                 }
3702         }
3703
3704         if (WARN_ON(ccs_limits[i].size))
3705                 return -EINVAL;
3706
3707         if (WARN_ON(l != CCS_L_LAST))
3708                 return -EINVAL;
3709
3710         return i2c_register_driver(THIS_MODULE, &ccs_i2c_driver);
3711 }
3712
3713 static void ccs_module_cleanup(void)
3714 {
3715         i2c_del_driver(&ccs_i2c_driver);
3716 }
3717
3718 module_init(ccs_module_init);
3719 module_exit(ccs_module_cleanup);
3720
3721 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>");
3722 MODULE_DESCRIPTION("Generic MIPI CCS/SMIA/SMIA++ camera sensor driver");
3723 MODULE_LICENSE("GPL v2");
3724 MODULE_ALIAS("smiapp");