drivers/staging/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
  35 int cec_debug;
  36 module_param_named(debug, cec_debug, int, 0644);
  37 MODULE_PARM_DESC(debug, "debug level (0-2)");
  38
  39 static dev_t cec_dev_t;
  40
  41 /* Active devices */
  42 static DEFINE_MUTEX(cec_devnode_lock);
  43 static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
  44
  45 static 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
  50 int 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 cec_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(&cec_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(&cec_devnode_lock);
  66                 return -ENXIO;
  67         }
  68         /* and increase the device refcount */
  69         get_device(&devnode->dev);
  70         mutex_unlock(&cec_devnode_lock);
  71         return 0;
  72 }
  73
  74 void cec_put_device(struct cec_devnode *devnode)
  75 {
  76         mutex_lock(&cec_devnode_lock);
  77         put_device(&devnode->dev);
  78         mutex_unlock(&cec_devnode_lock);
  79 }
  80
  81 /* Called when the last user of the cec device exits. */
  82 static void cec_devnode_release(struct device *cd)
  83 {
  84         struct cec_devnode *devnode = to_cec_devnode(cd);
  85
  86         mutex_lock(&cec_devnode_lock);
  87
  88         /* Mark device node number as free */
  89         clear_bit(devnode->minor, cec_devnode_nums);
  90
  91         mutex_unlock(&cec_devnode_lock);
  92         cec_delete_adapter(to_cec_adapter(devnode));
  93 }
  94
  95 static struct bus_type cec_bus_type = {
  96         .name = CEC_NAME,
  97 };
  98
  99 /*
 100  * Register a cec device node
 101  *
 102  * The registration code assigns minor numbers and registers the new device node
 103  * with the kernel. An error is returned if no free minor number can be found,
 104  * or if the registration of the device node fails.
 105  *
 106  * Zero is returned on success.
 107  *
 108  * Note that if the cec_devnode_register call fails, the release() callback of
 109  * the cec_devnode structure is *not* called, so the caller is responsible for
 110  * freeing any data.
 111  */
 112 static int __must_check cec_devnode_register(struct cec_devnode *devnode,
 113                                              struct module *owner)
 114 {
 115         int minor;
 116         int ret;
 117
 118         /* Initialization */
 119         INIT_LIST_HEAD(&devnode->fhs);
 120         mutex_init(&devnode->fhs_lock);
 121
 122         /* Part 1: Find a free minor number */
 123         mutex_lock(&cec_devnode_lock);
 124         minor = find_next_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES, 0);
 125         if (minor == CEC_NUM_DEVICES) {
 126                 mutex_unlock(&cec_devnode_lock);
 127                 pr_err("could not get a free minor\n");
 128                 return -ENFILE;
 129         }
 130
 131         set_bit(minor, cec_devnode_nums);
 132         mutex_unlock(&cec_devnode_lock);
 133
 134         devnode->minor = minor;
 135         devnode->dev.bus = &cec_bus_type;
 136         devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
 137         devnode->dev.release = cec_devnode_release;
 138         devnode->dev.parent = devnode->parent;
 139         dev_set_name(&devnode->dev, "cec%d", devnode->minor);
 140         device_initialize(&devnode->dev);
 141
 142         /* Part 2: Initialize and register the character device */
 143         cdev_init(&devnode->cdev, &cec_devnode_fops);
 144         devnode->cdev.kobj.parent = &devnode->dev.kobj;
 145         devnode->cdev.owner = owner;
 146
 147         ret = cdev_add(&devnode->cdev, devnode->dev.devt, 1);
 148         if (ret < 0) {
 149                 pr_err("%s: cdev_add failed\n", __func__);
 150                 goto clr_bit;
 151         }
 152
 153         ret = device_add(&devnode->dev);
 154         if (ret)
 155                 goto cdev_del;
 156
 157         devnode->registered = true;
 158         return 0;
 159
 160 cdev_del:
 161         cdev_del(&devnode->cdev);
 162 clr_bit:
 163         clear_bit(devnode->minor, cec_devnode_nums);
 164         return ret;
 165 }
 166
 167 /*
 168  * Unregister a cec device node
 169  *
 170  * This unregisters the passed device. Future open calls will be met with
 171  * errors.
 172  *
 173  * This function can safely be called if the device node has never been
 174  * registered or has already been unregistered.
 175  */
 176 static void cec_devnode_unregister(struct cec_devnode *devnode)
 177 {
 178         struct cec_fh *fh;
 179
 180         /* Check if devnode was never registered or already unregistered */
 181         if (!devnode->registered || devnode->unregistered)
 182                 return;
 183
 184         mutex_lock(&devnode->fhs_lock);
 185         list_for_each_entry(fh, &devnode->fhs, list)
 186                 wake_up_interruptible(&fh->wait);
 187         mutex_unlock(&devnode->fhs_lock);
 188
 189         devnode->registered = false;
 190         devnode->unregistered = true;
 191         device_del(&devnode->dev);
 192         cdev_del(&devnode->cdev);
 193         put_device(&devnode->dev);
 194 }
 195
 196 struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
 197                                          void *priv, const char *name, u32 caps,
 198                                          u8 available_las, struct device *parent)
 199 {
 200         struct cec_adapter *adap;
 201         int res;
 202
 203         if (WARN_ON(!parent))
 204                 return ERR_PTR(-EINVAL);
 205         if (WARN_ON(!caps))
 206                 return ERR_PTR(-EINVAL);
 207         if (WARN_ON(!ops))
 208                 return ERR_PTR(-EINVAL);
 209         if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
 210                 return ERR_PTR(-EINVAL);
 211         adap = kzalloc(sizeof(*adap), GFP_KERNEL);
 212         if (!adap)
 213                 return ERR_PTR(-ENOMEM);
 214         adap->owner = parent->driver->owner;
 215         adap->devnode.parent = parent;
 216         strlcpy(adap->name, name, sizeof(adap->name));
 217         adap->phys_addr = CEC_PHYS_ADDR_INVALID;
 218         adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
 219         adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
 220         adap->capabilities = caps;
 221         adap->available_log_addrs = available_las;
 222         adap->sequence = 0;
 223         adap->ops = ops;
 224         adap->priv = priv;
 225         memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs));
 226         mutex_init(&adap->lock);
 227         INIT_LIST_HEAD(&adap->transmit_queue);
 228         INIT_LIST_HEAD(&adap->wait_queue);
 229         init_waitqueue_head(&adap->kthread_waitq);
 230
 231         adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
 232         if (IS_ERR(adap->kthread)) {
 233                 pr_err("cec-%s: kernel_thread() failed\n", name);
 234                 res = PTR_ERR(adap->kthread);
 235                 kfree(adap);
 236                 return ERR_PTR(res);
 237         }
 238
 239         if (!(caps & CEC_CAP_RC))
 240                 return adap;
 241
 242 #if IS_REACHABLE(CONFIG_RC_CORE)
 243         /* Prepare the RC input device */
 244         adap->rc = rc_allocate_device();
 245         if (!adap->rc) {
 246                 pr_err("cec-%s: failed to allocate memory for rc_dev\n",
 247                        name);
 248                 kthread_stop(adap->kthread);
 249                 kfree(adap);
 250                 return ERR_PTR(-ENOMEM);
 251         }
 252
 253         snprintf(adap->input_name, sizeof(adap->input_name),
 254                  "RC for %s", name);
 255         snprintf(adap->input_phys, sizeof(adap->input_phys),
 256                  "%s/input0", name);
 257
 258         adap->rc->input_name = adap->input_name;
 259         adap->rc->input_phys = adap->input_phys;
 260         adap->rc->input_id.bustype = BUS_CEC;
 261         adap->rc->input_id.vendor = 0;
 262         adap->rc->input_id.product = 0;
 263         adap->rc->input_id.version = 1;
 264         adap->rc->dev.parent = parent;
 265         adap->rc->driver_type = RC_DRIVER_SCANCODE;
 266         adap->rc->driver_name = CEC_NAME;
 267         adap->rc->allowed_protocols = RC_BIT_CEC;
 268         adap->rc->priv = adap;
 269         adap->rc->map_name = RC_MAP_CEC;
 270         adap->rc->timeout = MS_TO_NS(100);
 271 #else
 272         adap->capabilities &= ~CEC_CAP_RC;
 273 #endif
 274         return adap;
 275 }
 276 EXPORT_SYMBOL_GPL(cec_allocate_adapter);
 277
 278 int cec_register_adapter(struct cec_adapter *adap)
 279 {
 280         int res;
 281
 282         if (IS_ERR_OR_NULL(adap))
 283                 return 0;
 284
 285 #if IS_REACHABLE(CONFIG_RC_CORE)
 286         if (adap->capabilities & CEC_CAP_RC) {
 287                 res = rc_register_device(adap->rc);
 288
 289                 if (res) {
 290                         pr_err("cec-%s: failed to prepare input device\n",
 291                                adap->name);
 292                         rc_free_device(adap->rc);
 293                         adap->rc = NULL;
 294                         return res;
 295                 }
 296         }
 297 #endif
 298
 299         res = cec_devnode_register(&adap->devnode, adap->owner);
 300         if (res) {
 301 #if IS_REACHABLE(CONFIG_RC_CORE)
 302                 /* Note: rc_unregister also calls rc_free */
 303                 rc_unregister_device(adap->rc);
 304                 adap->rc = NULL;
 305 #endif
 306                 return res;
 307         }
 308
 309         dev_set_drvdata(&adap->devnode.dev, adap);
 310 #ifdef CONFIG_MEDIA_CEC_DEBUG
 311         if (!top_cec_dir)
 312                 return 0;
 313
 314         adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir);
 315         if (IS_ERR_OR_NULL(adap->cec_dir)) {
 316                 pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name);
 317                 return 0;
 318         }
 319         adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev,
 320                 "status", adap->cec_dir, cec_adap_status);
 321         if (IS_ERR_OR_NULL(adap->status_file)) {
 322                 pr_warn("cec-%s: Failed to create status file\n", adap->name);
 323                 debugfs_remove_recursive(adap->cec_dir);
 324                 adap->cec_dir = NULL;
 325         }
 326 #endif
 327         return 0;
 328 }
 329 EXPORT_SYMBOL_GPL(cec_register_adapter);
 330
 331 void cec_unregister_adapter(struct cec_adapter *adap)
 332 {
 333         if (IS_ERR_OR_NULL(adap))
 334                 return;
 335
 336 #if IS_REACHABLE(CONFIG_RC_CORE)
 337         /* Note: rc_unregister also calls rc_free */
 338         rc_unregister_device(adap->rc);
 339         adap->rc = NULL;
 340 #endif
 341         debugfs_remove_recursive(adap->cec_dir);
 342         cec_devnode_unregister(&adap->devnode);
 343 }
 344 EXPORT_SYMBOL_GPL(cec_unregister_adapter);
 345
 346 void cec_delete_adapter(struct cec_adapter *adap)
 347 {
 348         if (IS_ERR_OR_NULL(adap))
 349                 return;
 350         mutex_lock(&adap->lock);
 351         __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
 352         mutex_unlock(&adap->lock);
 353         kthread_stop(adap->kthread);
 354         if (adap->kthread_config)
 355                 kthread_stop(adap->kthread_config);
 356 #if IS_REACHABLE(CONFIG_RC_CORE)
 357         if (adap->rc)
 358                 rc_free_device(adap->rc);
 359 #endif
 360         kfree(adap);
 361 }
 362 EXPORT_SYMBOL_GPL(cec_delete_adapter);
 363
 364 /*
 365  *      Initialise cec for linux
 366  */
 367 static int __init cec_devnode_init(void)
 368 {
 369         int ret;
 370
 371         pr_info("Linux cec interface: v0.10\n");
 372         ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES,
 373                                   CEC_NAME);
 374         if (ret < 0) {
 375                 pr_warn("cec: unable to allocate major\n");
 376                 return ret;
 377         }
 378
 379 #ifdef CONFIG_MEDIA_CEC_DEBUG
 380         top_cec_dir = debugfs_create_dir("cec", NULL);
 381         if (IS_ERR_OR_NULL(top_cec_dir)) {
 382                 pr_warn("cec: Failed to create debugfs cec dir\n");
 383                 top_cec_dir = NULL;
 384         }
 385 #endif
 386
 387         ret = bus_register(&cec_bus_type);
 388         if (ret < 0) {
 389                 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 390                 pr_warn("cec: bus_register failed\n");
 391                 return -EIO;
 392         }
 393
 394         return 0;
 395 }
 396
 397 static void __exit cec_devnode_exit(void)
 398 {
 399         debugfs_remove_recursive(top_cec_dir);
 400         bus_unregister(&cec_bus_type);
 401         unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 402 }
 403
 404 subsys_initcall(cec_devnode_init);
 405 module_exit(cec_devnode_exit)
 406
 407 MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
 408 MODULE_DESCRIPTION("Device node registration for cec drivers");
 409 MODULE_LICENSE("GPL");