i2c/ccs/ccs-core.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * drivers/media/i2c/ccs/ccs-core.c
0004  *
0005  * Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors
0006  *
0007  * Copyright (C) 2020 Intel Corporation
0008  * Copyright (C) 2010--2012 Nokia Corporation
0009  * Contact: Sakari Ailus <sakari.ailus@linux.intel.com>
0010  *
0011  * Based on smiapp driver by Vimarsh Zutshi
0012  * Based on jt8ev1.c by Vimarsh Zutshi
0013  * Based on smia-sensor.c by Tuukka Toivonen <tuukkat76@gmail.com>
0014  */
0015
0016 #include <linux/clk.h>
0017 #include <linux/delay.h>
0018 #include <linux/device.h>
0019 #include <linux/firmware.h>
0020 #include <linux/gpio/consumer.h>
0021 #include <linux/module.h>
0022 #include <linux/pm_runtime.h>
0023 #include <linux/property.h>
0024 #include <linux/regulator/consumer.h>
0025 #include <linux/slab.h>
0026 #include <linux/smiapp.h>
0027 #include <linux/v4l2-mediabus.h>
0028 #include <media/v4l2-fwnode.h>
0029 #include <media/v4l2-device.h>
0030 #include <uapi/linux/ccs.h>
0031
0032 #include "ccs.h"
0033
0034 #define CCS_ALIGN_DIM(dim, flags)   \
0035     ((flags) & V4L2_SEL_FLAG_GE \
0036      ? ALIGN((dim), 2)      \
0037      : (dim) & ~1)
0038
0039 static struct ccs_limit_offset {
0040     u16 lim;
0041     u16 info;
0042 } ccs_limit_offsets[CCS_L_LAST + 1];
0043
0044 /*
0045  * ccs_module_idents - supported camera modules
0046  */
0047 static const struct ccs_module_ident ccs_module_idents[] = {
0048     CCS_IDENT_L(0x01, 0x022b, -1, "vs6555"),
0049     CCS_IDENT_L(0x01, 0x022e, -1, "vw6558"),
0050     CCS_IDENT_L(0x07, 0x7698, -1, "ovm7698"),
0051     CCS_IDENT_L(0x0b, 0x4242, -1, "smiapp-003"),
0052     CCS_IDENT_L(0x0c, 0x208a, -1, "tcm8330md"),
0053     CCS_IDENT_LQ(0x0c, 0x2134, -1, "tcm8500md", &smiapp_tcm8500md_quirk),
0054     CCS_IDENT_L(0x0c, 0x213e, -1, "et8en2"),
0055     CCS_IDENT_L(0x0c, 0x2184, -1, "tcm8580md"),
0056     CCS_IDENT_LQ(0x0c, 0x560f, -1, "jt8ew9", &smiapp_jt8ew9_quirk),
0057     CCS_IDENT_LQ(0x10, 0x4141, -1, "jt8ev1", &smiapp_jt8ev1_quirk),
0058     CCS_IDENT_LQ(0x10, 0x4241, -1, "imx125es", &smiapp_imx125es_quirk),
0059 };
0060
0061 #define CCS_DEVICE_FLAG_IS_SMIA     BIT(0)
0062
0063 struct ccs_device {
0064     unsigned char flags;
0065 };
0066
0067 static const char * const ccs_regulators[] = { "vcore", "vio", "vana" };
0068
0069 /*
0070  *
0071  * Dynamic Capability Identification
0072  *
0073  */
0074
0075 static void ccs_assign_limit(void *ptr, unsigned int width, u32 val)
0076 {
0077     switch (width) {
0078     case sizeof(u8):
0079         *(u8 *)ptr = val;
0080         break;
0081     case sizeof(u16):
0082         *(u16 *)ptr = val;
0083         break;
0084     case sizeof(u32):
0085         *(u32 *)ptr = val;
0086         break;
0087     }
0088 }
0089
0090 static int ccs_limit_ptr(struct ccs_sensor *sensor, unsigned int limit,
0091              unsigned int offset, void **__ptr)
0092 {
0093     const struct ccs_limit *linfo;
0094
0095     if (WARN_ON(limit >= CCS_L_LAST))
0096         return -EINVAL;
0097
0098     linfo = &ccs_limits[ccs_limit_offsets[limit].info];
0099
0100     if (WARN_ON(!sensor->ccs_limits) ||
0101         WARN_ON(offset + ccs_reg_width(linfo->reg) >
0102             ccs_limit_offsets[limit + 1].lim))
0103         return -EINVAL;
0104
0105     *__ptr = sensor->ccs_limits + ccs_limit_offsets[limit].lim + offset;
0106
0107     return 0;
0108 }
0109
0110 void ccs_replace_limit(struct ccs_sensor *sensor,
0111                unsigned int limit, unsigned int offset, u32 val)
0112 {
0113     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0114     const struct ccs_limit *linfo;
0115     void *ptr;
0116     int ret;
0117
0118     ret = ccs_limit_ptr(sensor, limit, offset, &ptr);
0119     if (ret)
0120         return;
0121
0122     linfo = &ccs_limits[ccs_limit_offsets[limit].info];
0123
0124     dev_dbg(&client->dev, "quirk: 0x%8.8x \"%s\" %u = %u, 0x%x\n",
0125         linfo->reg, linfo->name, offset, val, val);
0126
0127     ccs_assign_limit(ptr, ccs_reg_width(linfo->reg), val);
0128 }
0129
0130 u32 ccs_get_limit(struct ccs_sensor *sensor, unsigned int limit,
0131           unsigned int offset)
0132 {
0133     void *ptr;
0134     u32 val;
0135     int ret;
0136
0137     ret = ccs_limit_ptr(sensor, limit, offset, &ptr);
0138     if (ret)
0139         return 0;
0140
0141     switch (ccs_reg_width(ccs_limits[ccs_limit_offsets[limit].info].reg)) {
0142     case sizeof(u8):
0143         val = *(u8 *)ptr;
0144         break;
0145     case sizeof(u16):
0146         val = *(u16 *)ptr;
0147         break;
0148     case sizeof(u32):
0149         val = *(u32 *)ptr;
0150         break;
0151     default:
0152         WARN_ON(1);
0153         return 0;
0154     }
0155
0156     return ccs_reg_conv(sensor, ccs_limits[limit].reg, val);
0157 }
0158
0159 static int ccs_read_all_limits(struct ccs_sensor *sensor)
0160 {
0161     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0162     void *ptr, *alloc, *end;
0163     unsigned int i, l;
0164     int ret;
0165
0166     kfree(sensor->ccs_limits);
0167     sensor->ccs_limits = NULL;
0168
0169     alloc = kzalloc(ccs_limit_offsets[CCS_L_LAST].lim, GFP_KERNEL);
0170     if (!alloc)
0171         return -ENOMEM;
0172
0173     end = alloc + ccs_limit_offsets[CCS_L_LAST].lim;
0174
0175     for (i = 0, l = 0, ptr = alloc; ccs_limits[i].size; i++) {
0176         u32 reg = ccs_limits[i].reg;
0177         unsigned int width = ccs_reg_width(reg);
0178         unsigned int j;
0179
0180         if (l == CCS_L_LAST) {
0181             dev_err(&client->dev,
0182                 "internal error --- end of limit array\n");
0183             ret = -EINVAL;
0184             goto out_err;
0185         }
0186
0187         for (j = 0; j < ccs_limits[i].size / width;
0188              j++, reg += width, ptr += width) {
0189             u32 val;
0190
0191             ret = ccs_read_addr_noconv(sensor, reg, &val);
0192             if (ret)
0193                 goto out_err;
0194
0195             if (ptr + width > end) {
0196                 dev_err(&client->dev,
0197                     "internal error --- no room for regs\n");
0198                 ret = -EINVAL;
0199                 goto out_err;
0200             }
0201
0202             if (!val && j)
0203                 break;
0204
0205             ccs_assign_limit(ptr, width, val);
0206
0207             dev_dbg(&client->dev, "0x%8.8x \"%s\" = %u, 0x%x\n",
0208                 reg, ccs_limits[i].name, val, val);
0209         }
0210
0211         if (ccs_limits[i].flags & CCS_L_FL_SAME_REG)
0212             continue;
0213
0214         l++;
0215         ptr = alloc + ccs_limit_offsets[l].lim;
0216     }
0217
0218     if (l != CCS_L_LAST) {
0219         dev_err(&client->dev,
0220             "internal error --- insufficient limits\n");
0221         ret = -EINVAL;
0222         goto out_err;
0223     }
0224
0225     sensor->ccs_limits = alloc;
0226
0227     if (CCS_LIM(sensor, SCALER_N_MIN) < 16)
0228         ccs_replace_limit(sensor, CCS_L_SCALER_N_MIN, 0, 16);
0229
0230     return 0;
0231
0232 out_err:
0233     kfree(alloc);
0234
0235     return ret;
0236 }
0237
0238 static int ccs_read_frame_fmt(struct ccs_sensor *sensor)
0239 {
0240     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0241     u8 fmt_model_type, fmt_model_subtype, ncol_desc, nrow_desc;
0242     unsigned int i;
0243     int pixel_count = 0;
0244     int line_count = 0;
0245
0246     fmt_model_type = CCS_LIM(sensor, FRAME_FORMAT_MODEL_TYPE);
0247     fmt_model_subtype = CCS_LIM(sensor, FRAME_FORMAT_MODEL_SUBTYPE);
0248
0249     ncol_desc = (fmt_model_subtype
0250              & CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_MASK)
0251         >> CCS_FRAME_FORMAT_MODEL_SUBTYPE_COLUMNS_SHIFT;
0252     nrow_desc = fmt_model_subtype
0253         & CCS_FRAME_FORMAT_MODEL_SUBTYPE_ROWS_MASK;
0254
0255     dev_dbg(&client->dev, "format_model_type %s\n",
0256         fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE
0257         ? "2 byte" :
0258         fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE
0259         ? "4 byte" : "is simply bad");
0260
0261     dev_dbg(&client->dev, "%u column and %u row descriptors\n",
0262         ncol_desc, nrow_desc);
0263
0264     for (i = 0; i < ncol_desc + nrow_desc; i++) {
0265         u32 desc;
0266         u32 pixelcode;
0267         u32 pixels;
0268         char *which;
0269         char *what;
0270
0271         if (fmt_model_type == CCS_FRAME_FORMAT_MODEL_TYPE_2_BYTE) {
0272             desc = CCS_LIM_AT(sensor, FRAME_FORMAT_DESCRIPTOR, i);
0273
0274             pixelcode =
0275                 (desc
0276                  & CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_MASK)
0277                 >> CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_SHIFT;
0278             pixels = desc & CCS_FRAME_FORMAT_DESCRIPTOR_PIXELS_MASK;
0279         } else if (fmt_model_type
0280                == CCS_FRAME_FORMAT_MODEL_TYPE_4_BYTE) {
0281             desc = CCS_LIM_AT(sensor, FRAME_FORMAT_DESCRIPTOR_4, i);
0282
0283             pixelcode =
0284                 (desc
0285                  & CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_MASK)
0286                 >> CCS_FRAME_FORMAT_DESCRIPTOR_4_PCODE_SHIFT;
0287             pixels = desc &
0288                 CCS_FRAME_FORMAT_DESCRIPTOR_4_PIXELS_MASK;
0289         } else {
0290             dev_dbg(&client->dev,
0291                 "invalid frame format model type %u\n",
0292                 fmt_model_type);
0293             return -EINVAL;
0294         }
0295
0296         if (i < ncol_desc)
0297             which = "columns";
0298         else
0299             which = "rows";
0300
0301         switch (pixelcode) {
0302         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED:
0303             what = "embedded";
0304             break;
0305         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DUMMY_PIXEL:
0306             what = "dummy";
0307             break;
0308         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_BLACK_PIXEL:
0309             what = "black";
0310             break;
0311         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_DARK_PIXEL:
0312             what = "dark";
0313             break;
0314         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL:
0315             what = "visible";
0316             break;
0317         default:
0318             what = "invalid";
0319             break;
0320         }
0321
0322         dev_dbg(&client->dev,
0323             "%s pixels: %u %s (pixelcode %u)\n",
0324             what, pixels, which, pixelcode);
0325
0326         if (i < ncol_desc) {
0327             if (pixelcode ==
0328                 CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL)
0329                 sensor->visible_pixel_start = pixel_count;
0330             pixel_count += pixels;
0331             continue;
0332         }
0333
0334         /* Handle row descriptors */
0335         switch (pixelcode) {
0336         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_EMBEDDED:
0337             if (sensor->embedded_end)
0338                 break;
0339             sensor->embedded_start = line_count;
0340             sensor->embedded_end = line_count + pixels;
0341             break;
0342         case CCS_FRAME_FORMAT_DESCRIPTOR_PCODE_VISIBLE_PIXEL:
0343             sensor->image_start = line_count;
0344             break;
0345         }
0346         line_count += pixels;
0347     }
0348
0349     if (sensor->embedded_end > sensor->image_start) {
0350         dev_dbg(&client->dev,
0351             "adjusting image start line to %u (was %u)\n",
0352             sensor->embedded_end, sensor->image_start);
0353         sensor->image_start = sensor->embedded_end;
0354     }
0355
0356     dev_dbg(&client->dev, "embedded data from lines %u to %u\n",
0357         sensor->embedded_start, sensor->embedded_end);
0358     dev_dbg(&client->dev, "image data starts at line %u\n",
0359         sensor->image_start);
0360
0361     return 0;
0362 }
0363
0364 static int ccs_pll_configure(struct ccs_sensor *sensor)
0365 {
0366     struct ccs_pll *pll = &sensor->pll;
0367     int rval;
0368
0369     rval = ccs_write(sensor, VT_PIX_CLK_DIV, pll->vt_bk.pix_clk_div);
0370     if (rval < 0)
0371         return rval;
0372
0373     rval = ccs_write(sensor, VT_SYS_CLK_DIV, pll->vt_bk.sys_clk_div);
0374     if (rval < 0)
0375         return rval;
0376
0377     rval = ccs_write(sensor, PRE_PLL_CLK_DIV, pll->vt_fr.pre_pll_clk_div);
0378     if (rval < 0)
0379         return rval;
0380
0381     rval = ccs_write(sensor, PLL_MULTIPLIER, pll->vt_fr.pll_multiplier);
0382     if (rval < 0)
0383         return rval;
0384
0385     if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY) &
0386           CCS_PHY_CTRL_CAPABILITY_AUTO_PHY_CTL)) {
0387         /* Lane op clock ratio does not apply here. */
0388         rval = ccs_write(sensor, REQUESTED_LINK_RATE,
0389                  DIV_ROUND_UP(pll->op_bk.sys_clk_freq_hz,
0390                           1000000 / 256 / 256) *
0391                  (pll->flags & CCS_PLL_FLAG_LANE_SPEED_MODEL ?
0392                   sensor->pll.csi2.lanes : 1) <<
0393                  (pll->flags & CCS_PLL_FLAG_OP_SYS_DDR ?
0394                   1 : 0));
0395         if (rval < 0)
0396             return rval;
0397     }
0398
0399     if (sensor->pll.flags & CCS_PLL_FLAG_NO_OP_CLOCKS)
0400         return 0;
0401
0402     rval = ccs_write(sensor, OP_PIX_CLK_DIV, pll->op_bk.pix_clk_div);
0403     if (rval < 0)
0404         return rval;
0405
0406     rval = ccs_write(sensor, OP_SYS_CLK_DIV, pll->op_bk.sys_clk_div);
0407     if (rval < 0)
0408         return rval;
0409
0410     if (!(pll->flags & CCS_PLL_FLAG_DUAL_PLL))
0411         return 0;
0412
0413     rval = ccs_write(sensor, PLL_MODE, CCS_PLL_MODE_DUAL);
0414     if (rval < 0)
0415         return rval;
0416
0417     rval = ccs_write(sensor, OP_PRE_PLL_CLK_DIV,
0418              pll->op_fr.pre_pll_clk_div);
0419     if (rval < 0)
0420         return rval;
0421
0422     return ccs_write(sensor, OP_PLL_MULTIPLIER, pll->op_fr.pll_multiplier);
0423 }
0424
0425 static int ccs_pll_try(struct ccs_sensor *sensor, struct ccs_pll *pll)
0426 {
0427     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0428     struct ccs_pll_limits lim = {
0429         .vt_fr = {
0430             .min_pre_pll_clk_div = CCS_LIM(sensor, MIN_PRE_PLL_CLK_DIV),
0431             .max_pre_pll_clk_div = CCS_LIM(sensor, MAX_PRE_PLL_CLK_DIV),
0432             .min_pll_ip_clk_freq_hz = CCS_LIM(sensor, MIN_PLL_IP_CLK_FREQ_MHZ),
0433             .max_pll_ip_clk_freq_hz = CCS_LIM(sensor, MAX_PLL_IP_CLK_FREQ_MHZ),
0434             .min_pll_multiplier = CCS_LIM(sensor, MIN_PLL_MULTIPLIER),
0435             .max_pll_multiplier = CCS_LIM(sensor, MAX_PLL_MULTIPLIER),
0436             .min_pll_op_clk_freq_hz = CCS_LIM(sensor, MIN_PLL_OP_CLK_FREQ_MHZ),
0437             .max_pll_op_clk_freq_hz = CCS_LIM(sensor, MAX_PLL_OP_CLK_FREQ_MHZ),
0438         },
0439         .op_fr = {
0440             .min_pre_pll_clk_div = CCS_LIM(sensor, MIN_OP_PRE_PLL_CLK_DIV),
0441             .max_pre_pll_clk_div = CCS_LIM(sensor, MAX_OP_PRE_PLL_CLK_DIV),
0442             .min_pll_ip_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PLL_IP_CLK_FREQ_MHZ),
0443             .max_pll_ip_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PLL_IP_CLK_FREQ_MHZ),
0444             .min_pll_multiplier = CCS_LIM(sensor, MIN_OP_PLL_MULTIPLIER),
0445             .max_pll_multiplier = CCS_LIM(sensor, MAX_OP_PLL_MULTIPLIER),
0446             .min_pll_op_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PLL_OP_CLK_FREQ_MHZ),
0447             .max_pll_op_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PLL_OP_CLK_FREQ_MHZ),
0448         },
0449         .op_bk = {
0450              .min_sys_clk_div = CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV),
0451              .max_sys_clk_div = CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV),
0452              .min_pix_clk_div = CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV),
0453              .max_pix_clk_div = CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV),
0454              .min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_OP_SYS_CLK_FREQ_MHZ),
0455              .max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_OP_SYS_CLK_FREQ_MHZ),
0456              .min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_OP_PIX_CLK_FREQ_MHZ),
0457              .max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_OP_PIX_CLK_FREQ_MHZ),
0458          },
0459         .vt_bk = {
0460              .min_sys_clk_div = CCS_LIM(sensor, MIN_VT_SYS_CLK_DIV),
0461              .max_sys_clk_div = CCS_LIM(sensor, MAX_VT_SYS_CLK_DIV),
0462              .min_pix_clk_div = CCS_LIM(sensor, MIN_VT_PIX_CLK_DIV),
0463              .max_pix_clk_div = CCS_LIM(sensor, MAX_VT_PIX_CLK_DIV),
0464              .min_sys_clk_freq_hz = CCS_LIM(sensor, MIN_VT_SYS_CLK_FREQ_MHZ),
0465              .max_sys_clk_freq_hz = CCS_LIM(sensor, MAX_VT_SYS_CLK_FREQ_MHZ),
0466              .min_pix_clk_freq_hz = CCS_LIM(sensor, MIN_VT_PIX_CLK_FREQ_MHZ),
0467              .max_pix_clk_freq_hz = CCS_LIM(sensor, MAX_VT_PIX_CLK_FREQ_MHZ),
0468          },
0469         .min_line_length_pck_bin = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN),
0470         .min_line_length_pck = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK),
0471     };
0472
0473     return ccs_pll_calculate(&client->dev, &lim, pll);
0474 }
0475
0476 static int ccs_pll_update(struct ccs_sensor *sensor)
0477 {
0478     struct ccs_pll *pll = &sensor->pll;
0479     int rval;
0480
0481     pll->binning_horizontal = sensor->binning_horizontal;
0482     pll->binning_vertical = sensor->binning_vertical;
0483     pll->link_freq =
0484         sensor->link_freq->qmenu_int[sensor->link_freq->val];
0485     pll->scale_m = sensor->scale_m;
0486     pll->bits_per_pixel = sensor->csi_format->compressed;
0487
0488     rval = ccs_pll_try(sensor, pll);
0489     if (rval < 0)
0490         return rval;
0491
0492     __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_parray,
0493                  pll->pixel_rate_pixel_array);
0494     __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_csi, pll->pixel_rate_csi);
0495
0496     return 0;
0497 }
0498
0499
0500 /*
0501  *
0502  * V4L2 Controls handling
0503  *
0504  */
0505
0506 static void __ccs_update_exposure_limits(struct ccs_sensor *sensor)
0507 {
0508     struct v4l2_ctrl *ctrl = sensor->exposure;
0509     int max;
0510
0511     max = sensor->pixel_array->crop[CCS_PA_PAD_SRC].height
0512         + sensor->vblank->val
0513         - CCS_LIM(sensor, COARSE_INTEGRATION_TIME_MAX_MARGIN);
0514
0515     __v4l2_ctrl_modify_range(ctrl, ctrl->minimum, max, ctrl->step, max);
0516 }
0517
0518 /*
0519  * Order matters.
0520  *
0521  * 1. Bits-per-pixel, descending.
0522  * 2. Bits-per-pixel compressed, descending.
0523  * 3. Pixel order, same as in pixel_order_str. Formats for all four pixel
0524  *    orders must be defined.
0525  */
0526 static const struct ccs_csi_data_format ccs_csi_data_formats[] = {
0527     { MEDIA_BUS_FMT_SGRBG16_1X16, 16, 16, CCS_PIXEL_ORDER_GRBG, },
0528     { MEDIA_BUS_FMT_SRGGB16_1X16, 16, 16, CCS_PIXEL_ORDER_RGGB, },
0529     { MEDIA_BUS_FMT_SBGGR16_1X16, 16, 16, CCS_PIXEL_ORDER_BGGR, },
0530     { MEDIA_BUS_FMT_SGBRG16_1X16, 16, 16, CCS_PIXEL_ORDER_GBRG, },
0531     { MEDIA_BUS_FMT_SGRBG14_1X14, 14, 14, CCS_PIXEL_ORDER_GRBG, },
0532     { MEDIA_BUS_FMT_SRGGB14_1X14, 14, 14, CCS_PIXEL_ORDER_RGGB, },
0533     { MEDIA_BUS_FMT_SBGGR14_1X14, 14, 14, CCS_PIXEL_ORDER_BGGR, },
0534     { MEDIA_BUS_FMT_SGBRG14_1X14, 14, 14, CCS_PIXEL_ORDER_GBRG, },
0535     { MEDIA_BUS_FMT_SGRBG12_1X12, 12, 12, CCS_PIXEL_ORDER_GRBG, },
0536     { MEDIA_BUS_FMT_SRGGB12_1X12, 12, 12, CCS_PIXEL_ORDER_RGGB, },
0537     { MEDIA_BUS_FMT_SBGGR12_1X12, 12, 12, CCS_PIXEL_ORDER_BGGR, },
0538     { MEDIA_BUS_FMT_SGBRG12_1X12, 12, 12, CCS_PIXEL_ORDER_GBRG, },
0539     { MEDIA_BUS_FMT_SGRBG10_1X10, 10, 10, CCS_PIXEL_ORDER_GRBG, },
0540     { MEDIA_BUS_FMT_SRGGB10_1X10, 10, 10, CCS_PIXEL_ORDER_RGGB, },
0541     { MEDIA_BUS_FMT_SBGGR10_1X10, 10, 10, CCS_PIXEL_ORDER_BGGR, },
0542     { MEDIA_BUS_FMT_SGBRG10_1X10, 10, 10, CCS_PIXEL_ORDER_GBRG, },
0543     { MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_GRBG, },
0544     { MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_RGGB, },
0545     { MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_BGGR, },
0546     { MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, 10, 8, CCS_PIXEL_ORDER_GBRG, },
0547     { MEDIA_BUS_FMT_SGRBG8_1X8, 8, 8, CCS_PIXEL_ORDER_GRBG, },
0548     { MEDIA_BUS_FMT_SRGGB8_1X8, 8, 8, CCS_PIXEL_ORDER_RGGB, },
0549     { MEDIA_BUS_FMT_SBGGR8_1X8, 8, 8, CCS_PIXEL_ORDER_BGGR, },
0550     { MEDIA_BUS_FMT_SGBRG8_1X8, 8, 8, CCS_PIXEL_ORDER_GBRG, },
0551 };
0552
0553 static const char *pixel_order_str[] = { "GRBG", "RGGB", "BGGR", "GBRG" };
0554
0555 #define to_csi_format_idx(fmt) (((unsigned long)(fmt)           \
0556                  - (unsigned long)ccs_csi_data_formats) \
0557                 / sizeof(*ccs_csi_data_formats))
0558
0559 static u32 ccs_pixel_order(struct ccs_sensor *sensor)
0560 {
0561     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0562     int flip = 0;
0563
0564     if (sensor->hflip) {
0565         if (sensor->hflip->val)
0566             flip |= CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR;
0567
0568         if (sensor->vflip->val)
0569             flip |= CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
0570     }
0571
0572     flip ^= sensor->hvflip_inv_mask;
0573
0574     dev_dbg(&client->dev, "flip %u\n", flip);
0575     return sensor->default_pixel_order ^ flip;
0576 }
0577
0578 static void ccs_update_mbus_formats(struct ccs_sensor *sensor)
0579 {
0580     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0581     unsigned int csi_format_idx =
0582         to_csi_format_idx(sensor->csi_format) & ~3;
0583     unsigned int internal_csi_format_idx =
0584         to_csi_format_idx(sensor->internal_csi_format) & ~3;
0585     unsigned int pixel_order = ccs_pixel_order(sensor);
0586
0587     if (WARN_ON_ONCE(max(internal_csi_format_idx, csi_format_idx) +
0588              pixel_order >= ARRAY_SIZE(ccs_csi_data_formats)))
0589         return;
0590
0591     sensor->mbus_frame_fmts =
0592         sensor->default_mbus_frame_fmts << pixel_order;
0593     sensor->csi_format =
0594         &ccs_csi_data_formats[csi_format_idx + pixel_order];
0595     sensor->internal_csi_format =
0596         &ccs_csi_data_formats[internal_csi_format_idx
0597                      + pixel_order];
0598
0599     dev_dbg(&client->dev, "new pixel order %s\n",
0600         pixel_order_str[pixel_order]);
0601 }
0602
0603 static const char * const ccs_test_patterns[] = {
0604     "Disabled",
0605     "Solid Colour",
0606     "Eight Vertical Colour Bars",
0607     "Colour Bars With Fade to Grey",
0608     "Pseudorandom Sequence (PN9)",
0609 };
0610
0611 static int ccs_set_ctrl(struct v4l2_ctrl *ctrl)
0612 {
0613     struct ccs_sensor *sensor =
0614         container_of(ctrl->handler, struct ccs_subdev, ctrl_handler)
0615             ->sensor;
0616     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0617     int pm_status;
0618     u32 orient = 0;
0619     unsigned int i;
0620     int exposure;
0621     int rval;
0622
0623     switch (ctrl->id) {
0624     case V4L2_CID_HFLIP:
0625     case V4L2_CID_VFLIP:
0626         if (sensor->streaming)
0627             return -EBUSY;
0628
0629         if (sensor->hflip->val)
0630             orient |= CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR;
0631
0632         if (sensor->vflip->val)
0633             orient |= CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
0634
0635         orient ^= sensor->hvflip_inv_mask;
0636
0637         ccs_update_mbus_formats(sensor);
0638
0639         break;
0640     case V4L2_CID_VBLANK:
0641         exposure = sensor->exposure->val;
0642
0643         __ccs_update_exposure_limits(sensor);
0644
0645         if (exposure > sensor->exposure->maximum) {
0646             sensor->exposure->val = sensor->exposure->maximum;
0647             rval = ccs_set_ctrl(sensor->exposure);
0648             if (rval < 0)
0649                 return rval;
0650         }
0651
0652         break;
0653     case V4L2_CID_LINK_FREQ:
0654         if (sensor->streaming)
0655             return -EBUSY;
0656
0657         rval = ccs_pll_update(sensor);
0658         if (rval)
0659             return rval;
0660
0661         return 0;
0662     case V4L2_CID_TEST_PATTERN:
0663         for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
0664             v4l2_ctrl_activate(
0665                 sensor->test_data[i],
0666                 ctrl->val ==
0667                 V4L2_SMIAPP_TEST_PATTERN_MODE_SOLID_COLOUR);
0668
0669         break;
0670     }
0671
0672     pm_status = pm_runtime_get_if_active(&client->dev, true);
0673     if (!pm_status)
0674         return 0;
0675
0676     switch (ctrl->id) {
0677     case V4L2_CID_ANALOGUE_GAIN:
0678         rval = ccs_write(sensor, ANALOG_GAIN_CODE_GLOBAL, ctrl->val);
0679
0680         break;
0681
0682     case V4L2_CID_CCS_ANALOGUE_LINEAR_GAIN:
0683         rval = ccs_write(sensor, ANALOG_LINEAR_GAIN_GLOBAL, ctrl->val);
0684
0685         break;
0686
0687     case V4L2_CID_CCS_ANALOGUE_EXPONENTIAL_GAIN:
0688         rval = ccs_write(sensor, ANALOG_EXPONENTIAL_GAIN_GLOBAL,
0689                  ctrl->val);
0690
0691         break;
0692
0693     case V4L2_CID_DIGITAL_GAIN:
0694         if (CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) ==
0695             CCS_DIGITAL_GAIN_CAPABILITY_GLOBAL) {
0696             rval = ccs_write(sensor, DIGITAL_GAIN_GLOBAL,
0697                      ctrl->val);
0698             break;
0699         }
0700
0701         rval = ccs_write_addr(sensor,
0702                       SMIAPP_REG_U16_DIGITAL_GAIN_GREENR,
0703                       ctrl->val);
0704         if (rval)
0705             break;
0706
0707         rval = ccs_write_addr(sensor,
0708                       SMIAPP_REG_U16_DIGITAL_GAIN_RED,
0709                       ctrl->val);
0710         if (rval)
0711             break;
0712
0713         rval = ccs_write_addr(sensor,
0714                       SMIAPP_REG_U16_DIGITAL_GAIN_BLUE,
0715                       ctrl->val);
0716         if (rval)
0717             break;
0718
0719         rval = ccs_write_addr(sensor,
0720                       SMIAPP_REG_U16_DIGITAL_GAIN_GREENB,
0721                       ctrl->val);
0722
0723         break;
0724     case V4L2_CID_EXPOSURE:
0725         rval = ccs_write(sensor, COARSE_INTEGRATION_TIME, ctrl->val);
0726
0727         break;
0728     case V4L2_CID_HFLIP:
0729     case V4L2_CID_VFLIP:
0730         rval = ccs_write(sensor, IMAGE_ORIENTATION, orient);
0731
0732         break;
0733     case V4L2_CID_VBLANK:
0734         rval = ccs_write(sensor, FRAME_LENGTH_LINES,
0735                  sensor->pixel_array->crop[
0736                      CCS_PA_PAD_SRC].height
0737                  + ctrl->val);
0738
0739         break;
0740     case V4L2_CID_HBLANK:
0741         rval = ccs_write(sensor, LINE_LENGTH_PCK,
0742                  sensor->pixel_array->crop[CCS_PA_PAD_SRC].width
0743                  + ctrl->val);
0744
0745         break;
0746     case V4L2_CID_TEST_PATTERN:
0747         rval = ccs_write(sensor, TEST_PATTERN_MODE, ctrl->val);
0748
0749         break;
0750     case V4L2_CID_TEST_PATTERN_RED:
0751         rval = ccs_write(sensor, TEST_DATA_RED, ctrl->val);
0752
0753         break;
0754     case V4L2_CID_TEST_PATTERN_GREENR:
0755         rval = ccs_write(sensor, TEST_DATA_GREENR, ctrl->val);
0756
0757         break;
0758     case V4L2_CID_TEST_PATTERN_BLUE:
0759         rval = ccs_write(sensor, TEST_DATA_BLUE, ctrl->val);
0760
0761         break;
0762     case V4L2_CID_TEST_PATTERN_GREENB:
0763         rval = ccs_write(sensor, TEST_DATA_GREENB, ctrl->val);
0764
0765         break;
0766     case V4L2_CID_CCS_SHADING_CORRECTION:
0767         rval = ccs_write(sensor, SHADING_CORRECTION_EN,
0768                  ctrl->val ? CCS_SHADING_CORRECTION_EN_ENABLE :
0769                  0);
0770
0771         if (!rval && sensor->luminance_level)
0772             v4l2_ctrl_activate(sensor->luminance_level, ctrl->val);
0773
0774         break;
0775     case V4L2_CID_CCS_LUMINANCE_CORRECTION_LEVEL:
0776         rval = ccs_write(sensor, LUMINANCE_CORRECTION_LEVEL, ctrl->val);
0777
0778         break;
0779     case V4L2_CID_PIXEL_RATE:
0780         /* For v4l2_ctrl_s_ctrl_int64() used internally. */
0781         rval = 0;
0782
0783         break;
0784     default:
0785         rval = -EINVAL;
0786     }
0787
0788     if (pm_status > 0) {
0789         pm_runtime_mark_last_busy(&client->dev);
0790         pm_runtime_put_autosuspend(&client->dev);
0791     }
0792
0793     return rval;
0794 }
0795
0796 static const struct v4l2_ctrl_ops ccs_ctrl_ops = {
0797     .s_ctrl = ccs_set_ctrl,
0798 };
0799
0800 static int ccs_init_controls(struct ccs_sensor *sensor)
0801 {
0802     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0803     int rval;
0804
0805     rval = v4l2_ctrl_handler_init(&sensor->pixel_array->ctrl_handler, 17);
0806     if (rval)
0807         return rval;
0808
0809     sensor->pixel_array->ctrl_handler.lock = &sensor->mutex;
0810
0811     switch (CCS_LIM(sensor, ANALOG_GAIN_CAPABILITY)) {
0812     case CCS_ANALOG_GAIN_CAPABILITY_GLOBAL: {
0813         struct {
0814             const char *name;
0815             u32 id;
0816             s32 value;
0817         } const gain_ctrls[] = {
0818             { "Analogue Gain m0", V4L2_CID_CCS_ANALOGUE_GAIN_M0,
0819               CCS_LIM(sensor, ANALOG_GAIN_M0), },
0820             { "Analogue Gain c0", V4L2_CID_CCS_ANALOGUE_GAIN_C0,
0821               CCS_LIM(sensor, ANALOG_GAIN_C0), },
0822             { "Analogue Gain m1", V4L2_CID_CCS_ANALOGUE_GAIN_M1,
0823               CCS_LIM(sensor, ANALOG_GAIN_M1), },
0824             { "Analogue Gain c1", V4L2_CID_CCS_ANALOGUE_GAIN_C1,
0825               CCS_LIM(sensor, ANALOG_GAIN_C1), },
0826         };
0827         struct v4l2_ctrl_config ctrl_cfg = {
0828             .type = V4L2_CTRL_TYPE_INTEGER,
0829             .ops = &ccs_ctrl_ops,
0830             .flags = V4L2_CTRL_FLAG_READ_ONLY,
0831             .step = 1,
0832         };
0833         unsigned int i;
0834
0835         for (i = 0; i < ARRAY_SIZE(gain_ctrls); i++) {
0836             ctrl_cfg.name = gain_ctrls[i].name;
0837             ctrl_cfg.id = gain_ctrls[i].id;
0838             ctrl_cfg.min = ctrl_cfg.max = ctrl_cfg.def =
0839                 gain_ctrls[i].value;
0840
0841             v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
0842                          &ctrl_cfg, NULL);
0843         }
0844
0845         v4l2_ctrl_new_std(&sensor->pixel_array->ctrl_handler,
0846                   &ccs_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
0847                   CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN),
0848                   CCS_LIM(sensor, ANALOG_GAIN_CODE_MAX),
0849                   max(CCS_LIM(sensor, ANALOG_GAIN_CODE_STEP),
0850                       1U),
0851                   CCS_LIM(sensor, ANALOG_GAIN_CODE_MIN));
0852     }
0853         break;
0854
0855     case CCS_ANALOG_GAIN_CAPABILITY_ALTERNATE_GLOBAL: {
0856         struct {
0857             const char *name;
0858             u32 id;
0859             u16 min, max, step;
0860         } const gain_ctrls[] = {
0861             {
0862                 "Analogue Linear Gain",
0863                 V4L2_CID_CCS_ANALOGUE_LINEAR_GAIN,
0864                 CCS_LIM(sensor, ANALOG_LINEAR_GAIN_MIN),
0865                 CCS_LIM(sensor, ANALOG_LINEAR_GAIN_MAX),
0866                 max(CCS_LIM(sensor,
0867                         ANALOG_LINEAR_GAIN_STEP_SIZE),
0868                     1U),
0869             },
0870             {
0871                 "Analogue Exponential Gain",
0872                 V4L2_CID_CCS_ANALOGUE_EXPONENTIAL_GAIN,
0873                 CCS_LIM(sensor, ANALOG_EXPONENTIAL_GAIN_MIN),
0874                 CCS_LIM(sensor, ANALOG_EXPONENTIAL_GAIN_MAX),
0875                 max(CCS_LIM(sensor,
0876                         ANALOG_EXPONENTIAL_GAIN_STEP_SIZE),
0877                     1U),
0878             },
0879         };
0880         struct v4l2_ctrl_config ctrl_cfg = {
0881             .type = V4L2_CTRL_TYPE_INTEGER,
0882             .ops = &ccs_ctrl_ops,
0883         };
0884         unsigned int i;
0885
0886         for (i = 0; i < ARRAY_SIZE(gain_ctrls); i++) {
0887             ctrl_cfg.name = gain_ctrls[i].name;
0888             ctrl_cfg.min = ctrl_cfg.def = gain_ctrls[i].min;
0889             ctrl_cfg.max = gain_ctrls[i].max;
0890             ctrl_cfg.step = gain_ctrls[i].step;
0891             ctrl_cfg.id = gain_ctrls[i].id;
0892
0893             v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
0894                          &ctrl_cfg, NULL);
0895         }
0896     }
0897     }
0898
0899     if (CCS_LIM(sensor, SHADING_CORRECTION_CAPABILITY) &
0900         (CCS_SHADING_CORRECTION_CAPABILITY_COLOR_SHADING |
0901          CCS_SHADING_CORRECTION_CAPABILITY_LUMINANCE_CORRECTION)) {
0902         const struct v4l2_ctrl_config ctrl_cfg = {
0903             .name = "Shading Correction",
0904             .type = V4L2_CTRL_TYPE_BOOLEAN,
0905             .id = V4L2_CID_CCS_SHADING_CORRECTION,
0906             .ops = &ccs_ctrl_ops,
0907             .max = 1,
0908             .step = 1,
0909         };
0910
0911         v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
0912                      &ctrl_cfg, NULL);
0913     }
0914
0915     if (CCS_LIM(sensor, SHADING_CORRECTION_CAPABILITY) &
0916         CCS_SHADING_CORRECTION_CAPABILITY_LUMINANCE_CORRECTION) {
0917         const struct v4l2_ctrl_config ctrl_cfg = {
0918             .name = "Luminance Correction Level",
0919             .type = V4L2_CTRL_TYPE_BOOLEAN,
0920             .id = V4L2_CID_CCS_LUMINANCE_CORRECTION_LEVEL,
0921             .ops = &ccs_ctrl_ops,
0922             .max = 255,
0923             .step = 1,
0924             .def = 128,
0925         };
0926
0927         sensor->luminance_level =
0928             v4l2_ctrl_new_custom(&sensor->pixel_array->ctrl_handler,
0929                          &ctrl_cfg, NULL);
0930     }
0931
0932     if (CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) ==
0933         CCS_DIGITAL_GAIN_CAPABILITY_GLOBAL ||
0934         CCS_LIM(sensor, DIGITAL_GAIN_CAPABILITY) ==
0935         SMIAPP_DIGITAL_GAIN_CAPABILITY_PER_CHANNEL)
0936         v4l2_ctrl_new_std(&sensor->pixel_array->ctrl_handler,
0937                   &ccs_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
0938                   CCS_LIM(sensor, DIGITAL_GAIN_MIN),
0939                   CCS_LIM(sensor, DIGITAL_GAIN_MAX),
0940                   max(CCS_LIM(sensor, DIGITAL_GAIN_STEP_SIZE),
0941                       1U),
0942                   0x100);
0943
0944     /* Exposure limits will be updated soon, use just something here. */
0945     sensor->exposure = v4l2_ctrl_new_std(
0946         &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
0947         V4L2_CID_EXPOSURE, 0, 0, 1, 0);
0948
0949     sensor->hflip = v4l2_ctrl_new_std(
0950         &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
0951         V4L2_CID_HFLIP, 0, 1, 1, 0);
0952     sensor->vflip = v4l2_ctrl_new_std(
0953         &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
0954         V4L2_CID_VFLIP, 0, 1, 1, 0);
0955
0956     sensor->vblank = v4l2_ctrl_new_std(
0957         &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
0958         V4L2_CID_VBLANK, 0, 1, 1, 0);
0959
0960     if (sensor->vblank)
0961         sensor->vblank->flags |= V4L2_CTRL_FLAG_UPDATE;
0962
0963     sensor->hblank = v4l2_ctrl_new_std(
0964         &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
0965         V4L2_CID_HBLANK, 0, 1, 1, 0);
0966
0967     if (sensor->hblank)
0968         sensor->hblank->flags |= V4L2_CTRL_FLAG_UPDATE;
0969
0970     sensor->pixel_rate_parray = v4l2_ctrl_new_std(
0971         &sensor->pixel_array->ctrl_handler, &ccs_ctrl_ops,
0972         V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
0973
0974     v4l2_ctrl_new_std_menu_items(&sensor->pixel_array->ctrl_handler,
0975                      &ccs_ctrl_ops, V4L2_CID_TEST_PATTERN,
0976                      ARRAY_SIZE(ccs_test_patterns) - 1,
0977                      0, 0, ccs_test_patterns);
0978
0979     if (sensor->pixel_array->ctrl_handler.error) {
0980         dev_err(&client->dev,
0981             "pixel array controls initialization failed (%d)\n",
0982             sensor->pixel_array->ctrl_handler.error);
0983         return sensor->pixel_array->ctrl_handler.error;
0984     }
0985
0986     sensor->pixel_array->sd.ctrl_handler =
0987         &sensor->pixel_array->ctrl_handler;
0988
0989     v4l2_ctrl_cluster(2, &sensor->hflip);
0990
0991     rval = v4l2_ctrl_handler_init(&sensor->src->ctrl_handler, 0);
0992     if (rval)
0993         return rval;
0994
0995     sensor->src->ctrl_handler.lock = &sensor->mutex;
0996
0997     sensor->pixel_rate_csi = v4l2_ctrl_new_std(
0998         &sensor->src->ctrl_handler, &ccs_ctrl_ops,
0999         V4L2_CID_PIXEL_RATE, 1, INT_MAX, 1, 1);
1000
1001     if (sensor->src->ctrl_handler.error) {
1002         dev_err(&client->dev,
1003             "src controls initialization failed (%d)\n",
1004             sensor->src->ctrl_handler.error);
1005         return sensor->src->ctrl_handler.error;
1006     }
1007
1008     sensor->src->sd.ctrl_handler = &sensor->src->ctrl_handler;
1009
1010     return 0;
1011 }
1012
1013 /*
1014  * For controls that require information on available media bus codes
1015  * and linke frequencies.
1016  */
1017 static int ccs_init_late_controls(struct ccs_sensor *sensor)
1018 {
1019     unsigned long *valid_link_freqs = &sensor->valid_link_freqs[
1020         sensor->csi_format->compressed - sensor->compressed_min_bpp];
1021     unsigned int i;
1022
1023     for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++) {
1024         int max_value = (1 << sensor->csi_format->width) - 1;
1025
1026         sensor->test_data[i] = v4l2_ctrl_new_std(
1027                 &sensor->pixel_array->ctrl_handler,
1028                 &ccs_ctrl_ops, V4L2_CID_TEST_PATTERN_RED + i,
1029                 0, max_value, 1, max_value);
1030     }
1031
1032     sensor->link_freq = v4l2_ctrl_new_int_menu(
1033         &sensor->src->ctrl_handler, &ccs_ctrl_ops,
1034         V4L2_CID_LINK_FREQ, __fls(*valid_link_freqs),
1035         __ffs(*valid_link_freqs), sensor->hwcfg.op_sys_clock);
1036
1037     return sensor->src->ctrl_handler.error;
1038 }
1039
1040 static void ccs_free_controls(struct ccs_sensor *sensor)
1041 {
1042     unsigned int i;
1043
1044     for (i = 0; i < sensor->ssds_used; i++)
1045         v4l2_ctrl_handler_free(&sensor->ssds[i].ctrl_handler);
1046 }
1047
1048 static int ccs_get_mbus_formats(struct ccs_sensor *sensor)
1049 {
1050     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1051     struct ccs_pll *pll = &sensor->pll;
1052     u8 compressed_max_bpp = 0;
1053     unsigned int type, n;
1054     unsigned int i, pixel_order;
1055     int rval;
1056
1057     type = CCS_LIM(sensor, DATA_FORMAT_MODEL_TYPE);
1058
1059     dev_dbg(&client->dev, "data_format_model_type %u\n", type);
1060
1061     rval = ccs_read(sensor, PIXEL_ORDER, &pixel_order);
1062     if (rval)
1063         return rval;
1064
1065     if (pixel_order >= ARRAY_SIZE(pixel_order_str)) {
1066         dev_dbg(&client->dev, "bad pixel order %u\n", pixel_order);
1067         return -EINVAL;
1068     }
1069
1070     dev_dbg(&client->dev, "pixel order %u (%s)\n", pixel_order,
1071         pixel_order_str[pixel_order]);
1072
1073     switch (type) {
1074     case CCS_DATA_FORMAT_MODEL_TYPE_NORMAL:
1075         n = SMIAPP_DATA_FORMAT_MODEL_TYPE_NORMAL_N;
1076         break;
1077     case CCS_DATA_FORMAT_MODEL_TYPE_EXTENDED:
1078         n = CCS_LIM_DATA_FORMAT_DESCRIPTOR_MAX_N + 1;
1079         break;
1080     default:
1081         return -EINVAL;
1082     }
1083
1084     sensor->default_pixel_order = pixel_order;
1085     sensor->mbus_frame_fmts = 0;
1086
1087     for (i = 0; i < n; i++) {
1088         unsigned int fmt, j;
1089
1090         fmt = CCS_LIM_AT(sensor, DATA_FORMAT_DESCRIPTOR, i);
1091
1092         dev_dbg(&client->dev, "%u: bpp %u, compressed %u\n",
1093             i, fmt >> 8, (u8)fmt);
1094
1095         for (j = 0; j < ARRAY_SIZE(ccs_csi_data_formats); j++) {
1096             const struct ccs_csi_data_format *f =
1097                 &ccs_csi_data_formats[j];
1098
1099             if (f->pixel_order != CCS_PIXEL_ORDER_GRBG)
1100                 continue;
1101
1102             if (f->width != fmt >>
1103                 CCS_DATA_FORMAT_DESCRIPTOR_UNCOMPRESSED_SHIFT ||
1104                 f->compressed !=
1105                 (fmt & CCS_DATA_FORMAT_DESCRIPTOR_COMPRESSED_MASK))
1106                 continue;
1107
1108             dev_dbg(&client->dev, "jolly good! %u\n", j);
1109
1110             sensor->default_mbus_frame_fmts |= 1 << j;
1111         }
1112     }
1113
1114     /* Figure out which BPP values can be used with which formats. */
1115     pll->binning_horizontal = 1;
1116     pll->binning_vertical = 1;
1117     pll->scale_m = sensor->scale_m;
1118
1119     for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
1120         sensor->compressed_min_bpp =
1121             min(ccs_csi_data_formats[i].compressed,
1122                 sensor->compressed_min_bpp);
1123         compressed_max_bpp =
1124             max(ccs_csi_data_formats[i].compressed,
1125                 compressed_max_bpp);
1126     }
1127
1128     sensor->valid_link_freqs = devm_kcalloc(
1129         &client->dev,
1130         compressed_max_bpp - sensor->compressed_min_bpp + 1,
1131         sizeof(*sensor->valid_link_freqs), GFP_KERNEL);
1132     if (!sensor->valid_link_freqs)
1133         return -ENOMEM;
1134
1135     for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
1136         const struct ccs_csi_data_format *f =
1137             &ccs_csi_data_formats[i];
1138         unsigned long *valid_link_freqs =
1139             &sensor->valid_link_freqs[
1140                 f->compressed - sensor->compressed_min_bpp];
1141         unsigned int j;
1142
1143         if (!(sensor->default_mbus_frame_fmts & 1 << i))
1144             continue;
1145
1146         pll->bits_per_pixel = f->compressed;
1147
1148         for (j = 0; sensor->hwcfg.op_sys_clock[j]; j++) {
1149             pll->link_freq = sensor->hwcfg.op_sys_clock[j];
1150
1151             rval = ccs_pll_try(sensor, pll);
1152             dev_dbg(&client->dev, "link freq %u Hz, bpp %u %s\n",
1153                 pll->link_freq, pll->bits_per_pixel,
1154                 rval ? "not ok" : "ok");
1155             if (rval)
1156                 continue;
1157
1158             set_bit(j, valid_link_freqs);
1159         }
1160
1161         if (!*valid_link_freqs) {
1162             dev_info(&client->dev,
1163                  "no valid link frequencies for %u bpp\n",
1164                  f->compressed);
1165             sensor->default_mbus_frame_fmts &= ~BIT(i);
1166             continue;
1167         }
1168
1169         if (!sensor->csi_format
1170             || f->width > sensor->csi_format->width
1171             || (f->width == sensor->csi_format->width
1172             && f->compressed > sensor->csi_format->compressed)) {
1173             sensor->csi_format = f;
1174             sensor->internal_csi_format = f;
1175         }
1176     }
1177
1178     if (!sensor->csi_format) {
1179         dev_err(&client->dev, "no supported mbus code found\n");
1180         return -EINVAL;
1181     }
1182
1183     ccs_update_mbus_formats(sensor);
1184
1185     return 0;
1186 }
1187
1188 static void ccs_update_blanking(struct ccs_sensor *sensor)
1189 {
1190     struct v4l2_ctrl *vblank = sensor->vblank;
1191     struct v4l2_ctrl *hblank = sensor->hblank;
1192     u16 min_fll, max_fll, min_llp, max_llp, min_lbp;
1193     int min, max;
1194
1195     if (sensor->binning_vertical > 1 || sensor->binning_horizontal > 1) {
1196         min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES_BIN);
1197         max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES_BIN);
1198         min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK_BIN);
1199         max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK_BIN);
1200         min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK_BIN);
1201     } else {
1202         min_fll = CCS_LIM(sensor, MIN_FRAME_LENGTH_LINES);
1203         max_fll = CCS_LIM(sensor, MAX_FRAME_LENGTH_LINES);
1204         min_llp = CCS_LIM(sensor, MIN_LINE_LENGTH_PCK);
1205         max_llp = CCS_LIM(sensor, MAX_LINE_LENGTH_PCK);
1206         min_lbp = CCS_LIM(sensor, MIN_LINE_BLANKING_PCK);
1207     }
1208
1209     min = max_t(int,
1210             CCS_LIM(sensor, MIN_FRAME_BLANKING_LINES),
1211             min_fll - sensor->pixel_array->crop[CCS_PA_PAD_SRC].height);
1212     max = max_fll - sensor->pixel_array->crop[CCS_PA_PAD_SRC].height;
1213
1214     __v4l2_ctrl_modify_range(vblank, min, max, vblank->step, min);
1215
1216     min = max_t(int,
1217             min_llp - sensor->pixel_array->crop[CCS_PA_PAD_SRC].width,
1218             min_lbp);
1219     max = max_llp - sensor->pixel_array->crop[CCS_PA_PAD_SRC].width;
1220
1221     __v4l2_ctrl_modify_range(hblank, min, max, hblank->step, min);
1222
1223     __ccs_update_exposure_limits(sensor);
1224 }
1225
1226 static int ccs_pll_blanking_update(struct ccs_sensor *sensor)
1227 {
1228     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1229     int rval;
1230
1231     rval = ccs_pll_update(sensor);
1232     if (rval < 0)
1233         return rval;
1234
1235     /* Output from pixel array, including blanking */
1236     ccs_update_blanking(sensor);
1237
1238     dev_dbg(&client->dev, "vblank\t\t%d\n", sensor->vblank->val);
1239     dev_dbg(&client->dev, "hblank\t\t%d\n", sensor->hblank->val);
1240
1241     dev_dbg(&client->dev, "real timeperframe\t100/%d\n",
1242         sensor->pll.pixel_rate_pixel_array /
1243         ((sensor->pixel_array->crop[CCS_PA_PAD_SRC].width
1244           + sensor->hblank->val) *
1245          (sensor->pixel_array->crop[CCS_PA_PAD_SRC].height
1246           + sensor->vblank->val) / 100));
1247
1248     return 0;
1249 }
1250
1251 /*
1252  *
1253  * SMIA++ NVM handling
1254  *
1255  */
1256
1257 static int ccs_read_nvm_page(struct ccs_sensor *sensor, u32 p, u8 *nvm,
1258                  u8 *status)
1259 {
1260     unsigned int i;
1261     int rval;
1262     u32 s;
1263
1264     *status = 0;
1265
1266     rval = ccs_write(sensor, DATA_TRANSFER_IF_1_PAGE_SELECT, p);
1267     if (rval)
1268         return rval;
1269
1270     rval = ccs_write(sensor, DATA_TRANSFER_IF_1_CTRL,
1271              CCS_DATA_TRANSFER_IF_1_CTRL_ENABLE);
1272     if (rval)
1273         return rval;
1274
1275     rval = ccs_read(sensor, DATA_TRANSFER_IF_1_STATUS, &s);
1276     if (rval)
1277         return rval;
1278
1279     if (s & CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE) {
1280         *status = s;
1281         return -ENODATA;
1282     }
1283
1284     if (CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &
1285         CCS_DATA_TRANSFER_IF_CAPABILITY_POLLING) {
1286         for (i = 1000; i > 0; i--) {
1287             if (s & CCS_DATA_TRANSFER_IF_1_STATUS_READ_IF_READY)
1288                 break;
1289
1290             rval = ccs_read(sensor, DATA_TRANSFER_IF_1_STATUS, &s);
1291             if (rval)
1292                 return rval;
1293         }
1294
1295         if (!i)
1296             return -ETIMEDOUT;
1297     }
1298
1299     for (i = 0; i <= CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P; i++) {
1300         u32 v;
1301
1302         rval = ccs_read(sensor, DATA_TRANSFER_IF_1_DATA(i), &v);
1303         if (rval)
1304             return rval;
1305
1306         *nvm++ = v;
1307     }
1308
1309     return 0;
1310 }
1311
1312 static int ccs_read_nvm(struct ccs_sensor *sensor, unsigned char *nvm,
1313             size_t nvm_size)
1314 {
1315     u8 status = 0;
1316     u32 p;
1317     int rval = 0, rval2;
1318
1319     for (p = 0; p < nvm_size / (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1)
1320              && !rval; p++) {
1321         rval = ccs_read_nvm_page(sensor, p, nvm, &status);
1322         nvm += CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1;
1323     }
1324
1325     if (rval == -ENODATA &&
1326         status & CCS_DATA_TRANSFER_IF_1_STATUS_IMPROPER_IF_USAGE)
1327         rval = 0;
1328
1329     rval2 = ccs_write(sensor, DATA_TRANSFER_IF_1_CTRL, 0);
1330     if (rval < 0)
1331         return rval;
1332     else
1333         return rval2 ?: p * (CCS_LIM_DATA_TRANSFER_IF_1_DATA_MAX_P + 1);
1334 }
1335
1336 /*
1337  *
1338  * SMIA++ CCI address control
1339  *
1340  */
1341 static int ccs_change_cci_addr(struct ccs_sensor *sensor)
1342 {
1343     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1344     int rval;
1345     u32 val;
1346
1347     client->addr = sensor->hwcfg.i2c_addr_dfl;
1348
1349     rval = ccs_write(sensor, CCI_ADDRESS_CTRL,
1350              sensor->hwcfg.i2c_addr_alt << 1);
1351     if (rval)
1352         return rval;
1353
1354     client->addr = sensor->hwcfg.i2c_addr_alt;
1355
1356     /* verify addr change went ok */
1357     rval = ccs_read(sensor, CCI_ADDRESS_CTRL, &val);
1358     if (rval)
1359         return rval;
1360
1361     if (val != sensor->hwcfg.i2c_addr_alt << 1)
1362         return -ENODEV;
1363
1364     return 0;
1365 }
1366
1367 /*
1368  *
1369  * SMIA++ Mode Control
1370  *
1371  */
1372 static int ccs_setup_flash_strobe(struct ccs_sensor *sensor)
1373 {
1374     struct ccs_flash_strobe_parms *strobe_setup;
1375     unsigned int ext_freq = sensor->hwcfg.ext_clk;
1376     u32 tmp;
1377     u32 strobe_adjustment;
1378     u32 strobe_width_high_rs;
1379     int rval;
1380
1381     strobe_setup = sensor->hwcfg.strobe_setup;
1382
1383     /*
1384      * How to calculate registers related to strobe length. Please
1385      * do not change, or if you do at least know what you're
1386      * doing. :-)
1387      *
1388      * Sakari Ailus <sakari.ailus@linux.intel.com> 2010-10-25
1389      *
1390      * flash_strobe_length [us] / 10^6 = (tFlash_strobe_width_ctrl
1391      *  / EXTCLK freq [Hz]) * flash_strobe_adjustment
1392      *
1393      * tFlash_strobe_width_ctrl E N, [1 - 0xffff]
1394      * flash_strobe_adjustment E N, [1 - 0xff]
1395      *
1396      * The formula above is written as below to keep it on one
1397      * line:
1398      *
1399      * l / 10^6 = w / e * a
1400      *
1401      * Let's mark w * a by x:
1402      *
1403      * x = w * a
1404      *
1405      * Thus, we get:
1406      *
1407      * x = l * e / 10^6
1408      *
1409      * The strobe width must be at least as long as requested,
1410      * thus rounding upwards is needed.
1411      *
1412      * x = (l * e + 10^6 - 1) / 10^6
1413      * -----------------------------
1414      *
1415      * Maximum possible accuracy is wanted at all times. Thus keep
1416      * a as small as possible.
1417      *
1418      * Calculate a, assuming maximum w, with rounding upwards:
1419      *
1420      * a = (x + (2^16 - 1) - 1) / (2^16 - 1)
1421      * -------------------------------------
1422      *
1423      * Thus, we also get w, with that a, with rounding upwards:
1424      *
1425      * w = (x + a - 1) / a
1426      * -------------------
1427      *
1428      * To get limits:
1429      *
1430      * x E [1, (2^16 - 1) * (2^8 - 1)]
1431      *
1432      * Substituting maximum x to the original formula (with rounding),
1433      * the maximum l is thus
1434      *
1435      * (2^16 - 1) * (2^8 - 1) * 10^6 = l * e + 10^6 - 1
1436      *
1437      * l = (10^6 * (2^16 - 1) * (2^8 - 1) - 10^6 + 1) / e
1438      * --------------------------------------------------
1439      *
1440      * flash_strobe_length must be clamped between 1 and
1441      * (10^6 * (2^16 - 1) * (2^8 - 1) - 10^6 + 1) / EXTCLK freq.
1442      *
1443      * Then,
1444      *
1445      * flash_strobe_adjustment = ((flash_strobe_length *
1446      *  EXTCLK freq + 10^6 - 1) / 10^6 + (2^16 - 1) - 1) / (2^16 - 1)
1447      *
1448      * tFlash_strobe_width_ctrl = ((flash_strobe_length *
1449      *  EXTCLK freq + 10^6 - 1) / 10^6 +
1450      *  flash_strobe_adjustment - 1) / flash_strobe_adjustment
1451      */
1452     tmp = div_u64(1000000ULL * ((1 << 16) - 1) * ((1 << 8) - 1) -
1453               1000000 + 1, ext_freq);
1454     strobe_setup->strobe_width_high_us =
1455         clamp_t(u32, strobe_setup->strobe_width_high_us, 1, tmp);
1456
1457     tmp = div_u64(((u64)strobe_setup->strobe_width_high_us * (u64)ext_freq +
1458             1000000 - 1), 1000000ULL);
1459     strobe_adjustment = (tmp + (1 << 16) - 1 - 1) / ((1 << 16) - 1);
1460     strobe_width_high_rs = (tmp + strobe_adjustment - 1) /
1461                 strobe_adjustment;
1462
1463     rval = ccs_write(sensor, FLASH_MODE_RS, strobe_setup->mode);
1464     if (rval < 0)
1465         goto out;
1466
1467     rval = ccs_write(sensor, FLASH_STROBE_ADJUSTMENT, strobe_adjustment);
1468     if (rval < 0)
1469         goto out;
1470
1471     rval = ccs_write(sensor, TFLASH_STROBE_WIDTH_HIGH_RS_CTRL,
1472              strobe_width_high_rs);
1473     if (rval < 0)
1474         goto out;
1475
1476     rval = ccs_write(sensor, TFLASH_STROBE_DELAY_RS_CTRL,
1477              strobe_setup->strobe_delay);
1478     if (rval < 0)
1479         goto out;
1480
1481     rval = ccs_write(sensor, FLASH_STROBE_START_POINT,
1482              strobe_setup->stobe_start_point);
1483     if (rval < 0)
1484         goto out;
1485
1486     rval = ccs_write(sensor, FLASH_TRIGGER_RS, strobe_setup->trigger);
1487
1488 out:
1489     sensor->hwcfg.strobe_setup->trigger = 0;
1490
1491     return rval;
1492 }
1493
1494 /* -----------------------------------------------------------------------------
1495  * Power management
1496  */
1497
1498 static int ccs_write_msr_regs(struct ccs_sensor *sensor)
1499 {
1500     int rval;
1501
1502     rval = ccs_write_data_regs(sensor,
1503                    sensor->sdata.sensor_manufacturer_regs,
1504                    sensor->sdata.num_sensor_manufacturer_regs);
1505     if (rval)
1506         return rval;
1507
1508     return ccs_write_data_regs(sensor,
1509                    sensor->mdata.module_manufacturer_regs,
1510                    sensor->mdata.num_module_manufacturer_regs);
1511 }
1512
1513 static int ccs_update_phy_ctrl(struct ccs_sensor *sensor)
1514 {
1515     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1516     u8 val;
1517
1518     if (!sensor->ccs_limits)
1519         return 0;
1520
1521     if (CCS_LIM(sensor, PHY_CTRL_CAPABILITY) &
1522         CCS_PHY_CTRL_CAPABILITY_AUTO_PHY_CTL) {
1523         val = CCS_PHY_CTRL_AUTO;
1524     } else if (CCS_LIM(sensor, PHY_CTRL_CAPABILITY) &
1525            CCS_PHY_CTRL_CAPABILITY_UI_PHY_CTL) {
1526         val = CCS_PHY_CTRL_UI;
1527     } else {
1528         dev_err(&client->dev, "manual PHY control not supported\n");
1529         return -EINVAL;
1530     }
1531
1532     return ccs_write(sensor, PHY_CTRL, val);
1533 }
1534
1535 static int ccs_power_on(struct device *dev)
1536 {
1537     struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1538     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
1539     /*
1540      * The sub-device related to the I2C device is always the
1541      * source one, i.e. ssds[0].
1542      */
1543     struct ccs_sensor *sensor =
1544         container_of(ssd, struct ccs_sensor, ssds[0]);
1545     const struct ccs_device *ccsdev = device_get_match_data(dev);
1546     int rval;
1547
1548     rval = regulator_bulk_enable(ARRAY_SIZE(ccs_regulators),
1549                      sensor->regulators);
1550     if (rval) {
1551         dev_err(dev, "failed to enable vana regulator\n");
1552         return rval;
1553     }
1554
1555     if (sensor->reset || sensor->xshutdown || sensor->ext_clk) {
1556         unsigned int sleep;
1557
1558         rval = clk_prepare_enable(sensor->ext_clk);
1559         if (rval < 0) {
1560             dev_dbg(dev, "failed to enable xclk\n");
1561             goto out_xclk_fail;
1562         }
1563
1564         gpiod_set_value(sensor->reset, 0);
1565         gpiod_set_value(sensor->xshutdown, 1);
1566
1567         if (ccsdev->flags & CCS_DEVICE_FLAG_IS_SMIA)
1568             sleep = SMIAPP_RESET_DELAY(sensor->hwcfg.ext_clk);
1569         else
1570             sleep = 5000;
1571
1572         usleep_range(sleep, sleep);
1573     }
1574
1575     /*
1576      * Failures to respond to the address change command have been noticed.
1577      * Those failures seem to be caused by the sensor requiring a longer
1578      * boot time than advertised. An additional 10ms delay seems to work
1579      * around the issue, but the SMIA++ I2C write retry hack makes the delay
1580      * unnecessary. The failures need to be investigated to find a proper
1581      * fix, and a delay will likely need to be added here if the I2C write
1582      * retry hack is reverted before the root cause of the boot time issue
1583      * is found.
1584      */
1585
1586     if (!sensor->reset && !sensor->xshutdown) {
1587         u8 retry = 100;
1588         u32 reset;
1589
1590         rval = ccs_write(sensor, SOFTWARE_RESET, CCS_SOFTWARE_RESET_ON);
1591         if (rval < 0) {
1592             dev_err(dev, "software reset failed\n");
1593             goto out_cci_addr_fail;
1594         }
1595
1596         do {
1597             rval = ccs_read(sensor, SOFTWARE_RESET, &reset);
1598             reset = !rval && reset == CCS_SOFTWARE_RESET_OFF;
1599             if (reset)
1600                 break;
1601
1602             usleep_range(1000, 2000);
1603         } while (--retry);
1604
1605         if (!reset) {
1606             dev_err(dev, "software reset failed\n");
1607             rval = -EIO;
1608             goto out_cci_addr_fail;
1609         }
1610     }
1611
1612     if (sensor->hwcfg.i2c_addr_alt) {
1613         rval = ccs_change_cci_addr(sensor);
1614         if (rval) {
1615             dev_err(dev, "cci address change error\n");
1616             goto out_cci_addr_fail;
1617         }
1618     }
1619
1620     rval = ccs_write(sensor, COMPRESSION_MODE,
1621              CCS_COMPRESSION_MODE_DPCM_PCM_SIMPLE);
1622     if (rval) {
1623         dev_err(dev, "compression mode set failed\n");
1624         goto out_cci_addr_fail;
1625     }
1626
1627     rval = ccs_write(sensor, EXTCLK_FREQUENCY_MHZ,
1628              sensor->hwcfg.ext_clk / (1000000 / (1 << 8)));
1629     if (rval) {
1630         dev_err(dev, "extclk frequency set failed\n");
1631         goto out_cci_addr_fail;
1632     }
1633
1634     rval = ccs_write(sensor, CSI_LANE_MODE, sensor->hwcfg.lanes - 1);
1635     if (rval) {
1636         dev_err(dev, "csi lane mode set failed\n");
1637         goto out_cci_addr_fail;
1638     }
1639
1640     rval = ccs_write(sensor, FAST_STANDBY_CTRL,
1641              CCS_FAST_STANDBY_CTRL_FRAME_TRUNCATION);
1642     if (rval) {
1643         dev_err(dev, "fast standby set failed\n");
1644         goto out_cci_addr_fail;
1645     }
1646
1647     rval = ccs_write(sensor, CSI_SIGNALING_MODE,
1648              sensor->hwcfg.csi_signalling_mode);
1649     if (rval) {
1650         dev_err(dev, "csi signalling mode set failed\n");
1651         goto out_cci_addr_fail;
1652     }
1653
1654     rval = ccs_update_phy_ctrl(sensor);
1655     if (rval < 0)
1656         goto out_cci_addr_fail;
1657
1658     rval = ccs_write_msr_regs(sensor);
1659     if (rval)
1660         goto out_cci_addr_fail;
1661
1662     rval = ccs_call_quirk(sensor, post_poweron);
1663     if (rval) {
1664         dev_err(dev, "post_poweron quirks failed\n");
1665         goto out_cci_addr_fail;
1666     }
1667
1668     return 0;
1669
1670 out_cci_addr_fail:
1671     gpiod_set_value(sensor->reset, 1);
1672     gpiod_set_value(sensor->xshutdown, 0);
1673     clk_disable_unprepare(sensor->ext_clk);
1674
1675 out_xclk_fail:
1676     regulator_bulk_disable(ARRAY_SIZE(ccs_regulators),
1677                    sensor->regulators);
1678
1679     return rval;
1680 }
1681
1682 static int ccs_power_off(struct device *dev)
1683 {
1684     struct v4l2_subdev *subdev = dev_get_drvdata(dev);
1685     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
1686     struct ccs_sensor *sensor =
1687         container_of(ssd, struct ccs_sensor, ssds[0]);
1688
1689     /*
1690      * Currently power/clock to lens are enable/disabled separately
1691      * but they are essentially the same signals. So if the sensor is
1692      * powered off while the lens is powered on the sensor does not
1693      * really see a power off and next time the cci address change
1694      * will fail. So do a soft reset explicitly here.
1695      */
1696     if (sensor->hwcfg.i2c_addr_alt)
1697         ccs_write(sensor, SOFTWARE_RESET, CCS_SOFTWARE_RESET_ON);
1698
1699     gpiod_set_value(sensor->reset, 1);
1700     gpiod_set_value(sensor->xshutdown, 0);
1701     clk_disable_unprepare(sensor->ext_clk);
1702     usleep_range(5000, 5000);
1703     regulator_bulk_disable(ARRAY_SIZE(ccs_regulators),
1704                    sensor->regulators);
1705     sensor->streaming = false;
1706
1707     return 0;
1708 }
1709
1710 /* -----------------------------------------------------------------------------
1711  * Video stream management
1712  */
1713
1714 static int ccs_start_streaming(struct ccs_sensor *sensor)
1715 {
1716     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1717     unsigned int binning_mode;
1718     int rval;
1719
1720     mutex_lock(&sensor->mutex);
1721
1722     rval = ccs_write(sensor, CSI_DATA_FORMAT,
1723              (sensor->csi_format->width << 8) |
1724              sensor->csi_format->compressed);
1725     if (rval)
1726         goto out;
1727
1728     /* Binning configuration */
1729     if (sensor->binning_horizontal == 1 &&
1730         sensor->binning_vertical == 1) {
1731         binning_mode = 0;
1732     } else {
1733         u8 binning_type =
1734             (sensor->binning_horizontal << 4)
1735             | sensor->binning_vertical;
1736
1737         rval = ccs_write(sensor, BINNING_TYPE, binning_type);
1738         if (rval < 0)
1739             goto out;
1740
1741         binning_mode = 1;
1742     }
1743     rval = ccs_write(sensor, BINNING_MODE, binning_mode);
1744     if (rval < 0)
1745         goto out;
1746
1747     /* Set up PLL */
1748     rval = ccs_pll_configure(sensor);
1749     if (rval)
1750         goto out;
1751
1752     /* Analog crop start coordinates */
1753     rval = ccs_write(sensor, X_ADDR_START,
1754              sensor->pixel_array->crop[CCS_PA_PAD_SRC].left);
1755     if (rval < 0)
1756         goto out;
1757
1758     rval = ccs_write(sensor, Y_ADDR_START,
1759              sensor->pixel_array->crop[CCS_PA_PAD_SRC].top);
1760     if (rval < 0)
1761         goto out;
1762
1763     /* Analog crop end coordinates */
1764     rval = ccs_write(
1765         sensor, X_ADDR_END,
1766         sensor->pixel_array->crop[CCS_PA_PAD_SRC].left
1767         + sensor->pixel_array->crop[CCS_PA_PAD_SRC].width - 1);
1768     if (rval < 0)
1769         goto out;
1770
1771     rval = ccs_write(
1772         sensor, Y_ADDR_END,
1773         sensor->pixel_array->crop[CCS_PA_PAD_SRC].top
1774         + sensor->pixel_array->crop[CCS_PA_PAD_SRC].height - 1);
1775     if (rval < 0)
1776         goto out;
1777
1778     /*
1779      * Output from pixel array, including blanking, is set using
1780      * controls below. No need to set here.
1781      */
1782
1783     /* Digital crop */
1784     if (CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
1785         == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
1786         rval = ccs_write(
1787             sensor, DIGITAL_CROP_X_OFFSET,
1788             sensor->scaler->crop[CCS_PAD_SINK].left);
1789         if (rval < 0)
1790             goto out;
1791
1792         rval = ccs_write(
1793             sensor, DIGITAL_CROP_Y_OFFSET,
1794             sensor->scaler->crop[CCS_PAD_SINK].top);
1795         if (rval < 0)
1796             goto out;
1797
1798         rval = ccs_write(
1799             sensor, DIGITAL_CROP_IMAGE_WIDTH,
1800             sensor->scaler->crop[CCS_PAD_SINK].width);
1801         if (rval < 0)
1802             goto out;
1803
1804         rval = ccs_write(
1805             sensor, DIGITAL_CROP_IMAGE_HEIGHT,
1806             sensor->scaler->crop[CCS_PAD_SINK].height);
1807         if (rval < 0)
1808             goto out;
1809     }
1810
1811     /* Scaling */
1812     if (CCS_LIM(sensor, SCALING_CAPABILITY)
1813         != CCS_SCALING_CAPABILITY_NONE) {
1814         rval = ccs_write(sensor, SCALING_MODE, sensor->scaling_mode);
1815         if (rval < 0)
1816             goto out;
1817
1818         rval = ccs_write(sensor, SCALE_M, sensor->scale_m);
1819         if (rval < 0)
1820             goto out;
1821     }
1822
1823     /* Output size from sensor */
1824     rval = ccs_write(sensor, X_OUTPUT_SIZE,
1825              sensor->src->crop[CCS_PAD_SRC].width);
1826     if (rval < 0)
1827         goto out;
1828     rval = ccs_write(sensor, Y_OUTPUT_SIZE,
1829              sensor->src->crop[CCS_PAD_SRC].height);
1830     if (rval < 0)
1831         goto out;
1832
1833     if (CCS_LIM(sensor, FLASH_MODE_CAPABILITY) &
1834         (CCS_FLASH_MODE_CAPABILITY_SINGLE_STROBE |
1835          SMIAPP_FLASH_MODE_CAPABILITY_MULTIPLE_STROBE) &&
1836         sensor->hwcfg.strobe_setup != NULL &&
1837         sensor->hwcfg.strobe_setup->trigger != 0) {
1838         rval = ccs_setup_flash_strobe(sensor);
1839         if (rval)
1840             goto out;
1841     }
1842
1843     rval = ccs_call_quirk(sensor, pre_streamon);
1844     if (rval) {
1845         dev_err(&client->dev, "pre_streamon quirks failed\n");
1846         goto out;
1847     }
1848
1849     rval = ccs_write(sensor, MODE_SELECT, CCS_MODE_SELECT_STREAMING);
1850
1851 out:
1852     mutex_unlock(&sensor->mutex);
1853
1854     return rval;
1855 }
1856
1857 static int ccs_stop_streaming(struct ccs_sensor *sensor)
1858 {
1859     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1860     int rval;
1861
1862     mutex_lock(&sensor->mutex);
1863     rval = ccs_write(sensor, MODE_SELECT, CCS_MODE_SELECT_SOFTWARE_STANDBY);
1864     if (rval)
1865         goto out;
1866
1867     rval = ccs_call_quirk(sensor, post_streamoff);
1868     if (rval)
1869         dev_err(&client->dev, "post_streamoff quirks failed\n");
1870
1871 out:
1872     mutex_unlock(&sensor->mutex);
1873     return rval;
1874 }
1875
1876 /* -----------------------------------------------------------------------------
1877  * V4L2 subdev video operations
1878  */
1879
1880 static int ccs_pm_get_init(struct ccs_sensor *sensor)
1881 {
1882     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1883     int rval;
1884
1885     /*
1886      * It can't use pm_runtime_resume_and_get() here, as the driver
1887      * relies at the returned value to detect if the device was already
1888      * active or not.
1889      */
1890     rval = pm_runtime_get_sync(&client->dev);
1891     if (rval < 0)
1892         goto error;
1893
1894     /* Device was already active, so don't set controls */
1895     if (rval == 1)
1896         return 0;
1897
1898     /* Restore V4L2 controls to the previously suspended device */
1899     rval = v4l2_ctrl_handler_setup(&sensor->pixel_array->ctrl_handler);
1900     if (rval)
1901         goto error;
1902
1903     rval = v4l2_ctrl_handler_setup(&sensor->src->ctrl_handler);
1904     if (rval)
1905         goto error;
1906
1907     /* Keep PM runtime usage_count incremented on success */
1908     return 0;
1909 error:
1910     pm_runtime_put(&client->dev);
1911     return rval;
1912 }
1913
1914 static int ccs_set_stream(struct v4l2_subdev *subdev, int enable)
1915 {
1916     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1917     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1918     int rval;
1919
1920     if (sensor->streaming == enable)
1921         return 0;
1922
1923     if (!enable) {
1924         ccs_stop_streaming(sensor);
1925         sensor->streaming = false;
1926         pm_runtime_mark_last_busy(&client->dev);
1927         pm_runtime_put_autosuspend(&client->dev);
1928
1929         return 0;
1930     }
1931
1932     rval = ccs_pm_get_init(sensor);
1933     if (rval)
1934         return rval;
1935
1936     sensor->streaming = true;
1937
1938     rval = ccs_start_streaming(sensor);
1939     if (rval < 0) {
1940         sensor->streaming = false;
1941         pm_runtime_mark_last_busy(&client->dev);
1942         pm_runtime_put_autosuspend(&client->dev);
1943     }
1944
1945     return rval;
1946 }
1947
1948 static int ccs_pre_streamon(struct v4l2_subdev *subdev, u32 flags)
1949 {
1950     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1951     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1952     int rval;
1953
1954     if (flags & V4L2_SUBDEV_PRE_STREAMON_FL_MANUAL_LP) {
1955         switch (sensor->hwcfg.csi_signalling_mode) {
1956         case CCS_CSI_SIGNALING_MODE_CSI_2_DPHY:
1957             if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY_2) &
1958                   CCS_PHY_CTRL_CAPABILITY_2_MANUAL_LP_DPHY))
1959                 return -EACCES;
1960             break;
1961         case CCS_CSI_SIGNALING_MODE_CSI_2_CPHY:
1962             if (!(CCS_LIM(sensor, PHY_CTRL_CAPABILITY_2) &
1963                   CCS_PHY_CTRL_CAPABILITY_2_MANUAL_LP_CPHY))
1964                 return -EACCES;
1965             break;
1966         default:
1967             return -EACCES;
1968         }
1969     }
1970
1971     rval = ccs_pm_get_init(sensor);
1972     if (rval)
1973         return rval;
1974
1975     if (flags & V4L2_SUBDEV_PRE_STREAMON_FL_MANUAL_LP) {
1976         rval = ccs_write(sensor, MANUAL_LP_CTRL,
1977                  CCS_MANUAL_LP_CTRL_ENABLE);
1978         if (rval)
1979             pm_runtime_put(&client->dev);
1980     }
1981
1982     return rval;
1983 }
1984
1985 static int ccs_post_streamoff(struct v4l2_subdev *subdev)
1986 {
1987     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1988     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
1989
1990     return pm_runtime_put(&client->dev);
1991 }
1992
1993 static int ccs_enum_mbus_code(struct v4l2_subdev *subdev,
1994                   struct v4l2_subdev_state *sd_state,
1995                   struct v4l2_subdev_mbus_code_enum *code)
1996 {
1997     struct i2c_client *client = v4l2_get_subdevdata(subdev);
1998     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
1999     unsigned int i;
2000     int idx = -1;
2001     int rval = -EINVAL;
2002
2003     mutex_lock(&sensor->mutex);
2004
2005     dev_err(&client->dev, "subdev %s, pad %u, index %u\n",
2006         subdev->name, code->pad, code->index);
2007
2008     if (subdev != &sensor->src->sd || code->pad != CCS_PAD_SRC) {
2009         if (code->index)
2010             goto out;
2011
2012         code->code = sensor->internal_csi_format->code;
2013         rval = 0;
2014         goto out;
2015     }
2016
2017     for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
2018         if (sensor->mbus_frame_fmts & (1 << i))
2019             idx++;
2020
2021         if (idx == code->index) {
2022             code->code = ccs_csi_data_formats[i].code;
2023             dev_err(&client->dev, "found index %u, i %u, code %x\n",
2024                 code->index, i, code->code);
2025             rval = 0;
2026             break;
2027         }
2028     }
2029
2030 out:
2031     mutex_unlock(&sensor->mutex);
2032
2033     return rval;
2034 }
2035
2036 static u32 __ccs_get_mbus_code(struct v4l2_subdev *subdev, unsigned int pad)
2037 {
2038     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2039
2040     if (subdev == &sensor->src->sd && pad == CCS_PAD_SRC)
2041         return sensor->csi_format->code;
2042     else
2043         return sensor->internal_csi_format->code;
2044 }
2045
2046 static int __ccs_get_format(struct v4l2_subdev *subdev,
2047                 struct v4l2_subdev_state *sd_state,
2048                 struct v4l2_subdev_format *fmt)
2049 {
2050     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2051
2052     if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
2053         fmt->format = *v4l2_subdev_get_try_format(subdev, sd_state,
2054                               fmt->pad);
2055     } else {
2056         struct v4l2_rect *r;
2057
2058         if (fmt->pad == ssd->source_pad)
2059             r = &ssd->crop[ssd->source_pad];
2060         else
2061             r = &ssd->sink_fmt;
2062
2063         fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);
2064         fmt->format.width = r->width;
2065         fmt->format.height = r->height;
2066         fmt->format.field = V4L2_FIELD_NONE;
2067     }
2068
2069     return 0;
2070 }
2071
2072 static int ccs_get_format(struct v4l2_subdev *subdev,
2073               struct v4l2_subdev_state *sd_state,
2074               struct v4l2_subdev_format *fmt)
2075 {
2076     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2077     int rval;
2078
2079     mutex_lock(&sensor->mutex);
2080     rval = __ccs_get_format(subdev, sd_state, fmt);
2081     mutex_unlock(&sensor->mutex);
2082
2083     return rval;
2084 }
2085
2086 static void ccs_get_crop_compose(struct v4l2_subdev *subdev,
2087                  struct v4l2_subdev_state *sd_state,
2088                  struct v4l2_rect **crops,
2089                  struct v4l2_rect **comps, int which)
2090 {
2091     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2092     unsigned int i;
2093
2094     if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2095         if (crops)
2096             for (i = 0; i < subdev->entity.num_pads; i++)
2097                 crops[i] = &ssd->crop[i];
2098         if (comps)
2099             *comps = &ssd->compose;
2100     } else {
2101         if (crops) {
2102             for (i = 0; i < subdev->entity.num_pads; i++)
2103                 crops[i] = v4l2_subdev_get_try_crop(subdev,
2104                                     sd_state,
2105                                     i);
2106         }
2107         if (comps)
2108             *comps = v4l2_subdev_get_try_compose(subdev, sd_state,
2109                                  CCS_PAD_SINK);
2110     }
2111 }
2112
2113 /* Changes require propagation only on sink pad. */
2114 static void ccs_propagate(struct v4l2_subdev *subdev,
2115               struct v4l2_subdev_state *sd_state, int which,
2116               int target)
2117 {
2118     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2119     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2120     struct v4l2_rect *comp, *crops[CCS_PADS];
2121
2122     ccs_get_crop_compose(subdev, sd_state, crops, &comp, which);
2123
2124     switch (target) {
2125     case V4L2_SEL_TGT_CROP:
2126         comp->width = crops[CCS_PAD_SINK]->width;
2127         comp->height = crops[CCS_PAD_SINK]->height;
2128         if (which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2129             if (ssd == sensor->scaler) {
2130                 sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);
2131                 sensor->scaling_mode =
2132                     CCS_SCALING_MODE_NO_SCALING;
2133             } else if (ssd == sensor->binner) {
2134                 sensor->binning_horizontal = 1;
2135                 sensor->binning_vertical = 1;
2136             }
2137         }
2138         fallthrough;
2139     case V4L2_SEL_TGT_COMPOSE:
2140         *crops[CCS_PAD_SRC] = *comp;
2141         break;
2142     default:
2143         WARN_ON_ONCE(1);
2144     }
2145 }
2146
2147 static const struct ccs_csi_data_format
2148 *ccs_validate_csi_data_format(struct ccs_sensor *sensor, u32 code)
2149 {
2150     unsigned int i;
2151
2152     for (i = 0; i < ARRAY_SIZE(ccs_csi_data_formats); i++) {
2153         if (sensor->mbus_frame_fmts & (1 << i) &&
2154             ccs_csi_data_formats[i].code == code)
2155             return &ccs_csi_data_formats[i];
2156     }
2157
2158     return sensor->csi_format;
2159 }
2160
2161 static int ccs_set_format_source(struct v4l2_subdev *subdev,
2162                  struct v4l2_subdev_state *sd_state,
2163                  struct v4l2_subdev_format *fmt)
2164 {
2165     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2166     const struct ccs_csi_data_format *csi_format,
2167         *old_csi_format = sensor->csi_format;
2168     unsigned long *valid_link_freqs;
2169     u32 code = fmt->format.code;
2170     unsigned int i;
2171     int rval;
2172
2173     rval = __ccs_get_format(subdev, sd_state, fmt);
2174     if (rval)
2175         return rval;
2176
2177     /*
2178      * Media bus code is changeable on src subdev's source pad. On
2179      * other source pads we just get format here.
2180      */
2181     if (subdev != &sensor->src->sd)
2182         return 0;
2183
2184     csi_format = ccs_validate_csi_data_format(sensor, code);
2185
2186     fmt->format.code = csi_format->code;
2187
2188     if (fmt->which != V4L2_SUBDEV_FORMAT_ACTIVE)
2189         return 0;
2190
2191     sensor->csi_format = csi_format;
2192
2193     if (csi_format->width != old_csi_format->width)
2194         for (i = 0; i < ARRAY_SIZE(sensor->test_data); i++)
2195             __v4l2_ctrl_modify_range(
2196                 sensor->test_data[i], 0,
2197                 (1 << csi_format->width) - 1, 1, 0);
2198
2199     if (csi_format->compressed == old_csi_format->compressed)
2200         return 0;
2201
2202     valid_link_freqs =
2203         &sensor->valid_link_freqs[sensor->csi_format->compressed
2204                       - sensor->compressed_min_bpp];
2205
2206     __v4l2_ctrl_modify_range(
2207         sensor->link_freq, 0,
2208         __fls(*valid_link_freqs), ~*valid_link_freqs,
2209         __ffs(*valid_link_freqs));
2210
2211     return ccs_pll_update(sensor);
2212 }
2213
2214 static int ccs_set_format(struct v4l2_subdev *subdev,
2215               struct v4l2_subdev_state *sd_state,
2216               struct v4l2_subdev_format *fmt)
2217 {
2218     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2219     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2220     struct v4l2_rect *crops[CCS_PADS];
2221
2222     mutex_lock(&sensor->mutex);
2223
2224     if (fmt->pad == ssd->source_pad) {
2225         int rval;
2226
2227         rval = ccs_set_format_source(subdev, sd_state, fmt);
2228
2229         mutex_unlock(&sensor->mutex);
2230
2231         return rval;
2232     }
2233
2234     /* Sink pad. Width and height are changeable here. */
2235     fmt->format.code = __ccs_get_mbus_code(subdev, fmt->pad);
2236     fmt->format.width &= ~1;
2237     fmt->format.height &= ~1;
2238     fmt->format.field = V4L2_FIELD_NONE;
2239
2240     fmt->format.width =
2241         clamp(fmt->format.width,
2242               CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),
2243               CCS_LIM(sensor, MAX_X_OUTPUT_SIZE));
2244     fmt->format.height =
2245         clamp(fmt->format.height,
2246               CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),
2247               CCS_LIM(sensor, MAX_Y_OUTPUT_SIZE));
2248
2249     ccs_get_crop_compose(subdev, sd_state, crops, NULL, fmt->which);
2250
2251     crops[ssd->sink_pad]->left = 0;
2252     crops[ssd->sink_pad]->top = 0;
2253     crops[ssd->sink_pad]->width = fmt->format.width;
2254     crops[ssd->sink_pad]->height = fmt->format.height;
2255     if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE)
2256         ssd->sink_fmt = *crops[ssd->sink_pad];
2257     ccs_propagate(subdev, sd_state, fmt->which, V4L2_SEL_TGT_CROP);
2258
2259     mutex_unlock(&sensor->mutex);
2260
2261     return 0;
2262 }
2263
2264 /*
2265  * Calculate goodness of scaled image size compared to expected image
2266  * size and flags provided.
2267  */
2268 #define SCALING_GOODNESS        100000
2269 #define SCALING_GOODNESS_EXTREME    100000000
2270 static int scaling_goodness(struct v4l2_subdev *subdev, int w, int ask_w,
2271                 int h, int ask_h, u32 flags)
2272 {
2273     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2274     struct i2c_client *client = v4l2_get_subdevdata(subdev);
2275     int val = 0;
2276
2277     w &= ~1;
2278     ask_w &= ~1;
2279     h &= ~1;
2280     ask_h &= ~1;
2281
2282     if (flags & V4L2_SEL_FLAG_GE) {
2283         if (w < ask_w)
2284             val -= SCALING_GOODNESS;
2285         if (h < ask_h)
2286             val -= SCALING_GOODNESS;
2287     }
2288
2289     if (flags & V4L2_SEL_FLAG_LE) {
2290         if (w > ask_w)
2291             val -= SCALING_GOODNESS;
2292         if (h > ask_h)
2293             val -= SCALING_GOODNESS;
2294     }
2295
2296     val -= abs(w - ask_w);
2297     val -= abs(h - ask_h);
2298
2299     if (w < CCS_LIM(sensor, MIN_X_OUTPUT_SIZE))
2300         val -= SCALING_GOODNESS_EXTREME;
2301
2302     dev_dbg(&client->dev, "w %d ask_w %d h %d ask_h %d goodness %d\n",
2303         w, ask_w, h, ask_h, val);
2304
2305     return val;
2306 }
2307
2308 static void ccs_set_compose_binner(struct v4l2_subdev *subdev,
2309                    struct v4l2_subdev_state *sd_state,
2310                    struct v4l2_subdev_selection *sel,
2311                    struct v4l2_rect **crops,
2312                    struct v4l2_rect *comp)
2313 {
2314     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2315     unsigned int i;
2316     unsigned int binh = 1, binv = 1;
2317     int best = scaling_goodness(
2318         subdev,
2319         crops[CCS_PAD_SINK]->width, sel->r.width,
2320         crops[CCS_PAD_SINK]->height, sel->r.height, sel->flags);
2321
2322     for (i = 0; i < sensor->nbinning_subtypes; i++) {
2323         int this = scaling_goodness(
2324             subdev,
2325             crops[CCS_PAD_SINK]->width
2326             / sensor->binning_subtypes[i].horizontal,
2327             sel->r.width,
2328             crops[CCS_PAD_SINK]->height
2329             / sensor->binning_subtypes[i].vertical,
2330             sel->r.height, sel->flags);
2331
2332         if (this > best) {
2333             binh = sensor->binning_subtypes[i].horizontal;
2334             binv = sensor->binning_subtypes[i].vertical;
2335             best = this;
2336         }
2337     }
2338     if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2339         sensor->binning_vertical = binv;
2340         sensor->binning_horizontal = binh;
2341     }
2342
2343     sel->r.width = (crops[CCS_PAD_SINK]->width / binh) & ~1;
2344     sel->r.height = (crops[CCS_PAD_SINK]->height / binv) & ~1;
2345 }
2346
2347 /*
2348  * Calculate best scaling ratio and mode for given output resolution.
2349  *
2350  * Try all of these: horizontal ratio, vertical ratio and smallest
2351  * size possible (horizontally).
2352  *
2353  * Also try whether horizontal scaler or full scaler gives a better
2354  * result.
2355  */
2356 static void ccs_set_compose_scaler(struct v4l2_subdev *subdev,
2357                    struct v4l2_subdev_state *sd_state,
2358                    struct v4l2_subdev_selection *sel,
2359                    struct v4l2_rect **crops,
2360                    struct v4l2_rect *comp)
2361 {
2362     struct i2c_client *client = v4l2_get_subdevdata(subdev);
2363     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2364     u32 min, max, a, b, max_m;
2365     u32 scale_m = CCS_LIM(sensor, SCALER_N_MIN);
2366     int mode = CCS_SCALING_MODE_HORIZONTAL;
2367     u32 try[4];
2368     u32 ntry = 0;
2369     unsigned int i;
2370     int best = INT_MIN;
2371
2372     sel->r.width = min_t(unsigned int, sel->r.width,
2373                  crops[CCS_PAD_SINK]->width);
2374     sel->r.height = min_t(unsigned int, sel->r.height,
2375                   crops[CCS_PAD_SINK]->height);
2376
2377     a = crops[CCS_PAD_SINK]->width
2378         * CCS_LIM(sensor, SCALER_N_MIN) / sel->r.width;
2379     b = crops[CCS_PAD_SINK]->height
2380         * CCS_LIM(sensor, SCALER_N_MIN) / sel->r.height;
2381     max_m = crops[CCS_PAD_SINK]->width
2382         * CCS_LIM(sensor, SCALER_N_MIN)
2383         / CCS_LIM(sensor, MIN_X_OUTPUT_SIZE);
2384
2385     a = clamp(a, CCS_LIM(sensor, SCALER_M_MIN),
2386           CCS_LIM(sensor, SCALER_M_MAX));
2387     b = clamp(b, CCS_LIM(sensor, SCALER_M_MIN),
2388           CCS_LIM(sensor, SCALER_M_MAX));
2389     max_m = clamp(max_m, CCS_LIM(sensor, SCALER_M_MIN),
2390               CCS_LIM(sensor, SCALER_M_MAX));
2391
2392     dev_dbg(&client->dev, "scaling: a %u b %u max_m %u\n", a, b, max_m);
2393
2394     min = min(max_m, min(a, b));
2395     max = min(max_m, max(a, b));
2396
2397     try[ntry] = min;
2398     ntry++;
2399     if (min != max) {
2400         try[ntry] = max;
2401         ntry++;
2402     }
2403     if (max != max_m) {
2404         try[ntry] = min + 1;
2405         ntry++;
2406         if (min != max) {
2407             try[ntry] = max + 1;
2408             ntry++;
2409         }
2410     }
2411
2412     for (i = 0; i < ntry; i++) {
2413         int this = scaling_goodness(
2414             subdev,
2415             crops[CCS_PAD_SINK]->width
2416             / try[i] * CCS_LIM(sensor, SCALER_N_MIN),
2417             sel->r.width,
2418             crops[CCS_PAD_SINK]->height,
2419             sel->r.height,
2420             sel->flags);
2421
2422         dev_dbg(&client->dev, "trying factor %u (%u)\n", try[i], i);
2423
2424         if (this > best) {
2425             scale_m = try[i];
2426             mode = CCS_SCALING_MODE_HORIZONTAL;
2427             best = this;
2428         }
2429
2430         if (CCS_LIM(sensor, SCALING_CAPABILITY)
2431             == CCS_SCALING_CAPABILITY_HORIZONTAL)
2432             continue;
2433
2434         this = scaling_goodness(
2435             subdev, crops[CCS_PAD_SINK]->width
2436             / try[i]
2437             * CCS_LIM(sensor, SCALER_N_MIN),
2438             sel->r.width,
2439             crops[CCS_PAD_SINK]->height
2440             / try[i]
2441             * CCS_LIM(sensor, SCALER_N_MIN),
2442             sel->r.height,
2443             sel->flags);
2444
2445         if (this > best) {
2446             scale_m = try[i];
2447             mode = SMIAPP_SCALING_MODE_BOTH;
2448             best = this;
2449         }
2450     }
2451
2452     sel->r.width =
2453         (crops[CCS_PAD_SINK]->width
2454          / scale_m
2455          * CCS_LIM(sensor, SCALER_N_MIN)) & ~1;
2456     if (mode == SMIAPP_SCALING_MODE_BOTH)
2457         sel->r.height =
2458             (crops[CCS_PAD_SINK]->height
2459              / scale_m
2460              * CCS_LIM(sensor, SCALER_N_MIN))
2461             & ~1;
2462     else
2463         sel->r.height = crops[CCS_PAD_SINK]->height;
2464
2465     if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2466         sensor->scale_m = scale_m;
2467         sensor->scaling_mode = mode;
2468     }
2469 }
2470 /* We're only called on source pads. This function sets scaling. */
2471 static int ccs_set_compose(struct v4l2_subdev *subdev,
2472                struct v4l2_subdev_state *sd_state,
2473                struct v4l2_subdev_selection *sel)
2474 {
2475     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2476     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2477     struct v4l2_rect *comp, *crops[CCS_PADS];
2478
2479     ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which);
2480
2481     sel->r.top = 0;
2482     sel->r.left = 0;
2483
2484     if (ssd == sensor->binner)
2485         ccs_set_compose_binner(subdev, sd_state, sel, crops, comp);
2486     else
2487         ccs_set_compose_scaler(subdev, sd_state, sel, crops, comp);
2488
2489     *comp = sel->r;
2490     ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_COMPOSE);
2491
2492     if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE)
2493         return ccs_pll_blanking_update(sensor);
2494
2495     return 0;
2496 }
2497
2498 static int __ccs_sel_supported(struct v4l2_subdev *subdev,
2499                    struct v4l2_subdev_selection *sel)
2500 {
2501     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2502     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2503
2504     /* We only implement crop in three places. */
2505     switch (sel->target) {
2506     case V4L2_SEL_TGT_CROP:
2507     case V4L2_SEL_TGT_CROP_BOUNDS:
2508         if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC)
2509             return 0;
2510         if (ssd == sensor->src && sel->pad == CCS_PAD_SRC)
2511             return 0;
2512         if (ssd == sensor->scaler && sel->pad == CCS_PAD_SINK &&
2513             CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
2514             == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP)
2515             return 0;
2516         return -EINVAL;
2517     case V4L2_SEL_TGT_NATIVE_SIZE:
2518         if (ssd == sensor->pixel_array && sel->pad == CCS_PA_PAD_SRC)
2519             return 0;
2520         return -EINVAL;
2521     case V4L2_SEL_TGT_COMPOSE:
2522     case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2523         if (sel->pad == ssd->source_pad)
2524             return -EINVAL;
2525         if (ssd == sensor->binner)
2526             return 0;
2527         if (ssd == sensor->scaler && CCS_LIM(sensor, SCALING_CAPABILITY)
2528             != CCS_SCALING_CAPABILITY_NONE)
2529             return 0;
2530         fallthrough;
2531     default:
2532         return -EINVAL;
2533     }
2534 }
2535
2536 static int ccs_set_crop(struct v4l2_subdev *subdev,
2537             struct v4l2_subdev_state *sd_state,
2538             struct v4l2_subdev_selection *sel)
2539 {
2540     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2541     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2542     struct v4l2_rect *src_size, *crops[CCS_PADS];
2543     struct v4l2_rect _r;
2544
2545     ccs_get_crop_compose(subdev, sd_state, crops, NULL, sel->which);
2546
2547     if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2548         if (sel->pad == ssd->sink_pad)
2549             src_size = &ssd->sink_fmt;
2550         else
2551             src_size = &ssd->compose;
2552     } else {
2553         if (sel->pad == ssd->sink_pad) {
2554             _r.left = 0;
2555             _r.top = 0;
2556             _r.width = v4l2_subdev_get_try_format(subdev,
2557                                   sd_state,
2558                                   sel->pad)
2559                 ->width;
2560             _r.height = v4l2_subdev_get_try_format(subdev,
2561                                    sd_state,
2562                                    sel->pad)
2563                 ->height;
2564             src_size = &_r;
2565         } else {
2566             src_size = v4l2_subdev_get_try_compose(
2567                 subdev, sd_state, ssd->sink_pad);
2568         }
2569     }
2570
2571     if (ssd == sensor->src && sel->pad == CCS_PAD_SRC) {
2572         sel->r.left = 0;
2573         sel->r.top = 0;
2574     }
2575
2576     sel->r.width = min(sel->r.width, src_size->width);
2577     sel->r.height = min(sel->r.height, src_size->height);
2578
2579     sel->r.left = min_t(int, sel->r.left, src_size->width - sel->r.width);
2580     sel->r.top = min_t(int, sel->r.top, src_size->height - sel->r.height);
2581
2582     *crops[sel->pad] = sel->r;
2583
2584     if (ssd != sensor->pixel_array && sel->pad == CCS_PAD_SINK)
2585         ccs_propagate(subdev, sd_state, sel->which, V4L2_SEL_TGT_CROP);
2586
2587     return 0;
2588 }
2589
2590 static void ccs_get_native_size(struct ccs_subdev *ssd, struct v4l2_rect *r)
2591 {
2592     r->top = 0;
2593     r->left = 0;
2594     r->width = CCS_LIM(ssd->sensor, X_ADDR_MAX) + 1;
2595     r->height = CCS_LIM(ssd->sensor, Y_ADDR_MAX) + 1;
2596 }
2597
2598 static int __ccs_get_selection(struct v4l2_subdev *subdev,
2599                    struct v4l2_subdev_state *sd_state,
2600                    struct v4l2_subdev_selection *sel)
2601 {
2602     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2603     struct ccs_subdev *ssd = to_ccs_subdev(subdev);
2604     struct v4l2_rect *comp, *crops[CCS_PADS];
2605     struct v4l2_rect sink_fmt;
2606     int ret;
2607
2608     ret = __ccs_sel_supported(subdev, sel);
2609     if (ret)
2610         return ret;
2611
2612     ccs_get_crop_compose(subdev, sd_state, crops, &comp, sel->which);
2613
2614     if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
2615         sink_fmt = ssd->sink_fmt;
2616     } else {
2617         struct v4l2_mbus_framefmt *fmt =
2618             v4l2_subdev_get_try_format(subdev, sd_state,
2619                            ssd->sink_pad);
2620
2621         sink_fmt.left = 0;
2622         sink_fmt.top = 0;
2623         sink_fmt.width = fmt->width;
2624         sink_fmt.height = fmt->height;
2625     }
2626
2627     switch (sel->target) {
2628     case V4L2_SEL_TGT_CROP_BOUNDS:
2629     case V4L2_SEL_TGT_NATIVE_SIZE:
2630         if (ssd == sensor->pixel_array)
2631             ccs_get_native_size(ssd, &sel->r);
2632         else if (sel->pad == ssd->sink_pad)
2633             sel->r = sink_fmt;
2634         else
2635             sel->r = *comp;
2636         break;
2637     case V4L2_SEL_TGT_CROP:
2638     case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2639         sel->r = *crops[sel->pad];
2640         break;
2641     case V4L2_SEL_TGT_COMPOSE:
2642         sel->r = *comp;
2643         break;
2644     }
2645
2646     return 0;
2647 }
2648
2649 static int ccs_get_selection(struct v4l2_subdev *subdev,
2650                  struct v4l2_subdev_state *sd_state,
2651                  struct v4l2_subdev_selection *sel)
2652 {
2653     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2654     int rval;
2655
2656     mutex_lock(&sensor->mutex);
2657     rval = __ccs_get_selection(subdev, sd_state, sel);
2658     mutex_unlock(&sensor->mutex);
2659
2660     return rval;
2661 }
2662
2663 static int ccs_set_selection(struct v4l2_subdev *subdev,
2664                  struct v4l2_subdev_state *sd_state,
2665                  struct v4l2_subdev_selection *sel)
2666 {
2667     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2668     int ret;
2669
2670     ret = __ccs_sel_supported(subdev, sel);
2671     if (ret)
2672         return ret;
2673
2674     mutex_lock(&sensor->mutex);
2675
2676     sel->r.left = max(0, sel->r.left & ~1);
2677     sel->r.top = max(0, sel->r.top & ~1);
2678     sel->r.width = CCS_ALIGN_DIM(sel->r.width, sel->flags);
2679     sel->r.height = CCS_ALIGN_DIM(sel->r.height, sel->flags);
2680
2681     sel->r.width = max_t(unsigned int, CCS_LIM(sensor, MIN_X_OUTPUT_SIZE),
2682                  sel->r.width);
2683     sel->r.height = max_t(unsigned int, CCS_LIM(sensor, MIN_Y_OUTPUT_SIZE),
2684                   sel->r.height);
2685
2686     switch (sel->target) {
2687     case V4L2_SEL_TGT_CROP:
2688         ret = ccs_set_crop(subdev, sd_state, sel);
2689         break;
2690     case V4L2_SEL_TGT_COMPOSE:
2691         ret = ccs_set_compose(subdev, sd_state, sel);
2692         break;
2693     default:
2694         ret = -EINVAL;
2695     }
2696
2697     mutex_unlock(&sensor->mutex);
2698     return ret;
2699 }
2700
2701 static int ccs_get_skip_frames(struct v4l2_subdev *subdev, u32 *frames)
2702 {
2703     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2704
2705     *frames = sensor->frame_skip;
2706     return 0;
2707 }
2708
2709 static int ccs_get_skip_top_lines(struct v4l2_subdev *subdev, u32 *lines)
2710 {
2711     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2712
2713     *lines = sensor->image_start;
2714
2715     return 0;
2716 }
2717
2718 /* -----------------------------------------------------------------------------
2719  * sysfs attributes
2720  */
2721
2722 static ssize_t
2723 nvm_show(struct device *dev, struct device_attribute *attr, char *buf)
2724 {
2725     struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2726     struct i2c_client *client = v4l2_get_subdevdata(subdev);
2727     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2728     int rval;
2729
2730     if (!sensor->dev_init_done)
2731         return -EBUSY;
2732
2733     rval = ccs_pm_get_init(sensor);
2734     if (rval < 0)
2735         return -ENODEV;
2736
2737     rval = ccs_read_nvm(sensor, buf, PAGE_SIZE);
2738     if (rval < 0) {
2739         pm_runtime_put(&client->dev);
2740         dev_err(&client->dev, "nvm read failed\n");
2741         return -ENODEV;
2742     }
2743
2744     pm_runtime_mark_last_busy(&client->dev);
2745     pm_runtime_put_autosuspend(&client->dev);
2746
2747     /*
2748      * NVM is still way below a PAGE_SIZE, so we can safely
2749      * assume this for now.
2750      */
2751     return rval;
2752 }
2753 static DEVICE_ATTR_RO(nvm);
2754
2755 static ssize_t
2756 ident_show(struct device *dev, struct device_attribute *attr, char *buf)
2757 {
2758     struct v4l2_subdev *subdev = i2c_get_clientdata(to_i2c_client(dev));
2759     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2760     struct ccs_module_info *minfo = &sensor->minfo;
2761
2762     if (minfo->mipi_manufacturer_id)
2763         return sysfs_emit(buf, "%4.4x%4.4x%2.2x\n",
2764                     minfo->mipi_manufacturer_id, minfo->model_id,
2765                     minfo->revision_number) + 1;
2766     else
2767         return sysfs_emit(buf, "%2.2x%4.4x%2.2x\n",
2768                     minfo->smia_manufacturer_id, minfo->model_id,
2769                     minfo->revision_number) + 1;
2770 }
2771 static DEVICE_ATTR_RO(ident);
2772
2773 /* -----------------------------------------------------------------------------
2774  * V4L2 subdev core operations
2775  */
2776
2777 static int ccs_identify_module(struct ccs_sensor *sensor)
2778 {
2779     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2780     struct ccs_module_info *minfo = &sensor->minfo;
2781     unsigned int i;
2782     u32 rev;
2783     int rval = 0;
2784
2785     /* Module info */
2786     rval = ccs_read(sensor, MODULE_MANUFACTURER_ID,
2787             &minfo->mipi_manufacturer_id);
2788     if (!rval && !minfo->mipi_manufacturer_id)
2789         rval = ccs_read_addr_8only(sensor,
2790                        SMIAPP_REG_U8_MANUFACTURER_ID,
2791                        &minfo->smia_manufacturer_id);
2792     if (!rval)
2793         rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_MODEL_ID,
2794                        &minfo->model_id);
2795     if (!rval)
2796         rval = ccs_read_addr_8only(sensor,
2797                        CCS_R_MODULE_REVISION_NUMBER_MAJOR,
2798                        &rev);
2799     if (!rval) {
2800         rval = ccs_read_addr_8only(sensor,
2801                        CCS_R_MODULE_REVISION_NUMBER_MINOR,
2802                        &minfo->revision_number);
2803         minfo->revision_number |= rev << 8;
2804     }
2805     if (!rval)
2806         rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_YEAR,
2807                        &minfo->module_year);
2808     if (!rval)
2809         rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_MONTH,
2810                        &minfo->module_month);
2811     if (!rval)
2812         rval = ccs_read_addr_8only(sensor, CCS_R_MODULE_DATE_DAY,
2813                        &minfo->module_day);
2814
2815     /* Sensor info */
2816     if (!rval)
2817         rval = ccs_read(sensor, SENSOR_MANUFACTURER_ID,
2818                 &minfo->sensor_mipi_manufacturer_id);
2819     if (!rval && !minfo->sensor_mipi_manufacturer_id)
2820         rval = ccs_read_addr_8only(sensor,
2821                        CCS_R_SENSOR_MANUFACTURER_ID,
2822                        &minfo->sensor_smia_manufacturer_id);
2823     if (!rval)
2824         rval = ccs_read_addr_8only(sensor,
2825                        CCS_R_SENSOR_MODEL_ID,
2826                        &minfo->sensor_model_id);
2827     if (!rval)
2828         rval = ccs_read_addr_8only(sensor,
2829                        CCS_R_SENSOR_REVISION_NUMBER,
2830                        &minfo->sensor_revision_number);
2831     if (!rval)
2832         rval = ccs_read_addr_8only(sensor,
2833                        CCS_R_SENSOR_FIRMWARE_VERSION,
2834                        &minfo->sensor_firmware_version);
2835
2836     /* SMIA */
2837     if (!rval)
2838         rval = ccs_read(sensor, MIPI_CCS_VERSION, &minfo->ccs_version);
2839     if (!rval && !minfo->ccs_version)
2840         rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIA_VERSION,
2841                        &minfo->smia_version);
2842     if (!rval && !minfo->ccs_version)
2843         rval = ccs_read_addr_8only(sensor, SMIAPP_REG_U8_SMIAPP_VERSION,
2844                        &minfo->smiapp_version);
2845
2846     if (rval) {
2847         dev_err(&client->dev, "sensor detection failed\n");
2848         return -ENODEV;
2849     }
2850
2851     if (minfo->mipi_manufacturer_id)
2852         dev_dbg(&client->dev, "MIPI CCS module 0x%4.4x-0x%4.4x\n",
2853             minfo->mipi_manufacturer_id, minfo->model_id);
2854     else
2855         dev_dbg(&client->dev, "SMIA module 0x%2.2x-0x%4.4x\n",
2856             minfo->smia_manufacturer_id, minfo->model_id);
2857
2858     dev_dbg(&client->dev,
2859         "module revision 0x%4.4x date %2.2d-%2.2d-%2.2d\n",
2860         minfo->revision_number, minfo->module_year, minfo->module_month,
2861         minfo->module_day);
2862
2863     if (minfo->sensor_mipi_manufacturer_id)
2864         dev_dbg(&client->dev, "MIPI CCS sensor 0x%4.4x-0x%4.4x\n",
2865             minfo->sensor_mipi_manufacturer_id,
2866             minfo->sensor_model_id);
2867     else
2868         dev_dbg(&client->dev, "SMIA sensor 0x%2.2x-0x%4.4x\n",
2869             minfo->sensor_smia_manufacturer_id,
2870             minfo->sensor_model_id);
2871
2872     dev_dbg(&client->dev,
2873         "sensor revision 0x%2.2x firmware version 0x%2.2x\n",
2874         minfo->sensor_revision_number, minfo->sensor_firmware_version);
2875
2876     if (minfo->ccs_version) {
2877         dev_dbg(&client->dev, "MIPI CCS version %u.%u",
2878             (minfo->ccs_version & CCS_MIPI_CCS_VERSION_MAJOR_MASK)
2879             >> CCS_MIPI_CCS_VERSION_MAJOR_SHIFT,
2880             (minfo->ccs_version & CCS_MIPI_CCS_VERSION_MINOR_MASK));
2881         minfo->name = CCS_NAME;
2882     } else {
2883         dev_dbg(&client->dev,
2884             "smia version %2.2d smiapp version %2.2d\n",
2885             minfo->smia_version, minfo->smiapp_version);
2886         minfo->name = SMIAPP_NAME;
2887     }
2888
2889     /*
2890      * Some modules have bad data in the lvalues below. Hope the
2891      * rvalues have better stuff. The lvalues are module
2892      * parameters whereas the rvalues are sensor parameters.
2893      */
2894     if (minfo->sensor_smia_manufacturer_id &&
2895         !minfo->smia_manufacturer_id && !minfo->model_id) {
2896         minfo->smia_manufacturer_id =
2897             minfo->sensor_smia_manufacturer_id;
2898         minfo->model_id = minfo->sensor_model_id;
2899         minfo->revision_number = minfo->sensor_revision_number;
2900     }
2901
2902     for (i = 0; i < ARRAY_SIZE(ccs_module_idents); i++) {
2903         if (ccs_module_idents[i].mipi_manufacturer_id &&
2904             ccs_module_idents[i].mipi_manufacturer_id
2905             != minfo->mipi_manufacturer_id)
2906             continue;
2907         if (ccs_module_idents[i].smia_manufacturer_id &&
2908             ccs_module_idents[i].smia_manufacturer_id
2909             != minfo->smia_manufacturer_id)
2910             continue;
2911         if (ccs_module_idents[i].model_id != minfo->model_id)
2912             continue;
2913         if (ccs_module_idents[i].flags
2914             & CCS_MODULE_IDENT_FLAG_REV_LE) {
2915             if (ccs_module_idents[i].revision_number_major
2916                 < (minfo->revision_number >> 8))
2917                 continue;
2918         } else {
2919             if (ccs_module_idents[i].revision_number_major
2920                 != (minfo->revision_number >> 8))
2921                 continue;
2922         }
2923
2924         minfo->name = ccs_module_idents[i].name;
2925         minfo->quirk = ccs_module_idents[i].quirk;
2926         break;
2927     }
2928
2929     if (i >= ARRAY_SIZE(ccs_module_idents))
2930         dev_warn(&client->dev,
2931              "no quirks for this module; let's hope it's fully compliant\n");
2932
2933     dev_dbg(&client->dev, "the sensor is called %s\n", minfo->name);
2934
2935     return 0;
2936 }
2937
2938 static const struct v4l2_subdev_ops ccs_ops;
2939 static const struct v4l2_subdev_internal_ops ccs_internal_ops;
2940 static const struct media_entity_operations ccs_entity_ops;
2941
2942 static int ccs_register_subdev(struct ccs_sensor *sensor,
2943                    struct ccs_subdev *ssd,
2944                    struct ccs_subdev *sink_ssd,
2945                    u16 source_pad, u16 sink_pad, u32 link_flags)
2946 {
2947     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
2948     int rval;
2949
2950     if (!sink_ssd)
2951         return 0;
2952
2953     rval = media_entity_pads_init(&ssd->sd.entity, ssd->npads, ssd->pads);
2954     if (rval) {
2955         dev_err(&client->dev, "media_entity_pads_init failed\n");
2956         return rval;
2957     }
2958
2959     rval = v4l2_device_register_subdev(sensor->src->sd.v4l2_dev, &ssd->sd);
2960     if (rval) {
2961         dev_err(&client->dev, "v4l2_device_register_subdev failed\n");
2962         return rval;
2963     }
2964
2965     rval = media_create_pad_link(&ssd->sd.entity, source_pad,
2966                      &sink_ssd->sd.entity, sink_pad,
2967                      link_flags);
2968     if (rval) {
2969         dev_err(&client->dev, "media_create_pad_link failed\n");
2970         v4l2_device_unregister_subdev(&ssd->sd);
2971         return rval;
2972     }
2973
2974     return 0;
2975 }
2976
2977 static void ccs_unregistered(struct v4l2_subdev *subdev)
2978 {
2979     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2980     unsigned int i;
2981
2982     for (i = 1; i < sensor->ssds_used; i++)
2983         v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
2984 }
2985
2986 static int ccs_registered(struct v4l2_subdev *subdev)
2987 {
2988     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
2989     int rval;
2990
2991     if (sensor->scaler) {
2992         rval = ccs_register_subdev(sensor, sensor->binner,
2993                        sensor->scaler,
2994                        CCS_PAD_SRC, CCS_PAD_SINK,
2995                        MEDIA_LNK_FL_ENABLED |
2996                        MEDIA_LNK_FL_IMMUTABLE);
2997         if (rval < 0)
2998             return rval;
2999     }
3000
3001     rval = ccs_register_subdev(sensor, sensor->pixel_array, sensor->binner,
3002                    CCS_PA_PAD_SRC, CCS_PAD_SINK,
3003                    MEDIA_LNK_FL_ENABLED |
3004                    MEDIA_LNK_FL_IMMUTABLE);
3005     if (rval)
3006         goto out_err;
3007
3008     return 0;
3009
3010 out_err:
3011     ccs_unregistered(subdev);
3012
3013     return rval;
3014 }
3015
3016 static void ccs_cleanup(struct ccs_sensor *sensor)
3017 {
3018     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
3019
3020     device_remove_file(&client->dev, &dev_attr_nvm);
3021     device_remove_file(&client->dev, &dev_attr_ident);
3022
3023     ccs_free_controls(sensor);
3024 }
3025
3026 static void ccs_create_subdev(struct ccs_sensor *sensor,
3027                   struct ccs_subdev *ssd, const char *name,
3028                   unsigned short num_pads, u32 function)
3029 {
3030     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
3031
3032     if (!ssd)
3033         return;
3034
3035     if (ssd != sensor->src)
3036         v4l2_subdev_init(&ssd->sd, &ccs_ops);
3037
3038     ssd->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
3039     ssd->sd.entity.function = function;
3040     ssd->sensor = sensor;
3041
3042     ssd->npads = num_pads;
3043     ssd->source_pad = num_pads - 1;
3044
3045     v4l2_i2c_subdev_set_name(&ssd->sd, client, sensor->minfo.name, name);
3046
3047     ccs_get_native_size(ssd, &ssd->sink_fmt);
3048
3049     ssd->compose.width = ssd->sink_fmt.width;
3050     ssd->compose.height = ssd->sink_fmt.height;
3051     ssd->crop[ssd->source_pad] = ssd->compose;
3052     ssd->pads[ssd->source_pad].flags = MEDIA_PAD_FL_SOURCE;
3053     if (ssd != sensor->pixel_array) {
3054         ssd->crop[ssd->sink_pad] = ssd->compose;
3055         ssd->pads[ssd->sink_pad].flags = MEDIA_PAD_FL_SINK;
3056     }
3057
3058     ssd->sd.entity.ops = &ccs_entity_ops;
3059
3060     if (ssd == sensor->src)
3061         return;
3062
3063     ssd->sd.internal_ops = &ccs_internal_ops;
3064     ssd->sd.owner = THIS_MODULE;
3065     ssd->sd.dev = &client->dev;
3066     v4l2_set_subdevdata(&ssd->sd, client);
3067 }
3068
3069 static int ccs_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
3070 {
3071     struct ccs_subdev *ssd = to_ccs_subdev(sd);
3072     struct ccs_sensor *sensor = ssd->sensor;
3073     unsigned int i;
3074
3075     mutex_lock(&sensor->mutex);
3076
3077     for (i = 0; i < ssd->npads; i++) {
3078         struct v4l2_mbus_framefmt *try_fmt =
3079             v4l2_subdev_get_try_format(sd, fh->state, i);
3080         struct v4l2_rect *try_crop =
3081             v4l2_subdev_get_try_crop(sd, fh->state, i);
3082         struct v4l2_rect *try_comp;
3083
3084         ccs_get_native_size(ssd, try_crop);
3085
3086         try_fmt->width = try_crop->width;
3087         try_fmt->height = try_crop->height;
3088         try_fmt->code = sensor->internal_csi_format->code;
3089         try_fmt->field = V4L2_FIELD_NONE;
3090
3091         if (ssd != sensor->pixel_array)
3092             continue;
3093
3094         try_comp = v4l2_subdev_get_try_compose(sd, fh->state, i);
3095         *try_comp = *try_crop;
3096     }
3097
3098     mutex_unlock(&sensor->mutex);
3099
3100     return 0;
3101 }
3102
3103 static const struct v4l2_subdev_video_ops ccs_video_ops = {
3104     .s_stream = ccs_set_stream,
3105     .pre_streamon = ccs_pre_streamon,
3106     .post_streamoff = ccs_post_streamoff,
3107 };
3108
3109 static const struct v4l2_subdev_pad_ops ccs_pad_ops = {
3110     .enum_mbus_code = ccs_enum_mbus_code,
3111     .get_fmt = ccs_get_format,
3112     .set_fmt = ccs_set_format,
3113     .get_selection = ccs_get_selection,
3114     .set_selection = ccs_set_selection,
3115 };
3116
3117 static const struct v4l2_subdev_sensor_ops ccs_sensor_ops = {
3118     .g_skip_frames = ccs_get_skip_frames,
3119     .g_skip_top_lines = ccs_get_skip_top_lines,
3120 };
3121
3122 static const struct v4l2_subdev_ops ccs_ops = {
3123     .video = &ccs_video_ops,
3124     .pad = &ccs_pad_ops,
3125     .sensor = &ccs_sensor_ops,
3126 };
3127
3128 static const struct media_entity_operations ccs_entity_ops = {
3129     .link_validate = v4l2_subdev_link_validate,
3130 };
3131
3132 static const struct v4l2_subdev_internal_ops ccs_internal_src_ops = {
3133     .registered = ccs_registered,
3134     .unregistered = ccs_unregistered,
3135     .open = ccs_open,
3136 };
3137
3138 static const struct v4l2_subdev_internal_ops ccs_internal_ops = {
3139     .open = ccs_open,
3140 };
3141
3142 /* -----------------------------------------------------------------------------
3143  * I2C Driver
3144  */
3145
3146 static int __maybe_unused ccs_suspend(struct device *dev)
3147 {
3148     struct i2c_client *client = to_i2c_client(dev);
3149     struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3150     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3151     bool streaming = sensor->streaming;
3152     int rval;
3153
3154     rval = pm_runtime_resume_and_get(dev);
3155     if (rval < 0)
3156         return rval;
3157
3158     if (sensor->streaming)
3159         ccs_stop_streaming(sensor);
3160
3161     /* save state for resume */
3162     sensor->streaming = streaming;
3163
3164     return 0;
3165 }
3166
3167 static int __maybe_unused ccs_resume(struct device *dev)
3168 {
3169     struct i2c_client *client = to_i2c_client(dev);
3170     struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3171     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3172     int rval = 0;
3173
3174     pm_runtime_put(dev);
3175
3176     if (sensor->streaming)
3177         rval = ccs_start_streaming(sensor);
3178
3179     return rval;
3180 }
3181
3182 static int ccs_get_hwconfig(struct ccs_sensor *sensor, struct device *dev)
3183 {
3184     struct ccs_hwconfig *hwcfg = &sensor->hwcfg;
3185     struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = V4L2_MBUS_UNKNOWN };
3186     struct fwnode_handle *ep;
3187     struct fwnode_handle *fwnode = dev_fwnode(dev);
3188     u32 rotation;
3189     unsigned int i;
3190     int rval;
3191
3192     ep = fwnode_graph_get_endpoint_by_id(fwnode, 0, 0,
3193                          FWNODE_GRAPH_ENDPOINT_NEXT);
3194     if (!ep)
3195         return -ENODEV;
3196
3197     /*
3198      * Note that we do need to rely on detecting the bus type between CSI-2
3199      * D-PHY and CCP2 as the old bindings did not require it.
3200      */
3201     rval = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
3202     if (rval)
3203         goto out_err;
3204
3205     switch (bus_cfg.bus_type) {
3206     case V4L2_MBUS_CSI2_DPHY:
3207         hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_DPHY;
3208         hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;
3209         break;
3210     case V4L2_MBUS_CSI2_CPHY:
3211         hwcfg->csi_signalling_mode = CCS_CSI_SIGNALING_MODE_CSI_2_CPHY;
3212         hwcfg->lanes = bus_cfg.bus.mipi_csi2.num_data_lanes;
3213         break;
3214     case V4L2_MBUS_CSI1:
3215     case V4L2_MBUS_CCP2:
3216         hwcfg->csi_signalling_mode = (bus_cfg.bus.mipi_csi1.strobe) ?
3217         SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_STROBE :
3218         SMIAPP_CSI_SIGNALLING_MODE_CCP2_DATA_CLOCK;
3219         hwcfg->lanes = 1;
3220         break;
3221     default:
3222         dev_err(dev, "unsupported bus %u\n", bus_cfg.bus_type);
3223         rval = -EINVAL;
3224         goto out_err;
3225     }
3226
3227     rval = fwnode_property_read_u32(fwnode, "rotation", &rotation);
3228     if (!rval) {
3229         switch (rotation) {
3230         case 180:
3231             hwcfg->module_board_orient =
3232                 CCS_MODULE_BOARD_ORIENT_180;
3233             fallthrough;
3234         case 0:
3235             break;
3236         default:
3237             dev_err(dev, "invalid rotation %u\n", rotation);
3238             rval = -EINVAL;
3239             goto out_err;
3240         }
3241     }
3242
3243     rval = fwnode_property_read_u32(dev_fwnode(dev), "clock-frequency",
3244                     &hwcfg->ext_clk);
3245     if (rval)
3246         dev_info(dev, "can't get clock-frequency\n");
3247
3248     dev_dbg(dev, "clk %u, mode %u\n", hwcfg->ext_clk,
3249         hwcfg->csi_signalling_mode);
3250
3251     if (!bus_cfg.nr_of_link_frequencies) {
3252         dev_warn(dev, "no link frequencies defined\n");
3253         rval = -EINVAL;
3254         goto out_err;
3255     }
3256
3257     hwcfg->op_sys_clock = devm_kcalloc(
3258         dev, bus_cfg.nr_of_link_frequencies + 1 /* guardian */,
3259         sizeof(*hwcfg->op_sys_clock), GFP_KERNEL);
3260     if (!hwcfg->op_sys_clock) {
3261         rval = -ENOMEM;
3262         goto out_err;
3263     }
3264
3265     for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++) {
3266         hwcfg->op_sys_clock[i] = bus_cfg.link_frequencies[i];
3267         dev_dbg(dev, "freq %u: %lld\n", i, hwcfg->op_sys_clock[i]);
3268     }
3269
3270     v4l2_fwnode_endpoint_free(&bus_cfg);
3271     fwnode_handle_put(ep);
3272
3273     return 0;
3274
3275 out_err:
3276     v4l2_fwnode_endpoint_free(&bus_cfg);
3277     fwnode_handle_put(ep);
3278
3279     return rval;
3280 }
3281
3282 static int ccs_probe(struct i2c_client *client)
3283 {
3284     struct ccs_sensor *sensor;
3285     const struct firmware *fw;
3286     char filename[40];
3287     unsigned int i;
3288     int rval;
3289
3290     sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
3291     if (sensor == NULL)
3292         return -ENOMEM;
3293
3294     rval = ccs_get_hwconfig(sensor, &client->dev);
3295     if (rval)
3296         return rval;
3297
3298     sensor->src = &sensor->ssds[sensor->ssds_used];
3299
3300     v4l2_i2c_subdev_init(&sensor->src->sd, client, &ccs_ops);
3301     sensor->src->sd.internal_ops = &ccs_internal_src_ops;
3302
3303     sensor->regulators = devm_kcalloc(&client->dev,
3304                       ARRAY_SIZE(ccs_regulators),
3305                       sizeof(*sensor->regulators),
3306                       GFP_KERNEL);
3307     if (!sensor->regulators)
3308         return -ENOMEM;
3309
3310     for (i = 0; i < ARRAY_SIZE(ccs_regulators); i++)
3311         sensor->regulators[i].supply = ccs_regulators[i];
3312
3313     rval = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(ccs_regulators),
3314                        sensor->regulators);
3315     if (rval) {
3316         dev_err(&client->dev, "could not get regulators\n");
3317         return rval;
3318     }
3319
3320     sensor->ext_clk = devm_clk_get(&client->dev, NULL);
3321     if (PTR_ERR(sensor->ext_clk) == -ENOENT) {
3322         dev_info(&client->dev, "no clock defined, continuing...\n");
3323         sensor->ext_clk = NULL;
3324     } else if (IS_ERR(sensor->ext_clk)) {
3325         dev_err(&client->dev, "could not get clock (%ld)\n",
3326             PTR_ERR(sensor->ext_clk));
3327         return -EPROBE_DEFER;
3328     }
3329
3330     if (sensor->ext_clk) {
3331         if (sensor->hwcfg.ext_clk) {
3332             unsigned long rate;
3333
3334             rval = clk_set_rate(sensor->ext_clk,
3335                         sensor->hwcfg.ext_clk);
3336             if (rval < 0) {
3337                 dev_err(&client->dev,
3338                     "unable to set clock freq to %u\n",
3339                     sensor->hwcfg.ext_clk);
3340                 return rval;
3341             }
3342
3343             rate = clk_get_rate(sensor->ext_clk);
3344             if (rate != sensor->hwcfg.ext_clk) {
3345                 dev_err(&client->dev,
3346                     "can't set clock freq, asked for %u but got %lu\n",
3347                     sensor->hwcfg.ext_clk, rate);
3348                 return -EINVAL;
3349             }
3350         } else {
3351             sensor->hwcfg.ext_clk = clk_get_rate(sensor->ext_clk);
3352             dev_dbg(&client->dev, "obtained clock freq %u\n",
3353                 sensor->hwcfg.ext_clk);
3354         }
3355     } else if (sensor->hwcfg.ext_clk) {
3356         dev_dbg(&client->dev, "assuming clock freq %u\n",
3357             sensor->hwcfg.ext_clk);
3358     } else {
3359         dev_err(&client->dev, "unable to obtain clock freq\n");
3360         return -EINVAL;
3361     }
3362
3363     if (!sensor->hwcfg.ext_clk) {
3364         dev_err(&client->dev, "cannot work with xclk frequency 0\n");
3365         return -EINVAL;
3366     }
3367
3368     sensor->reset = devm_gpiod_get_optional(&client->dev, "reset",
3369                         GPIOD_OUT_HIGH);
3370     if (IS_ERR(sensor->reset))
3371         return PTR_ERR(sensor->reset);
3372     /* Support old users that may have used "xshutdown" property. */
3373     if (!sensor->reset)
3374         sensor->xshutdown = devm_gpiod_get_optional(&client->dev,
3375                                 "xshutdown",
3376                                 GPIOD_OUT_LOW);
3377     if (IS_ERR(sensor->xshutdown))
3378         return PTR_ERR(sensor->xshutdown);
3379
3380     rval = ccs_power_on(&client->dev);
3381     if (rval < 0)
3382         return rval;
3383
3384     mutex_init(&sensor->mutex);
3385
3386     rval = ccs_identify_module(sensor);
3387     if (rval) {
3388         rval = -ENODEV;
3389         goto out_power_off;
3390     }
3391
3392     rval = snprintf(filename, sizeof(filename),
3393             "ccs/ccs-sensor-%4.4x-%4.4x-%4.4x.fw",
3394             sensor->minfo.sensor_mipi_manufacturer_id,
3395             sensor->minfo.sensor_model_id,
3396             sensor->minfo.sensor_revision_number);
3397     if (rval >= sizeof(filename)) {
3398         rval = -ENOMEM;
3399         goto out_power_off;
3400     }
3401
3402     rval = request_firmware(&fw, filename, &client->dev);
3403     if (!rval) {
3404         ccs_data_parse(&sensor->sdata, fw->data, fw->size, &client->dev,
3405                    true);
3406         release_firmware(fw);
3407     }
3408
3409     rval = snprintf(filename, sizeof(filename),
3410             "ccs/ccs-module-%4.4x-%4.4x-%4.4x.fw",
3411             sensor->minfo.mipi_manufacturer_id,
3412             sensor->minfo.model_id,
3413             sensor->minfo.revision_number);
3414     if (rval >= sizeof(filename)) {
3415         rval = -ENOMEM;
3416         goto out_release_sdata;
3417     }
3418
3419     rval = request_firmware(&fw, filename, &client->dev);
3420     if (!rval) {
3421         ccs_data_parse(&sensor->mdata, fw->data, fw->size, &client->dev,
3422                    true);
3423         release_firmware(fw);
3424     }
3425
3426     rval = ccs_read_all_limits(sensor);
3427     if (rval)
3428         goto out_release_mdata;
3429
3430     rval = ccs_read_frame_fmt(sensor);
3431     if (rval) {
3432         rval = -ENODEV;
3433         goto out_free_ccs_limits;
3434     }
3435
3436     rval = ccs_update_phy_ctrl(sensor);
3437     if (rval < 0)
3438         goto out_free_ccs_limits;
3439
3440     /*
3441      * Handle Sensor Module orientation on the board.
3442      *
3443      * The application of H-FLIP and V-FLIP on the sensor is modified by
3444      * the sensor orientation on the board.
3445      *
3446      * For CCS_BOARD_SENSOR_ORIENT_180 the default behaviour is to set
3447      * both H-FLIP and V-FLIP for normal operation which also implies
3448      * that a set/unset operation for user space HFLIP and VFLIP v4l2
3449      * controls will need to be internally inverted.
3450      *
3451      * Rotation also changes the bayer pattern.
3452      */
3453     if (sensor->hwcfg.module_board_orient ==
3454         CCS_MODULE_BOARD_ORIENT_180)
3455         sensor->hvflip_inv_mask =
3456             CCS_IMAGE_ORIENTATION_HORIZONTAL_MIRROR |
3457             CCS_IMAGE_ORIENTATION_VERTICAL_FLIP;
3458
3459     rval = ccs_call_quirk(sensor, limits);
3460     if (rval) {
3461         dev_err(&client->dev, "limits quirks failed\n");
3462         goto out_free_ccs_limits;
3463     }
3464
3465     if (CCS_LIM(sensor, BINNING_CAPABILITY)) {
3466         sensor->nbinning_subtypes =
3467             min_t(u8, CCS_LIM(sensor, BINNING_SUB_TYPES),
3468                   CCS_LIM_BINNING_SUB_TYPE_MAX_N);
3469
3470         for (i = 0; i < sensor->nbinning_subtypes; i++) {
3471             sensor->binning_subtypes[i].horizontal =
3472                 CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) >>
3473                 CCS_BINNING_SUB_TYPE_COLUMN_SHIFT;
3474             sensor->binning_subtypes[i].vertical =
3475                 CCS_LIM_AT(sensor, BINNING_SUB_TYPE, i) &
3476                 CCS_BINNING_SUB_TYPE_ROW_MASK;
3477
3478             dev_dbg(&client->dev, "binning %xx%x\n",
3479                 sensor->binning_subtypes[i].horizontal,
3480                 sensor->binning_subtypes[i].vertical);
3481         }
3482     }
3483     sensor->binning_horizontal = 1;
3484     sensor->binning_vertical = 1;
3485
3486     if (device_create_file(&client->dev, &dev_attr_ident) != 0) {
3487         dev_err(&client->dev, "sysfs ident entry creation failed\n");
3488         rval = -ENOENT;
3489         goto out_free_ccs_limits;
3490     }
3491
3492     if (sensor->minfo.smiapp_version &&
3493         CCS_LIM(sensor, DATA_TRANSFER_IF_CAPABILITY) &
3494         CCS_DATA_TRANSFER_IF_CAPABILITY_SUPPORTED) {
3495         if (device_create_file(&client->dev, &dev_attr_nvm) != 0) {
3496             dev_err(&client->dev, "sysfs nvm entry failed\n");
3497             rval = -EBUSY;
3498             goto out_cleanup;
3499         }
3500     }
3501
3502     if (!CCS_LIM(sensor, MIN_OP_SYS_CLK_DIV) ||
3503         !CCS_LIM(sensor, MAX_OP_SYS_CLK_DIV) ||
3504         !CCS_LIM(sensor, MIN_OP_PIX_CLK_DIV) ||
3505         !CCS_LIM(sensor, MAX_OP_PIX_CLK_DIV)) {
3506         /* No OP clock branch */
3507         sensor->pll.flags |= CCS_PLL_FLAG_NO_OP_CLOCKS;
3508     } else if (CCS_LIM(sensor, SCALING_CAPABILITY)
3509            != CCS_SCALING_CAPABILITY_NONE ||
3510            CCS_LIM(sensor, DIGITAL_CROP_CAPABILITY)
3511            == CCS_DIGITAL_CROP_CAPABILITY_INPUT_CROP) {
3512         /* We have a scaler or digital crop. */
3513         sensor->scaler = &sensor->ssds[sensor->ssds_used];
3514         sensor->ssds_used++;
3515     }
3516     sensor->binner = &sensor->ssds[sensor->ssds_used];
3517     sensor->ssds_used++;
3518     sensor->pixel_array = &sensor->ssds[sensor->ssds_used];
3519     sensor->ssds_used++;
3520
3521     sensor->scale_m = CCS_LIM(sensor, SCALER_N_MIN);
3522
3523     /* prepare PLL configuration input values */
3524     sensor->pll.bus_type = CCS_PLL_BUS_TYPE_CSI2_DPHY;
3525     sensor->pll.csi2.lanes = sensor->hwcfg.lanes;
3526     if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3527         CCS_CLOCK_CALCULATION_LANE_SPEED) {
3528         sensor->pll.flags |= CCS_PLL_FLAG_LANE_SPEED_MODEL;
3529         if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3530             CCS_CLOCK_CALCULATION_LINK_DECOUPLED) {
3531             sensor->pll.vt_lanes =
3532                 CCS_LIM(sensor, NUM_OF_VT_LANES) + 1;
3533             sensor->pll.op_lanes =
3534                 CCS_LIM(sensor, NUM_OF_OP_LANES) + 1;
3535             sensor->pll.flags |= CCS_PLL_FLAG_LINK_DECOUPLED;
3536         } else {
3537             sensor->pll.vt_lanes = sensor->pll.csi2.lanes;
3538             sensor->pll.op_lanes = sensor->pll.csi2.lanes;
3539         }
3540     }
3541     if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3542         CCS_CLOCK_TREE_PLL_CAPABILITY_EXT_DIVIDER)
3543         sensor->pll.flags |= CCS_PLL_FLAG_EXT_IP_PLL_DIVIDER;
3544     if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3545         CCS_CLOCK_TREE_PLL_CAPABILITY_FLEXIBLE_OP_PIX_CLK_DIV)
3546         sensor->pll.flags |= CCS_PLL_FLAG_FLEXIBLE_OP_PIX_CLK_DIV;
3547     if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) &
3548         CCS_FIFO_SUPPORT_CAPABILITY_DERATING)
3549         sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING;
3550     if (CCS_LIM(sensor, FIFO_SUPPORT_CAPABILITY) &
3551         CCS_FIFO_SUPPORT_CAPABILITY_DERATING_OVERRATING)
3552         sensor->pll.flags |= CCS_PLL_FLAG_FIFO_DERATING |
3553                      CCS_PLL_FLAG_FIFO_OVERRATING;
3554     if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3555         CCS_CLOCK_TREE_PLL_CAPABILITY_DUAL_PLL) {
3556         if (CCS_LIM(sensor, CLOCK_TREE_PLL_CAPABILITY) &
3557             CCS_CLOCK_TREE_PLL_CAPABILITY_SINGLE_PLL) {
3558             u32 v;
3559
3560             /* Use sensor default in PLL mode selection */
3561             rval = ccs_read(sensor, PLL_MODE, &v);
3562             if (rval)
3563                 goto out_cleanup;
3564
3565             if (v == CCS_PLL_MODE_DUAL)
3566                 sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL;
3567         } else {
3568             sensor->pll.flags |= CCS_PLL_FLAG_DUAL_PLL;
3569         }
3570         if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3571             CCS_CLOCK_CALCULATION_DUAL_PLL_OP_SYS_DDR)
3572             sensor->pll.flags |= CCS_PLL_FLAG_OP_SYS_DDR;
3573         if (CCS_LIM(sensor, CLOCK_CALCULATION) &
3574             CCS_CLOCK_CALCULATION_DUAL_PLL_OP_PIX_DDR)
3575             sensor->pll.flags |= CCS_PLL_FLAG_OP_PIX_DDR;
3576     }
3577     sensor->pll.op_bits_per_lane = CCS_LIM(sensor, OP_BITS_PER_LANE);
3578     sensor->pll.ext_clk_freq_hz = sensor->hwcfg.ext_clk;
3579     sensor->pll.scale_n = CCS_LIM(sensor, SCALER_N_MIN);
3580
3581     ccs_create_subdev(sensor, sensor->scaler, " scaler", 2,
3582               MEDIA_ENT_F_PROC_VIDEO_SCALER);
3583     ccs_create_subdev(sensor, sensor->binner, " binner", 2,
3584               MEDIA_ENT_F_PROC_VIDEO_SCALER);
3585     ccs_create_subdev(sensor, sensor->pixel_array, " pixel_array", 1,
3586               MEDIA_ENT_F_CAM_SENSOR);
3587
3588     rval = ccs_init_controls(sensor);
3589     if (rval < 0)
3590         goto out_cleanup;
3591
3592     rval = ccs_call_quirk(sensor, init);
3593     if (rval)
3594         goto out_cleanup;
3595
3596     rval = ccs_get_mbus_formats(sensor);
3597     if (rval) {
3598         rval = -ENODEV;
3599         goto out_cleanup;
3600     }
3601
3602     rval = ccs_init_late_controls(sensor);
3603     if (rval) {
3604         rval = -ENODEV;
3605         goto out_cleanup;
3606     }
3607
3608     mutex_lock(&sensor->mutex);
3609     rval = ccs_pll_blanking_update(sensor);
3610     mutex_unlock(&sensor->mutex);
3611     if (rval) {
3612         dev_err(&client->dev, "update mode failed\n");
3613         goto out_cleanup;
3614     }
3615
3616     sensor->streaming = false;
3617     sensor->dev_init_done = true;
3618
3619     rval = media_entity_pads_init(&sensor->src->sd.entity, 2,
3620                  sensor->src->pads);
3621     if (rval < 0)
3622         goto out_media_entity_cleanup;
3623
3624     rval = ccs_write_msr_regs(sensor);
3625     if (rval)
3626         goto out_media_entity_cleanup;
3627
3628     pm_runtime_set_active(&client->dev);
3629     pm_runtime_get_noresume(&client->dev);
3630     pm_runtime_enable(&client->dev);
3631
3632     rval = v4l2_async_register_subdev_sensor(&sensor->src->sd);
3633     if (rval < 0)
3634         goto out_disable_runtime_pm;
3635
3636     pm_runtime_set_autosuspend_delay(&client->dev, 1000);
3637     pm_runtime_use_autosuspend(&client->dev);
3638     pm_runtime_put_autosuspend(&client->dev);
3639
3640     return 0;
3641
3642 out_disable_runtime_pm:
3643     pm_runtime_put_noidle(&client->dev);
3644     pm_runtime_disable(&client->dev);
3645
3646 out_media_entity_cleanup:
3647     media_entity_cleanup(&sensor->src->sd.entity);
3648
3649 out_cleanup:
3650     ccs_cleanup(sensor);
3651
3652 out_release_mdata:
3653     kvfree(sensor->mdata.backing);
3654
3655 out_release_sdata:
3656     kvfree(sensor->sdata.backing);
3657
3658 out_free_ccs_limits:
3659     kfree(sensor->ccs_limits);
3660
3661 out_power_off:
3662     ccs_power_off(&client->dev);
3663     mutex_destroy(&sensor->mutex);
3664
3665     return rval;
3666 }
3667
3668 static int ccs_remove(struct i2c_client *client)
3669 {
3670     struct v4l2_subdev *subdev = i2c_get_clientdata(client);
3671     struct ccs_sensor *sensor = to_ccs_sensor(subdev);
3672     unsigned int i;
3673
3674     v4l2_async_unregister_subdev(subdev);
3675
3676     pm_runtime_disable(&client->dev);
3677     if (!pm_runtime_status_suspended(&client->dev))
3678         ccs_power_off(&client->dev);
3679     pm_runtime_set_suspended(&client->dev);
3680
3681     for (i = 0; i < sensor->ssds_used; i++) {
3682         v4l2_device_unregister_subdev(&sensor->ssds[i].sd);
3683         media_entity_cleanup(&sensor->ssds[i].sd.entity);
3684     }
3685     ccs_cleanup(sensor);
3686     mutex_destroy(&sensor->mutex);
3687     kfree(sensor->ccs_limits);
3688     kvfree(sensor->sdata.backing);
3689     kvfree(sensor->mdata.backing);
3690
3691     return 0;
3692 }
3693
3694 static const struct ccs_device smia_device = {
3695     .flags = CCS_DEVICE_FLAG_IS_SMIA,
3696 };
3697
3698 static const struct ccs_device ccs_device = {};
3699
3700 static const struct acpi_device_id ccs_acpi_table[] = {
3701     { .id = "MIPI0200", .driver_data = (unsigned long)&ccs_device },
3702     { },
3703 };
3704 MODULE_DEVICE_TABLE(acpi, ccs_acpi_table);
3705
3706 static const struct of_device_id ccs_of_table[] = {
3707     { .compatible = "mipi-ccs-1.1", .data = &ccs_device },
3708     { .compatible = "mipi-ccs-1.0", .data = &ccs_device },
3709     { .compatible = "mipi-ccs", .data = &ccs_device },
3710     { .compatible = "nokia,smia", .data = &smia_device },
3711     { },
3712 };
3713 MODULE_DEVICE_TABLE(of, ccs_of_table);
3714
3715 static const struct dev_pm_ops ccs_pm_ops = {
3716     SET_SYSTEM_SLEEP_PM_OPS(ccs_suspend, ccs_resume)
3717     SET_RUNTIME_PM_OPS(ccs_power_off, ccs_power_on, NULL)
3718 };
3719
3720 static struct i2c_driver ccs_i2c_driver = {
3721     .driver = {
3722         .acpi_match_table = ccs_acpi_table,
3723         .of_match_table = ccs_of_table,
3724         .name = CCS_NAME,
3725         .pm = &ccs_pm_ops,
3726     },
3727     .probe_new = ccs_probe,
3728     .remove = ccs_remove,
3729 };
3730
3731 static int ccs_module_init(void)
3732 {
3733     unsigned int i, l;
3734
3735     for (i = 0, l = 0; ccs_limits[i].size && l < CCS_L_LAST; i++) {
3736         if (!(ccs_limits[i].flags & CCS_L_FL_SAME_REG)) {
3737             ccs_limit_offsets[l + 1].lim =
3738                 ALIGN(ccs_limit_offsets[l].lim +
3739                       ccs_limits[i].size,
3740                       ccs_reg_width(ccs_limits[i + 1].reg));
3741             ccs_limit_offsets[l].info = i;
3742             l++;
3743         } else {
3744             ccs_limit_offsets[l].lim += ccs_limits[i].size;
3745         }
3746     }
3747
3748     if (WARN_ON(ccs_limits[i].size))
3749         return -EINVAL;
3750
3751     if (WARN_ON(l != CCS_L_LAST))
3752         return -EINVAL;
3753
3754     return i2c_register_driver(THIS_MODULE, &ccs_i2c_driver);
3755 }
3756
3757 static void ccs_module_cleanup(void)
3758 {
3759     i2c_del_driver(&ccs_i2c_driver);
3760 }
3761
3762 module_init(ccs_module_init);
3763 module_exit(ccs_module_cleanup);
3764
3765 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>");
3766 MODULE_DESCRIPTION("Generic MIPI CCS/SMIA/SMIA++ camera sensor driver");
3767 MODULE_LICENSE("GPL v2");
3768 MODULE_ALIAS("smiapp");