443 lines
12 KiB
C
443 lines
12 KiB
C
/*
|
|
* cec-core.c - HDMI Consumer Electronics Control framework - Core
|
|
*
|
|
* Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
|
|
*
|
|
* This program is free software; you may redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#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"
|
|
|
|
int cec_debug;
|
|
module_param_named(debug, cec_debug, int, 0644);
|
|
MODULE_PARM_DESC(debug, "debug level (0-2)");
|
|
|
|
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;
|
|
|
|
/* Initialization */
|
|
INIT_LIST_HEAD(&devnode->fhs);
|
|
mutex_init(&devnode->lock);
|
|
|
|
/* Part 1: Find a free minor number */
|
|
mutex_lock(&cec_devnode_lock);
|
|
minor = find_next_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES, 0);
|
|
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;
|
|
|
|
ret = cdev_device_add(&devnode->cdev, &devnode->dev);
|
|
if (ret) {
|
|
pr_err("%s: cdev_device_add failed\n", __func__);
|
|
goto clr_bit;
|
|
}
|
|
|
|
devnode->registered = true;
|
|
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_devnode *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;
|
|
}
|
|
|
|
list_for_each_entry(fh, &devnode->fhs, list)
|
|
wake_up_interruptible(&fh->wait);
|
|
|
|
devnode->registered = false;
|
|
devnode->unregistered = true;
|
|
mutex_unlock(&devnode->lock);
|
|
|
|
cdev_device_del(&devnode->cdev, &devnode->dev);
|
|
put_device(&devnode->dev);
|
|
}
|
|
|
|
#ifdef CONFIG_CEC_NOTIFIER
|
|
static void cec_cec_notify(struct cec_adapter *adap, u16 pa)
|
|
{
|
|
cec_s_phys_addr(adap, pa, false);
|
|
}
|
|
|
|
void cec_register_cec_notifier(struct cec_adapter *adap,
|
|
struct cec_notifier *notifier)
|
|
{
|
|
if (WARN_ON(!adap->devnode.registered))
|
|
return;
|
|
|
|
adap->notifier = notifier;
|
|
cec_notifier_register(adap->notifier, adap, cec_cec_notify);
|
|
}
|
|
EXPORT_SYMBOL_GPL(cec_register_cec_notifier);
|
|
#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);
|
|
strlcpy(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;
|
|
adap->needs_hpd = caps & CEC_CAP_NEEDS_HPD;
|
|
adap->available_log_addrs = available_las;
|
|
adap->sequence = 0;
|
|
adap->ops = ops;
|
|
adap->priv = priv;
|
|
memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs));
|
|
mutex_init(&adap->lock);
|
|
INIT_LIST_HEAD(&adap->transmit_queue);
|
|
INIT_LIST_HEAD(&adap->wait_queue);
|
|
init_waitqueue_head(&adap->kthread_waitq);
|
|
|
|
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->device_name, sizeof(adap->device_name),
|
|
"RC for %s", name);
|
|
snprintf(adap->input_phys, sizeof(adap->input_phys),
|
|
"%s/input0", name);
|
|
|
|
adap->rc->device_name = adap->device_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->enabled_protocols = RC_PROTO_BIT_CEC;
|
|
adap->rc->priv = adap;
|
|
adap->rc->map_name = RC_MAP_CEC;
|
|
adap->rc->timeout = MS_TO_NS(100);
|
|
adap->rc_last_scancode = -1;
|
|
#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;
|
|
|
|
#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;
|
|
}
|
|
/*
|
|
* The REP_DELAY for CEC is really the time between the initial
|
|
* 'User Control Pressed' message and the second. The first
|
|
* keypress is always seen as non-repeating, the second
|
|
* (provided it has the same UI Command) will start the 'Press
|
|
* and Hold' (aka repeat) behavior. By setting REP_DELAY to the
|
|
* same value as REP_PERIOD the expected CEC behavior is
|
|
* reproduced.
|
|
*/
|
|
adap->rc->input_dev->rep[REP_DELAY] =
|
|
adap->rc->input_dev->rep[REP_PERIOD];
|
|
}
|
|
#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);
|
|
if (IS_ERR_OR_NULL(adap->cec_dir)) {
|
|
pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name);
|
|
return 0;
|
|
}
|
|
adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev,
|
|
"status", adap->cec_dir, cec_adap_status);
|
|
if (IS_ERR_OR_NULL(adap->status_file)) {
|
|
pr_warn("cec-%s: Failed to create status file\n", adap->name);
|
|
debugfs_remove_recursive(adap->cec_dir);
|
|
adap->cec_dir = NULL;
|
|
}
|
|
#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
|
|
if (adap->notifier)
|
|
cec_notifier_unregister(adap->notifier);
|
|
#endif
|
|
cec_devnode_unregister(&adap->devnode);
|
|
}
|
|
EXPORT_SYMBOL_GPL(cec_unregister_adapter);
|
|
|
|
void cec_delete_adapter(struct cec_adapter *adap)
|
|
{
|
|
if (IS_ERR_OR_NULL(adap))
|
|
return;
|
|
mutex_lock(&adap->lock);
|
|
__cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
|
|
mutex_unlock(&adap->lock);
|
|
kthread_stop(adap->kthread);
|
|
if (adap->kthread_config)
|
|
kthread_stop(adap->kthread_config);
|
|
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");
|