1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * camss-ispif.c 4 * 5 * Qualcomm MSM Camera Subsystem - ISPIF (ISP Interface) Module 6 * 7 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. 8 * Copyright (C) 2015-2018 Linaro Ltd. 9 */ 10 #include <linux/clk.h> 11 #include <linux/completion.h> 12 #include <linux/interrupt.h> 13 #include <linux/io.h> 14 #include <linux/iopoll.h> 15 #include <linux/kernel.h> 16 #include <linux/mutex.h> 17 #include <linux/platform_device.h> 18 #include <linux/pm_runtime.h> 19 #include <media/media-entity.h> 20 #include <media/v4l2-device.h> 21 #include <media/v4l2-subdev.h> 22 23 #include "camss-ispif.h" 24 #include "camss.h" 25 26 #define MSM_ISPIF_NAME "msm_ispif" 27 28 #define ISPIF_RST_CMD_0 0x008 29 #define ISPIF_RST_CMD_1 0x00c 30 #define ISPIF_RST_CMD_0_STROBED_RST_EN (1 << 0) 31 #define ISPIF_RST_CMD_0_MISC_LOGIC_RST (1 << 1) 32 #define ISPIF_RST_CMD_0_SW_REG_RST (1 << 2) 33 #define ISPIF_RST_CMD_0_PIX_INTF_0_CSID_RST (1 << 3) 34 #define ISPIF_RST_CMD_0_PIX_INTF_0_VFE_RST (1 << 4) 35 #define ISPIF_RST_CMD_0_PIX_INTF_1_CSID_RST (1 << 5) 36 #define ISPIF_RST_CMD_0_PIX_INTF_1_VFE_RST (1 << 6) 37 #define ISPIF_RST_CMD_0_RDI_INTF_0_CSID_RST (1 << 7) 38 #define ISPIF_RST_CMD_0_RDI_INTF_0_VFE_RST (1 << 8) 39 #define ISPIF_RST_CMD_0_RDI_INTF_1_CSID_RST (1 << 9) 40 #define ISPIF_RST_CMD_0_RDI_INTF_1_VFE_RST (1 << 10) 41 #define ISPIF_RST_CMD_0_RDI_INTF_2_CSID_RST (1 << 11) 42 #define ISPIF_RST_CMD_0_RDI_INTF_2_VFE_RST (1 << 12) 43 #define ISPIF_RST_CMD_0_PIX_OUTPUT_0_MISR_RST (1 << 16) 44 #define ISPIF_RST_CMD_0_RDI_OUTPUT_0_MISR_RST (1 << 17) 45 #define ISPIF_RST_CMD_0_RDI_OUTPUT_1_MISR_RST (1 << 18) 46 #define ISPIF_RST_CMD_0_RDI_OUTPUT_2_MISR_RST (1 << 19) 47 #define ISPIF_IRQ_GLOBAL_CLEAR_CMD 0x01c 48 #define ISPIF_VFE_m_CTRL_0(m) (0x200 + 0x200 * (m)) 49 #define ISPIF_VFE_m_CTRL_0_PIX0_LINE_BUF_EN (1 << 6) 50 #define ISPIF_VFE_m_IRQ_MASK_0(m) (0x208 + 0x200 * (m)) 51 #define ISPIF_VFE_m_IRQ_MASK_0_PIX0_ENABLE 0x00001249 52 #define ISPIF_VFE_m_IRQ_MASK_0_PIX0_MASK 0x00001fff 53 #define ISPIF_VFE_m_IRQ_MASK_0_RDI0_ENABLE 0x02492000 54 #define ISPIF_VFE_m_IRQ_MASK_0_RDI0_MASK 0x03ffe000 55 #define ISPIF_VFE_m_IRQ_MASK_1(m) (0x20c + 0x200 * (m)) 56 #define ISPIF_VFE_m_IRQ_MASK_1_PIX1_ENABLE 0x00001249 57 #define ISPIF_VFE_m_IRQ_MASK_1_PIX1_MASK 0x00001fff 58 #define ISPIF_VFE_m_IRQ_MASK_1_RDI1_ENABLE 0x02492000 59 #define ISPIF_VFE_m_IRQ_MASK_1_RDI1_MASK 0x03ffe000 60 #define ISPIF_VFE_m_IRQ_MASK_2(m) (0x210 + 0x200 * (m)) 61 #define ISPIF_VFE_m_IRQ_MASK_2_RDI2_ENABLE 0x00001249 62 #define ISPIF_VFE_m_IRQ_MASK_2_RDI2_MASK 0x00001fff 63 #define ISPIF_VFE_m_IRQ_STATUS_0(m) (0x21c + 0x200 * (m)) 64 #define ISPIF_VFE_m_IRQ_STATUS_0_PIX0_OVERFLOW (1 << 12) 65 #define ISPIF_VFE_m_IRQ_STATUS_0_RDI0_OVERFLOW (1 << 25) 66 #define ISPIF_VFE_m_IRQ_STATUS_1(m) (0x220 + 0x200 * (m)) 67 #define ISPIF_VFE_m_IRQ_STATUS_1_PIX1_OVERFLOW (1 << 12) 68 #define ISPIF_VFE_m_IRQ_STATUS_1_RDI1_OVERFLOW (1 << 25) 69 #define ISPIF_VFE_m_IRQ_STATUS_2(m) (0x224 + 0x200 * (m)) 70 #define ISPIF_VFE_m_IRQ_STATUS_2_RDI2_OVERFLOW (1 << 12) 71 #define ISPIF_VFE_m_IRQ_CLEAR_0(m) (0x230 + 0x200 * (m)) 72 #define ISPIF_VFE_m_IRQ_CLEAR_1(m) (0x234 + 0x200 * (m)) 73 #define ISPIF_VFE_m_IRQ_CLEAR_2(m) (0x238 + 0x200 * (m)) 74 #define ISPIF_VFE_m_INTF_INPUT_SEL(m) (0x244 + 0x200 * (m)) 75 #define ISPIF_VFE_m_INTF_CMD_0(m) (0x248 + 0x200 * (m)) 76 #define ISPIF_VFE_m_INTF_CMD_1(m) (0x24c + 0x200 * (m)) 77 #define ISPIF_VFE_m_PIX_INTF_n_CID_MASK(m, n) \ 78 (0x254 + 0x200 * (m) + 0x4 * (n)) 79 #define ISPIF_VFE_m_RDI_INTF_n_CID_MASK(m, n) \ 80 (0x264 + 0x200 * (m) + 0x4 * (n)) 81 /* PACK_CFG registers are 8x96 only */ 82 #define ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_0(m, n) \ 83 (0x270 + 0x200 * (m) + 0x4 * (n)) 84 #define ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_1(m, n) \ 85 (0x27c + 0x200 * (m) + 0x4 * (n)) 86 #define ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_0_CID_c_PLAIN(c) \ 87 (1 << ((cid % 8) * 4)) 88 #define ISPIF_VFE_m_PIX_INTF_n_STATUS(m, n) \ 89 (0x2c0 + 0x200 * (m) + 0x4 * (n)) 90 #define ISPIF_VFE_m_RDI_INTF_n_STATUS(m, n) \ 91 (0x2d0 + 0x200 * (m) + 0x4 * (n)) 92 93 #define CSI_PIX_CLK_MUX_SEL 0x000 94 #define CSI_RDI_CLK_MUX_SEL 0x008 95 96 #define ISPIF_TIMEOUT_SLEEP_US 1000 97 #define ISPIF_TIMEOUT_ALL_US 1000000 98 #define ISPIF_RESET_TIMEOUT_MS 500 99 100 enum ispif_intf_cmd { 101 CMD_DISABLE_FRAME_BOUNDARY = 0x0, 102 CMD_ENABLE_FRAME_BOUNDARY = 0x1, 103 CMD_DISABLE_IMMEDIATELY = 0x2, 104 CMD_ALL_DISABLE_IMMEDIATELY = 0xaaaaaaaa, 105 CMD_ALL_NO_CHANGE = 0xffffffff, 106 }; 107 108 static const u32 ispif_formats_8x16[] = { 109 MEDIA_BUS_FMT_UYVY8_1X16, 110 MEDIA_BUS_FMT_VYUY8_1X16, 111 MEDIA_BUS_FMT_YUYV8_1X16, 112 MEDIA_BUS_FMT_YVYU8_1X16, 113 MEDIA_BUS_FMT_SBGGR8_1X8, 114 MEDIA_BUS_FMT_SGBRG8_1X8, 115 MEDIA_BUS_FMT_SGRBG8_1X8, 116 MEDIA_BUS_FMT_SRGGB8_1X8, 117 MEDIA_BUS_FMT_SBGGR10_1X10, 118 MEDIA_BUS_FMT_SGBRG10_1X10, 119 MEDIA_BUS_FMT_SGRBG10_1X10, 120 MEDIA_BUS_FMT_SRGGB10_1X10, 121 MEDIA_BUS_FMT_SBGGR12_1X12, 122 MEDIA_BUS_FMT_SGBRG12_1X12, 123 MEDIA_BUS_FMT_SGRBG12_1X12, 124 MEDIA_BUS_FMT_SRGGB12_1X12, 125 MEDIA_BUS_FMT_Y10_1X10, 126 }; 127 128 static const u32 ispif_formats_8x96[] = { 129 MEDIA_BUS_FMT_UYVY8_1X16, 130 MEDIA_BUS_FMT_VYUY8_1X16, 131 MEDIA_BUS_FMT_YUYV8_1X16, 132 MEDIA_BUS_FMT_YVYU8_1X16, 133 MEDIA_BUS_FMT_SBGGR8_1X8, 134 MEDIA_BUS_FMT_SGBRG8_1X8, 135 MEDIA_BUS_FMT_SGRBG8_1X8, 136 MEDIA_BUS_FMT_SRGGB8_1X8, 137 MEDIA_BUS_FMT_SBGGR10_1X10, 138 MEDIA_BUS_FMT_SGBRG10_1X10, 139 MEDIA_BUS_FMT_SGRBG10_1X10, 140 MEDIA_BUS_FMT_SRGGB10_1X10, 141 MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, 142 MEDIA_BUS_FMT_SBGGR12_1X12, 143 MEDIA_BUS_FMT_SGBRG12_1X12, 144 MEDIA_BUS_FMT_SGRBG12_1X12, 145 MEDIA_BUS_FMT_SRGGB12_1X12, 146 MEDIA_BUS_FMT_SBGGR14_1X14, 147 MEDIA_BUS_FMT_SGBRG14_1X14, 148 MEDIA_BUS_FMT_SGRBG14_1X14, 149 MEDIA_BUS_FMT_SRGGB14_1X14, 150 MEDIA_BUS_FMT_Y10_1X10, 151 MEDIA_BUS_FMT_Y10_2X8_PADHI_LE, 152 }; 153 154 /* 155 * ispif_isr_8x96 - ISPIF module interrupt handler for 8x96 156 * @irq: Interrupt line 157 * @dev: ISPIF device 158 * 159 * Return IRQ_HANDLED on success 160 */ 161 static irqreturn_t ispif_isr_8x96(int irq, void *dev) 162 { 163 struct ispif_device *ispif = dev; 164 struct camss *camss = ispif->camss; 165 u32 value0, value1, value2, value3, value4, value5; 166 167 value0 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_0(0)); 168 value1 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_1(0)); 169 value2 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_2(0)); 170 value3 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_0(1)); 171 value4 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_1(1)); 172 value5 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_2(1)); 173 174 writel_relaxed(value0, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_0(0)); 175 writel_relaxed(value1, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_1(0)); 176 writel_relaxed(value2, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_2(0)); 177 writel_relaxed(value3, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_0(1)); 178 writel_relaxed(value4, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_1(1)); 179 writel_relaxed(value5, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_2(1)); 180 181 writel(0x1, ispif->base + ISPIF_IRQ_GLOBAL_CLEAR_CMD); 182 183 if ((value0 >> 27) & 0x1) 184 complete(&ispif->reset_complete[0]); 185 186 if ((value3 >> 27) & 0x1) 187 complete(&ispif->reset_complete[1]); 188 189 if (unlikely(value0 & ISPIF_VFE_m_IRQ_STATUS_0_PIX0_OVERFLOW)) 190 dev_err_ratelimited(camss->dev, "VFE0 pix0 overflow\n"); 191 192 if (unlikely(value0 & ISPIF_VFE_m_IRQ_STATUS_0_RDI0_OVERFLOW)) 193 dev_err_ratelimited(camss->dev, "VFE0 rdi0 overflow\n"); 194 195 if (unlikely(value1 & ISPIF_VFE_m_IRQ_STATUS_1_PIX1_OVERFLOW)) 196 dev_err_ratelimited(camss->dev, "VFE0 pix1 overflow\n"); 197 198 if (unlikely(value1 & ISPIF_VFE_m_IRQ_STATUS_1_RDI1_OVERFLOW)) 199 dev_err_ratelimited(camss->dev, "VFE0 rdi1 overflow\n"); 200 201 if (unlikely(value2 & ISPIF_VFE_m_IRQ_STATUS_2_RDI2_OVERFLOW)) 202 dev_err_ratelimited(camss->dev, "VFE0 rdi2 overflow\n"); 203 204 if (unlikely(value3 & ISPIF_VFE_m_IRQ_STATUS_0_PIX0_OVERFLOW)) 205 dev_err_ratelimited(camss->dev, "VFE1 pix0 overflow\n"); 206 207 if (unlikely(value3 & ISPIF_VFE_m_IRQ_STATUS_0_RDI0_OVERFLOW)) 208 dev_err_ratelimited(camss->dev, "VFE1 rdi0 overflow\n"); 209 210 if (unlikely(value4 & ISPIF_VFE_m_IRQ_STATUS_1_PIX1_OVERFLOW)) 211 dev_err_ratelimited(camss->dev, "VFE1 pix1 overflow\n"); 212 213 if (unlikely(value4 & ISPIF_VFE_m_IRQ_STATUS_1_RDI1_OVERFLOW)) 214 dev_err_ratelimited(camss->dev, "VFE1 rdi1 overflow\n"); 215 216 if (unlikely(value5 & ISPIF_VFE_m_IRQ_STATUS_2_RDI2_OVERFLOW)) 217 dev_err_ratelimited(camss->dev, "VFE1 rdi2 overflow\n"); 218 219 return IRQ_HANDLED; 220 } 221 222 /* 223 * ispif_isr_8x16 - ISPIF module interrupt handler for 8x16 224 * @irq: Interrupt line 225 * @dev: ISPIF device 226 * 227 * Return IRQ_HANDLED on success 228 */ 229 static irqreturn_t ispif_isr_8x16(int irq, void *dev) 230 { 231 struct ispif_device *ispif = dev; 232 struct camss *camss = ispif->camss; 233 u32 value0, value1, value2; 234 235 value0 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_0(0)); 236 value1 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_1(0)); 237 value2 = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_STATUS_2(0)); 238 239 writel_relaxed(value0, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_0(0)); 240 writel_relaxed(value1, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_1(0)); 241 writel_relaxed(value2, ispif->base + ISPIF_VFE_m_IRQ_CLEAR_2(0)); 242 243 writel(0x1, ispif->base + ISPIF_IRQ_GLOBAL_CLEAR_CMD); 244 245 if ((value0 >> 27) & 0x1) 246 complete(&ispif->reset_complete[0]); 247 248 if (unlikely(value0 & ISPIF_VFE_m_IRQ_STATUS_0_PIX0_OVERFLOW)) 249 dev_err_ratelimited(camss->dev, "VFE0 pix0 overflow\n"); 250 251 if (unlikely(value0 & ISPIF_VFE_m_IRQ_STATUS_0_RDI0_OVERFLOW)) 252 dev_err_ratelimited(camss->dev, "VFE0 rdi0 overflow\n"); 253 254 if (unlikely(value1 & ISPIF_VFE_m_IRQ_STATUS_1_PIX1_OVERFLOW)) 255 dev_err_ratelimited(camss->dev, "VFE0 pix1 overflow\n"); 256 257 if (unlikely(value1 & ISPIF_VFE_m_IRQ_STATUS_1_RDI1_OVERFLOW)) 258 dev_err_ratelimited(camss->dev, "VFE0 rdi1 overflow\n"); 259 260 if (unlikely(value2 & ISPIF_VFE_m_IRQ_STATUS_2_RDI2_OVERFLOW)) 261 dev_err_ratelimited(camss->dev, "VFE0 rdi2 overflow\n"); 262 263 return IRQ_HANDLED; 264 } 265 266 static int ispif_vfe_reset(struct ispif_device *ispif, u8 vfe_id) 267 { 268 struct camss *camss = ispif->camss; 269 270 unsigned long time; 271 u32 val; 272 273 if (vfe_id >= camss->res->vfe_num) { 274 dev_err(camss->dev, 275 "Error: asked reset for invalid VFE%d\n", vfe_id); 276 return -ENOENT; 277 } 278 279 reinit_completion(&ispif->reset_complete[vfe_id]); 280 281 val = ISPIF_RST_CMD_0_STROBED_RST_EN | 282 ISPIF_RST_CMD_0_MISC_LOGIC_RST | 283 ISPIF_RST_CMD_0_SW_REG_RST | 284 ISPIF_RST_CMD_0_PIX_INTF_0_CSID_RST | 285 ISPIF_RST_CMD_0_PIX_INTF_0_VFE_RST | 286 ISPIF_RST_CMD_0_PIX_INTF_1_CSID_RST | 287 ISPIF_RST_CMD_0_PIX_INTF_1_VFE_RST | 288 ISPIF_RST_CMD_0_RDI_INTF_0_CSID_RST | 289 ISPIF_RST_CMD_0_RDI_INTF_0_VFE_RST | 290 ISPIF_RST_CMD_0_RDI_INTF_1_CSID_RST | 291 ISPIF_RST_CMD_0_RDI_INTF_1_VFE_RST | 292 ISPIF_RST_CMD_0_RDI_INTF_2_CSID_RST | 293 ISPIF_RST_CMD_0_RDI_INTF_2_VFE_RST | 294 ISPIF_RST_CMD_0_PIX_OUTPUT_0_MISR_RST | 295 ISPIF_RST_CMD_0_RDI_OUTPUT_0_MISR_RST | 296 ISPIF_RST_CMD_0_RDI_OUTPUT_1_MISR_RST | 297 ISPIF_RST_CMD_0_RDI_OUTPUT_2_MISR_RST; 298 299 if (vfe_id == 1) 300 writel_relaxed(val, ispif->base + ISPIF_RST_CMD_1); 301 else 302 writel_relaxed(val, ispif->base + ISPIF_RST_CMD_0); 303 304 time = wait_for_completion_timeout(&ispif->reset_complete[vfe_id], 305 msecs_to_jiffies(ISPIF_RESET_TIMEOUT_MS)); 306 if (!time) { 307 dev_err(camss->dev, 308 "ISPIF for VFE%d reset timeout\n", vfe_id); 309 return -EIO; 310 } 311 312 return 0; 313 } 314 315 /* 316 * ispif_reset - Trigger reset on ISPIF module and wait to complete 317 * @ispif: ISPIF device 318 * 319 * Return 0 on success or a negative error code otherwise 320 */ 321 static int ispif_reset(struct ispif_device *ispif, u8 vfe_id) 322 { 323 struct camss *camss = ispif->camss; 324 int ret; 325 326 ret = camss_pm_domain_on(camss, PM_DOMAIN_VFE0); 327 if (ret < 0) 328 return ret; 329 330 ret = camss_pm_domain_on(camss, PM_DOMAIN_VFE1); 331 if (ret < 0) 332 return ret; 333 334 ret = camss_enable_clocks(ispif->nclocks_for_reset, 335 ispif->clock_for_reset, 336 camss->dev); 337 if (ret < 0) 338 return ret; 339 340 ret = ispif_vfe_reset(ispif, vfe_id); 341 if (ret) 342 dev_dbg(camss->dev, "ISPIF Reset failed\n"); 343 344 camss_disable_clocks(ispif->nclocks_for_reset, ispif->clock_for_reset); 345 346 camss_pm_domain_off(camss, PM_DOMAIN_VFE0); 347 camss_pm_domain_off(camss, PM_DOMAIN_VFE1); 348 349 return ret; 350 } 351 352 /* 353 * ispif_set_power - Power on/off ISPIF module 354 * @sd: ISPIF V4L2 subdevice 355 * @on: Requested power state 356 * 357 * Return 0 on success or a negative error code otherwise 358 */ 359 static int ispif_set_power(struct v4l2_subdev *sd, int on) 360 { 361 struct ispif_line *line = v4l2_get_subdevdata(sd); 362 struct ispif_device *ispif = line->ispif; 363 struct device *dev = ispif->camss->dev; 364 int ret = 0; 365 366 mutex_lock(&ispif->power_lock); 367 368 if (on) { 369 if (ispif->power_count) { 370 /* Power is already on */ 371 ispif->power_count++; 372 goto exit; 373 } 374 375 ret = pm_runtime_resume_and_get(dev); 376 if (ret < 0) 377 goto exit; 378 379 ret = camss_enable_clocks(ispif->nclocks, ispif->clock, dev); 380 if (ret < 0) { 381 pm_runtime_put_sync(dev); 382 goto exit; 383 } 384 385 ret = ispif_reset(ispif, line->vfe_id); 386 if (ret < 0) { 387 pm_runtime_put_sync(dev); 388 camss_disable_clocks(ispif->nclocks, ispif->clock); 389 goto exit; 390 } 391 392 ispif->intf_cmd[line->vfe_id].cmd_0 = CMD_ALL_NO_CHANGE; 393 ispif->intf_cmd[line->vfe_id].cmd_1 = CMD_ALL_NO_CHANGE; 394 395 ispif->power_count++; 396 } else { 397 if (ispif->power_count == 0) { 398 dev_err(dev, "ispif power off on power_count == 0\n"); 399 goto exit; 400 } else if (ispif->power_count == 1) { 401 camss_disable_clocks(ispif->nclocks, ispif->clock); 402 pm_runtime_put_sync(dev); 403 } 404 405 ispif->power_count--; 406 } 407 408 exit: 409 mutex_unlock(&ispif->power_lock); 410 411 return ret; 412 } 413 414 /* 415 * ispif_select_clk_mux - Select clock for PIX/RDI interface 416 * @ispif: ISPIF device 417 * @intf: VFE interface 418 * @csid: CSID HW module id 419 * @vfe: VFE HW module id 420 * @enable: enable or disable the selected clock 421 */ 422 static void ispif_select_clk_mux(struct ispif_device *ispif, 423 enum ispif_intf intf, u8 csid, 424 u8 vfe, u8 enable) 425 { 426 u32 val; 427 428 switch (intf) { 429 case PIX0: 430 val = readl_relaxed(ispif->base_clk_mux + CSI_PIX_CLK_MUX_SEL); 431 val &= ~(0xf << (vfe * 8)); 432 if (enable) 433 val |= (csid << (vfe * 8)); 434 writel_relaxed(val, ispif->base_clk_mux + CSI_PIX_CLK_MUX_SEL); 435 break; 436 437 case RDI0: 438 val = readl_relaxed(ispif->base_clk_mux + CSI_RDI_CLK_MUX_SEL); 439 val &= ~(0xf << (vfe * 12)); 440 if (enable) 441 val |= (csid << (vfe * 12)); 442 writel_relaxed(val, ispif->base_clk_mux + CSI_RDI_CLK_MUX_SEL); 443 break; 444 445 case PIX1: 446 val = readl_relaxed(ispif->base_clk_mux + CSI_PIX_CLK_MUX_SEL); 447 val &= ~(0xf << (4 + (vfe * 8))); 448 if (enable) 449 val |= (csid << (4 + (vfe * 8))); 450 writel_relaxed(val, ispif->base_clk_mux + CSI_PIX_CLK_MUX_SEL); 451 break; 452 453 case RDI1: 454 val = readl_relaxed(ispif->base_clk_mux + CSI_RDI_CLK_MUX_SEL); 455 val &= ~(0xf << (4 + (vfe * 12))); 456 if (enable) 457 val |= (csid << (4 + (vfe * 12))); 458 writel_relaxed(val, ispif->base_clk_mux + CSI_RDI_CLK_MUX_SEL); 459 break; 460 461 case RDI2: 462 val = readl_relaxed(ispif->base_clk_mux + CSI_RDI_CLK_MUX_SEL); 463 val &= ~(0xf << (8 + (vfe * 12))); 464 if (enable) 465 val |= (csid << (8 + (vfe * 12))); 466 writel_relaxed(val, ispif->base_clk_mux + CSI_RDI_CLK_MUX_SEL); 467 break; 468 } 469 470 mb(); 471 } 472 473 /* 474 * ispif_validate_intf_status - Validate current status of PIX/RDI interface 475 * @ispif: ISPIF device 476 * @intf: VFE interface 477 * @vfe: VFE HW module id 478 * 479 * Return 0 when interface is idle or -EBUSY otherwise 480 */ 481 static int ispif_validate_intf_status(struct ispif_device *ispif, 482 enum ispif_intf intf, u8 vfe) 483 { 484 int ret = 0; 485 u32 val = 0; 486 487 switch (intf) { 488 case PIX0: 489 val = readl_relaxed(ispif->base + 490 ISPIF_VFE_m_PIX_INTF_n_STATUS(vfe, 0)); 491 break; 492 case RDI0: 493 val = readl_relaxed(ispif->base + 494 ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe, 0)); 495 break; 496 case PIX1: 497 val = readl_relaxed(ispif->base + 498 ISPIF_VFE_m_PIX_INTF_n_STATUS(vfe, 1)); 499 break; 500 case RDI1: 501 val = readl_relaxed(ispif->base + 502 ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe, 1)); 503 break; 504 case RDI2: 505 val = readl_relaxed(ispif->base + 506 ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe, 2)); 507 break; 508 } 509 510 if ((val & 0xf) != 0xf) { 511 dev_err(ispif->camss->dev, "%s: ispif is busy: 0x%x\n", 512 __func__, val); 513 ret = -EBUSY; 514 } 515 516 return ret; 517 } 518 519 /* 520 * ispif_wait_for_stop - Wait for PIX/RDI interface to stop 521 * @ispif: ISPIF device 522 * @intf: VFE interface 523 * @vfe: VFE HW module id 524 * 525 * Return 0 on success or a negative error code otherwise 526 */ 527 static int ispif_wait_for_stop(struct ispif_device *ispif, 528 enum ispif_intf intf, u8 vfe) 529 { 530 u32 addr = 0; 531 u32 stop_flag = 0; 532 int ret; 533 534 switch (intf) { 535 case PIX0: 536 addr = ISPIF_VFE_m_PIX_INTF_n_STATUS(vfe, 0); 537 break; 538 case RDI0: 539 addr = ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe, 0); 540 break; 541 case PIX1: 542 addr = ISPIF_VFE_m_PIX_INTF_n_STATUS(vfe, 1); 543 break; 544 case RDI1: 545 addr = ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe, 1); 546 break; 547 case RDI2: 548 addr = ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe, 2); 549 break; 550 } 551 552 ret = readl_poll_timeout(ispif->base + addr, 553 stop_flag, 554 (stop_flag & 0xf) == 0xf, 555 ISPIF_TIMEOUT_SLEEP_US, 556 ISPIF_TIMEOUT_ALL_US); 557 if (ret < 0) 558 dev_err(ispif->camss->dev, "%s: ispif stop timeout\n", 559 __func__); 560 561 return ret; 562 } 563 564 /* 565 * ispif_select_csid - Select CSID HW module for input from 566 * @ispif: ISPIF device 567 * @intf: VFE interface 568 * @csid: CSID HW module id 569 * @vfe: VFE HW module id 570 * @enable: enable or disable the selected input 571 */ 572 static void ispif_select_csid(struct ispif_device *ispif, enum ispif_intf intf, 573 u8 csid, u8 vfe, u8 enable) 574 { 575 u32 val; 576 577 val = readl_relaxed(ispif->base + ISPIF_VFE_m_INTF_INPUT_SEL(vfe)); 578 switch (intf) { 579 case PIX0: 580 val &= ~(BIT(1) | BIT(0)); 581 if (enable) 582 val |= csid; 583 break; 584 case RDI0: 585 val &= ~(BIT(5) | BIT(4)); 586 if (enable) 587 val |= (csid << 4); 588 break; 589 case PIX1: 590 val &= ~(BIT(9) | BIT(8)); 591 if (enable) 592 val |= (csid << 8); 593 break; 594 case RDI1: 595 val &= ~(BIT(13) | BIT(12)); 596 if (enable) 597 val |= (csid << 12); 598 break; 599 case RDI2: 600 val &= ~(BIT(21) | BIT(20)); 601 if (enable) 602 val |= (csid << 20); 603 break; 604 } 605 606 writel(val, ispif->base + ISPIF_VFE_m_INTF_INPUT_SEL(vfe)); 607 } 608 609 /* 610 * ispif_select_cid - Enable/disable desired CID 611 * @ispif: ISPIF device 612 * @intf: VFE interface 613 * @cid: desired CID to enable/disable 614 * @vfe: VFE HW module id 615 * @enable: enable or disable the desired CID 616 */ 617 static void ispif_select_cid(struct ispif_device *ispif, enum ispif_intf intf, 618 u8 cid, u8 vfe, u8 enable) 619 { 620 u32 cid_mask = 1 << cid; 621 u32 addr = 0; 622 u32 val; 623 624 switch (intf) { 625 case PIX0: 626 addr = ISPIF_VFE_m_PIX_INTF_n_CID_MASK(vfe, 0); 627 break; 628 case RDI0: 629 addr = ISPIF_VFE_m_RDI_INTF_n_CID_MASK(vfe, 0); 630 break; 631 case PIX1: 632 addr = ISPIF_VFE_m_PIX_INTF_n_CID_MASK(vfe, 1); 633 break; 634 case RDI1: 635 addr = ISPIF_VFE_m_RDI_INTF_n_CID_MASK(vfe, 1); 636 break; 637 case RDI2: 638 addr = ISPIF_VFE_m_RDI_INTF_n_CID_MASK(vfe, 2); 639 break; 640 } 641 642 val = readl_relaxed(ispif->base + addr); 643 if (enable) 644 val |= cid_mask; 645 else 646 val &= ~cid_mask; 647 648 writel(val, ispif->base + addr); 649 } 650 651 /* 652 * ispif_config_irq - Enable/disable interrupts for PIX/RDI interface 653 * @ispif: ISPIF device 654 * @intf: VFE interface 655 * @vfe: VFE HW module id 656 * @enable: enable or disable 657 */ 658 static void ispif_config_irq(struct ispif_device *ispif, enum ispif_intf intf, 659 u8 vfe, u8 enable) 660 { 661 u32 val; 662 663 switch (intf) { 664 case PIX0: 665 val = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_MASK_0(vfe)); 666 val &= ~ISPIF_VFE_m_IRQ_MASK_0_PIX0_MASK; 667 if (enable) 668 val |= ISPIF_VFE_m_IRQ_MASK_0_PIX0_ENABLE; 669 writel_relaxed(val, ispif->base + ISPIF_VFE_m_IRQ_MASK_0(vfe)); 670 writel_relaxed(ISPIF_VFE_m_IRQ_MASK_0_PIX0_ENABLE, 671 ispif->base + ISPIF_VFE_m_IRQ_CLEAR_0(vfe)); 672 break; 673 case RDI0: 674 val = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_MASK_0(vfe)); 675 val &= ~ISPIF_VFE_m_IRQ_MASK_0_RDI0_MASK; 676 if (enable) 677 val |= ISPIF_VFE_m_IRQ_MASK_0_RDI0_ENABLE; 678 writel_relaxed(val, ispif->base + ISPIF_VFE_m_IRQ_MASK_0(vfe)); 679 writel_relaxed(ISPIF_VFE_m_IRQ_MASK_0_RDI0_ENABLE, 680 ispif->base + ISPIF_VFE_m_IRQ_CLEAR_0(vfe)); 681 break; 682 case PIX1: 683 val = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_MASK_1(vfe)); 684 val &= ~ISPIF_VFE_m_IRQ_MASK_1_PIX1_MASK; 685 if (enable) 686 val |= ISPIF_VFE_m_IRQ_MASK_1_PIX1_ENABLE; 687 writel_relaxed(val, ispif->base + ISPIF_VFE_m_IRQ_MASK_1(vfe)); 688 writel_relaxed(ISPIF_VFE_m_IRQ_MASK_1_PIX1_ENABLE, 689 ispif->base + ISPIF_VFE_m_IRQ_CLEAR_1(vfe)); 690 break; 691 case RDI1: 692 val = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_MASK_1(vfe)); 693 val &= ~ISPIF_VFE_m_IRQ_MASK_1_RDI1_MASK; 694 if (enable) 695 val |= ISPIF_VFE_m_IRQ_MASK_1_RDI1_ENABLE; 696 writel_relaxed(val, ispif->base + ISPIF_VFE_m_IRQ_MASK_1(vfe)); 697 writel_relaxed(ISPIF_VFE_m_IRQ_MASK_1_RDI1_ENABLE, 698 ispif->base + ISPIF_VFE_m_IRQ_CLEAR_1(vfe)); 699 break; 700 case RDI2: 701 val = readl_relaxed(ispif->base + ISPIF_VFE_m_IRQ_MASK_2(vfe)); 702 val &= ~ISPIF_VFE_m_IRQ_MASK_2_RDI2_MASK; 703 if (enable) 704 val |= ISPIF_VFE_m_IRQ_MASK_2_RDI2_ENABLE; 705 writel_relaxed(val, ispif->base + ISPIF_VFE_m_IRQ_MASK_2(vfe)); 706 writel_relaxed(ISPIF_VFE_m_IRQ_MASK_2_RDI2_ENABLE, 707 ispif->base + ISPIF_VFE_m_IRQ_CLEAR_2(vfe)); 708 break; 709 } 710 711 writel(0x1, ispif->base + ISPIF_IRQ_GLOBAL_CLEAR_CMD); 712 } 713 714 /* 715 * ispif_config_pack - Config packing for PRDI mode 716 * @ispif: ISPIF device 717 * @code: media bus format code 718 * @intf: VFE interface 719 * @cid: desired CID to handle 720 * @vfe: VFE HW module id 721 * @enable: enable or disable 722 */ 723 static void ispif_config_pack(struct ispif_device *ispif, u32 code, 724 enum ispif_intf intf, u8 cid, u8 vfe, u8 enable) 725 { 726 u32 addr, val; 727 728 if (code != MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE && 729 code != MEDIA_BUS_FMT_Y10_2X8_PADHI_LE) 730 return; 731 732 switch (intf) { 733 case RDI0: 734 if (cid < 8) 735 addr = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_0(vfe, 0); 736 else 737 addr = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_1(vfe, 0); 738 break; 739 case RDI1: 740 if (cid < 8) 741 addr = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_0(vfe, 1); 742 else 743 addr = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_1(vfe, 1); 744 break; 745 case RDI2: 746 if (cid < 8) 747 addr = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_0(vfe, 2); 748 else 749 addr = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_1(vfe, 2); 750 break; 751 default: 752 return; 753 } 754 755 if (enable) 756 val = ISPIF_VFE_m_RDI_INTF_n_PACK_CFG_0_CID_c_PLAIN(cid); 757 else 758 val = 0; 759 760 writel_relaxed(val, ispif->base + addr); 761 } 762 763 /* 764 * ispif_set_intf_cmd - Set command to enable/disable interface 765 * @ispif: ISPIF device 766 * @cmd: interface command 767 * @intf: VFE interface 768 * @vfe: VFE HW module id 769 * @vc: virtual channel 770 */ 771 static void ispif_set_intf_cmd(struct ispif_device *ispif, u8 cmd, 772 enum ispif_intf intf, u8 vfe, u8 vc) 773 { 774 u32 *val; 775 776 if (intf == RDI2) { 777 val = &ispif->intf_cmd[vfe].cmd_1; 778 *val &= ~(0x3 << (vc * 2 + 8)); 779 *val |= (cmd << (vc * 2 + 8)); 780 wmb(); 781 writel_relaxed(*val, ispif->base + ISPIF_VFE_m_INTF_CMD_1(vfe)); 782 wmb(); 783 } else { 784 val = &ispif->intf_cmd[vfe].cmd_0; 785 *val &= ~(0x3 << (vc * 2 + intf * 8)); 786 *val |= (cmd << (vc * 2 + intf * 8)); 787 wmb(); 788 writel_relaxed(*val, ispif->base + ISPIF_VFE_m_INTF_CMD_0(vfe)); 789 wmb(); 790 } 791 } 792 793 /* 794 * ispif_set_stream - Enable/disable streaming on ISPIF module 795 * @sd: ISPIF V4L2 subdevice 796 * @enable: Requested streaming state 797 * 798 * Main configuration of ISPIF module is also done here. 799 * 800 * Return 0 on success or a negative error code otherwise 801 */ 802 static int ispif_set_stream(struct v4l2_subdev *sd, int enable) 803 { 804 struct ispif_line *line = v4l2_get_subdevdata(sd); 805 struct ispif_device *ispif = line->ispif; 806 struct camss *camss = ispif->camss; 807 enum ispif_intf intf = line->interface; 808 u8 csid = line->csid_id; 809 u8 vfe = line->vfe_id; 810 u8 vc = 0; /* Virtual Channel 0 */ 811 u8 cid = vc * 4; /* id of Virtual Channel and Data Type set */ 812 int ret; 813 814 if (enable) { 815 if (!media_pad_remote_pad_first(&line->pads[MSM_ISPIF_PAD_SINK])) 816 return -ENOLINK; 817 818 /* Config */ 819 820 mutex_lock(&ispif->config_lock); 821 ispif_select_clk_mux(ispif, intf, csid, vfe, 1); 822 823 ret = ispif_validate_intf_status(ispif, intf, vfe); 824 if (ret < 0) { 825 mutex_unlock(&ispif->config_lock); 826 return ret; 827 } 828 829 ispif_select_csid(ispif, intf, csid, vfe, 1); 830 ispif_select_cid(ispif, intf, cid, vfe, 1); 831 ispif_config_irq(ispif, intf, vfe, 1); 832 if (camss->res->version == CAMSS_8x96 || 833 camss->res->version == CAMSS_8x53 || 834 camss->res->version == CAMSS_660) 835 ispif_config_pack(ispif, 836 line->fmt[MSM_ISPIF_PAD_SINK].code, 837 intf, cid, vfe, 1); 838 ispif_set_intf_cmd(ispif, CMD_ENABLE_FRAME_BOUNDARY, 839 intf, vfe, vc); 840 } else { 841 mutex_lock(&ispif->config_lock); 842 ispif_set_intf_cmd(ispif, CMD_DISABLE_FRAME_BOUNDARY, 843 intf, vfe, vc); 844 mutex_unlock(&ispif->config_lock); 845 846 ret = ispif_wait_for_stop(ispif, intf, vfe); 847 if (ret < 0) 848 return ret; 849 850 mutex_lock(&ispif->config_lock); 851 if (camss->res->version == CAMSS_8x96 || 852 camss->res->version == CAMSS_8x53 || 853 camss->res->version == CAMSS_660) 854 ispif_config_pack(ispif, 855 line->fmt[MSM_ISPIF_PAD_SINK].code, 856 intf, cid, vfe, 0); 857 ispif_config_irq(ispif, intf, vfe, 0); 858 ispif_select_cid(ispif, intf, cid, vfe, 0); 859 ispif_select_csid(ispif, intf, csid, vfe, 0); 860 ispif_select_clk_mux(ispif, intf, csid, vfe, 0); 861 } 862 863 mutex_unlock(&ispif->config_lock); 864 865 return 0; 866 } 867 868 /* 869 * __ispif_get_format - Get pointer to format structure 870 * @ispif: ISPIF line 871 * @sd_state: V4L2 subdev state 872 * @pad: pad from which format is requested 873 * @which: TRY or ACTIVE format 874 * 875 * Return pointer to TRY or ACTIVE format structure 876 */ 877 static struct v4l2_mbus_framefmt * 878 __ispif_get_format(struct ispif_line *line, 879 struct v4l2_subdev_state *sd_state, 880 unsigned int pad, 881 enum v4l2_subdev_format_whence which) 882 { 883 if (which == V4L2_SUBDEV_FORMAT_TRY) 884 return v4l2_subdev_state_get_format(sd_state, pad); 885 886 return &line->fmt[pad]; 887 } 888 889 /* 890 * ispif_try_format - Handle try format by pad subdev method 891 * @ispif: ISPIF line 892 * @sd_state: V4L2 subdev state 893 * @pad: pad on which format is requested 894 * @fmt: pointer to v4l2 format structure 895 * @which: wanted subdev format 896 */ 897 static void ispif_try_format(struct ispif_line *line, 898 struct v4l2_subdev_state *sd_state, 899 unsigned int pad, 900 struct v4l2_mbus_framefmt *fmt, 901 enum v4l2_subdev_format_whence which) 902 { 903 unsigned int i; 904 905 switch (pad) { 906 case MSM_ISPIF_PAD_SINK: 907 /* Set format on sink pad */ 908 909 for (i = 0; i < line->nformats; i++) 910 if (fmt->code == line->formats[i]) 911 break; 912 913 /* If not found, use UYVY as default */ 914 if (i >= line->nformats) 915 fmt->code = MEDIA_BUS_FMT_UYVY8_1X16; 916 917 fmt->width = clamp_t(u32, fmt->width, 1, 8191); 918 fmt->height = clamp_t(u32, fmt->height, 1, 8191); 919 920 fmt->field = V4L2_FIELD_NONE; 921 fmt->colorspace = V4L2_COLORSPACE_SRGB; 922 923 break; 924 925 case MSM_ISPIF_PAD_SRC: 926 /* Set and return a format same as sink pad */ 927 928 *fmt = *__ispif_get_format(line, sd_state, MSM_ISPIF_PAD_SINK, 929 which); 930 931 break; 932 } 933 934 fmt->colorspace = V4L2_COLORSPACE_SRGB; 935 } 936 937 /* 938 * ispif_enum_mbus_code - Handle pixel format enumeration 939 * @sd: ISPIF V4L2 subdevice 940 * @sd_state: V4L2 subdev state 941 * @code: pointer to v4l2_subdev_mbus_code_enum structure 942 * return -EINVAL or zero on success 943 */ 944 static int ispif_enum_mbus_code(struct v4l2_subdev *sd, 945 struct v4l2_subdev_state *sd_state, 946 struct v4l2_subdev_mbus_code_enum *code) 947 { 948 struct ispif_line *line = v4l2_get_subdevdata(sd); 949 struct v4l2_mbus_framefmt *format; 950 951 if (code->pad == MSM_ISPIF_PAD_SINK) { 952 if (code->index >= line->nformats) 953 return -EINVAL; 954 955 code->code = line->formats[code->index]; 956 } else { 957 if (code->index > 0) 958 return -EINVAL; 959 960 format = __ispif_get_format(line, sd_state, 961 MSM_ISPIF_PAD_SINK, 962 code->which); 963 964 code->code = format->code; 965 } 966 967 return 0; 968 } 969 970 /* 971 * ispif_enum_frame_size - Handle frame size enumeration 972 * @sd: ISPIF V4L2 subdevice 973 * @sd_state: V4L2 subdev state 974 * @fse: pointer to v4l2_subdev_frame_size_enum structure 975 * return -EINVAL or zero on success 976 */ 977 static int ispif_enum_frame_size(struct v4l2_subdev *sd, 978 struct v4l2_subdev_state *sd_state, 979 struct v4l2_subdev_frame_size_enum *fse) 980 { 981 struct ispif_line *line = v4l2_get_subdevdata(sd); 982 struct v4l2_mbus_framefmt format; 983 984 if (fse->index != 0) 985 return -EINVAL; 986 987 format.code = fse->code; 988 format.width = 1; 989 format.height = 1; 990 ispif_try_format(line, sd_state, fse->pad, &format, fse->which); 991 fse->min_width = format.width; 992 fse->min_height = format.height; 993 994 if (format.code != fse->code) 995 return -EINVAL; 996 997 format.code = fse->code; 998 format.width = -1; 999 format.height = -1; 1000 ispif_try_format(line, sd_state, fse->pad, &format, fse->which); 1001 fse->max_width = format.width; 1002 fse->max_height = format.height; 1003 1004 return 0; 1005 } 1006 1007 /* 1008 * ispif_get_format - Handle get format by pads subdev method 1009 * @sd: ISPIF V4L2 subdevice 1010 * @sd_state: V4L2 subdev state 1011 * @fmt: pointer to v4l2 subdev format structure 1012 * 1013 * Return -EINVAL or zero on success 1014 */ 1015 static int ispif_get_format(struct v4l2_subdev *sd, 1016 struct v4l2_subdev_state *sd_state, 1017 struct v4l2_subdev_format *fmt) 1018 { 1019 struct ispif_line *line = v4l2_get_subdevdata(sd); 1020 struct v4l2_mbus_framefmt *format; 1021 1022 format = __ispif_get_format(line, sd_state, fmt->pad, fmt->which); 1023 if (format == NULL) 1024 return -EINVAL; 1025 1026 fmt->format = *format; 1027 1028 return 0; 1029 } 1030 1031 /* 1032 * ispif_set_format - Handle set format by pads subdev method 1033 * @sd: ISPIF V4L2 subdevice 1034 * @sd_state: V4L2 subdev state 1035 * @fmt: pointer to v4l2 subdev format structure 1036 * 1037 * Return -EINVAL or zero on success 1038 */ 1039 static int ispif_set_format(struct v4l2_subdev *sd, 1040 struct v4l2_subdev_state *sd_state, 1041 struct v4l2_subdev_format *fmt) 1042 { 1043 struct ispif_line *line = v4l2_get_subdevdata(sd); 1044 struct v4l2_mbus_framefmt *format; 1045 1046 format = __ispif_get_format(line, sd_state, fmt->pad, fmt->which); 1047 if (format == NULL) 1048 return -EINVAL; 1049 1050 ispif_try_format(line, sd_state, fmt->pad, &fmt->format, fmt->which); 1051 *format = fmt->format; 1052 1053 /* Propagate the format from sink to source */ 1054 if (fmt->pad == MSM_ISPIF_PAD_SINK) { 1055 format = __ispif_get_format(line, sd_state, MSM_ISPIF_PAD_SRC, 1056 fmt->which); 1057 1058 *format = fmt->format; 1059 ispif_try_format(line, sd_state, MSM_ISPIF_PAD_SRC, format, 1060 fmt->which); 1061 } 1062 1063 return 0; 1064 } 1065 1066 /* 1067 * ispif_init_formats - Initialize formats on all pads 1068 * @sd: ISPIF V4L2 subdevice 1069 * @fh: V4L2 subdev file handle 1070 * 1071 * Initialize all pad formats with default values. 1072 * 1073 * Return 0 on success or a negative error code otherwise 1074 */ 1075 static int ispif_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 1076 { 1077 struct v4l2_subdev_format format = { 1078 .pad = MSM_ISPIF_PAD_SINK, 1079 .which = fh ? V4L2_SUBDEV_FORMAT_TRY : 1080 V4L2_SUBDEV_FORMAT_ACTIVE, 1081 .format = { 1082 .code = MEDIA_BUS_FMT_UYVY8_1X16, 1083 .width = 1920, 1084 .height = 1080 1085 } 1086 }; 1087 1088 return ispif_set_format(sd, fh ? fh->state : NULL, &format); 1089 } 1090 1091 /* 1092 * msm_ispif_subdev_init - Initialize ISPIF device structure and resources 1093 * @ispif: ISPIF device 1094 * @res: ISPIF module resources table 1095 * 1096 * Return 0 on success or a negative error code otherwise 1097 */ 1098 int msm_ispif_subdev_init(struct camss *camss, 1099 const struct camss_subdev_resources *res) 1100 { 1101 struct device *dev = camss->dev; 1102 struct ispif_device *ispif = camss->ispif; 1103 struct platform_device *pdev = to_platform_device(dev); 1104 int i; 1105 int ret; 1106 1107 if (!camss->ispif) 1108 return 0; 1109 1110 ispif->camss = camss; 1111 1112 /* Number of ISPIF lines - same as number of CSID hardware modules */ 1113 if (camss->res->version == CAMSS_8x16) 1114 ispif->line_num = 2; 1115 else if (camss->res->version == CAMSS_8x96 || 1116 camss->res->version == CAMSS_8x53 || 1117 camss->res->version == CAMSS_660) 1118 ispif->line_num = 4; 1119 else 1120 return -EINVAL; 1121 1122 ispif->line = devm_kcalloc(dev, ispif->line_num, 1123 sizeof(*ispif->line), GFP_KERNEL); 1124 if (!ispif->line) 1125 return -ENOMEM; 1126 1127 for (i = 0; i < ispif->line_num; i++) { 1128 ispif->line[i].ispif = ispif; 1129 ispif->line[i].id = i; 1130 1131 if (camss->res->version == CAMSS_8x16) { 1132 ispif->line[i].formats = ispif_formats_8x16; 1133 ispif->line[i].nformats = 1134 ARRAY_SIZE(ispif_formats_8x16); 1135 } else if (camss->res->version == CAMSS_8x96 || 1136 camss->res->version == CAMSS_8x53 || 1137 camss->res->version == CAMSS_660) { 1138 ispif->line[i].formats = ispif_formats_8x96; 1139 ispif->line[i].nformats = 1140 ARRAY_SIZE(ispif_formats_8x96); 1141 } else { 1142 return -EINVAL; 1143 } 1144 } 1145 1146 /* Memory */ 1147 1148 ispif->base = devm_platform_ioremap_resource_byname(pdev, res->reg[0]); 1149 if (IS_ERR(ispif->base)) 1150 return PTR_ERR(ispif->base); 1151 1152 ispif->base_clk_mux = devm_platform_ioremap_resource_byname(pdev, res->reg[1]); 1153 if (IS_ERR(ispif->base_clk_mux)) 1154 return PTR_ERR(ispif->base_clk_mux); 1155 1156 /* Interrupt */ 1157 1158 ret = platform_get_irq_byname(pdev, res->interrupt[0]); 1159 if (ret < 0) 1160 return ret; 1161 1162 ispif->irq = ret; 1163 snprintf(ispif->irq_name, sizeof(ispif->irq_name), "%s_%s", 1164 dev_name(dev), MSM_ISPIF_NAME); 1165 if (camss->res->version == CAMSS_8x16) 1166 ret = devm_request_irq(dev, ispif->irq, ispif_isr_8x16, 1167 IRQF_TRIGGER_RISING, ispif->irq_name, ispif); 1168 else if (camss->res->version == CAMSS_8x96 || 1169 camss->res->version == CAMSS_8x53 || 1170 camss->res->version == CAMSS_660) 1171 ret = devm_request_irq(dev, ispif->irq, ispif_isr_8x96, 1172 IRQF_TRIGGER_RISING, ispif->irq_name, ispif); 1173 else 1174 ret = -EINVAL; 1175 1176 if (ret < 0) { 1177 dev_err(dev, "request_irq failed: %d\n", ret); 1178 return ret; 1179 } 1180 1181 /* Clocks */ 1182 1183 ispif->nclocks = 0; 1184 while (res->clock[ispif->nclocks]) 1185 ispif->nclocks++; 1186 1187 ispif->clock = devm_kcalloc(dev, 1188 ispif->nclocks, sizeof(*ispif->clock), 1189 GFP_KERNEL); 1190 if (!ispif->clock) 1191 return -ENOMEM; 1192 1193 for (i = 0; i < ispif->nclocks; i++) { 1194 struct camss_clock *clock = &ispif->clock[i]; 1195 1196 clock->clk = devm_clk_get(dev, res->clock[i]); 1197 if (IS_ERR(clock->clk)) 1198 return PTR_ERR(clock->clk); 1199 1200 clock->freq = NULL; 1201 clock->nfreqs = 0; 1202 } 1203 1204 ispif->nclocks_for_reset = 0; 1205 while (res->clock_for_reset[ispif->nclocks_for_reset]) 1206 ispif->nclocks_for_reset++; 1207 1208 ispif->clock_for_reset = devm_kcalloc(dev, 1209 ispif->nclocks_for_reset, 1210 sizeof(*ispif->clock_for_reset), 1211 GFP_KERNEL); 1212 if (!ispif->clock_for_reset) 1213 return -ENOMEM; 1214 1215 for (i = 0; i < ispif->nclocks_for_reset; i++) { 1216 struct camss_clock *clock = &ispif->clock_for_reset[i]; 1217 1218 clock->clk = devm_clk_get(dev, res->clock_for_reset[i]); 1219 if (IS_ERR(clock->clk)) 1220 return PTR_ERR(clock->clk); 1221 1222 clock->freq = NULL; 1223 clock->nfreqs = 0; 1224 } 1225 1226 mutex_init(&ispif->power_lock); 1227 ispif->power_count = 0; 1228 1229 mutex_init(&ispif->config_lock); 1230 1231 for (i = 0; i < MSM_ISPIF_VFE_NUM; i++) 1232 init_completion(&ispif->reset_complete[i]); 1233 1234 return 0; 1235 } 1236 1237 /* 1238 * ispif_get_intf - Get ISPIF interface to use by VFE line id 1239 * @line_id: VFE line id that the ISPIF line is connected to 1240 * 1241 * Return ISPIF interface to use 1242 */ 1243 static enum ispif_intf ispif_get_intf(enum vfe_line_id line_id) 1244 { 1245 switch (line_id) { 1246 case (VFE_LINE_RDI0): 1247 return RDI0; 1248 case (VFE_LINE_RDI1): 1249 return RDI1; 1250 case (VFE_LINE_RDI2): 1251 return RDI2; 1252 case (VFE_LINE_PIX): 1253 return PIX0; 1254 default: 1255 return RDI0; 1256 } 1257 } 1258 1259 /* 1260 * ispif_get_vfe_id - Get VFE HW module id 1261 * @entity: Pointer to VFE media entity structure 1262 * @id: Return CSID HW module id here 1263 */ 1264 static void ispif_get_vfe_id(struct media_entity *entity, u8 *id) 1265 { 1266 struct v4l2_subdev *sd; 1267 struct vfe_line *line; 1268 struct vfe_device *vfe; 1269 1270 sd = media_entity_to_v4l2_subdev(entity); 1271 line = v4l2_get_subdevdata(sd); 1272 vfe = to_vfe(line); 1273 1274 *id = vfe->id; 1275 } 1276 1277 /* 1278 * ispif_get_vfe_line_id - Get VFE line id by media entity 1279 * @entity: Pointer to VFE media entity structure 1280 * @id: Return VFE line id here 1281 */ 1282 static void ispif_get_vfe_line_id(struct media_entity *entity, 1283 enum vfe_line_id *id) 1284 { 1285 struct v4l2_subdev *sd; 1286 struct vfe_line *line; 1287 1288 sd = media_entity_to_v4l2_subdev(entity); 1289 line = v4l2_get_subdevdata(sd); 1290 1291 *id = line->id; 1292 } 1293 1294 /* 1295 * ispif_link_setup - Setup ISPIF connections 1296 * @entity: Pointer to media entity structure 1297 * @local: Pointer to local pad 1298 * @remote: Pointer to remote pad 1299 * @flags: Link flags 1300 * 1301 * Return 0 on success 1302 */ 1303 static int ispif_link_setup(struct media_entity *entity, 1304 const struct media_pad *local, 1305 const struct media_pad *remote, u32 flags) 1306 { 1307 if (flags & MEDIA_LNK_FL_ENABLED) { 1308 if (media_pad_remote_pad_first(local)) 1309 return -EBUSY; 1310 1311 if (local->flags & MEDIA_PAD_FL_SINK) { 1312 struct v4l2_subdev *sd; 1313 struct ispif_line *line; 1314 1315 sd = media_entity_to_v4l2_subdev(entity); 1316 line = v4l2_get_subdevdata(sd); 1317 1318 msm_csid_get_csid_id(remote->entity, &line->csid_id); 1319 } else { /* MEDIA_PAD_FL_SOURCE */ 1320 struct v4l2_subdev *sd; 1321 struct ispif_line *line; 1322 enum vfe_line_id id; 1323 1324 sd = media_entity_to_v4l2_subdev(entity); 1325 line = v4l2_get_subdevdata(sd); 1326 1327 ispif_get_vfe_id(remote->entity, &line->vfe_id); 1328 ispif_get_vfe_line_id(remote->entity, &id); 1329 line->interface = ispif_get_intf(id); 1330 } 1331 } 1332 1333 return 0; 1334 } 1335 1336 static const struct v4l2_subdev_core_ops ispif_core_ops = { 1337 .s_power = ispif_set_power, 1338 }; 1339 1340 static const struct v4l2_subdev_video_ops ispif_video_ops = { 1341 .s_stream = ispif_set_stream, 1342 }; 1343 1344 static const struct v4l2_subdev_pad_ops ispif_pad_ops = { 1345 .enum_mbus_code = ispif_enum_mbus_code, 1346 .enum_frame_size = ispif_enum_frame_size, 1347 .get_fmt = ispif_get_format, 1348 .set_fmt = ispif_set_format, 1349 }; 1350 1351 static const struct v4l2_subdev_ops ispif_v4l2_ops = { 1352 .core = &ispif_core_ops, 1353 .video = &ispif_video_ops, 1354 .pad = &ispif_pad_ops, 1355 }; 1356 1357 static const struct v4l2_subdev_internal_ops ispif_v4l2_internal_ops = { 1358 .open = ispif_init_formats, 1359 }; 1360 1361 static const struct media_entity_operations ispif_media_ops = { 1362 .link_setup = ispif_link_setup, 1363 .link_validate = v4l2_subdev_link_validate, 1364 }; 1365 1366 /* 1367 * msm_ispif_register_entities - Register subdev node for ISPIF module 1368 * @ispif: ISPIF device 1369 * @v4l2_dev: V4L2 device 1370 * 1371 * Return 0 on success or a negative error code otherwise 1372 */ 1373 int msm_ispif_register_entities(struct ispif_device *ispif, 1374 struct v4l2_device *v4l2_dev) 1375 { 1376 struct camss *camss; 1377 int ret; 1378 int i; 1379 1380 if (!ispif) 1381 return 0; 1382 1383 camss = ispif->camss; 1384 1385 for (i = 0; i < ispif->line_num; i++) { 1386 struct v4l2_subdev *sd = &ispif->line[i].subdev; 1387 struct media_pad *pads = ispif->line[i].pads; 1388 1389 v4l2_subdev_init(sd, &ispif_v4l2_ops); 1390 sd->internal_ops = &ispif_v4l2_internal_ops; 1391 sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1392 snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d", 1393 MSM_ISPIF_NAME, i); 1394 v4l2_set_subdevdata(sd, &ispif->line[i]); 1395 1396 ret = ispif_init_formats(sd, NULL); 1397 if (ret < 0) { 1398 dev_err(camss->dev, "Failed to init format: %d\n", ret); 1399 goto error; 1400 } 1401 1402 pads[MSM_ISPIF_PAD_SINK].flags = MEDIA_PAD_FL_SINK; 1403 pads[MSM_ISPIF_PAD_SRC].flags = MEDIA_PAD_FL_SOURCE; 1404 1405 sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER; 1406 sd->entity.ops = &ispif_media_ops; 1407 ret = media_entity_pads_init(&sd->entity, MSM_ISPIF_PADS_NUM, 1408 pads); 1409 if (ret < 0) { 1410 dev_err(camss->dev, "Failed to init media entity: %d\n", 1411 ret); 1412 goto error; 1413 } 1414 1415 ret = v4l2_device_register_subdev(v4l2_dev, sd); 1416 if (ret < 0) { 1417 dev_err(camss->dev, "Failed to register subdev: %d\n", 1418 ret); 1419 media_entity_cleanup(&sd->entity); 1420 goto error; 1421 } 1422 } 1423 1424 return 0; 1425 1426 error: 1427 for (i--; i >= 0; i--) { 1428 struct v4l2_subdev *sd = &ispif->line[i].subdev; 1429 1430 v4l2_device_unregister_subdev(sd); 1431 media_entity_cleanup(&sd->entity); 1432 } 1433 1434 return ret; 1435 } 1436 1437 /* 1438 * msm_ispif_unregister_entities - Unregister ISPIF module subdev node 1439 * @ispif: ISPIF device 1440 */ 1441 void msm_ispif_unregister_entities(struct ispif_device *ispif) 1442 { 1443 int i; 1444 1445 if (!ispif) 1446 return; 1447 1448 mutex_destroy(&ispif->power_lock); 1449 mutex_destroy(&ispif->config_lock); 1450 1451 for (i = 0; i < ispif->line_num; i++) { 1452 struct v4l2_subdev *sd = &ispif->line[i].subdev; 1453 1454 v4l2_device_unregister_subdev(sd); 1455 media_entity_cleanup(&sd->entity); 1456 } 1457 } 1458