cec/core/cec-core.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * cec-core.c - HDMI Consumer Electronics Control framework - Core
0004  *
0005  * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
0006  */
0007
0008 #include <linux/errno.h>
0009 #include <linux/init.h>
0010 #include <linux/module.h>
0011 #include <linux/kernel.h>
0012 #include <linux/kmod.h>
0013 #include <linux/slab.h>
0014 #include <linux/mm.h>
0015 #include <linux/string.h>
0016 #include <linux/types.h>
0017
0018 #include "cec-priv.h"
0019
0020 #define CEC_NUM_DEVICES 256
0021 #define CEC_NAME    "cec"
0022
0023 /*
0024  * 400 ms is the time it takes for one 16 byte message to be
0025  * transferred and 5 is the maximum number of retries. Add
0026  * another 100 ms as a margin. So if the transmit doesn't
0027  * finish before that time something is really wrong and we
0028  * have to time out.
0029  *
0030  * This is a sign that something it really wrong and a warning
0031  * will be issued.
0032  */
0033 #define CEC_XFER_TIMEOUT_MS (5 * 400 + 100)
0034
0035 int cec_debug;
0036 module_param_named(debug, cec_debug, int, 0644);
0037 MODULE_PARM_DESC(debug, "debug level (0-2)");
0038
0039 static bool debug_phys_addr;
0040 module_param(debug_phys_addr, bool, 0644);
0041 MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set");
0042
0043 static dev_t cec_dev_t;
0044
0045 /* Active devices */
0046 static DEFINE_MUTEX(cec_devnode_lock);
0047 static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
0048
0049 static struct dentry *top_cec_dir;
0050
0051 /* dev to cec_devnode */
0052 #define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
0053
0054 int cec_get_device(struct cec_devnode *devnode)
0055 {
0056     /*
0057      * Check if the cec device is available. This needs to be done with
0058      * the devnode->lock held to prevent an open/unregister race:
0059      * without the lock, the device could be unregistered and freed between
0060      * the devnode->registered check and get_device() calls, leading to
0061      * a crash.
0062      */
0063     mutex_lock(&devnode->lock);
0064     /*
0065      * return ENXIO if the cec device has been removed
0066      * already or if it is not registered anymore.
0067      */
0068     if (!devnode->registered) {
0069         mutex_unlock(&devnode->lock);
0070         return -ENXIO;
0071     }
0072     /* and increase the device refcount */
0073     get_device(&devnode->dev);
0074     mutex_unlock(&devnode->lock);
0075     return 0;
0076 }
0077
0078 void cec_put_device(struct cec_devnode *devnode)
0079 {
0080     put_device(&devnode->dev);
0081 }
0082
0083 /* Called when the last user of the cec device exits. */
0084 static void cec_devnode_release(struct device *cd)
0085 {
0086     struct cec_devnode *devnode = to_cec_devnode(cd);
0087
0088     mutex_lock(&cec_devnode_lock);
0089     /* Mark device node number as free */
0090     clear_bit(devnode->minor, cec_devnode_nums);
0091     mutex_unlock(&cec_devnode_lock);
0092
0093     cec_delete_adapter(to_cec_adapter(devnode));
0094 }
0095
0096 static struct bus_type cec_bus_type = {
0097     .name = CEC_NAME,
0098 };
0099
0100 /*
0101  * Register a cec device node
0102  *
0103  * The registration code assigns minor numbers and registers the new device node
0104  * with the kernel. An error is returned if no free minor number can be found,
0105  * or if the registration of the device node fails.
0106  *
0107  * Zero is returned on success.
0108  *
0109  * Note that if the cec_devnode_register call fails, the release() callback of
0110  * the cec_devnode structure is *not* called, so the caller is responsible for
0111  * freeing any data.
0112  */
0113 static int __must_check cec_devnode_register(struct cec_devnode *devnode,
0114                          struct module *owner)
0115 {
0116     int minor;
0117     int ret;
0118
0119     /* Part 1: Find a free minor number */
0120     mutex_lock(&cec_devnode_lock);
0121     minor = find_first_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES);
0122     if (minor == CEC_NUM_DEVICES) {
0123         mutex_unlock(&cec_devnode_lock);
0124         pr_err("could not get a free minor\n");
0125         return -ENFILE;
0126     }
0127
0128     set_bit(minor, cec_devnode_nums);
0129     mutex_unlock(&cec_devnode_lock);
0130
0131     devnode->minor = minor;
0132     devnode->dev.bus = &cec_bus_type;
0133     devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
0134     devnode->dev.release = cec_devnode_release;
0135     dev_set_name(&devnode->dev, "cec%d", devnode->minor);
0136     device_initialize(&devnode->dev);
0137
0138     /* Part 2: Initialize and register the character device */
0139     cdev_init(&devnode->cdev, &cec_devnode_fops);
0140     devnode->cdev.owner = owner;
0141     kobject_set_name(&devnode->cdev.kobj, "cec%d", devnode->minor);
0142
0143     devnode->registered = true;
0144     ret = cdev_device_add(&devnode->cdev, &devnode->dev);
0145     if (ret) {
0146         devnode->registered = false;
0147         pr_err("%s: cdev_device_add failed\n", __func__);
0148         goto clr_bit;
0149     }
0150
0151     return 0;
0152
0153 clr_bit:
0154     mutex_lock(&cec_devnode_lock);
0155     clear_bit(devnode->minor, cec_devnode_nums);
0156     mutex_unlock(&cec_devnode_lock);
0157     return ret;
0158 }
0159
0160 /*
0161  * Unregister a cec device node
0162  *
0163  * This unregisters the passed device. Future open calls will be met with
0164  * errors.
0165  *
0166  * This function can safely be called if the device node has never been
0167  * registered or has already been unregistered.
0168  */
0169 static void cec_devnode_unregister(struct cec_adapter *adap)
0170 {
0171     struct cec_devnode *devnode = &adap->devnode;
0172     struct cec_fh *fh;
0173
0174     mutex_lock(&devnode->lock);
0175
0176     /* Check if devnode was never registered or already unregistered */
0177     if (!devnode->registered || devnode->unregistered) {
0178         mutex_unlock(&devnode->lock);
0179         return;
0180     }
0181     devnode->registered = false;
0182     devnode->unregistered = true;
0183
0184     mutex_lock(&devnode->lock_fhs);
0185     list_for_each_entry(fh, &devnode->fhs, list)
0186         wake_up_interruptible(&fh->wait);
0187     mutex_unlock(&devnode->lock_fhs);
0188
0189     mutex_unlock(&devnode->lock);
0190
0191     mutex_lock(&adap->lock);
0192     __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
0193     __cec_s_log_addrs(adap, NULL, false);
0194     mutex_unlock(&adap->lock);
0195
0196     cdev_device_del(&devnode->cdev, &devnode->dev);
0197     put_device(&devnode->dev);
0198 }
0199
0200 #ifdef CONFIG_DEBUG_FS
0201 static ssize_t cec_error_inj_write(struct file *file,
0202     const char __user *ubuf, size_t count, loff_t *ppos)
0203 {
0204     struct seq_file *sf = file->private_data;
0205     struct cec_adapter *adap = sf->private;
0206     char *buf;
0207     char *line;
0208     char *p;
0209
0210     buf = memdup_user_nul(ubuf, min_t(size_t, PAGE_SIZE, count));
0211     if (IS_ERR(buf))
0212         return PTR_ERR(buf);
0213     p = buf;
0214     while (p && *p) {
0215         p = skip_spaces(p);
0216         line = strsep(&p, "\n");
0217         if (!*line || *line == '#')
0218             continue;
0219         if (!call_op(adap, error_inj_parse_line, line)) {
0220             kfree(buf);
0221             return -EINVAL;
0222         }
0223     }
0224     kfree(buf);
0225     return count;
0226 }
0227
0228 static int cec_error_inj_show(struct seq_file *sf, void *unused)
0229 {
0230     struct cec_adapter *adap = sf->private;
0231
0232     return call_op(adap, error_inj_show, sf);
0233 }
0234
0235 static int cec_error_inj_open(struct inode *inode, struct file *file)
0236 {
0237     return single_open(file, cec_error_inj_show, inode->i_private);
0238 }
0239
0240 static const struct file_operations cec_error_inj_fops = {
0241     .open = cec_error_inj_open,
0242     .write = cec_error_inj_write,
0243     .read = seq_read,
0244     .llseek = seq_lseek,
0245     .release = single_release,
0246 };
0247 #endif
0248
0249 struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
0250                      void *priv, const char *name, u32 caps,
0251                      u8 available_las)
0252 {
0253     struct cec_adapter *adap;
0254     int res;
0255
0256 #ifndef CONFIG_MEDIA_CEC_RC
0257     caps &= ~CEC_CAP_RC;
0258 #endif
0259
0260     if (WARN_ON(!caps))
0261         return ERR_PTR(-EINVAL);
0262     if (WARN_ON(!ops))
0263         return ERR_PTR(-EINVAL);
0264     if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS))
0265         return ERR_PTR(-EINVAL);
0266     adap = kzalloc(sizeof(*adap), GFP_KERNEL);
0267     if (!adap)
0268         return ERR_PTR(-ENOMEM);
0269     strscpy(adap->name, name, sizeof(adap->name));
0270     adap->phys_addr = CEC_PHYS_ADDR_INVALID;
0271     adap->cec_pin_is_high = true;
0272     adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
0273     adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
0274     adap->capabilities = caps;
0275     if (debug_phys_addr)
0276         adap->capabilities |= CEC_CAP_PHYS_ADDR;
0277     adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
0278     adap->available_log_addrs = available_las;
0279     adap->sequence = 0;
0280     adap->ops = ops;
0281     adap->priv = priv;
0282     mutex_init(&adap->lock);
0283     INIT_LIST_HEAD(&adap->transmit_queue);
0284     INIT_LIST_HEAD(&adap->wait_queue);
0285     init_waitqueue_head(&adap->kthread_waitq);
0286
0287     /* adap->devnode initialization */
0288     INIT_LIST_HEAD(&adap->devnode.fhs);
0289     mutex_init(&adap->devnode.lock_fhs);
0290     mutex_init(&adap->devnode.lock);
0291
0292     adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
0293     if (IS_ERR(adap->kthread)) {
0294         pr_err("cec-%s: kernel_thread() failed\n", name);
0295         res = PTR_ERR(adap->kthread);
0296         kfree(adap);
0297         return ERR_PTR(res);
0298     }
0299
0300 #ifdef CONFIG_MEDIA_CEC_RC
0301     if (!(caps & CEC_CAP_RC))
0302         return adap;
0303
0304     /* Prepare the RC input device */
0305     adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE);
0306     if (!adap->rc) {
0307         pr_err("cec-%s: failed to allocate memory for rc_dev\n",
0308                name);
0309         kthread_stop(adap->kthread);
0310         kfree(adap);
0311         return ERR_PTR(-ENOMEM);
0312     }
0313
0314     snprintf(adap->input_phys, sizeof(adap->input_phys),
0315          "%s/input0", adap->name);
0316
0317     adap->rc->device_name = adap->name;
0318     adap->rc->input_phys = adap->input_phys;
0319     adap->rc->input_id.bustype = BUS_CEC;
0320     adap->rc->input_id.vendor = 0;
0321     adap->rc->input_id.product = 0;
0322     adap->rc->input_id.version = 1;
0323     adap->rc->driver_name = CEC_NAME;
0324     adap->rc->allowed_protocols = RC_PROTO_BIT_CEC;
0325     adap->rc->priv = adap;
0326     adap->rc->map_name = RC_MAP_CEC;
0327     adap->rc->timeout = MS_TO_US(550);
0328 #endif
0329     return adap;
0330 }
0331 EXPORT_SYMBOL_GPL(cec_allocate_adapter);
0332
0333 int cec_register_adapter(struct cec_adapter *adap,
0334              struct device *parent)
0335 {
0336     int res;
0337
0338     if (IS_ERR_OR_NULL(adap))
0339         return 0;
0340
0341     if (WARN_ON(!parent))
0342         return -EINVAL;
0343
0344     adap->owner = parent->driver->owner;
0345     adap->devnode.dev.parent = parent;
0346     if (!adap->xfer_timeout_ms)
0347         adap->xfer_timeout_ms = CEC_XFER_TIMEOUT_MS;
0348
0349 #ifdef CONFIG_MEDIA_CEC_RC
0350     if (adap->capabilities & CEC_CAP_RC) {
0351         adap->rc->dev.parent = parent;
0352         res = rc_register_device(adap->rc);
0353
0354         if (res) {
0355             pr_err("cec-%s: failed to prepare input device\n",
0356                    adap->name);
0357             rc_free_device(adap->rc);
0358             adap->rc = NULL;
0359             return res;
0360         }
0361     }
0362 #endif
0363
0364     res = cec_devnode_register(&adap->devnode, adap->owner);
0365     if (res) {
0366 #ifdef CONFIG_MEDIA_CEC_RC
0367         /* Note: rc_unregister also calls rc_free */
0368         rc_unregister_device(adap->rc);
0369         adap->rc = NULL;
0370 #endif
0371         return res;
0372     }
0373
0374     dev_set_drvdata(&adap->devnode.dev, adap);
0375 #ifdef CONFIG_DEBUG_FS
0376     if (!top_cec_dir)
0377         return 0;
0378
0379     adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev),
0380                        top_cec_dir);
0381
0382     debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir,
0383                     cec_adap_status);
0384
0385     if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line)
0386         return 0;
0387     debugfs_create_file("error-inj", 0644, adap->cec_dir, adap,
0388                 &cec_error_inj_fops);
0389 #endif
0390     return 0;
0391 }
0392 EXPORT_SYMBOL_GPL(cec_register_adapter);
0393
0394 void cec_unregister_adapter(struct cec_adapter *adap)
0395 {
0396     if (IS_ERR_OR_NULL(adap))
0397         return;
0398
0399 #ifdef CONFIG_MEDIA_CEC_RC
0400     /* Note: rc_unregister also calls rc_free */
0401     rc_unregister_device(adap->rc);
0402     adap->rc = NULL;
0403 #endif
0404     debugfs_remove_recursive(adap->cec_dir);
0405 #ifdef CONFIG_CEC_NOTIFIER
0406     cec_notifier_cec_adap_unregister(adap->notifier, adap);
0407 #endif
0408     cec_devnode_unregister(adap);
0409 }
0410 EXPORT_SYMBOL_GPL(cec_unregister_adapter);
0411
0412 void cec_delete_adapter(struct cec_adapter *adap)
0413 {
0414     if (IS_ERR_OR_NULL(adap))
0415         return;
0416     if (adap->kthread_config)
0417         kthread_stop(adap->kthread_config);
0418     kthread_stop(adap->kthread);
0419     if (adap->ops->adap_free)
0420         adap->ops->adap_free(adap);
0421 #ifdef CONFIG_MEDIA_CEC_RC
0422     rc_free_device(adap->rc);
0423 #endif
0424     kfree(adap);
0425 }
0426 EXPORT_SYMBOL_GPL(cec_delete_adapter);
0427
0428 /*
0429  *  Initialise cec for linux
0430  */
0431 static int __init cec_devnode_init(void)
0432 {
0433     int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME);
0434
0435     if (ret < 0) {
0436         pr_warn("cec: unable to allocate major\n");
0437         return ret;
0438     }
0439
0440 #ifdef CONFIG_DEBUG_FS
0441     top_cec_dir = debugfs_create_dir("cec", NULL);
0442     if (IS_ERR_OR_NULL(top_cec_dir)) {
0443         pr_warn("cec: Failed to create debugfs cec dir\n");
0444         top_cec_dir = NULL;
0445     }
0446 #endif
0447
0448     ret = bus_register(&cec_bus_type);
0449     if (ret < 0) {
0450         unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
0451         pr_warn("cec: bus_register failed\n");
0452         return -EIO;
0453     }
0454
0455     return 0;
0456 }
0457
0458 static void __exit cec_devnode_exit(void)
0459 {
0460     debugfs_remove_recursive(top_cec_dir);
0461     bus_unregister(&cec_bus_type);
0462     unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
0463 }
0464
0465 subsys_initcall(cec_devnode_init);
0466 module_exit(cec_devnode_exit)
0467
0468 MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
0469 MODULE_DESCRIPTION("Device node registration for cec drivers");
0470 MODULE_LICENSE("GPL");