drivers/media/platform/vimc/vimc-core.c

   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                 .add = vimc_sen_add,
  51                 .rm = vimc_sen_rm,
  52         },
  53         {
  54                 .name = "Sensor B",
  55                 .add = vimc_sen_add,
  56                 .rm = vimc_sen_rm,
  57         },
  58         {
  59                 .name = "Debayer A",
  60                 .add = vimc_deb_add,
  61                 .rm = vimc_deb_rm,
  62         },
  63         {
  64                 .name = "Debayer B",
  65                 .add = vimc_deb_add,
  66                 .rm = vimc_deb_rm,
  67         },
  68         {
  69                 .name = "Raw Capture 0",
  70                 .add = vimc_cap_add,
  71                 .rm = vimc_cap_rm,
  72         },
  73         {
  74                 .name = "Raw Capture 1",
  75                 .add = vimc_cap_add,
  76                 .rm = vimc_cap_rm,
  77         },
  78         {
  79                 /* TODO: change this to vimc-input when it is implemented */
  80                 .name = "RGB/YUV Input",
  81                 .add = vimc_sen_add,
  82                 .rm = vimc_sen_rm,
  83         },
  84         {
  85                 .name = "Scaler",
  86                 .add = vimc_sca_add,
  87                 .rm = vimc_sca_rm,
  88         },
  89         {
  90                 .name = "RGB/YUV Capture",
  91                 .add = vimc_cap_add,
  92                 .rm = vimc_cap_rm,
  93         },
  94 };
  95
  96 static const struct vimc_ent_link ent_links[] = {
  97         /* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */
  98         VIMC_ENT_LINK(0, 0, 2, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
  99         /* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */
 100         VIMC_ENT_LINK(0, 0, 4, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
 101         /* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */
 102         VIMC_ENT_LINK(1, 0, 3, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
 103         /* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */
 104         VIMC_ENT_LINK(1, 0, 5, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
 105         /* Link: Debayer A (Pad 1)->(Pad 0) Scaler */
 106         VIMC_ENT_LINK(2, 1, 7, 0, MEDIA_LNK_FL_ENABLED),
 107         /* Link: Debayer B (Pad 1)->(Pad 0) Scaler */
 108         VIMC_ENT_LINK(3, 1, 7, 0, 0),
 109         /* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */
 110         VIMC_ENT_LINK(6, 0, 7, 0, 0),
 111         /* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */
 112         VIMC_ENT_LINK(7, 1, 8, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
 113 };
 114
 115 static struct vimc_pipeline_config pipe_cfg = {
 116         .ents           = ent_config,
 117         .num_ents       = ARRAY_SIZE(ent_config),
 118         .links          = ent_links,
 119         .num_links      = ARRAY_SIZE(ent_links)
 120 };
 121
 122 /* -------------------------------------------------------------------------- */
 123
 124 static void vimc_rm_links(struct vimc_device *vimc)
 125 {
 126         unsigned int i;
 127
 128         for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
 129                 media_entity_remove_links(vimc->ent_devs[i]->ent);
 130 }
 131
 132 static int vimc_create_links(struct vimc_device *vimc)
 133 {
 134         unsigned int i;
 135         int ret;
 136
 137         /* Initialize the links between entities */
 138         for (i = 0; i < vimc->pipe_cfg->num_links; i++) {
 139                 const struct vimc_ent_link *link = &vimc->pipe_cfg->links[i];
 140
 141                 struct vimc_ent_device *ved_src =
 142                         vimc->ent_devs[link->src_ent];
 143                 struct vimc_ent_device *ved_sink =
 144                         vimc->ent_devs[link->sink_ent];
 145
 146                 ret = media_create_pad_link(ved_src->ent, link->src_pad,
 147                                             ved_sink->ent, link->sink_pad,
 148                                             link->flags);
 149                 if (ret)
 150                         goto err_rm_links;
 151         }
 152
 153         return 0;
 154
 155 err_rm_links:
 156         vimc_rm_links(vimc);
 157         return ret;
 158 }
 159
 160 static int vimc_add_subdevs(struct vimc_device *vimc)
 161 {
 162         unsigned int i;
 163         struct vimc_ent_device *ved;
 164
 165         for (i = 0; i < vimc->pipe_cfg->num_ents; i++) {
 166                 dev_dbg(&vimc->pdev.dev, "new entity for %s\n",
 167                         vimc->pipe_cfg->ents[i].name);
 168                 ved = vimc->pipe_cfg->ents[i].add(vimc,
 169                                         vimc->pipe_cfg->ents[i].name);
 170                 if (!ved) {
 171                         dev_err(&vimc->pdev.dev, "add new entity for %s\n",
 172                                 vimc->pipe_cfg->ents[i].name);
 173                         return -EINVAL;
 174                 }
 175                 vimc->ent_devs[i] = ved;
 176         }
 177         return 0;
 178 }
 179
 180 static void vimc_rm_subdevs(struct vimc_device *vimc)
 181 {
 182         unsigned int i;
 183
 184         for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
 185                 if (vimc->ent_devs[i])
 186                         vimc->pipe_cfg->ents[i].rm(vimc, vimc->ent_devs[i]);
 187 }
 188
 189 static int vimc_register_devices(struct vimc_device *vimc)
 190 {
 191         int ret;
 192
 193         /* Register the v4l2 struct */
 194         ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev);
 195         if (ret) {
 196                 dev_err(vimc->mdev.dev,
 197                         "v4l2 device register failed (err=%d)\n", ret);
 198                 return ret;
 199         }
 200
 201         /* allocate ent_devs */
 202         vimc->ent_devs = kmalloc_array(vimc->pipe_cfg->num_ents,
 203                                        sizeof(*vimc->ent_devs),
 204                                        GFP_KERNEL);
 205         if (!vimc->ent_devs)
 206                 goto err_v4l2_unregister;
 207
 208         /* Invoke entity config hooks to initialize and register subdevs */
 209         ret = vimc_add_subdevs(vimc);
 210         if (ret)
 211                 /* remove sundevs that got added */
 212                 goto err_rm_subdevs;
 213
 214         /* Initialize links */
 215         ret = vimc_create_links(vimc);
 216         if (ret)
 217                 goto err_rm_subdevs;
 218
 219         /* Register the media device */
 220         ret = media_device_register(&vimc->mdev);
 221         if (ret) {
 222                 dev_err(vimc->mdev.dev,
 223                         "media device register failed (err=%d)\n", ret);
 224                 goto err_rm_subdevs;
 225         }
 226
 227         /* Expose all subdev's nodes*/
 228         ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev);
 229         if (ret) {
 230                 dev_err(vimc->mdev.dev,
 231                         "vimc subdev nodes registration failed (err=%d)\n",
 232                         ret);
 233                 goto err_mdev_unregister;
 234         }
 235
 236         return 0;
 237
 238 err_mdev_unregister:
 239         media_device_unregister(&vimc->mdev);
 240         media_device_cleanup(&vimc->mdev);
 241 err_rm_subdevs:
 242         vimc_rm_subdevs(vimc);
 243         kfree(vimc->ent_devs);
 244 err_v4l2_unregister:
 245         v4l2_device_unregister(&vimc->v4l2_dev);
 246
 247         return ret;
 248 }
 249
 250 static void vimc_unregister(struct vimc_device *vimc)
 251 {
 252         media_device_unregister(&vimc->mdev);
 253         media_device_cleanup(&vimc->mdev);
 254         v4l2_device_unregister(&vimc->v4l2_dev);
 255         kfree(vimc->ent_devs);
 256 }
 257
 258 static int vimc_probe(struct platform_device *pdev)
 259 {
 260         struct vimc_device *vimc = container_of(pdev, struct vimc_device, pdev);
 261         int ret;
 262
 263         dev_dbg(&pdev->dev, "probe");
 264
 265         memset(&vimc->mdev, 0, sizeof(vimc->mdev));
 266
 267         /* Link the media device within the v4l2_device */
 268         vimc->v4l2_dev.mdev = &vimc->mdev;
 269
 270         /* Initialize media device */
 271         strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME,
 272                 sizeof(vimc->mdev.model));
 273         snprintf(vimc->mdev.bus_info, sizeof(vimc->mdev.bus_info),
 274                  "platform:%s", VIMC_PDEV_NAME);
 275         vimc->mdev.dev = &pdev->dev;
 276         media_device_init(&vimc->mdev);
 277
 278         ret = vimc_register_devices(vimc);
 279         if (ret) {
 280                 media_device_cleanup(&vimc->mdev);
 281                 return ret;
 282         }
 283
 284         return 0;
 285 }
 286
 287 static int vimc_remove(struct platform_device *pdev)
 288 {
 289         struct vimc_device *vimc = container_of(pdev, struct vimc_device, pdev);
 290
 291         dev_dbg(&pdev->dev, "remove");
 292
 293         vimc_rm_subdevs(vimc);
 294         vimc_unregister(vimc);
 295
 296         return 0;
 297 }
 298
 299 static void vimc_dev_release(struct device *dev)
 300 {
 301 }
 302
 303 static struct vimc_device vimc_dev = {
 304         .pipe_cfg = &pipe_cfg,
 305         .pdev = {
 306                 .name = VIMC_PDEV_NAME,
 307                 .dev.release = vimc_dev_release,
 308         }
 309 };
 310
 311 static struct platform_driver vimc_pdrv = {
 312         .probe          = vimc_probe,
 313         .remove         = vimc_remove,
 314         .driver         = {
 315                 .name   = VIMC_PDEV_NAME,
 316         },
 317 };
 318
 319 static int __init vimc_init(void)
 320 {
 321         int ret;
 322
 323         ret = platform_device_register(&vimc_dev.pdev);
 324         if (ret) {
 325                 dev_err(&vimc_dev.pdev.dev,
 326                         "platform device registration failed (err=%d)\n", ret);
 327                 return ret;
 328         }
 329
 330         ret = platform_driver_register(&vimc_pdrv);
 331         if (ret) {
 332                 dev_err(&vimc_dev.pdev.dev,
 333                         "platform driver registration failed (err=%d)\n", ret);
 334                 platform_driver_unregister(&vimc_pdrv);
 335                 return ret;
 336         }
 337
 338         return 0;
 339 }
 340
 341 static void __exit vimc_exit(void)
 342 {
 343         platform_driver_unregister(&vimc_pdrv);
 344
 345         platform_device_unregister(&vimc_dev.pdev);
 346 }
 347
 348 module_init(vimc_init);
 349 module_exit(vimc_exit);
 350
 351 MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)");
 352 MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>");
 353 MODULE_LICENSE("GPL");