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/init.h> 9 #include <linux/module.h> 10 #include <linux/platform_device.h> 11 #include <media/media-device.h> 12 #include <media/v4l2-device.h> 13 14 #include "vimc-common.h" 15 16 #define VIMC_MDEV_MODEL_NAME "VIMC MDEV" 17 18 #define VIMC_ENT_LINK(src, srcpad, sink, sinkpad, link_flags) { \ 19 .src_ent = src, \ 20 .src_pad = srcpad, \ 21 .sink_ent = sink, \ 22 .sink_pad = sinkpad, \ 23 .flags = link_flags, \ 24 } 25 26 /* Structure which describes links between entities */ 27 struct vimc_ent_link { 28 unsigned int src_ent; 29 u16 src_pad; 30 unsigned int sink_ent; 31 u16 sink_pad; 32 u32 flags; 33 }; 34 35 /* Structure which describes the whole topology */ 36 struct vimc_pipeline_config { 37 const struct vimc_ent_config *ents; 38 size_t num_ents; 39 const struct vimc_ent_link *links; 40 size_t num_links; 41 }; 42 43 /* -------------------------------------------------------------------------- 44 * Topology Configuration 45 */ 46 47 static struct vimc_ent_config ent_config[] = { 48 { 49 .name = "Sensor A", 50 .type = &vimc_sen_type 51 }, 52 { 53 .name = "Sensor B", 54 .type = &vimc_sen_type 55 }, 56 { 57 .name = "Debayer A", 58 .type = &vimc_deb_type 59 }, 60 { 61 .name = "Debayer B", 62 .type = &vimc_deb_type 63 }, 64 { 65 .name = "Raw Capture 0", 66 .type = &vimc_cap_type 67 }, 68 { 69 .name = "Raw Capture 1", 70 .type = &vimc_cap_type 71 }, 72 { 73 /* TODO: change this to vimc-input when it is implemented */ 74 .name = "RGB/YUV Input", 75 .type = &vimc_sen_type 76 }, 77 { 78 .name = "Scaler", 79 .type = &vimc_sca_type 80 }, 81 { 82 .name = "RGB/YUV Capture", 83 .type = &vimc_cap_type 84 }, 85 }; 86 87 static const struct vimc_ent_link ent_links[] = { 88 /* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */ 89 VIMC_ENT_LINK(0, 0, 2, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 90 /* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */ 91 VIMC_ENT_LINK(0, 0, 4, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 92 /* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */ 93 VIMC_ENT_LINK(1, 0, 3, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 94 /* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */ 95 VIMC_ENT_LINK(1, 0, 5, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 96 /* Link: Debayer A (Pad 1)->(Pad 0) Scaler */ 97 VIMC_ENT_LINK(2, 1, 7, 0, MEDIA_LNK_FL_ENABLED), 98 /* Link: Debayer B (Pad 1)->(Pad 0) Scaler */ 99 VIMC_ENT_LINK(3, 1, 7, 0, 0), 100 /* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */ 101 VIMC_ENT_LINK(6, 0, 7, 0, 0), 102 /* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */ 103 VIMC_ENT_LINK(7, 1, 8, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), 104 }; 105 106 static struct vimc_pipeline_config pipe_cfg = { 107 .ents = ent_config, 108 .num_ents = ARRAY_SIZE(ent_config), 109 .links = ent_links, 110 .num_links = ARRAY_SIZE(ent_links) 111 }; 112 113 /* -------------------------------------------------------------------------- */ 114 115 static void vimc_rm_links(struct vimc_device *vimc) 116 { 117 unsigned int i; 118 119 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) 120 media_entity_remove_links(vimc->ent_devs[i]->ent); 121 } 122 123 static int vimc_create_links(struct vimc_device *vimc) 124 { 125 unsigned int i; 126 int ret; 127 128 /* Initialize the links between entities */ 129 for (i = 0; i < vimc->pipe_cfg->num_links; i++) { 130 const struct vimc_ent_link *link = &vimc->pipe_cfg->links[i]; 131 132 struct vimc_ent_device *ved_src = 133 vimc->ent_devs[link->src_ent]; 134 struct vimc_ent_device *ved_sink = 135 vimc->ent_devs[link->sink_ent]; 136 137 ret = media_create_pad_link(ved_src->ent, link->src_pad, 138 ved_sink->ent, link->sink_pad, 139 link->flags); 140 if (ret) 141 goto err_rm_links; 142 } 143 144 return 0; 145 146 err_rm_links: 147 vimc_rm_links(vimc); 148 return ret; 149 } 150 151 static void vimc_release_subdevs(struct vimc_device *vimc) 152 { 153 unsigned int i; 154 155 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) 156 if (vimc->ent_devs[i]) 157 vimc->pipe_cfg->ents[i].type->release(vimc->ent_devs[i]); 158 } 159 160 static void vimc_unregister_subdevs(struct vimc_device *vimc) 161 { 162 unsigned int i; 163 164 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) 165 if (vimc->ent_devs[i] && vimc->pipe_cfg->ents[i].type->unregister) 166 vimc->pipe_cfg->ents[i].type->unregister(vimc->ent_devs[i]); 167 } 168 169 static int vimc_add_subdevs(struct vimc_device *vimc) 170 { 171 unsigned int i; 172 173 for (i = 0; i < vimc->pipe_cfg->num_ents; i++) { 174 dev_dbg(vimc->mdev.dev, "new entity for %s\n", 175 vimc->pipe_cfg->ents[i].name); 176 vimc->ent_devs[i] = vimc->pipe_cfg->ents[i].type->add(vimc, 177 vimc->pipe_cfg->ents[i].name); 178 if (IS_ERR(vimc->ent_devs[i])) { 179 int err = PTR_ERR(vimc->ent_devs[i]); 180 181 dev_err(vimc->mdev.dev, "adding entity %s failed (%d)\n", 182 vimc->pipe_cfg->ents[i].name, err); 183 vimc->ent_devs[i] = NULL; 184 vimc_unregister_subdevs(vimc); 185 vimc_release_subdevs(vimc); 186 return err; 187 } 188 } 189 return 0; 190 } 191 192 static void vimc_v4l2_dev_release(struct v4l2_device *v4l2_dev) 193 { 194 struct vimc_device *vimc = 195 container_of(v4l2_dev, struct vimc_device, v4l2_dev); 196 197 vimc_release_subdevs(vimc); 198 media_device_cleanup(&vimc->mdev); 199 kfree(vimc->ent_devs); 200 kfree(vimc); 201 } 202 203 static int vimc_register_devices(struct vimc_device *vimc) 204 { 205 int ret; 206 207 /* Register the v4l2 struct */ 208 ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev); 209 if (ret) { 210 dev_err(vimc->mdev.dev, 211 "v4l2 device register failed (err=%d)\n", ret); 212 return ret; 213 } 214 /* allocate ent_devs */ 215 vimc->ent_devs = kcalloc(vimc->pipe_cfg->num_ents, 216 sizeof(*vimc->ent_devs), GFP_KERNEL); 217 if (!vimc->ent_devs) { 218 ret = -ENOMEM; 219 goto err_v4l2_unregister; 220 } 221 222 /* Invoke entity config hooks to initialize and register subdevs */ 223 ret = vimc_add_subdevs(vimc); 224 if (ret) 225 goto err_free_ent_devs; 226 227 /* Initialize links */ 228 ret = vimc_create_links(vimc); 229 if (ret) 230 goto err_rm_subdevs; 231 232 /* Register the media device */ 233 ret = media_device_register(&vimc->mdev); 234 if (ret) { 235 dev_err(vimc->mdev.dev, 236 "media device register failed (err=%d)\n", ret); 237 goto err_rm_subdevs; 238 } 239 240 /* Expose all subdev's nodes*/ 241 ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev); 242 if (ret) { 243 dev_err(vimc->mdev.dev, 244 "vimc subdev nodes registration failed (err=%d)\n", 245 ret); 246 goto err_mdev_unregister; 247 } 248 249 return 0; 250 251 err_mdev_unregister: 252 media_device_unregister(&vimc->mdev); 253 err_rm_subdevs: 254 vimc_unregister_subdevs(vimc); 255 vimc_release_subdevs(vimc); 256 err_free_ent_devs: 257 kfree(vimc->ent_devs); 258 err_v4l2_unregister: 259 v4l2_device_unregister(&vimc->v4l2_dev); 260 261 return ret; 262 } 263 264 static int vimc_probe(struct platform_device *pdev) 265 { 266 struct vimc_device *vimc; 267 int ret; 268 269 dev_dbg(&pdev->dev, "probe"); 270 271 vimc = kzalloc(sizeof(*vimc), GFP_KERNEL); 272 if (!vimc) 273 return -ENOMEM; 274 275 vimc->pipe_cfg = &pipe_cfg; 276 277 /* Link the media device within the v4l2_device */ 278 vimc->v4l2_dev.mdev = &vimc->mdev; 279 280 /* Initialize media device */ 281 strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME, 282 sizeof(vimc->mdev.model)); 283 snprintf(vimc->mdev.bus_info, sizeof(vimc->mdev.bus_info), 284 "platform:%s", VIMC_PDEV_NAME); 285 vimc->mdev.dev = &pdev->dev; 286 media_device_init(&vimc->mdev); 287 288 ret = vimc_register_devices(vimc); 289 if (ret) { 290 media_device_cleanup(&vimc->mdev); 291 kfree(vimc); 292 return ret; 293 } 294 /* 295 * the release cb is set only after successful registration. 296 * if the registration fails, we release directly from probe 297 */ 298 299 vimc->v4l2_dev.release = vimc_v4l2_dev_release; 300 platform_set_drvdata(pdev, vimc); 301 return 0; 302 } 303 304 static int vimc_remove(struct platform_device *pdev) 305 { 306 struct vimc_device *vimc = platform_get_drvdata(pdev); 307 308 dev_dbg(&pdev->dev, "remove"); 309 310 vimc_unregister_subdevs(vimc); 311 media_device_unregister(&vimc->mdev); 312 v4l2_device_unregister(&vimc->v4l2_dev); 313 v4l2_device_put(&vimc->v4l2_dev); 314 315 return 0; 316 } 317 318 static void vimc_dev_release(struct device *dev) 319 { 320 } 321 322 static struct platform_device vimc_pdev = { 323 .name = VIMC_PDEV_NAME, 324 .dev.release = vimc_dev_release, 325 }; 326 327 static struct platform_driver vimc_pdrv = { 328 .probe = vimc_probe, 329 .remove = vimc_remove, 330 .driver = { 331 .name = VIMC_PDEV_NAME, 332 }, 333 }; 334 335 static int __init vimc_init(void) 336 { 337 int ret; 338 339 ret = platform_device_register(&vimc_pdev); 340 if (ret) { 341 dev_err(&vimc_pdev.dev, 342 "platform device registration failed (err=%d)\n", ret); 343 return ret; 344 } 345 346 ret = platform_driver_register(&vimc_pdrv); 347 if (ret) { 348 dev_err(&vimc_pdev.dev, 349 "platform driver registration failed (err=%d)\n", ret); 350 platform_driver_unregister(&vimc_pdrv); 351 return ret; 352 } 353 354 return 0; 355 } 356 357 static void __exit vimc_exit(void) 358 { 359 platform_driver_unregister(&vimc_pdrv); 360 361 platform_device_unregister(&vimc_pdev); 362 } 363 364 module_init(vimc_init); 365 module_exit(vimc_exit); 366 367 MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)"); 368 MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>"); 369 MODULE_LICENSE("GPL"); 370