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