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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * cec-core.c - HDMI Consumer Electronics Control framework - Core
   4  *
   5  * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/kmod.h>
  13 #include <linux/slab.h>
  14 #include <linux/mm.h>
  15 #include <linux/string.h>
  16 #include <linux/types.h>
  17
  18 #include "cec-priv.h"
  19
  20 #define CEC_NUM_DEVICES 256
  21 #define CEC_NAME        "cec"
  22
  23 /*
  24  * 400 ms is the time it takes for one 16 byte message to be
  25  * transferred and 5 is the maximum number of retries. Add
  26  * another 100 ms as a margin. So if the transmit doesn't
  27  * finish before that time something is really wrong and we
  28  * have to time out.
  29  *
  30  * This is a sign that something it really wrong and a warning
  31  * will be issued.
  32  */
  33 #define CEC_XFER_TIMEOUT_MS (5 * 400 + 100)
  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 bool debug_phys_addr;
  40 module_param(debug_phys_addr, bool, 0644);
  41 MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set");
  42
  43 static dev_t cec_dev_t;
  44
  45 /* Active devices */
  46 static DEFINE_MUTEX(cec_devnode_lock);
  47 static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
  48
  49 static struct dentry *top_cec_dir;
  50
  51 /* dev to cec_devnode */
  52 #define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
  53
  54 /* Called when the last user of the cec device exits. */
  55 static void cec_devnode_release(struct device *cd)
  56 {
  57         struct cec_devnode *devnode = to_cec_devnode(cd);
  58
  59         mutex_lock(&cec_devnode_lock);
  60         /* Mark device node number as free */
  61         clear_bit(devnode->minor, cec_devnode_nums);
  62         mutex_unlock(&cec_devnode_lock);
  63
  64         cec_delete_adapter(to_cec_adapter(devnode));
  65 }
  66
  67 static const struct bus_type cec_bus_type = {
  68         .name = CEC_NAME,
  69 };
  70
  71 /*
  72  * Register a cec device node
  73  *
  74  * The registration code assigns minor numbers and registers the new device node
  75  * with the kernel. An error is returned if no free minor number can be found,
  76  * or if the registration of the device node fails.
  77  *
  78  * Zero is returned on success.
  79  *
  80  * Note that if the cec_devnode_register call fails, the release() callback of
  81  * the cec_devnode structure is *not* called, so the caller is responsible for
  82  * freeing any data.
  83  */
  84 static int __must_check cec_devnode_register(struct cec_devnode *devnode,
  85                                              struct module *owner)
  86 {
  87         int minor;
  88         int ret;
  89
  90         /* Part 1: Find a free minor number */
  91         mutex_lock(&cec_devnode_lock);
  92         minor = find_first_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES);
  93         if (minor == CEC_NUM_DEVICES) {
  94                 mutex_unlock(&cec_devnode_lock);
  95                 pr_err("could not get a free minor\n");
  96                 return -ENFILE;
  97         }
  98
  99         set_bit(minor, cec_devnode_nums);
 100         mutex_unlock(&cec_devnode_lock);
 101
 102         devnode->minor = minor;
 103         devnode->dev.bus = &cec_bus_type;
 104         devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
 105         devnode->dev.release = cec_devnode_release;
 106         dev_set_name(&devnode->dev, "cec%d", devnode->minor);
 107         device_initialize(&devnode->dev);
 108
 109         /* Part 2: Initialize and register the character device */
 110         cdev_init(&devnode->cdev, &cec_devnode_fops);
 111         devnode->cdev.owner = owner;
 112         kobject_set_name(&devnode->cdev.kobj, "cec%d", devnode->minor);
 113
 114         devnode->registered = true;
 115         ret = cdev_device_add(&devnode->cdev, &devnode->dev);
 116         if (ret) {
 117                 devnode->registered = false;
 118                 pr_err("%s: cdev_device_add failed\n", __func__);
 119                 goto clr_bit;
 120         }
 121
 122         return 0;
 123
 124 clr_bit:
 125         mutex_lock(&cec_devnode_lock);
 126         clear_bit(devnode->minor, cec_devnode_nums);
 127         mutex_unlock(&cec_devnode_lock);
 128         return ret;
 129 }
 130
 131 /*
 132  * Unregister a cec device node
 133  *
 134  * This unregisters the passed device. Future open calls will be met with
 135  * errors.
 136  *
 137  * This function can safely be called if the device node has never been
 138  * registered or has already been unregistered.
 139  */
 140 static void cec_devnode_unregister(struct cec_adapter *adap)
 141 {
 142         struct cec_devnode *devnode = &adap->devnode;
 143         struct cec_fh *fh;
 144
 145         mutex_lock(&devnode->lock);
 146
 147         /* Check if devnode was never registered or already unregistered */
 148         if (!devnode->registered || devnode->unregistered) {
 149                 mutex_unlock(&devnode->lock);
 150                 return;
 151         }
 152         devnode->registered = false;
 153         devnode->unregistered = true;
 154
 155         mutex_lock(&devnode->lock_fhs);
 156         list_for_each_entry(fh, &devnode->fhs, list)
 157                 wake_up_interruptible(&fh->wait);
 158         mutex_unlock(&devnode->lock_fhs);
 159
 160         mutex_unlock(&devnode->lock);
 161
 162         mutex_lock(&adap->lock);
 163         __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
 164         __cec_s_log_addrs(adap, NULL, false);
 165         // Disable the adapter (since adap->devnode.unregistered is true)
 166         cec_adap_enable(adap);
 167         mutex_unlock(&adap->lock);
 168
 169         cdev_device_del(&devnode->cdev, &devnode->dev);
 170         put_device(&devnode->dev);
 171 }
 172
 173 #ifdef CONFIG_DEBUG_FS
 174 static ssize_t cec_error_inj_write(struct file *file,
 175         const char __user *ubuf, size_t count, loff_t *ppos)
 176 {
 177         struct seq_file *sf = file->private_data;
 178         struct cec_adapter *adap = sf->private;
 179         char *buf;
 180         char *line;
 181         char *p;
 182
 183         buf = memdup_user_nul(ubuf, min_t(size_t, PAGE_SIZE, count));
 184         if (IS_ERR(buf))
 185                 return PTR_ERR(buf);
 186         p = buf;
 187         while (p && *p) {
 188                 p = skip_spaces(p);
 189                 line = strsep(&p, "\n");
 190                 if (!*line || *line == '#')
 191                         continue;
 192                 if (!call_op(adap, error_inj_parse_line, line)) {
 193                         kfree(buf);
 194                         return -EINVAL;
 195                 }
 196         }
 197         kfree(buf);
 198         return count;
 199 }
 200
 201 static int cec_error_inj_show(struct seq_file *sf, void *unused)
 202 {
 203         struct cec_adapter *adap = sf->private;
 204
 205         return call_op(adap, error_inj_show, sf);
 206 }
 207
 208 static int cec_error_inj_open(struct inode *inode, struct file *file)
 209 {
 210         return single_open(file, cec_error_inj_show, inode->i_private);
 211 }
 212
 213 static const struct file_operations cec_error_inj_fops = {
 214         .open = cec_error_inj_open,
 215         .write = cec_error_inj_write,
 216         .read = seq_read,
 217         .llseek = seq_lseek,
 218         .release = single_release,
 219 };
 220 #endif
 221
 222 struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
 223                                          void *priv, const char *name, u32 caps,
 224                                          u8 available_las)
 225 {
 226         struct cec_adapter *adap;
 227         int res;
 228
 229 #ifndef CONFIG_MEDIA_CEC_RC
 230         caps &= ~CEC_CAP_RC;
 231 #endif
 232
 233         if (WARN_ON(!caps))
 234                 return ERR_PTR(-EINVAL);
 235         if (WARN_ON(!ops))
 236                 return ERR_PTR(-EINVAL);
 237         if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
 238                 return ERR_PTR(-EINVAL);
 239         adap = kzalloc(sizeof(*adap), GFP_KERNEL);
 240         if (!adap)
 241                 return ERR_PTR(-ENOMEM);
 242         strscpy(adap->name, name, sizeof(adap->name));
 243         adap->phys_addr = CEC_PHYS_ADDR_INVALID;
 244         adap->cec_pin_is_high = true;
 245         adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
 246         adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
 247         adap->capabilities = caps | CEC_CAP_REPLY_VENDOR_ID;
 248         if (debug_phys_addr)
 249                 adap->capabilities |= CEC_CAP_PHYS_ADDR;
 250         adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
 251         adap->available_log_addrs = available_las;
 252         adap->sequence = 0;
 253         adap->ops = ops;
 254         adap->priv = priv;
 255         mutex_init(&adap->lock);
 256         INIT_LIST_HEAD(&adap->transmit_queue);
 257         INIT_LIST_HEAD(&adap->wait_queue);
 258         init_waitqueue_head(&adap->kthread_waitq);
 259
 260         /* adap->devnode initialization */
 261         INIT_LIST_HEAD(&adap->devnode.fhs);
 262         mutex_init(&adap->devnode.lock_fhs);
 263         mutex_init(&adap->devnode.lock);
 264
 265         adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
 266         if (IS_ERR(adap->kthread)) {
 267                 pr_err("cec-%s: kernel_thread() failed\n", name);
 268                 res = PTR_ERR(adap->kthread);
 269                 kfree(adap);
 270                 return ERR_PTR(res);
 271         }
 272
 273 #ifdef CONFIG_MEDIA_CEC_RC
 274         if (!(caps & CEC_CAP_RC))
 275                 return adap;
 276
 277         /* Prepare the RC input device */
 278         adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
 279         if (!adap->rc) {
 280                 pr_err("cec-%s: failed to allocate memory for rc_dev\n",
 281                        name);
 282                 kthread_stop(adap->kthread);
 283                 kfree(adap);
 284                 return ERR_PTR(-ENOMEM);
 285         }
 286
 287         snprintf(adap->input_phys, sizeof(adap->input_phys),
 288                  "%s/input0", adap->name);
 289
 290         adap->rc->device_name = adap->name;
 291         adap->rc->input_phys = adap->input_phys;
 292         adap->rc->input_id.bustype = BUS_CEC;
 293         adap->rc->input_id.vendor = 0;
 294         adap->rc->input_id.product = 0;
 295         adap->rc->input_id.version = 1;
 296         adap->rc->driver_name = CEC_NAME;
 297         adap->rc->allowed_protocols = RC_PROTO_BIT_CEC;
 298         adap->rc->priv = adap;
 299         adap->rc->map_name = RC_MAP_CEC;
 300         adap->rc->timeout = MS_TO_US(550);
 301 #endif
 302         return adap;
 303 }
 304 EXPORT_SYMBOL_GPL(cec_allocate_adapter);
 305
 306 int cec_register_adapter(struct cec_adapter *adap,
 307                          struct device *parent)
 308 {
 309         int res;
 310
 311         if (IS_ERR_OR_NULL(adap))
 312                 return 0;
 313
 314         if (WARN_ON(!parent))
 315                 return -EINVAL;
 316
 317         adap->owner = parent->driver->owner;
 318         adap->devnode.dev.parent = parent;
 319         if (!adap->xfer_timeout_ms)
 320                 adap->xfer_timeout_ms = CEC_XFER_TIMEOUT_MS;
 321
 322 #ifdef CONFIG_MEDIA_CEC_RC
 323         if (adap->capabilities & CEC_CAP_RC) {
 324                 adap->rc->dev.parent = parent;
 325                 res = rc_register_device(adap->rc);
 326
 327                 if (res) {
 328                         pr_err("cec-%s: failed to prepare input device\n",
 329                                adap->name);
 330                         rc_free_device(adap->rc);
 331                         adap->rc = NULL;
 332                         return res;
 333                 }
 334         }
 335 #endif
 336
 337         res = cec_devnode_register(&adap->devnode, adap->owner);
 338         if (res) {
 339 #ifdef CONFIG_MEDIA_CEC_RC
 340                 /* Note: rc_unregister also calls rc_free */
 341                 rc_unregister_device(adap->rc);
 342                 adap->rc = NULL;
 343 #endif
 344                 return res;
 345         }
 346
 347         dev_set_drvdata(&adap->devnode.dev, adap);
 348 #ifdef CONFIG_DEBUG_FS
 349         if (!top_cec_dir)
 350                 return 0;
 351
 352         adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev),
 353                                            top_cec_dir);
 354
 355         debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir,
 356                                     cec_adap_status);
 357
 358         if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line)
 359                 return 0;
 360         debugfs_create_file("error-inj", 0644, adap->cec_dir, adap,
 361                             &cec_error_inj_fops);
 362 #endif
 363         return 0;
 364 }
 365 EXPORT_SYMBOL_GPL(cec_register_adapter);
 366
 367 void cec_unregister_adapter(struct cec_adapter *adap)
 368 {
 369         if (IS_ERR_OR_NULL(adap))
 370                 return;
 371
 372 #ifdef CONFIG_MEDIA_CEC_RC
 373         /* Note: rc_unregister also calls rc_free */
 374         rc_unregister_device(adap->rc);
 375         adap->rc = NULL;
 376 #endif
 377         debugfs_remove_recursive(adap->cec_dir);
 378 #ifdef CONFIG_CEC_NOTIFIER
 379         cec_notifier_cec_adap_unregister(adap->notifier, adap);
 380 #endif
 381         cec_devnode_unregister(adap);
 382 }
 383 EXPORT_SYMBOL_GPL(cec_unregister_adapter);
 384
 385 void cec_delete_adapter(struct cec_adapter *adap)
 386 {
 387         if (IS_ERR_OR_NULL(adap))
 388                 return;
 389         if (adap->kthread_config)
 390                 kthread_stop(adap->kthread_config);
 391         kthread_stop(adap->kthread);
 392         if (adap->ops->adap_free)
 393                 adap->ops->adap_free(adap);
 394 #ifdef CONFIG_MEDIA_CEC_RC
 395         rc_free_device(adap->rc);
 396 #endif
 397         kfree(adap);
 398 }
 399 EXPORT_SYMBOL_GPL(cec_delete_adapter);
 400
 401 /*
 402  *      Initialise cec for linux
 403  */
 404 static int __init cec_devnode_init(void)
 405 {
 406         int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME);
 407
 408         if (ret < 0) {
 409                 pr_warn("cec: unable to allocate major\n");
 410                 return ret;
 411         }
 412
 413 #ifdef CONFIG_DEBUG_FS
 414         top_cec_dir = debugfs_create_dir("cec", NULL);
 415         if (IS_ERR_OR_NULL(top_cec_dir)) {
 416                 pr_warn("cec: Failed to create debugfs cec dir\n");
 417                 top_cec_dir = NULL;
 418         }
 419 #endif
 420
 421         ret = bus_register(&cec_bus_type);
 422         if (ret < 0) {
 423                 unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 424                 pr_warn("cec: bus_register failed\n");
 425                 return -EIO;
 426         }
 427
 428         return 0;
 429 }
 430
 431 static void __exit cec_devnode_exit(void)
 432 {
 433         debugfs_remove_recursive(top_cec_dir);
 434         bus_unregister(&cec_bus_type);
 435         unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
 436 }
 437
 438 subsys_initcall(cec_devnode_init);
 439 module_exit(cec_devnode_exit)
 440
 441 MODULE_AUTHOR("Hans Verkuil <[email protected]>");
 442 MODULE_DESCRIPTION("Device node registration for cec drivers");
 443 MODULE_LICENSE("GPL");