1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2021 Renesas Electronics Corp. 4 * 5 * Driver for Renesas R-Car ISP Channel Selector 6 * 7 * The ISP hardware is capable of more than just channel selection, features 8 * such as demosaicing, white balance control and color space conversion are 9 * also possible. These more advanced features are not supported by the driver 10 * due to lack of documentation. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/mutex.h> 15 #include <linux/of_device.h> 16 #include <linux/platform_device.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/reset.h> 19 20 #include <media/mipi-csi2.h> 21 #include <media/v4l2-subdev.h> 22 23 #define ISPINPUTSEL0_REG 0x0008 24 #define ISPINPUTSEL0_SEL_CSI0 BIT(31) 25 26 #define ISPSTART_REG 0x0014 27 #define ISPSTART_START 0xffff 28 #define ISPSTART_STOP 0x0000 29 30 #define ISPPROCMODE_DT_REG(n) (0x1100 + (0x4 * (n))) 31 #define ISPPROCMODE_DT_PROC_MODE_VC3(pm) (((pm) & 0x3f) << 24) 32 #define ISPPROCMODE_DT_PROC_MODE_VC2(pm) (((pm) & 0x3f) << 16) 33 #define ISPPROCMODE_DT_PROC_MODE_VC1(pm) (((pm) & 0x3f) << 8) 34 #define ISPPROCMODE_DT_PROC_MODE_VC0(pm) ((pm) & 0x3f) 35 36 #define ISPCS_FILTER_ID_CH_REG(n) (0x3000 + (0x0100 * (n))) 37 38 #define ISPCS_DT_CODE03_CH_REG(n) (0x3008 + (0x100 * (n))) 39 #define ISPCS_DT_CODE03_EN3 BIT(31) 40 #define ISPCS_DT_CODE03_DT3(dt) (((dt) & 0x3f) << 24) 41 #define ISPCS_DT_CODE03_EN2 BIT(23) 42 #define ISPCS_DT_CODE03_DT2(dt) (((dt) & 0x3f) << 16) 43 #define ISPCS_DT_CODE03_EN1 BIT(15) 44 #define ISPCS_DT_CODE03_DT1(dt) (((dt) & 0x3f) << 8) 45 #define ISPCS_DT_CODE03_EN0 BIT(7) 46 #define ISPCS_DT_CODE03_DT0(dt) ((dt) & 0x3f) 47 48 struct rcar_isp_format { 49 u32 code; 50 unsigned int datatype; 51 unsigned int procmode; 52 }; 53 54 static const struct rcar_isp_format rcar_isp_formats[] = { 55 { 56 .code = MEDIA_BUS_FMT_RGB888_1X24, 57 .datatype = MIPI_CSI2_DT_RGB888, 58 .procmode = 0x15 59 }, { 60 .code = MEDIA_BUS_FMT_Y10_1X10, 61 .datatype = MIPI_CSI2_DT_RAW10, 62 .procmode = 0x10, 63 }, { 64 .code = MEDIA_BUS_FMT_UYVY8_1X16, 65 .datatype = MIPI_CSI2_DT_YUV422_8B, 66 .procmode = 0x0c, 67 }, { 68 .code = MEDIA_BUS_FMT_YUYV8_1X16, 69 .datatype = MIPI_CSI2_DT_YUV422_8B, 70 .procmode = 0x0c, 71 }, { 72 .code = MEDIA_BUS_FMT_UYVY8_2X8, 73 .datatype = MIPI_CSI2_DT_YUV422_8B, 74 .procmode = 0x0c, 75 }, { 76 .code = MEDIA_BUS_FMT_YUYV10_2X10, 77 .datatype = MIPI_CSI2_DT_YUV422_8B, 78 .procmode = 0x0c, 79 }, 80 }; 81 82 static const struct rcar_isp_format *risp_code_to_fmt(unsigned int code) 83 { 84 unsigned int i; 85 86 for (i = 0; i < ARRAY_SIZE(rcar_isp_formats); i++) { 87 if (rcar_isp_formats[i].code == code) 88 return &rcar_isp_formats[i]; 89 } 90 91 return NULL; 92 } 93 94 enum rcar_isp_input { 95 RISP_CSI_INPUT0, 96 RISP_CSI_INPUT1, 97 }; 98 99 enum rcar_isp_pads { 100 RCAR_ISP_SINK, 101 RCAR_ISP_PORT0, 102 RCAR_ISP_PORT1, 103 RCAR_ISP_PORT2, 104 RCAR_ISP_PORT3, 105 RCAR_ISP_PORT4, 106 RCAR_ISP_PORT5, 107 RCAR_ISP_PORT6, 108 RCAR_ISP_PORT7, 109 RCAR_ISP_NUM_PADS, 110 }; 111 112 struct rcar_isp { 113 struct device *dev; 114 void __iomem *base; 115 struct reset_control *rstc; 116 117 enum rcar_isp_input csi_input; 118 119 struct v4l2_subdev subdev; 120 struct media_pad pads[RCAR_ISP_NUM_PADS]; 121 122 struct v4l2_async_notifier notifier; 123 struct v4l2_subdev *remote; 124 125 struct mutex lock; /* Protects mf and stream_count. */ 126 struct v4l2_mbus_framefmt mf; 127 int stream_count; 128 }; 129 130 static inline struct rcar_isp *sd_to_isp(struct v4l2_subdev *sd) 131 { 132 return container_of(sd, struct rcar_isp, subdev); 133 } 134 135 static inline struct rcar_isp *notifier_to_isp(struct v4l2_async_notifier *n) 136 { 137 return container_of(n, struct rcar_isp, notifier); 138 } 139 140 static void risp_write(struct rcar_isp *isp, u32 offset, u32 value) 141 { 142 iowrite32(value, isp->base + offset); 143 } 144 145 static u32 risp_read(struct rcar_isp *isp, u32 offset) 146 { 147 return ioread32(isp->base + offset); 148 } 149 150 static int risp_power_on(struct rcar_isp *isp) 151 { 152 int ret; 153 154 ret = pm_runtime_resume_and_get(isp->dev); 155 if (ret < 0) 156 return ret; 157 158 ret = reset_control_deassert(isp->rstc); 159 if (ret < 0) { 160 pm_runtime_put(isp->dev); 161 return ret; 162 } 163 164 return 0; 165 } 166 167 static void risp_power_off(struct rcar_isp *isp) 168 { 169 reset_control_assert(isp->rstc); 170 pm_runtime_put(isp->dev); 171 } 172 173 static int risp_start(struct rcar_isp *isp) 174 { 175 const struct rcar_isp_format *format; 176 unsigned int vc; 177 u32 sel_csi = 0; 178 int ret; 179 180 format = risp_code_to_fmt(isp->mf.code); 181 if (!format) { 182 dev_err(isp->dev, "Unsupported bus format\n"); 183 return -EINVAL; 184 } 185 186 ret = risp_power_on(isp); 187 if (ret) { 188 dev_err(isp->dev, "Failed to power on ISP\n"); 189 return ret; 190 } 191 192 /* Select CSI-2 input source. */ 193 if (isp->csi_input == RISP_CSI_INPUT1) 194 sel_csi = ISPINPUTSEL0_SEL_CSI0; 195 196 risp_write(isp, ISPINPUTSEL0_REG, 197 risp_read(isp, ISPINPUTSEL0_REG) | sel_csi); 198 199 /* Configure Channel Selector. */ 200 for (vc = 0; vc < 4; vc++) { 201 u8 ch = vc + 4; 202 u8 dt = format->datatype; 203 204 risp_write(isp, ISPCS_FILTER_ID_CH_REG(ch), BIT(vc)); 205 risp_write(isp, ISPCS_DT_CODE03_CH_REG(ch), 206 ISPCS_DT_CODE03_EN3 | ISPCS_DT_CODE03_DT3(dt) | 207 ISPCS_DT_CODE03_EN2 | ISPCS_DT_CODE03_DT2(dt) | 208 ISPCS_DT_CODE03_EN1 | ISPCS_DT_CODE03_DT1(dt) | 209 ISPCS_DT_CODE03_EN0 | ISPCS_DT_CODE03_DT0(dt)); 210 } 211 212 /* Setup processing method. */ 213 risp_write(isp, ISPPROCMODE_DT_REG(format->datatype), 214 ISPPROCMODE_DT_PROC_MODE_VC3(format->procmode) | 215 ISPPROCMODE_DT_PROC_MODE_VC2(format->procmode) | 216 ISPPROCMODE_DT_PROC_MODE_VC1(format->procmode) | 217 ISPPROCMODE_DT_PROC_MODE_VC0(format->procmode)); 218 219 /* Start ISP. */ 220 risp_write(isp, ISPSTART_REG, ISPSTART_START); 221 222 ret = v4l2_subdev_call(isp->remote, video, s_stream, 1); 223 if (ret) 224 risp_power_off(isp); 225 226 return ret; 227 } 228 229 static void risp_stop(struct rcar_isp *isp) 230 { 231 v4l2_subdev_call(isp->remote, video, s_stream, 0); 232 233 /* Stop ISP. */ 234 risp_write(isp, ISPSTART_REG, ISPSTART_STOP); 235 236 risp_power_off(isp); 237 } 238 239 static int risp_s_stream(struct v4l2_subdev *sd, int enable) 240 { 241 struct rcar_isp *isp = sd_to_isp(sd); 242 int ret = 0; 243 244 mutex_lock(&isp->lock); 245 246 if (!isp->remote) { 247 ret = -ENODEV; 248 goto out; 249 } 250 251 if (enable && isp->stream_count == 0) { 252 ret = risp_start(isp); 253 if (ret) 254 goto out; 255 } else if (!enable && isp->stream_count == 1) { 256 risp_stop(isp); 257 } 258 259 isp->stream_count += enable ? 1 : -1; 260 out: 261 mutex_unlock(&isp->lock); 262 263 return ret; 264 } 265 266 static const struct v4l2_subdev_video_ops risp_video_ops = { 267 .s_stream = risp_s_stream, 268 }; 269 270 static int risp_set_pad_format(struct v4l2_subdev *sd, 271 struct v4l2_subdev_state *sd_state, 272 struct v4l2_subdev_format *format) 273 { 274 struct rcar_isp *isp = sd_to_isp(sd); 275 struct v4l2_mbus_framefmt *framefmt; 276 277 mutex_lock(&isp->lock); 278 279 if (!risp_code_to_fmt(format->format.code)) 280 format->format.code = rcar_isp_formats[0].code; 281 282 if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE) { 283 isp->mf = format->format; 284 } else { 285 framefmt = v4l2_subdev_get_try_format(sd, sd_state, 0); 286 *framefmt = format->format; 287 } 288 289 mutex_unlock(&isp->lock); 290 291 return 0; 292 } 293 294 static int risp_get_pad_format(struct v4l2_subdev *sd, 295 struct v4l2_subdev_state *sd_state, 296 struct v4l2_subdev_format *format) 297 { 298 struct rcar_isp *isp = sd_to_isp(sd); 299 300 mutex_lock(&isp->lock); 301 302 if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE) 303 format->format = isp->mf; 304 else 305 format->format = *v4l2_subdev_get_try_format(sd, sd_state, 0); 306 307 mutex_unlock(&isp->lock); 308 309 return 0; 310 } 311 312 static const struct v4l2_subdev_pad_ops risp_pad_ops = { 313 .set_fmt = risp_set_pad_format, 314 .get_fmt = risp_get_pad_format, 315 .link_validate = v4l2_subdev_link_validate_default, 316 }; 317 318 static const struct v4l2_subdev_ops rcar_isp_subdev_ops = { 319 .video = &risp_video_ops, 320 .pad = &risp_pad_ops, 321 }; 322 323 /* ----------------------------------------------------------------------------- 324 * Async handling and registration of subdevices and links 325 */ 326 327 static int risp_notify_bound(struct v4l2_async_notifier *notifier, 328 struct v4l2_subdev *subdev, 329 struct v4l2_async_subdev *asd) 330 { 331 struct rcar_isp *isp = notifier_to_isp(notifier); 332 int pad; 333 334 pad = media_entity_get_fwnode_pad(&subdev->entity, asd->match.fwnode, 335 MEDIA_PAD_FL_SOURCE); 336 if (pad < 0) { 337 dev_err(isp->dev, "Failed to find pad for %s\n", subdev->name); 338 return pad; 339 } 340 341 isp->remote = subdev; 342 343 dev_dbg(isp->dev, "Bound %s pad: %d\n", subdev->name, pad); 344 345 return media_create_pad_link(&subdev->entity, pad, 346 &isp->subdev.entity, 0, 347 MEDIA_LNK_FL_ENABLED | 348 MEDIA_LNK_FL_IMMUTABLE); 349 } 350 351 static void risp_notify_unbind(struct v4l2_async_notifier *notifier, 352 struct v4l2_subdev *subdev, 353 struct v4l2_async_subdev *asd) 354 { 355 struct rcar_isp *isp = notifier_to_isp(notifier); 356 357 isp->remote = NULL; 358 359 dev_dbg(isp->dev, "Unbind %s\n", subdev->name); 360 } 361 362 static const struct v4l2_async_notifier_operations risp_notify_ops = { 363 .bound = risp_notify_bound, 364 .unbind = risp_notify_unbind, 365 }; 366 367 static int risp_parse_dt(struct rcar_isp *isp) 368 { 369 struct v4l2_async_subdev *asd; 370 struct fwnode_handle *fwnode; 371 struct fwnode_handle *ep; 372 unsigned int id; 373 int ret; 374 375 for (id = 0; id < 2; id++) { 376 ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(isp->dev), 377 0, id, 0); 378 if (ep) 379 break; 380 } 381 382 if (!ep) { 383 dev_err(isp->dev, "Not connected to subdevice\n"); 384 return -EINVAL; 385 } 386 387 if (id == 1) 388 isp->csi_input = RISP_CSI_INPUT1; 389 390 fwnode = fwnode_graph_get_remote_endpoint(ep); 391 fwnode_handle_put(ep); 392 393 dev_dbg(isp->dev, "Found '%pOF'\n", to_of_node(fwnode)); 394 395 v4l2_async_nf_init(&isp->notifier); 396 isp->notifier.ops = &risp_notify_ops; 397 398 asd = v4l2_async_nf_add_fwnode(&isp->notifier, fwnode, 399 struct v4l2_async_subdev); 400 fwnode_handle_put(fwnode); 401 if (IS_ERR(asd)) 402 return PTR_ERR(asd); 403 404 ret = v4l2_async_subdev_nf_register(&isp->subdev, &isp->notifier); 405 if (ret) 406 v4l2_async_nf_cleanup(&isp->notifier); 407 408 return ret; 409 } 410 411 /* ----------------------------------------------------------------------------- 412 * Platform Device Driver 413 */ 414 415 static const struct media_entity_operations risp_entity_ops = { 416 .link_validate = v4l2_subdev_link_validate, 417 }; 418 419 static int risp_probe_resources(struct rcar_isp *isp, 420 struct platform_device *pdev) 421 { 422 struct resource *res; 423 424 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 425 isp->base = devm_ioremap_resource(&pdev->dev, res); 426 if (IS_ERR(isp->base)) 427 return PTR_ERR(isp->base); 428 429 isp->rstc = devm_reset_control_get(&pdev->dev, NULL); 430 431 return PTR_ERR_OR_ZERO(isp->rstc); 432 } 433 434 static const struct of_device_id risp_of_id_table[] = { 435 { .compatible = "renesas,r8a779a0-isp" }, 436 { /* sentinel */ }, 437 }; 438 MODULE_DEVICE_TABLE(of, risp_of_id_table); 439 440 static int risp_probe(struct platform_device *pdev) 441 { 442 struct rcar_isp *isp; 443 unsigned int i; 444 int ret; 445 446 isp = devm_kzalloc(&pdev->dev, sizeof(*isp), GFP_KERNEL); 447 if (!isp) 448 return -ENOMEM; 449 450 isp->dev = &pdev->dev; 451 452 mutex_init(&isp->lock); 453 454 ret = risp_probe_resources(isp, pdev); 455 if (ret) { 456 dev_err(isp->dev, "Failed to get resources\n"); 457 goto error_mutex; 458 } 459 460 platform_set_drvdata(pdev, isp); 461 462 pm_runtime_enable(&pdev->dev); 463 464 ret = risp_parse_dt(isp); 465 if (ret) 466 goto error_pm; 467 468 isp->subdev.owner = THIS_MODULE; 469 isp->subdev.dev = &pdev->dev; 470 v4l2_subdev_init(&isp->subdev, &rcar_isp_subdev_ops); 471 v4l2_set_subdevdata(&isp->subdev, &pdev->dev); 472 snprintf(isp->subdev.name, V4L2_SUBDEV_NAME_SIZE, "%s %s", 473 KBUILD_MODNAME, dev_name(&pdev->dev)); 474 isp->subdev.flags = V4L2_SUBDEV_FL_HAS_DEVNODE; 475 476 isp->subdev.entity.function = MEDIA_ENT_F_VID_MUX; 477 isp->subdev.entity.ops = &risp_entity_ops; 478 479 isp->pads[RCAR_ISP_SINK].flags = MEDIA_PAD_FL_SINK; 480 for (i = RCAR_ISP_PORT0; i < RCAR_ISP_NUM_PADS; i++) 481 isp->pads[i].flags = MEDIA_PAD_FL_SOURCE; 482 483 ret = media_entity_pads_init(&isp->subdev.entity, RCAR_ISP_NUM_PADS, 484 isp->pads); 485 if (ret) 486 goto error_notifier; 487 488 ret = v4l2_async_register_subdev(&isp->subdev); 489 if (ret < 0) 490 goto error_notifier; 491 492 dev_info(isp->dev, "Using CSI-2 input: %u\n", isp->csi_input); 493 494 return 0; 495 error_notifier: 496 v4l2_async_nf_unregister(&isp->notifier); 497 v4l2_async_nf_cleanup(&isp->notifier); 498 error_pm: 499 pm_runtime_disable(&pdev->dev); 500 error_mutex: 501 mutex_destroy(&isp->lock); 502 503 return ret; 504 } 505 506 static int risp_remove(struct platform_device *pdev) 507 { 508 struct rcar_isp *isp = platform_get_drvdata(pdev); 509 510 v4l2_async_nf_unregister(&isp->notifier); 511 v4l2_async_nf_cleanup(&isp->notifier); 512 513 v4l2_async_unregister_subdev(&isp->subdev); 514 515 pm_runtime_disable(&pdev->dev); 516 517 mutex_destroy(&isp->lock); 518 519 return 0; 520 } 521 522 static struct platform_driver rcar_isp_driver = { 523 .driver = { 524 .name = "rcar-isp", 525 .of_match_table = risp_of_id_table, 526 }, 527 .probe = risp_probe, 528 .remove = risp_remove, 529 }; 530 531 module_platform_driver(rcar_isp_driver); 532 533 MODULE_AUTHOR("Niklas Söderlund <niklas.soderlund@ragnatech.se>"); 534 MODULE_DESCRIPTION("Renesas R-Car ISP Channel Selector driver"); 535 MODULE_LICENSE("GPL"); 536