| /* |
| * vimc-core.c Virtual Media Controller Driver |
| * |
| * Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| */ |
| |
| #include <linux/init.h> |
| #include <linux/module.h> |
| #include <linux/platform_device.h> |
| #include <media/media-device.h> |
| #include <media/v4l2-device.h> |
| |
| #include "vimc-capture.h" |
| #include "vimc-core.h" |
| #include "vimc-sensor.h" |
| |
| #define VIMC_PDEV_NAME "vimc" |
| #define VIMC_MDEV_MODEL_NAME "VIMC MDEV" |
| |
| #define VIMC_ENT_LINK(src, srcpad, sink, sinkpad, link_flags) { \ |
| .src_ent = src, \ |
| .src_pad = srcpad, \ |
| .sink_ent = sink, \ |
| .sink_pad = sinkpad, \ |
| .flags = link_flags, \ |
| } |
| |
| struct vimc_device { |
| /* |
| * The pipeline configuration |
| * (filled before calling vimc_device_register) |
| */ |
| const struct vimc_pipeline_config *pipe_cfg; |
| |
| /* The Associated media_device parent */ |
| struct media_device mdev; |
| |
| /* Internal v4l2 parent device*/ |
| struct v4l2_device v4l2_dev; |
| |
| /* Internal topology */ |
| struct vimc_ent_device **ved; |
| }; |
| |
| /** |
| * enum vimc_ent_node - Select the functionality of a node in the topology |
| * @VIMC_ENT_NODE_SENSOR: A node of type SENSOR simulates a camera sensor |
| * generating internal images in bayer format and |
| * propagating those images through the pipeline |
| * @VIMC_ENT_NODE_CAPTURE: A node of type CAPTURE is a v4l2 video_device |
| * that exposes the received image from the |
| * pipeline to the user space |
| * @VIMC_ENT_NODE_INPUT: A node of type INPUT is a v4l2 video_device that |
| * receives images from the user space and |
| * propagates them through the pipeline |
| * @VIMC_ENT_NODE_DEBAYER: A node type DEBAYER expects to receive a frame |
| * in bayer format converts it to RGB |
| * @VIMC_ENT_NODE_SCALER: A node of type SCALER scales the received image |
| * by a given multiplier |
| * |
| * This enum is used in the entity configuration struct to allow the definition |
| * of a custom topology specifying the role of each node on it. |
| */ |
| enum vimc_ent_node { |
| VIMC_ENT_NODE_SENSOR, |
| VIMC_ENT_NODE_CAPTURE, |
| VIMC_ENT_NODE_INPUT, |
| VIMC_ENT_NODE_DEBAYER, |
| VIMC_ENT_NODE_SCALER, |
| }; |
| |
| /* Structure which describes individual configuration for each entity */ |
| struct vimc_ent_config { |
| const char *name; |
| size_t pads_qty; |
| const unsigned long *pads_flag; |
| enum vimc_ent_node node; |
| }; |
| |
| /* Structure which describes links between entities */ |
| struct vimc_ent_link { |
| unsigned int src_ent; |
| u16 src_pad; |
| unsigned int sink_ent; |
| u16 sink_pad; |
| u32 flags; |
| }; |
| |
| /* Structure which describes the whole topology */ |
| struct vimc_pipeline_config { |
| const struct vimc_ent_config *ents; |
| size_t num_ents; |
| const struct vimc_ent_link *links; |
| size_t num_links; |
| }; |
| |
| /* -------------------------------------------------------------------------- |
| * Topology Configuration |
| */ |
| |
| static const struct vimc_ent_config ent_config[] = { |
| { |
| .name = "Sensor A", |
| .pads_qty = 1, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SOURCE}, |
| .node = VIMC_ENT_NODE_SENSOR, |
| }, |
| { |
| .name = "Sensor B", |
| .pads_qty = 1, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SOURCE}, |
| .node = VIMC_ENT_NODE_SENSOR, |
| }, |
| { |
| .name = "Debayer A", |
| .pads_qty = 2, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SINK, |
| MEDIA_PAD_FL_SOURCE}, |
| .node = VIMC_ENT_NODE_DEBAYER, |
| }, |
| { |
| .name = "Debayer B", |
| .pads_qty = 2, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SINK, |
| MEDIA_PAD_FL_SOURCE}, |
| .node = VIMC_ENT_NODE_DEBAYER, |
| }, |
| { |
| .name = "Raw Capture 0", |
| .pads_qty = 1, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SINK}, |
| .node = VIMC_ENT_NODE_CAPTURE, |
| }, |
| { |
| .name = "Raw Capture 1", |
| .pads_qty = 1, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SINK}, |
| .node = VIMC_ENT_NODE_CAPTURE, |
| }, |
| { |
| .name = "RGB/YUV Input", |
| .pads_qty = 1, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SOURCE}, |
| .node = VIMC_ENT_NODE_INPUT, |
| }, |
| { |
| .name = "Scaler", |
| .pads_qty = 2, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SINK, |
| MEDIA_PAD_FL_SOURCE}, |
| .node = VIMC_ENT_NODE_SCALER, |
| }, |
| { |
| .name = "RGB/YUV Capture", |
| .pads_qty = 1, |
| .pads_flag = (const unsigned long[]){MEDIA_PAD_FL_SINK}, |
| .node = VIMC_ENT_NODE_CAPTURE, |
| }, |
| }; |
| |
| static const struct vimc_ent_link ent_links[] = { |
| /* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */ |
| VIMC_ENT_LINK(0, 0, 2, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), |
| /* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */ |
| VIMC_ENT_LINK(0, 0, 4, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), |
| /* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */ |
| VIMC_ENT_LINK(1, 0, 3, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), |
| /* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */ |
| VIMC_ENT_LINK(1, 0, 5, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), |
| /* Link: Debayer A (Pad 1)->(Pad 0) Scaler */ |
| VIMC_ENT_LINK(2, 1, 7, 0, MEDIA_LNK_FL_ENABLED), |
| /* Link: Debayer B (Pad 1)->(Pad 0) Scaler */ |
| VIMC_ENT_LINK(3, 1, 7, 0, 0), |
| /* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */ |
| VIMC_ENT_LINK(6, 0, 7, 0, 0), |
| /* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */ |
| VIMC_ENT_LINK(7, 1, 8, 0, MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE), |
| }; |
| |
| static const struct vimc_pipeline_config pipe_cfg = { |
| .ents = ent_config, |
| .num_ents = ARRAY_SIZE(ent_config), |
| .links = ent_links, |
| .num_links = ARRAY_SIZE(ent_links) |
| }; |
| |
| /* -------------------------------------------------------------------------- */ |
| |
| static const struct vimc_pix_map vimc_pix_map_list[] = { |
| /* TODO: add all missing formats */ |
| |
| /* RGB formats */ |
| { |
| .code = MEDIA_BUS_FMT_BGR888_1X24, |
| .pixelformat = V4L2_PIX_FMT_BGR24, |
| .bpp = 3, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_RGB888_1X24, |
| .pixelformat = V4L2_PIX_FMT_RGB24, |
| .bpp = 3, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_ARGB8888_1X32, |
| .pixelformat = V4L2_PIX_FMT_ARGB32, |
| .bpp = 4, |
| }, |
| |
| /* Bayer formats */ |
| { |
| .code = MEDIA_BUS_FMT_SBGGR8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SBGGR8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGBRG8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SGBRG8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGRBG8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SGRBG8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SRGGB8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SRGGB8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SBGGR10_1X10, |
| .pixelformat = V4L2_PIX_FMT_SBGGR10, |
| .bpp = 2, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGBRG10_1X10, |
| .pixelformat = V4L2_PIX_FMT_SGBRG10, |
| .bpp = 2, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGRBG10_1X10, |
| .pixelformat = V4L2_PIX_FMT_SGRBG10, |
| .bpp = 2, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SRGGB10_1X10, |
| .pixelformat = V4L2_PIX_FMT_SRGGB10, |
| .bpp = 2, |
| }, |
| |
| /* 10bit raw bayer a-law compressed to 8 bits */ |
| { |
| .code = MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SBGGR10ALAW8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SGBRG10ALAW8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SGRBG10ALAW8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SRGGB10ALAW8, |
| .bpp = 1, |
| }, |
| |
| /* 10bit raw bayer DPCM compressed to 8 bits */ |
| { |
| .code = MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SBGGR10DPCM8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SGBRG10DPCM8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SGRBG10DPCM8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8, |
| .pixelformat = V4L2_PIX_FMT_SRGGB10DPCM8, |
| .bpp = 1, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SBGGR12_1X12, |
| .pixelformat = V4L2_PIX_FMT_SBGGR12, |
| .bpp = 2, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGBRG12_1X12, |
| .pixelformat = V4L2_PIX_FMT_SGBRG12, |
| .bpp = 2, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SGRBG12_1X12, |
| .pixelformat = V4L2_PIX_FMT_SGRBG12, |
| .bpp = 2, |
| }, |
| { |
| .code = MEDIA_BUS_FMT_SRGGB12_1X12, |
| .pixelformat = V4L2_PIX_FMT_SRGGB12, |
| .bpp = 2, |
| }, |
| }; |
| |
| const struct vimc_pix_map *vimc_pix_map_by_code(u32 code) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < ARRAY_SIZE(vimc_pix_map_list); i++) { |
| if (vimc_pix_map_list[i].code == code) |
| return &vimc_pix_map_list[i]; |
| } |
| return NULL; |
| } |
| |
| const struct vimc_pix_map *vimc_pix_map_by_pixelformat(u32 pixelformat) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < ARRAY_SIZE(vimc_pix_map_list); i++) { |
| if (vimc_pix_map_list[i].pixelformat == pixelformat) |
| return &vimc_pix_map_list[i]; |
| } |
| return NULL; |
| } |
| |
| int vimc_propagate_frame(struct media_pad *src, const void *frame) |
| { |
| struct media_link *link; |
| |
| if (!(src->flags & MEDIA_PAD_FL_SOURCE)) |
| return -EINVAL; |
| |
| /* Send this frame to all sink pads that are direct linked */ |
| list_for_each_entry(link, &src->entity->links, list) { |
| if (link->source == src && |
| (link->flags & MEDIA_LNK_FL_ENABLED)) { |
| struct vimc_ent_device *ved = NULL; |
| struct media_entity *entity = link->sink->entity; |
| |
| if (is_media_entity_v4l2_subdev(entity)) { |
| struct v4l2_subdev *sd = |
| container_of(entity, struct v4l2_subdev, |
| entity); |
| ved = v4l2_get_subdevdata(sd); |
| } else if (is_media_entity_v4l2_video_device(entity)) { |
| struct video_device *vdev = |
| container_of(entity, |
| struct video_device, |
| entity); |
| ved = video_get_drvdata(vdev); |
| } |
| if (ved && ved->process_frame) |
| ved->process_frame(ved, link->sink, frame); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void vimc_device_unregister(struct vimc_device *vimc) |
| { |
| unsigned int i; |
| |
| media_device_unregister(&vimc->mdev); |
| /* Cleanup (only initialized) entities */ |
| for (i = 0; i < vimc->pipe_cfg->num_ents; i++) { |
| if (vimc->ved[i] && vimc->ved[i]->destroy) |
| vimc->ved[i]->destroy(vimc->ved[i]); |
| |
| vimc->ved[i] = NULL; |
| } |
| v4l2_device_unregister(&vimc->v4l2_dev); |
| media_device_cleanup(&vimc->mdev); |
| } |
| |
| /* Helper function to allocate and initialize pads */ |
| struct media_pad *vimc_pads_init(u16 num_pads, const unsigned long *pads_flag) |
| { |
| struct media_pad *pads; |
| unsigned int i; |
| |
| /* Allocate memory for the pads */ |
| pads = kcalloc(num_pads, sizeof(*pads), GFP_KERNEL); |
| if (!pads) |
| return ERR_PTR(-ENOMEM); |
| |
| /* Initialize the pads */ |
| for (i = 0; i < num_pads; i++) { |
| pads[i].index = i; |
| pads[i].flags = pads_flag[i]; |
| } |
| |
| return pads; |
| } |
| |
| /* |
| * TODO: remove this function when all the |
| * entities specific code are implemented |
| */ |
| static void vimc_raw_destroy(struct vimc_ent_device *ved) |
| { |
| media_device_unregister_entity(ved->ent); |
| |
| media_entity_cleanup(ved->ent); |
| |
| vimc_pads_cleanup(ved->pads); |
| |
| kfree(ved->ent); |
| |
| kfree(ved); |
| } |
| |
| /* |
| * TODO: remove this function when all the |
| * entities specific code are implemented |
| */ |
| static struct vimc_ent_device *vimc_raw_create(struct v4l2_device *v4l2_dev, |
| const char *const name, |
| u16 num_pads, |
| const unsigned long *pads_flag) |
| { |
| struct vimc_ent_device *ved; |
| int ret; |
| |
| /* Allocate the main ved struct */ |
| ved = kzalloc(sizeof(*ved), GFP_KERNEL); |
| if (!ved) |
| return ERR_PTR(-ENOMEM); |
| |
| /* Allocate the media entity */ |
| ved->ent = kzalloc(sizeof(*ved->ent), GFP_KERNEL); |
| if (!ved->ent) { |
| ret = -ENOMEM; |
| goto err_free_ved; |
| } |
| |
| /* Allocate the pads */ |
| ved->pads = vimc_pads_init(num_pads, pads_flag); |
| if (IS_ERR(ved->pads)) { |
| ret = PTR_ERR(ved->pads); |
| goto err_free_ent; |
| } |
| |
| /* Initialize the media entity */ |
| ved->ent->name = name; |
| ved->ent->function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN; |
| ret = media_entity_pads_init(ved->ent, num_pads, ved->pads); |
| if (ret) |
| goto err_cleanup_pads; |
| |
| /* Register the media entity */ |
| ret = media_device_register_entity(v4l2_dev->mdev, ved->ent); |
| if (ret) |
| goto err_cleanup_entity; |
| |
| /* Fill out the destroy function and return */ |
| ved->destroy = vimc_raw_destroy; |
| return ved; |
| |
| err_cleanup_entity: |
| media_entity_cleanup(ved->ent); |
| err_cleanup_pads: |
| vimc_pads_cleanup(ved->pads); |
| err_free_ent: |
| kfree(ved->ent); |
| err_free_ved: |
| kfree(ved); |
| |
| return ERR_PTR(ret); |
| } |
| |
| static int vimc_device_register(struct vimc_device *vimc) |
| { |
| unsigned int i; |
| int ret; |
| |
| /* Allocate memory for the vimc_ent_devices pointers */ |
| vimc->ved = devm_kcalloc(vimc->mdev.dev, vimc->pipe_cfg->num_ents, |
| sizeof(*vimc->ved), GFP_KERNEL); |
| if (!vimc->ved) |
| return -ENOMEM; |
| |
| /* Link the media device within the v4l2_device */ |
| vimc->v4l2_dev.mdev = &vimc->mdev; |
| |
| /* Register the v4l2 struct */ |
| ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev); |
| if (ret) { |
| dev_err(vimc->mdev.dev, |
| "v4l2 device register failed (err=%d)\n", ret); |
| return ret; |
| } |
| |
| /* Initialize entities */ |
| for (i = 0; i < vimc->pipe_cfg->num_ents; i++) { |
| struct vimc_ent_device *(*create_func)(struct v4l2_device *, |
| const char *const, |
| u16, |
| const unsigned long *); |
| |
| /* Register the specific node */ |
| switch (vimc->pipe_cfg->ents[i].node) { |
| case VIMC_ENT_NODE_SENSOR: |
| create_func = vimc_sen_create; |
| break; |
| |
| case VIMC_ENT_NODE_CAPTURE: |
| create_func = vimc_cap_create; |
| break; |
| |
| /* TODO: Instantiate the specific topology node */ |
| case VIMC_ENT_NODE_INPUT: |
| case VIMC_ENT_NODE_DEBAYER: |
| case VIMC_ENT_NODE_SCALER: |
| default: |
| /* |
| * TODO: remove this when all the entities specific |
| * code are implemented |
| */ |
| create_func = vimc_raw_create; |
| break; |
| } |
| |
| vimc->ved[i] = create_func(&vimc->v4l2_dev, |
| vimc->pipe_cfg->ents[i].name, |
| vimc->pipe_cfg->ents[i].pads_qty, |
| vimc->pipe_cfg->ents[i].pads_flag); |
| if (IS_ERR(vimc->ved[i])) { |
| ret = PTR_ERR(vimc->ved[i]); |
| vimc->ved[i] = NULL; |
| goto err; |
| } |
| } |
| |
| /* Initialize the links between entities */ |
| for (i = 0; i < vimc->pipe_cfg->num_links; i++) { |
| const struct vimc_ent_link *link = &vimc->pipe_cfg->links[i]; |
| |
| ret = media_create_pad_link(vimc->ved[link->src_ent]->ent, |
| link->src_pad, |
| vimc->ved[link->sink_ent]->ent, |
| link->sink_pad, |
| link->flags); |
| if (ret) |
| goto err; |
| } |
| |
| /* Register the media device */ |
| ret = media_device_register(&vimc->mdev); |
| if (ret) { |
| dev_err(vimc->mdev.dev, |
| "media device register failed (err=%d)\n", ret); |
| return ret; |
| } |
| |
| /* Expose all subdev's nodes*/ |
| ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev); |
| if (ret) { |
| dev_err(vimc->mdev.dev, |
| "vimc subdev nodes registration failed (err=%d)\n", |
| ret); |
| goto err; |
| } |
| |
| return 0; |
| |
| err: |
| /* Destroy the so far created topology */ |
| vimc_device_unregister(vimc); |
| |
| return ret; |
| } |
| |
| static int vimc_probe(struct platform_device *pdev) |
| { |
| struct vimc_device *vimc; |
| int ret; |
| |
| /* Prepare the vimc topology structure */ |
| |
| /* Allocate memory for the vimc structure */ |
| vimc = kzalloc(sizeof(*vimc), GFP_KERNEL); |
| if (!vimc) |
| return -ENOMEM; |
| |
| /* Set the pipeline configuration struct */ |
| vimc->pipe_cfg = &pipe_cfg; |
| |
| /* Initialize media device */ |
| strlcpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME, |
| sizeof(vimc->mdev.model)); |
| vimc->mdev.dev = &pdev->dev; |
| media_device_init(&vimc->mdev); |
| |
| /* Create vimc topology */ |
| ret = vimc_device_register(vimc); |
| if (ret) { |
| dev_err(vimc->mdev.dev, |
| "vimc device registration failed (err=%d)\n", ret); |
| kfree(vimc); |
| return ret; |
| } |
| |
| /* Link the topology object with the platform device object */ |
| platform_set_drvdata(pdev, vimc); |
| |
| return 0; |
| } |
| |
| static int vimc_remove(struct platform_device *pdev) |
| { |
| struct vimc_device *vimc = platform_get_drvdata(pdev); |
| |
| /* Destroy all the topology */ |
| vimc_device_unregister(vimc); |
| kfree(vimc); |
| |
| return 0; |
| } |
| |
| static void vimc_dev_release(struct device *dev) |
| { |
| } |
| |
| static struct platform_device vimc_pdev = { |
| .name = VIMC_PDEV_NAME, |
| .dev.release = vimc_dev_release, |
| }; |
| |
| static struct platform_driver vimc_pdrv = { |
| .probe = vimc_probe, |
| .remove = vimc_remove, |
| .driver = { |
| .name = VIMC_PDEV_NAME, |
| }, |
| }; |
| |
| static int __init vimc_init(void) |
| { |
| int ret; |
| |
| ret = platform_device_register(&vimc_pdev); |
| if (ret) { |
| dev_err(&vimc_pdev.dev, |
| "platform device registration failed (err=%d)\n", ret); |
| return ret; |
| } |
| |
| ret = platform_driver_register(&vimc_pdrv); |
| if (ret) { |
| dev_err(&vimc_pdev.dev, |
| "platform driver registration failed (err=%d)\n", ret); |
| |
| platform_device_unregister(&vimc_pdev); |
| } |
| |
| return ret; |
| } |
| |
| static void __exit vimc_exit(void) |
| { |
| platform_driver_unregister(&vimc_pdrv); |
| |
| platform_device_unregister(&vimc_pdev); |
| } |
| |
| module_init(vimc_init); |
| module_exit(vimc_exit); |
| |
| MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)"); |
| MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>"); |
| MODULE_LICENSE("GPL"); |