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
  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 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
  74 void 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. */
  80 static 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
  92 static 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  */
 109 static 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
 151 clr_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  */
 167 static 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
 191 static void cec_cec_notify(struct cec_adapter *adap, u16 pa)
 192 {
 193         cec_s_phys_addr(adap, pa, false);
 194 }
 195
 196 void 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 }
 205 EXPORT_SYMBOL_GPL(cec_register_cec_notifier);
 206 #endif
 207
 208 struct 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->cec_pin_is_high = true;
 231         adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
 232         adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
 233         adap->capabilities = caps;
 234         adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
 235         adap->available_log_addrs = available_las;
 236         adap->sequence = 0;
 237         adap->ops = ops;
 238         adap->priv = priv;
 239         memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs));
 240         mutex_init(&adap->lock);
 241         INIT_LIST_HEAD(&adap->transmit_queue);
 242         INIT_LIST_HEAD(&adap->wait_queue);
 243         init_waitqueue_head(&adap->kthread_waitq);
 244
 245         adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
 246         if (IS_ERR(adap->kthread)) {
 247                 pr_err("cec-%s: kernel_thread() failed\n", name);
 248                 res = PTR_ERR(adap->kthread);
 249                 kfree(adap);
 250                 return ERR_PTR(res);
 251         }
 252
 253 #ifdef CONFIG_MEDIA_CEC_RC
 254         if (!(caps & CEC_CAP_RC))
 255                 return adap;
 256
 257         /* Prepare the RC input device */
 258         adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
 259         if (!adap->rc) {
 260                 pr_err("cec-%s: failed to allocate memory for rc_dev\n",
 261                        name);
 262                 kthread_stop(adap->kthread);
 263                 kfree(adap);
 264                 return ERR_PTR(-ENOMEM);
 265         }
 266
 267         snprintf(adap->device_name, sizeof(adap->device_name),
 268                  "RC for %s", name);
 269         snprintf(adap->input_phys, sizeof(adap->input_phys),
 270                  "%s/input0", name);
 271
 272         adap->rc->device_name = adap->device_name;
 273         adap->rc->input_phys = adap->input_phys;
 274         adap->rc->input_id.bustype = BUS_CEC;
 275         adap->rc->input_id.vendor = 0;
 276         adap->rc->input_id.product = 0;
 277         adap->rc->input_id.version = 1;
 278         adap->rc->driver_name = CEC_NAME;
 279         adap->rc->allowed_protocols = RC_PROTO_BIT_CEC;
 280         adap->rc->enabled_protocols = RC_PROTO_BIT_CEC;
 281         adap->rc->priv = adap;
 282         adap->rc->map_name = RC_MAP_CEC;
 283         adap->rc->timeout = MS_TO_NS(100);
 284         adap->rc_last_scancode = -1;
 285 #endif
 286         return adap;
 287 }
 288 EXPORT_SYMBOL_GPL(cec_allocate_adapter);
 289
 290 int cec_register_adapter(struct cec_adapter *adap,
 291                          struct device *parent)
 292 {
 293         int res;
 294
 295         if (IS_ERR_OR_NULL(adap))
 296                 return 0;
 297
 298         if (WARN_ON(!parent))
 299                 return -EINVAL;
 300
 301         adap->owner = parent->driver->owner;
 302         adap->devnode.dev.parent = parent;
 303
 304 #ifdef CONFIG_MEDIA_CEC_RC
 305         if (adap->capabilities & CEC_CAP_RC) {
 306                 adap->rc->dev.parent = parent;
 307                 res = rc_register_device(adap->rc);
 308
 309                 if (res) {
 310                         pr_err("cec-%s: failed to prepare input device\n",
 311                                adap->name);
 312                         rc_free_device(adap->rc);
 313                         adap->rc = NULL;
 314                         return res;
 315                 }
 316                 /*
 317                  * The REP_DELAY for CEC is really the time between the initial
 318                  * 'User Control Pressed' message and the second. The first
 319                  * keypress is always seen as non-repeating, the second
 320                  * (provided it has the same UI Command) will start the 'Press
 321                  * and Hold' (aka repeat) behavior. By setting REP_DELAY to the
 322                  * same value as REP_PERIOD the expected CEC behavior is
 323                  * reproduced.
 324                  */
 325                 adap->rc->input_dev->rep[REP_DELAY] =
 326                         adap->rc->input_dev->rep[REP_PERIOD];
 327         }
 328 #endif
 329
 330         res = cec_devnode_register(&adap->devnode, adap->owner);
 331         if (res) {
 332 #ifdef CONFIG_MEDIA_CEC_RC
 333                 /* Note: rc_unregister also calls rc_free */
 334                 rc_unregister_device(adap->rc);
 335                 adap->rc = NULL;
 336 #endif
 337                 return res;
 338         }
 339
 340         dev_set_drvdata(&adap->devnode.dev, adap);
 341 #ifdef CONFIG_DEBUG_FS
 342         if (!top_cec_dir)
 343                 return 0;
 344
 345         adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir);
 346         if (IS_ERR_OR_NULL(adap->cec_dir)) {
 347                 pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name);
 348                 return 0;
 349         }
 350         adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev,
 351                 "status", adap->cec_dir, cec_adap_status);
 352         if (IS_ERR_OR_NULL(adap->status_file)) {
 353                 pr_warn("cec-%s: Failed to create status file\n", adap->name);
 354                 debugfs_remove_recursive(adap->cec_dir);
 355                 adap->cec_dir = NULL;
 356         }
 357 #endif
 358         return 0;
 359 }
 360 EXPORT_SYMBOL_GPL(cec_register_adapter);
 361
 362 void cec_unregister_adapter(struct cec_adapter *adap)
 363 {
 364         if (IS_ERR_OR_NULL(adap))
 365                 return;
 366
 367 #ifdef CONFIG_MEDIA_CEC_RC
 368         /* Note: rc_unregister also calls rc_free */
 369         rc_unregister_device(adap->rc);
 370         adap->rc = NULL;
 371 #endif
 372         debugfs_remove_recursive(adap->cec_dir);
 373 #ifdef CONFIG_CEC_NOTIFIER
 374         if (adap->notifier)
 375                 cec_notifier_unregister(adap->notifier);
 376 #endif
 377         cec_devnode_unregister(&adap->devnode);
 378 }
 379 EXPORT_SYMBOL_GPL(cec_unregister_adapter);
 380
 381 void cec_delete_adapter(struct cec_adapter *adap)
 382 {
 383         if (IS_ERR_OR_NULL(adap))
 384                 return;
 385         mutex_lock(&adap->lock);
 386         __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
 387         mutex_unlock(&adap->lock);
 388         kthread_stop(adap->kthread);
 389         if (adap->kthread_config)
 390                 kthread_stop(adap->kthread_config);
 391         if (adap->ops->adap_free)
 392                 adap->ops->adap_free(adap);
 393 #ifdef CONFIG_MEDIA_CEC_RC
 394         rc_free_device(adap->rc);
 395 #endif
 396         kfree(adap);
 397 }
 398 EXPORT_SYMBOL_GPL(cec_delete_adapter);
 399
 400 /*
 401  *      Initialise cec for linux
 402  */
 403 static int __init cec_devnode_init(void)
 404 {
 405         int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME);
 406
 407         if (ret < 0) {
 408                 pr_warn("cec: unable to allocate major\n");
 409                 return ret;
 410         }
 411
 412 #ifdef CONFIG_DEBUG_FS
 413         top_cec_dir = debugfs_create_dir("cec", NULL);
 414         if (IS_ERR_OR_NULL(top_cec_dir)) {
 415                 pr_warn("cec: Failed to create debugfs cec dir\n");
 416                 top_cec_dir = NULL;
 417         }
 418 #endif
 419
 420         ret = bus_register(&cec_bus_type);
 421         if (ret < 0) {
 422                 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 423                 pr_warn("cec: bus_register failed\n");
 424                 return -EIO;
 425         }
 426
 427         return 0;
 428 }
 429
 430 static void __exit cec_devnode_exit(void)
 431 {
 432         debugfs_remove_recursive(top_cec_dir);
 433         bus_unregister(&cec_bus_type);
 434         unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 435 }
 436
 437 subsys_initcall(cec_devnode_init);
 438 module_exit(cec_devnode_exit)
 439
 440 MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
 441 MODULE_DESCRIPTION("Device node registration for cec drivers");
 442 MODULE_LICENSE("GPL");