1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * vimc-core.c Virtual Media Controller Driver 4 * 5 * Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com> 6 */ 7 8 #include <linux/dma-mapping.h> 9 #include <linux/font.h> 10 #include <linux/init.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <media/media-device.h> 14 #include <media/tpg/v4l2-tpg.h> 15 #include <media/v4l2-device.h> 16 17 #include "vimc-common.h" 18 19 unsigned int vimc_allocator; 20 module_param_named(allocator, vimc_allocator, uint, 0444); 21 MODULE_PARM_DESC(allocator, " memory allocator selection, default is 0.\n" 22 "\t\t 0 == vmalloc\n" 23 "\t\t 1 == dma-contig"); 24 25 #define VIMC_MDEV_MODEL_NAME "VIMC MDEV" 26 27 #define VIMC_DATA_LINK(src, srcpad, sink, sinkpad, link_flags) { \ 28 .src_ent = src, \ 29 .src_pad = srcpad, \ 30 .sink_ent = sink, \ 31 .sink_pad = sinkpad, \ 32 .flags = link_flags, \ 33 } 34 35 #define VIMC_ANCILLARY_LINK(primary, ancillary) { \ 36 .primary_ent = primary, \ 37 .ancillary_ent = ancillary \ 38 } 39 40 /* Structure which describes data links between entities */ 41 struct vimc_data_link { 42 unsigned int src_ent; 43 u16 src_pad; 44 unsigned int sink_ent; 45 u16 sink_pad; 46 u32 flags; 47 }; 48 49 /* Enum to improve clarity when defining vimc_data_links */ 50 enum vimc_data_link_ents { 51 SENSOR_A, 52 SENSOR_B, 53 DEBAYER_A, 54 DEBAYER_B, 55 RAW_CAPTURE_0, 56 RAW_CAPTURE_1, 57 RGB_YUV_INPUT, 58 SCALER, 59 RGB_YUV_CAPTURE, 60 LENS_A, 61 LENS_B, 62 }; 63 64 /* Structure which describes ancillary links between entities */ 65 struct vimc_ancillary_link { 66 unsigned int primary_ent; 67 unsigned int ancillary_ent; 68 }; 69 70 /* Structure which describes the whole topology */ 71 struct vimc_pipeline_config { 72 const struct vimc_ent_config *ents; 73 size_t num_ents; 74 const struct vimc_data_link *data_links; 75 size_t num_data_links; 76 const struct vimc_ancillary_link *ancillary_links; 77 size_t num_ancillary_links; 78 }; 79 80 /* -------------------------------------------------------------------------- 81 * Topology Configuration 82 */ 83 84 static const struct vimc_ent_config ent_config[] = { 85 [SENSOR_A] = { 86 .name = "Sensor A", 87 .type = &vimc_sensor_type 88 }, 89 [SENSOR_B] = { 90 .name = "Sensor B", 91 .type = &vimc_sensor_type 92 }, 93 [DEBAYER_A] = { 94 .name = "Debayer A", 95 .type = &vimc_debayer_type 96 }, 97 [DEBAYER_B] = { 98 .name = "Debayer B", 99 .type = &vimc_debayer_type 100 }, 101 [RAW_CAPTURE_0] = { 102 .name = "Raw Capture 0", 103 .type = &vimc_capture_type 104 }, 105 [RAW_CAPTURE_1] = { 106 .name = "Raw Capture 1", 107 .type = &vimc_capture_type 108 }, 109 [RGB_YUV_INPUT] = { 110 /* TODO: change this to vimc-input when it is implemented */ 111 .name = "RGB/YUV Input", 112 .type = &vimc_sensor_type 113 }, 114 [SCALER] = { 115 .name = "Scaler", 116 .type = &vimc_scaler_type 117 }, 118 [RGB_YUV_CAPTURE] = { 119 .name = "RGB/YUV Capture", 120 .type = &vimc_capture_type 121 }, 122 [LENS_A] = { 123 .name = "Lens A", 124 .type = &vimc_lens_type 125 }, 126 [LENS_B] = { 127 .name = "Lens B", 128 .type = &vimc_lens_type 129 }, 130 }; 131 132 static const struct vimc_data_link data_links[] = { 133 /* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */ 134 VIMC_DATA_LINK(SENSOR_A, 0, DEBAYER_A, 0, 135 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 136 /* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */ 137 VIMC_DATA_LINK(SENSOR_A, 0, RAW_CAPTURE_0, 0, 138 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 139 /* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */ 140 VIMC_DATA_LINK(SENSOR_B, 0, DEBAYER_B, 0, 141 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 142 /* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */ 143 VIMC_DATA_LINK(SENSOR_B, 0, RAW_CAPTURE_1, 0, 144 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 145 /* Link: Debayer A (Pad 1)->(Pad 0) Scaler */ 146 VIMC_DATA_LINK(DEBAYER_A, 1, SCALER, 0, MEDIA_LNK_FL_ENABLED), 147 /* Link: Debayer B (Pad 1)->(Pad 0) Scaler */ 148 VIMC_DATA_LINK(DEBAYER_B, 1, SCALER, 0, 0), 149 /* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */ 150 VIMC_DATA_LINK(RGB_YUV_INPUT, 0, SCALER, 0, 0), 151 /* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */ 152 VIMC_DATA_LINK(SCALER, 1, RGB_YUV_CAPTURE, 0, 153 MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 154 }; 155 156 static const struct vimc_ancillary_link ancillary_links[] = { 157 /* Link: Sensor A -> Lens A */ 158 VIMC_ANCILLARY_LINK(0, 9), 159 /* Link: Sensor B -> Lens B */ 160 VIMC_ANCILLARY_LINK(1, 10), 161 }; 162 163 static struct vimc_pipeline_config pipe_cfg = { 164 .ents = ent_config, 165 .num_ents = ARRAY_SIZE(ent_config), 166 .data_links = data_links, 167 .num_data_links = ARRAY_SIZE(data_links), 168 .ancillary_links = ancillary_links, 169 .num_ancillary_links = ARRAY_SIZE(ancillary_links), 170 }; 171 172 /* -------------------------------------------------------------------------- */ 173 174 static void vimc_rm_links(struct vimc_device *vimc) 175 { 176 unsigned int i; 177 178 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) 179 media_entity_remove_links(vimc->ent_devs[i]->ent); 180 } 181 182 static int vimc_create_links(struct vimc_device *vimc) 183 { 184 unsigned int i; 185 int ret; 186 187 /* Initialize the links between entities */ 188 for (i = 0; i < vimc->pipe_cfg->num_data_links; i++) { 189 const struct vimc_data_link *link = &vimc->pipe_cfg->data_links[i]; 190 191 struct vimc_ent_device *ved_src = 192 vimc->ent_devs[link->src_ent]; 193 struct vimc_ent_device *ved_sink = 194 vimc->ent_devs[link->sink_ent]; 195 196 ret = media_create_pad_link(ved_src->ent, link->src_pad, 197 ved_sink->ent, link->sink_pad, 198 link->flags); 199 if (ret) 200 goto err_rm_links; 201 } 202 203 for (i = 0; i < vimc->pipe_cfg->num_ancillary_links; i++) { 204 const struct vimc_ancillary_link *link = &vimc->pipe_cfg->ancillary_links[i]; 205 206 struct vimc_ent_device *ved_primary = 207 vimc->ent_devs[link->primary_ent]; 208 struct vimc_ent_device *ved_ancillary = 209 vimc->ent_devs[link->ancillary_ent]; 210 struct media_link *ret_link = 211 media_create_ancillary_link(ved_primary->ent, ved_ancillary->ent); 212 213 if (IS_ERR(ret_link)) { 214 ret = PTR_ERR(ret_link); 215 goto err_rm_links; 216 } 217 } 218 219 return 0; 220 221 err_rm_links: 222 vimc_rm_links(vimc); 223 return ret; 224 } 225 226 static void vimc_release_subdevs(struct vimc_device *vimc) 227 { 228 unsigned int i; 229 230 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) 231 if (vimc->ent_devs[i]) 232 vimc->pipe_cfg->ents[i].type->release(vimc->ent_devs[i]); 233 } 234 235 static void vimc_unregister_subdevs(struct vimc_device *vimc) 236 { 237 unsigned int i; 238 239 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) 240 if (vimc->ent_devs[i] && vimc->pipe_cfg->ents[i].type->unregister) 241 vimc->pipe_cfg->ents[i].type->unregister(vimc->ent_devs[i]); 242 } 243 244 static int vimc_add_subdevs(struct vimc_device *vimc) 245 { 246 unsigned int i; 247 248 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) { 249 dev_dbg(vimc->mdev.dev, "new entity for %s\n", 250 vimc->pipe_cfg->ents[i].name); 251 vimc->ent_devs[i] = vimc->pipe_cfg->ents[i].type->add(vimc, 252 vimc->pipe_cfg->ents[i].name); 253 if (IS_ERR(vimc->ent_devs[i])) { 254 int err = PTR_ERR(vimc->ent_devs[i]); 255 256 dev_err(vimc->mdev.dev, "adding entity %s failed (%d)\n", 257 vimc->pipe_cfg->ents[i].name, err); 258 vimc->ent_devs[i] = NULL; 259 vimc_unregister_subdevs(vimc); 260 vimc_release_subdevs(vimc); 261 return err; 262 } 263 } 264 return 0; 265 } 266 267 static void vimc_v4l2_dev_release(struct v4l2_device *v4l2_dev) 268 { 269 struct vimc_device *vimc = 270 container_of(v4l2_dev, struct vimc_device, v4l2_dev); 271 272 vimc_release_subdevs(vimc); 273 media_device_cleanup(&vimc->mdev); 274 kfree(vimc->ent_devs); 275 kfree(vimc); 276 } 277 278 static int vimc_register_devices(struct vimc_device *vimc) 279 { 280 int ret; 281 282 /* Register the v4l2 struct */ 283 ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev); 284 if (ret) { 285 dev_err(vimc->mdev.dev, 286 "v4l2 device register failed (err=%d)\n", ret); 287 return ret; 288 } 289 /* allocate ent_devs */ 290 vimc->ent_devs = kcalloc(vimc->pipe_cfg->num_ents, 291 sizeof(*vimc->ent_devs), GFP_KERNEL); 292 if (!vimc->ent_devs) { 293 ret = -ENOMEM; 294 goto err_v4l2_unregister; 295 } 296 297 /* Invoke entity config hooks to initialize and register subdevs */ 298 ret = vimc_add_subdevs(vimc); 299 if (ret) 300 goto err_free_ent_devs; 301 302 /* Initialize links */ 303 ret = vimc_create_links(vimc); 304 if (ret) 305 goto err_rm_subdevs; 306 307 /* Register the media device */ 308 ret = media_device_register(&vimc->mdev); 309 if (ret) { 310 dev_err(vimc->mdev.dev, 311 "media device register failed (err=%d)\n", ret); 312 goto err_rm_subdevs; 313 } 314 315 /* Expose all subdev's nodes*/ 316 ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev); 317 if (ret) { 318 dev_err(vimc->mdev.dev, 319 "vimc subdev nodes registration failed (err=%d)\n", 320 ret); 321 goto err_mdev_unregister; 322 } 323 324 return 0; 325 326 err_mdev_unregister: 327 media_device_unregister(&vimc->mdev); 328 err_rm_subdevs: 329 vimc_unregister_subdevs(vimc); 330 vimc_release_subdevs(vimc); 331 err_free_ent_devs: 332 kfree(vimc->ent_devs); 333 err_v4l2_unregister: 334 v4l2_device_unregister(&vimc->v4l2_dev); 335 336 return ret; 337 } 338 339 static int vimc_probe(struct platform_device *pdev) 340 { 341 const struct font_desc *font = find_font("VGA8x16"); 342 struct vimc_device *vimc; 343 int ret; 344 345 dev_dbg(&pdev->dev, "probe"); 346 347 if (!font) { 348 dev_err(&pdev->dev, "could not find font\n"); 349 return -ENODEV; 350 } 351 352 tpg_set_font(font->data); 353 354 if (vimc_allocator == VIMC_ALLOCATOR_DMA_CONTIG) 355 dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 356 357 vimc = kzalloc(sizeof(*vimc), GFP_KERNEL); 358 if (!vimc) 359 return -ENOMEM; 360 361 vimc->pipe_cfg = &pipe_cfg; 362 363 /* Link the media device within the v4l2_device */ 364 vimc->v4l2_dev.mdev = &vimc->mdev; 365 366 /* Initialize media device */ 367 strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME, 368 sizeof(vimc->mdev.model)); 369 snprintf(vimc->mdev.bus_info, sizeof(vimc->mdev.bus_info), 370 "platform:%s", VIMC_PDEV_NAME); 371 vimc->mdev.dev = &pdev->dev; 372 media_device_init(&vimc->mdev); 373 374 ret = vimc_register_devices(vimc); 375 if (ret) { 376 media_device_cleanup(&vimc->mdev); 377 kfree(vimc); 378 return ret; 379 } 380 /* 381 * the release cb is set only after successful registration. 382 * if the registration fails, we release directly from probe 383 */ 384 385 vimc->v4l2_dev.release = vimc_v4l2_dev_release; 386 platform_set_drvdata(pdev, vimc); 387 return 0; 388 } 389 390 static void vimc_remove(struct platform_device *pdev) 391 { 392 struct vimc_device *vimc = platform_get_drvdata(pdev); 393 394 dev_dbg(&pdev->dev, "remove"); 395 396 vimc_unregister_subdevs(vimc); 397 media_device_unregister(&vimc->mdev); 398 v4l2_device_unregister(&vimc->v4l2_dev); 399 v4l2_device_put(&vimc->v4l2_dev); 400 } 401 402 static void vimc_dev_release(struct device *dev) 403 { 404 } 405 406 static struct platform_device vimc_pdev = { 407 .name = VIMC_PDEV_NAME, 408 .dev.release = vimc_dev_release, 409 }; 410 411 static struct platform_driver vimc_pdrv = { 412 .probe = vimc_probe, 413 .remove_new = vimc_remove, 414 .driver = { 415 .name = VIMC_PDEV_NAME, 416 }, 417 }; 418 419 static int __init vimc_init(void) 420 { 421 int ret; 422 423 ret = platform_device_register(&vimc_pdev); 424 if (ret) { 425 dev_err(&vimc_pdev.dev, 426 "platform device registration failed (err=%d)\n", ret); 427 return ret; 428 } 429 430 ret = platform_driver_register(&vimc_pdrv); 431 if (ret) { 432 dev_err(&vimc_pdev.dev, 433 "platform driver registration failed (err=%d)\n", ret); 434 platform_device_unregister(&vimc_pdev); 435 return ret; 436 } 437 438 return 0; 439 } 440 441 static void __exit vimc_exit(void) 442 { 443 platform_driver_unregister(&vimc_pdrv); 444 445 platform_device_unregister(&vimc_pdev); 446 } 447 448 module_init(vimc_init); 449 module_exit(vimc_exit); 450 451 MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)"); 452 MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>"); 453 MODULE_LICENSE("GPL"); 454