LXR linux/drivers/media/cec/cec-core.c

   1/*
   2 * cec-core.c - HDMI Consumer Electronics Control framework - Core
   3 *
   4 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   5 *
   6 * This program is free software; you may redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; version 2 of the License.
   9 *
  10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  17 * SOFTWARE.
  18 */
  19
  20#include <linux/errno.h>
  21#include <linux/init.h>
  22#include <linux/module.h>
  23#include <linux/kernel.h>
  24#include <linux/kmod.h>
  25#include <linux/slab.h>
  26#include <linux/mm.h>
  27#include <linux/string.h>
  28#include <linux/types.h>
  29
  30#include "cec-priv.h"
  31
  32#define CEC_NUM_DEVICES 256
  33#define CEC_NAME        "cec"
  34
  35int cec_debug;
  36module_param_named(debug, cec_debug, int, 0644);
  37MODULE_PARM_DESC(debug, "debug level (0-2)");
  38
  39static dev_t cec_dev_t;
  40
  41/* Active devices */
  42static DEFINE_MUTEX(cec_devnode_lock);
  43static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
  44
  45static struct dentry *top_cec_dir;
  46
  47/* dev to cec_devnode */
  48#define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
  49
  50int cec_get_device(struct cec_devnode *devnode)
  51{
  52        /*
  53         * Check if the cec device is available. This needs to be done with
  54         * the devnode->lock held to prevent an open/unregister race:
  55         * without the lock, the device could be unregistered and freed between
  56         * the devnode->registered check and get_device() calls, leading to
  57         * a crash.
  58         */
  59        mutex_lock(&devnode->lock);
  60        /*
  61         * return ENXIO if the cec device has been removed
  62         * already or if it is not registered anymore.
  63         */
  64        if (!devnode->registered) {
  65                mutex_unlock(&devnode->lock);
  66                return -ENXIO;
  67        }
  68        /* and increase the device refcount */
  69        get_device(&devnode->dev);
  70        mutex_unlock(&devnode->lock);
  71        return 0;
  72}
  73
  74void cec_put_device(struct cec_devnode *devnode)
  75{
  76        put_device(&devnode->dev);
  77}
  78
  79/* Called when the last user of the cec device exits. */
  80static void cec_devnode_release(struct device *cd)
  81{
  82        struct cec_devnode *devnode = to_cec_devnode(cd);
  83
  84        mutex_lock(&cec_devnode_lock);
  85        /* Mark device node number as free */
  86        clear_bit(devnode->minor, cec_devnode_nums);
  87        mutex_unlock(&cec_devnode_lock);
  88
  89        cec_delete_adapter(to_cec_adapter(devnode));
  90}
  91
  92static struct bus_type cec_bus_type = {
  93        .name = CEC_NAME,
  94};
  95
  96/*
  97 * Register a cec device node
  98 *
  99 * The registration code assigns minor numbers and registers the new device node
 100 * with the kernel. An error is returned if no free minor number can be found,
 101 * or if the registration of the device node fails.
 102 *
 103 * Zero is returned on success.
 104 *
 105 * Note that if the cec_devnode_register call fails, the release() callback of
 106 * the cec_devnode structure is *not* called, so the caller is responsible for
 107 * freeing any data.
 108 */
 109static int __must_check cec_devnode_register(struct cec_devnode *devnode,
 110                                             struct module *owner)
 111{
 112        int minor;
 113        int ret;
 114
 115        /* Initialization */
 116        INIT_LIST_HEAD(&devnode->fhs);
 117        mutex_init(&devnode->lock);
 118
 119        /* Part 1: Find a free minor number */
 120        mutex_lock(&cec_devnode_lock);
 121        minor = find_next_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES, 0);
 122        if (minor == CEC_NUM_DEVICES) {
 123                mutex_unlock(&cec_devnode_lock);
 124                pr_err("could not get a free minor\n");
 125                return -ENFILE;
 126        }
 127
 128        set_bit(minor, cec_devnode_nums);
 129        mutex_unlock(&cec_devnode_lock);
 130
 131        devnode->minor = minor;
 132        devnode->dev.bus = &cec_bus_type;
 133        devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
 134        devnode->dev.release = cec_devnode_release;
 135        dev_set_name(&devnode->dev, "cec%d", devnode->minor);
 136        device_initialize(&devnode->dev);
 137
 138        /* Part 2: Initialize and register the character device */
 139        cdev_init(&devnode->cdev, &cec_devnode_fops);
 140        devnode->cdev.owner = owner;
 141
 142        ret = cdev_device_add(&devnode->cdev, &devnode->dev);
 143        if (ret) {
 144                pr_err("%s: cdev_device_add failed\n", __func__);
 145                goto clr_bit;
 146        }
 147
 148        devnode->registered = true;
 149        return 0;
 150
 151clr_bit:
 152        mutex_lock(&cec_devnode_lock);
 153        clear_bit(devnode->minor, cec_devnode_nums);
 154        mutex_unlock(&cec_devnode_lock);
 155        return ret;
 156}
 157
 158/*
 159 * Unregister a cec device node
 160 *
 161 * This unregisters the passed device. Future open calls will be met with
 162 * errors.
 163 *
 164 * This function can safely be called if the device node has never been
 165 * registered or has already been unregistered.
 166 */
 167static void cec_devnode_unregister(struct cec_devnode *devnode)
 168{
 169        struct cec_fh *fh;
 170
 171        mutex_lock(&devnode->lock);
 172
 173        /* Check if devnode was never registered or already unregistered */
 174        if (!devnode->registered || devnode->unregistered) {
 175                mutex_unlock(&devnode->lock);
 176                return;
 177        }
 178
 179        list_for_each_entry(fh, &devnode->fhs, list)
 180                wake_up_interruptible(&fh->wait);
 181
 182        devnode->registered = false;
 183        devnode->unregistered = true;
 184        mutex_unlock(&devnode->lock);
 185
 186        cdev_device_del(&devnode->cdev, &devnode->dev);
 187        put_device(&devnode->dev);
 188}
 189
 190#ifdef CONFIG_CEC_NOTIFIER
 191static void cec_cec_notify(struct cec_adapter *adap, u16 pa)
 192{
 193        cec_s_phys_addr(adap, pa, false);
 194}
 195
 196void cec_register_cec_notifier(struct cec_adapter *adap,
 197                               struct cec_notifier *notifier)
 198{
 199        if (WARN_ON(!adap->devnode.registered))
 200                return;
 201
 202        adap->notifier = notifier;
 203        cec_notifier_register(adap->notifier, adap, cec_cec_notify);
 204}
 205EXPORT_SYMBOL_GPL(cec_register_cec_notifier);
 206#endif
 207
 208struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
 209                                         void *priv, const char *name, u32 caps,
 210                                         u8 available_las)
 211{
 212        struct cec_adapter *adap;
 213        int res;
 214
 215#ifndef CONFIG_MEDIA_CEC_RC
 216        caps &= ~CEC_CAP_RC;
 217#endif
 218
 219        if (WARN_ON(!caps))
 220                return ERR_PTR(-EINVAL);
 221        if (WARN_ON(!ops))
 222                return ERR_PTR(-EINVAL);
 223        if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
 224                return ERR_PTR(-EINVAL);
 225        adap = kzalloc(sizeof(*adap), GFP_KERNEL);
 226        if (!adap)
 227                return ERR_PTR(-ENOMEM);
 228        strlcpy(adap->name, name, sizeof(adap->name));
 229        adap->phys_addr = CEC_PHYS_ADDR_INVALID;
 230        adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
 231        adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
 232        adap->capabilities = caps;
 233        adap->available_log_addrs = available_las;
 234        adap->sequence = 0;
 235        adap->ops = ops;
 236        adap->priv = priv;
 237        memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs));
 238        mutex_init(&adap->lock);
 239        INIT_LIST_HEAD(&adap->transmit_queue);
 240        INIT_LIST_HEAD(&adap->wait_queue);
 241        init_waitqueue_head(&adap->kthread_waitq);
 242
 243        adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
 244        if (IS_ERR(adap->kthread)) {
 245                pr_err("cec-%s: kernel_thread() failed\n", name);
 246                res = PTR_ERR(adap->kthread);
 247                kfree(adap);
 248                return ERR_PTR(res);
 249        }
 250
 251#ifdef CONFIG_MEDIA_CEC_RC
 252        if (!(caps & CEC_CAP_RC))
 253                return adap;
 254
 255        /* Prepare the RC input device */
 256        adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
 257        if (!adap->rc) {
 258                pr_err("cec-%s: failed to allocate memory for rc_dev\n",
 259                       name);
 260                kthread_stop(adap->kthread);
 261                kfree(adap);
 262                return ERR_PTR(-ENOMEM);
 263        }
 264
 265        snprintf(adap->input_name, sizeof(adap->input_name),
 266                 "RC for %s", name);
 267        snprintf(adap->input_phys, sizeof(adap->input_phys),
 268                 "%s/input0", name);
 269
 270        adap->rc->input_name = adap->input_name;
 271        adap->rc->input_phys = adap->input_phys;
 272        adap->rc->input_id.bustype = BUS_CEC;
 273        adap->rc->input_id.vendor = 0;
 274        adap->rc->input_id.product = 0;
 275        adap->rc->input_id.version = 1;
 276        adap->rc->driver_name = CEC_NAME;
 277        adap->rc->allowed_protocols = RC_BIT_CEC;
 278        adap->rc->priv = adap;
 279        adap->rc->map_name = RC_MAP_CEC;
 280        adap->rc->timeout = MS_TO_NS(100);
 281#endif
 282        return adap;
 283}
 284EXPORT_SYMBOL_GPL(cec_allocate_adapter);
 285
 286int cec_register_adapter(struct cec_adapter *adap,
 287                         struct device *parent)
 288{
 289        int res;
 290
 291        if (IS_ERR_OR_NULL(adap))
 292                return 0;
 293
 294        if (WARN_ON(!parent))
 295                return -EINVAL;
 296
 297        adap->owner = parent->driver->owner;
 298        adap->devnode.dev.parent = parent;
 299
 300#ifdef CONFIG_MEDIA_CEC_RC
 301        if (adap->capabilities & CEC_CAP_RC) {
 302                adap->rc->dev.parent = parent;
 303                res = rc_register_device(adap->rc);
 304
 305                if (res) {
 306                        pr_err("cec-%s: failed to prepare input device\n",
 307                               adap->name);
 308                        rc_free_device(adap->rc);
 309                        adap->rc = NULL;
 310                        return res;
 311                }
 312        }
 313#endif
 314
 315        res = cec_devnode_register(&adap->devnode, adap->owner);
 316        if (res) {
 317#ifdef CONFIG_MEDIA_CEC_RC
 318                /* Note: rc_unregister also calls rc_free */
 319                rc_unregister_device(adap->rc);
 320                adap->rc = NULL;
 321#endif
 322                return res;
 323        }
 324
 325        dev_set_drvdata(&adap->devnode.dev, adap);
 326#ifdef CONFIG_DEBUG_FS
 327        if (!top_cec_dir)
 328                return 0;
 329
 330        adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir);
 331        if (IS_ERR_OR_NULL(adap->cec_dir)) {
 332                pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name);
 333                return 0;
 334        }
 335        adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev,
 336                "status", adap->cec_dir, cec_adap_status);
 337        if (IS_ERR_OR_NULL(adap->status_file)) {
 338                pr_warn("cec-%s: Failed to create status file\n", adap->name);
 339                debugfs_remove_recursive(adap->cec_dir);
 340                adap->cec_dir = NULL;
 341        }
 342#endif
 343        return 0;
 344}
 345EXPORT_SYMBOL_GPL(cec_register_adapter);
 346
 347void cec_unregister_adapter(struct cec_adapter *adap)
 348{
 349        if (IS_ERR_OR_NULL(adap))
 350                return;
 351
 352#ifdef CONFIG_MEDIA_CEC_RC
 353        /* Note: rc_unregister also calls rc_free */
 354        rc_unregister_device(adap->rc);
 355        adap->rc = NULL;
 356#endif
 357        debugfs_remove_recursive(adap->cec_dir);
 358#ifdef CONFIG_CEC_NOTIFIER
 359        if (adap->notifier)
 360                cec_notifier_unregister(adap->notifier);
 361#endif
 362        cec_devnode_unregister(&adap->devnode);
 363}
 364EXPORT_SYMBOL_GPL(cec_unregister_adapter);
 365
 366void cec_delete_adapter(struct cec_adapter *adap)
 367{
 368        if (IS_ERR_OR_NULL(adap))
 369                return;
 370        mutex_lock(&adap->lock);
 371        __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
 372        mutex_unlock(&adap->lock);
 373        kthread_stop(adap->kthread);
 374        if (adap->kthread_config)
 375                kthread_stop(adap->kthread_config);
 376#ifdef CONFIG_MEDIA_CEC_RC
 377        rc_free_device(adap->rc);
 378#endif
 379        kfree(adap);
 380}
 381EXPORT_SYMBOL_GPL(cec_delete_adapter);
 382
 383/*
 384 *      Initialise cec for linux
 385 */
 386static int __init cec_devnode_init(void)
 387{
 388        int ret;
 389
 390        pr_info("Linux cec interface: v0.10\n");
 391        ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES,
 392                                  CEC_NAME);
 393        if (ret < 0) {
 394                pr_warn("cec: unable to allocate major\n");
 395                return ret;
 396        }
 397
 398#ifdef CONFIG_DEBUG_FS
 399        top_cec_dir = debugfs_create_dir("cec", NULL);
 400        if (IS_ERR_OR_NULL(top_cec_dir)) {
 401                pr_warn("cec: Failed to create debugfs cec dir\n");
 402                top_cec_dir = NULL;
 403        }
 404#endif
 405
 406        ret = bus_register(&cec_bus_type);
 407        if (ret < 0) {
 408                unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 409                pr_warn("cec: bus_register failed\n");
 410                return -EIO;
 411        }
 412
 413        return 0;
 414}
 415
 416static void __exit cec_devnode_exit(void)
 417{
 418        debugfs_remove_recursive(top_cec_dir);
 419        bus_unregister(&cec_bus_type);
 420        unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 421}
 422
 423subsys_initcall(cec_devnode_init);
 424module_exit(cec_devnode_exit)
 425
 426MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
 427MODULE_DESCRIPTION("Device node registration for cec drivers");
 428MODULE_LICENSE("GPL");
 429