| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Hans Verkuil | 2003 | 98.28% | 26 | 70.27% |
| Lee Jones | 9 | 0.44% | 1 | 2.70% |
| Mauro Carvalho Chehab | 8 | 0.39% | 2 | 5.41% |
| Sean Young | 7 | 0.34% | 5 | 13.51% |
| Logan Gunthorpe | 7 | 0.34% | 1 | 2.70% |
| Andi Shyti | 3 | 0.15% | 1 | 2.70% |
| Yury Norov | 1 | 0.05% | 1 | 2.70% |
| Total | 2038 | 37 |
// SPDX-License-Identifier: GPL-2.0-only /* * cec-core.c - HDMI Consumer Electronics Control framework - Core * * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved. */ #include <linux/errno.h> #include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/kmod.h> #include <linux/slab.h> #include <linux/mm.h> #include <linux/string.h> #include <linux/types.h> #include "cec-priv.h" #define CEC_NUM_DEVICES 256 #define CEC_NAME "cec" /* * 400 ms is the time it takes for one 16 byte message to be * transferred and 5 is the maximum number of retries. Add * another 100 ms as a margin. So if the transmit doesn't * finish before that time something is really wrong and we * have to time out. * * This is a sign that something it really wrong and a warning * will be issued. */ #define CEC_XFER_TIMEOUT_MS (5 * 400 + 100) int cec_debug; module_param_named(debug, cec_debug, int, 0644); MODULE_PARM_DESC(debug, "debug level (0-2)"); static bool debug_phys_addr; module_param(debug_phys_addr, bool, 0644); MODULE_PARM_DESC(debug_phys_addr, "add CEC_CAP_PHYS_ADDR if set"); static dev_t cec_dev_t; /* Active devices */ static DEFINE_MUTEX(cec_devnode_lock); static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES); static struct dentry *top_cec_dir; /* dev to cec_devnode */ #define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev) int cec_get_device(struct cec_devnode *devnode) { /* * Check if the cec device is available. This needs to be done with * the devnode->lock held to prevent an open/unregister race: * without the lock, the device could be unregistered and freed between * the devnode->registered check and get_device() calls, leading to * a crash. */ mutex_lock(&devnode->lock); /* * return ENXIO if the cec device has been removed * already or if it is not registered anymore. */ if (!devnode->registered) { mutex_unlock(&devnode->lock); return -ENXIO; } /* and increase the device refcount */ get_device(&devnode->dev); mutex_unlock(&devnode->lock); return 0; } void cec_put_device(struct cec_devnode *devnode) { put_device(&devnode->dev); } /* Called when the last user of the cec device exits. */ static void cec_devnode_release(struct device *cd) { struct cec_devnode *devnode = to_cec_devnode(cd); mutex_lock(&cec_devnode_lock); /* Mark device node number as free */ clear_bit(devnode->minor, cec_devnode_nums); mutex_unlock(&cec_devnode_lock); cec_delete_adapter(to_cec_adapter(devnode)); } static struct bus_type cec_bus_type = { .name = CEC_NAME, }; /* * Register a cec device node * * The registration code assigns minor numbers and registers the new device node * with the kernel. An error is returned if no free minor number can be found, * or if the registration of the device node fails. * * Zero is returned on success. * * Note that if the cec_devnode_register call fails, the release() callback of * the cec_devnode structure is *not* called, so the caller is responsible for * freeing any data. */ static int __must_check cec_devnode_register(struct cec_devnode *devnode, struct module *owner) { int minor; int ret; /* Part 1: Find a free minor number */ mutex_lock(&cec_devnode_lock); minor = find_first_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES); if (minor == CEC_NUM_DEVICES) { mutex_unlock(&cec_devnode_lock); pr_err("could not get a free minor\n"); return -ENFILE; } set_bit(minor, cec_devnode_nums); mutex_unlock(&cec_devnode_lock); devnode->minor = minor; devnode->dev.bus = &cec_bus_type; devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor); devnode->dev.release = cec_devnode_release; dev_set_name(&devnode->dev, "cec%d", devnode->minor); device_initialize(&devnode->dev); /* Part 2: Initialize and register the character device */ cdev_init(&devnode->cdev, &cec_devnode_fops); devnode->cdev.owner = owner; kobject_set_name(&devnode->cdev.kobj, "cec%d", devnode->minor); devnode->registered = true; ret = cdev_device_add(&devnode->cdev, &devnode->dev); if (ret) { devnode->registered = false; pr_err("%s: cdev_device_add failed\n", __func__); goto clr_bit; } return 0; clr_bit: mutex_lock(&cec_devnode_lock); clear_bit(devnode->minor, cec_devnode_nums); mutex_unlock(&cec_devnode_lock); return ret; } /* * Unregister a cec device node * * This unregisters the passed device. Future open calls will be met with * errors. * * This function can safely be called if the device node has never been * registered or has already been unregistered. */ static void cec_devnode_unregister(struct cec_adapter *adap) { struct cec_devnode *devnode = &adap->devnode; struct cec_fh *fh; mutex_lock(&devnode->lock); /* Check if devnode was never registered or already unregistered */ if (!devnode->registered || devnode->unregistered) { mutex_unlock(&devnode->lock); return; } devnode->registered = false; devnode->unregistered = true; mutex_lock(&devnode->lock_fhs); list_for_each_entry(fh, &devnode->fhs, list) wake_up_interruptible(&fh->wait); mutex_unlock(&devnode->lock_fhs); mutex_unlock(&devnode->lock); mutex_lock(&adap->lock); __cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false); __cec_s_log_addrs(adap, NULL, false); mutex_unlock(&adap->lock); cdev_device_del(&devnode->cdev, &devnode->dev); put_device(&devnode->dev); } #ifdef CONFIG_DEBUG_FS static ssize_t cec_error_inj_write(struct file *file, const char __user *ubuf, size_t count, loff_t *ppos) { struct seq_file *sf = file->private_data; struct cec_adapter *adap = sf->private; char *buf; char *line; char *p; buf = memdup_user_nul(ubuf, min_t(size_t, PAGE_SIZE, count)); if (IS_ERR(buf)) return PTR_ERR(buf); p = buf; while (p && *p) { p = skip_spaces(p); line = strsep(&p, "\n"); if (!*line || *line == '#') continue; if (!call_op(adap, error_inj_parse_line, line)) { kfree(buf); return -EINVAL; } } kfree(buf); return count; } static int cec_error_inj_show(struct seq_file *sf, void *unused) { struct cec_adapter *adap = sf->private; return call_op(adap, error_inj_show, sf); } static int cec_error_inj_open(struct inode *inode, struct file *file) { return single_open(file, cec_error_inj_show, inode->i_private); } static const struct file_operations cec_error_inj_fops = { .open = cec_error_inj_open, .write = cec_error_inj_write, .read = seq_read, .llseek = seq_lseek, .release = single_release, }; #endif struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops, void *priv, const char *name, u32 caps, u8 available_las) { struct cec_adapter *adap; int res; #ifndef CONFIG_MEDIA_CEC_RC caps &= ~CEC_CAP_RC; #endif if (WARN_ON(!caps)) return ERR_PTR(-EINVAL); if (WARN_ON(!ops)) return ERR_PTR(-EINVAL); if (WARN_ON(!available_las || available_las > CEC_MAX_LOG_ADDRS)) return ERR_PTR(-EINVAL); adap = kzalloc(sizeof(*adap), GFP_KERNEL); if (!adap) return ERR_PTR(-ENOMEM); strscpy(adap->name, name, sizeof(adap->name)); adap->phys_addr = CEC_PHYS_ADDR_INVALID; adap->cec_pin_is_high = true; adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0; adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE; adap->capabilities = caps; if (debug_phys_addr) adap->capabilities |= CEC_CAP_PHYS_ADDR; adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD; adap->available_log_addrs = available_las; adap->sequence = 0; adap->ops = ops; adap->priv = priv; mutex_init(&adap->lock); INIT_LIST_HEAD(&adap->transmit_queue); INIT_LIST_HEAD(&adap->wait_queue); init_waitqueue_head(&adap->kthread_waitq); /* adap->devnode initialization */ INIT_LIST_HEAD(&adap->devnode.fhs); mutex_init(&adap->devnode.lock_fhs); mutex_init(&adap->devnode.lock); adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name); if (IS_ERR(adap->kthread)) { pr_err("cec-%s: kernel_thread() failed\n", name); res = PTR_ERR(adap->kthread); kfree(adap); return ERR_PTR(res); } #ifdef CONFIG_MEDIA_CEC_RC if (!(caps & CEC_CAP_RC)) return adap; /* Prepare the RC input device */ adap->rc = rc_allocate_device(RC_DRIVER_SCANCODE); if (!adap->rc) { pr_err("cec-%s: failed to allocate memory for rc_dev\n", name); kthread_stop(adap->kthread); kfree(adap); return ERR_PTR(-ENOMEM); } snprintf(adap->input_phys, sizeof(adap->input_phys), "%s/input0", adap->name); adap->rc->device_name = adap->name; adap->rc->input_phys = adap->input_phys; adap->rc->input_id.bustype = BUS_CEC; adap->rc->input_id.vendor = 0; adap->rc->input_id.product = 0; adap->rc->input_id.version = 1; adap->rc->driver_name = CEC_NAME; adap->rc->allowed_protocols = RC_PROTO_BIT_CEC; adap->rc->priv = adap; adap->rc->map_name = RC_MAP_CEC; adap->rc->timeout = MS_TO_US(550); #endif return adap; } EXPORT_SYMBOL_GPL(cec_allocate_adapter); int cec_register_adapter(struct cec_adapter *adap, struct device *parent) { int res; if (IS_ERR_OR_NULL(adap)) return 0; if (WARN_ON(!parent)) return -EINVAL; adap->owner = parent->driver->owner; adap->devnode.dev.parent = parent; if (!adap->xfer_timeout_ms) adap->xfer_timeout_ms = CEC_XFER_TIMEOUT_MS; #ifdef CONFIG_MEDIA_CEC_RC if (adap->capabilities & CEC_CAP_RC) { adap->rc->dev.parent = parent; res = rc_register_device(adap->rc); if (res) { pr_err("cec-%s: failed to prepare input device\n", adap->name); rc_free_device(adap->rc); adap->rc = NULL; return res; } } #endif res = cec_devnode_register(&adap->devnode, adap->owner); if (res) { #ifdef CONFIG_MEDIA_CEC_RC /* Note: rc_unregister also calls rc_free */ rc_unregister_device(adap->rc); adap->rc = NULL; #endif return res; } dev_set_drvdata(&adap->devnode.dev, adap); #ifdef CONFIG_DEBUG_FS if (!top_cec_dir) return 0; adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir); debugfs_create_devm_seqfile(&adap->devnode.dev, "status", adap->cec_dir, cec_adap_status); if (!adap->ops->error_inj_show || !adap->ops->error_inj_parse_line) return 0; debugfs_create_file("error-inj", 0644, adap->cec_dir, adap, &cec_error_inj_fops); #endif return 0; } EXPORT_SYMBOL_GPL(cec_register_adapter); void cec_unregister_adapter(struct cec_adapter *adap) { if (IS_ERR_OR_NULL(adap)) return; #ifdef CONFIG_MEDIA_CEC_RC /* Note: rc_unregister also calls rc_free */ rc_unregister_device(adap->rc); adap->rc = NULL; #endif debugfs_remove_recursive(adap->cec_dir); #ifdef CONFIG_CEC_NOTIFIER cec_notifier_cec_adap_unregister(adap->notifier, adap); #endif cec_devnode_unregister(adap); } EXPORT_SYMBOL_GPL(cec_unregister_adapter); void cec_delete_adapter(struct cec_adapter *adap) { if (IS_ERR_OR_NULL(adap)) return; if (adap->kthread_config) kthread_stop(adap->kthread_config); kthread_stop(adap->kthread); if (adap->ops->adap_free) adap->ops->adap_free(adap); #ifdef CONFIG_MEDIA_CEC_RC rc_free_device(adap->rc); #endif kfree(adap); } EXPORT_SYMBOL_GPL(cec_delete_adapter); /* * Initialise cec for linux */ static int __init cec_devnode_init(void) { int ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES, CEC_NAME); if (ret < 0) { pr_warn("cec: unable to allocate major\n"); return ret; } #ifdef CONFIG_DEBUG_FS top_cec_dir = debugfs_create_dir("cec", NULL); if (IS_ERR_OR_NULL(top_cec_dir)) { pr_warn("cec: Failed to create debugfs cec dir\n"); top_cec_dir = NULL; } #endif ret = bus_register(&cec_bus_type); if (ret < 0) { unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); pr_warn("cec: bus_register failed\n"); return -EIO; } return 0; } static void __exit cec_devnode_exit(void) { debugfs_remove_recursive(top_cec_dir); bus_unregister(&cec_bus_type); unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES); } subsys_initcall(cec_devnode_init); module_exit(cec_devnode_exit) MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>"); MODULE_DESCRIPTION("Device node registration for cec drivers"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1