[mirror_ubuntu-bionic-kernel.git] / drivers / staging / media / cec / cec-core.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;
	devnode->dev.parent = devnode->parent;
	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.kobj.parent = &devnode->dev.kobj;
	devnode->cdev.owner = owner;

	ret = cdev_add(&devnode->cdev, devnode->dev.devt, 1);
	if (ret < 0) {
		pr_err("%s: cdev_add failed\n", __func__);
		goto clr_bit;
	}

	ret = device_add(&devnode->dev);
	if (ret)
		goto cdev_del;

	devnode->registered = true;
	return 0;

cdev_del:
	cdev_del(&devnode->cdev);
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);

	device_del(&devnode->dev);
	cdev_del(&devnode->cdev);
	put_device(&devnode->dev);
}

struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
					 void *priv, const char *name, u32 caps,
					 u8 available_las, struct device *parent)
{
	struct cec_adapter *adap;
	int res;

	if (WARN_ON(!parent))
		return ERR_PTR(-EINVAL);
	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);
	adap->owner = parent->driver->owner;
	adap->devnode.parent = parent;
	strlcpy(adap->name, name, sizeof(adap->name));
	adap->phys_addr = CEC_PHYS_ADDR_INVALID;
	adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
	adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
	adap->capabilities = caps;
	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);
	}

	if (!(caps & CEC_CAP_RC))
		return adap;

#if IS_REACHABLE(CONFIG_RC_CORE)
	/* Prepare the RC input device */
	adap->rc = rc_allocate_device();
	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_name, sizeof(adap->input_name),
		 "RC for %s", name);
	snprintf(adap->input_phys, sizeof(adap->input_phys),
		 "%s/input0", name);

	adap->rc->input_name = adap->input_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->dev.parent = parent;
	adap->rc->driver_type = RC_DRIVER_SCANCODE;
	adap->rc->driver_name = CEC_NAME;
	adap->rc->allowed_protocols = RC_BIT_CEC;
	adap->rc->priv = adap;
	adap->rc->map_name = RC_MAP_CEC;
	adap->rc->timeout = MS_TO_NS(100);
#else
	adap->capabilities &= ~CEC_CAP_RC;
#endif
	return adap;
}
EXPORT_SYMBOL_GPL(cec_allocate_adapter);

int cec_register_adapter(struct cec_adapter *adap)
{
	int res;

	if (IS_ERR_OR_NULL(adap))
		return 0;

#if IS_REACHABLE(CONFIG_RC_CORE)
	if (adap->capabilities & CEC_CAP_RC) {
		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) {
#if IS_REACHABLE(CONFIG_RC_CORE)
		/* 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_MEDIA_CEC_DEBUG
	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;

#if IS_REACHABLE(CONFIG_RC_CORE)
	/* Note: rc_unregister also calls rc_free */
	rc_unregister_device(adap->rc);
	adap->rc = NULL;
#endif
	debugfs_remove_recursive(adap->cec_dir);
	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 IS_REACHABLE(CONFIG_RC_CORE)
	if (adap->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;

	pr_info("Linux cec interface: v0.10\n");
	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_MEDIA_CEC_DEBUG
	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");
Commit	Line	Data
a56960e8 HV	1	/*
	2	* cec-core.c - HDMI Consumer Electronics Control framework - Core
	3	*
	4	* Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
	5	*
	6	* This program is free software; you may redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; version 2 of the License.
	9	*
	10	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	11	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	12	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	13	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	14	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	15	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	16	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	17	* SOFTWARE.
	18	*/
	19
	20	#include <linux/errno.h>
	21	#include <linux/init.h>
	22	#include <linux/module.h>
	23	#include <linux/kernel.h>
	24	#include <linux/kmod.h>
	25	#include <linux/slab.h>
	26	#include <linux/mm.h>
	27	#include <linux/string.h>
	28	#include <linux/types.h>
	29
	30	#include "cec-priv.h"
	31
	32	#define CEC_NUM_DEVICES 256
	33	#define CEC_NAME "cec"
	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 dev_t cec_dev_t;
	40
	41	/* Active devices */
	42	static DEFINE_MUTEX(cec_devnode_lock);
	43	static DECLARE_BITMAP(cec_devnode_nums, CEC_NUM_DEVICES);
	44
	45	static struct dentry *top_cec_dir;
	46
	47	/* dev to cec_devnode */
	48	#define to_cec_devnode(cd) container_of(cd, struct cec_devnode, dev)
	49
	50	int cec_get_device(struct cec_devnode *devnode)
	51	{
	52	/*
	53	* Check if the cec device is available. This needs to be done with
2ab25d35	54	* the devnode->lock held to prevent an open/unregister race:
a56960e8 HV	55	* without the lock, the device could be unregistered and freed between
	56	* the devnode->registered check and get_device() calls, leading to
	57	* a crash.
	58	*/
2ab25d35	59	mutex_lock(&devnode->lock);
a56960e8 HV	60	/*
	61	* return ENXIO if the cec device has been removed
	62	* already or if it is not registered anymore.
	63	*/
	64	if (!devnode->registered) {
2ab25d35	65	mutex_unlock(&devnode->lock);
a56960e8 HV	66	return -ENXIO;
	67	}
	68	/* and increase the device refcount */
	69	get_device(&devnode->dev);
2ab25d35	70	mutex_unlock(&devnode->lock);
a56960e8 HV	71	return 0;
	72	}
	73
	74	void cec_put_device(struct cec_devnode *devnode)
	75	{
a56960e8	76	put_device(&devnode->dev);
a56960e8 HV	77	}
	78
	79	/* Called when the last user of the cec device exits. */
	80	static void cec_devnode_release(struct device *cd)
	81	{
	82	struct cec_devnode *devnode = to_cec_devnode(cd);
	83
	84	mutex_lock(&cec_devnode_lock);
a56960e8 HV	85	/* Mark device node number as free */
a56960e8 HV	86	clear_bit(devnode->minor, cec_devnode_nums);
a56960e8	87	mutex_unlock(&cec_devnode_lock);
2ab25d35	88
a56960e8 HV	89	cec_delete_adapter(to_cec_adapter(devnode));
	90	}
	91
	92	static struct bus_type cec_bus_type = {
	93	.name = CEC_NAME,
	94	};
	95
	96	/*
	97	* Register a cec device node
	98	*
	99	* The registration code assigns minor numbers and registers the new device node
	100	* with the kernel. An error is returned if no free minor number can be found,
	101	* or if the registration of the device node fails.
	102	*
	103	* Zero is returned on success.
	104	*
	105	* Note that if the cec_devnode_register call fails, the release() callback of
	106	* the cec_devnode structure is not called, so the caller is responsible for
	107	* freeing any data.
	108	*/
	109	static int __must_check cec_devnode_register(struct cec_devnode *devnode,
	110	struct module *owner)
	111	{
	112	int minor;
	113	int ret;
	114
	115	/* Initialization */
	116	INIT_LIST_HEAD(&devnode->fhs);
62148f09	117	mutex_init(&devnode->lock);
a56960e8 HV	118
	119	/* Part 1: Find a free minor number */
	120	mutex_lock(&cec_devnode_lock);
	121	minor = find_next_zero_bit(cec_devnode_nums, CEC_NUM_DEVICES, 0);
	122	if (minor == CEC_NUM_DEVICES) {
	123	mutex_unlock(&cec_devnode_lock);
	124	pr_err("could not get a free minor\n");
	125	return -ENFILE;
	126	}
	127
	128	set_bit(minor, cec_devnode_nums);
	129	mutex_unlock(&cec_devnode_lock);
	130
	131	devnode->minor = minor;
	132	devnode->dev.bus = &cec_bus_type;
	133	devnode->dev.devt = MKDEV(MAJOR(cec_dev_t), minor);
	134	devnode->dev.release = cec_devnode_release;
	135	devnode->dev.parent = devnode->parent;
	136	dev_set_name(&devnode->dev, "cec%d", devnode->minor);
	137	device_initialize(&devnode->dev);
	138
	139	/* Part 2: Initialize and register the character device */
	140	cdev_init(&devnode->cdev, &cec_devnode_fops);
	141	devnode->cdev.kobj.parent = &devnode->dev.kobj;
	142	devnode->cdev.owner = owner;
	143
	144	ret = cdev_add(&devnode->cdev, devnode->dev.devt, 1);
	145	if (ret < 0) {
	146	pr_err("%s: cdev_add failed\n", __func__);
	147	goto clr_bit;
	148	}
	149
	150	ret = device_add(&devnode->dev);
	151	if (ret)
	152	goto cdev_del;
	153
	154	devnode->registered = true;
	155	return 0;
	156
	157	cdev_del:
	158	cdev_del(&devnode->cdev);
	159	clr_bit:
2ab25d35	160	mutex_lock(&cec_devnode_lock);
a56960e8	161	clear_bit(devnode->minor, cec_devnode_nums);
2ab25d35	162	mutex_unlock(&cec_devnode_lock);
a56960e8 HV	163	return ret;
	164	}
	165
	166	/*
	167	* Unregister a cec device node
	168	*
	169	* This unregisters the passed device. Future open calls will be met with
	170	* errors.
	171	*
	172	* This function can safely be called if the device node has never been
	173	* registered or has already been unregistered.
	174	*/
	175	static void cec_devnode_unregister(struct cec_devnode *devnode)
	176	{
	177	struct cec_fh *fh;
	178
2ab25d35 HV	179	mutex_lock(&devnode->lock);
2ab25d35 HV	180
a56960e8	181	/* Check if devnode was never registered or already unregistered */
2ab25d35 HV	182	if (!devnode->registered \|\| devnode->unregistered) {
2ab25d35 HV	183	mutex_unlock(&devnode->lock);
a56960e8	184	return;
2ab25d35	185	}
a56960e8	186
a56960e8 HV	187	list_for_each_entry(fh, &devnode->fhs, list)
a56960e8 HV	188	wake_up_interruptible(&fh->wait);
a56960e8 HV	189
	190	devnode->registered = false;
	191	devnode->unregistered = true;
2ab25d35 HV	192	mutex_unlock(&devnode->lock);
2ab25d35 HV	193
a56960e8 HV	194	device_del(&devnode->dev);
	195	cdev_del(&devnode->cdev);
	196	put_device(&devnode->dev);
	197	}
	198
	199	struct cec_adapter cec_allocate_adapter(const struct cec_adap_ops ops,
	200	void priv, const char name, u32 caps,
	201	u8 available_las, struct device *parent)
	202	{
	203	struct cec_adapter *adap;
	204	int res;
	205
	206	if (WARN_ON(!parent))
	207	return ERR_PTR(-EINVAL);
	208	if (WARN_ON(!caps))
	209	return ERR_PTR(-EINVAL);
	210	if (WARN_ON(!ops))
	211	return ERR_PTR(-EINVAL);
	212	if (WARN_ON(!available_las \|\| available_las > CEC_MAX_LOG_ADDRS))
	213	return ERR_PTR(-EINVAL);
	214	adap = kzalloc(sizeof(*adap), GFP_KERNEL);
	215	if (!adap)
	216	return ERR_PTR(-ENOMEM);
	217	adap->owner = parent->driver->owner;
	218	adap->devnode.parent = parent;
	219	strlcpy(adap->name, name, sizeof(adap->name));
	220	adap->phys_addr = CEC_PHYS_ADDR_INVALID;
	221	adap->log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0;
	222	adap->log_addrs.vendor_id = CEC_VENDOR_ID_NONE;
	223	adap->capabilities = caps;
	224	adap->available_log_addrs = available_las;
	225	adap->sequence = 0;
	226	adap->ops = ops;
	227	adap->priv = priv;
	228	memset(adap->phys_addrs, 0xff, sizeof(adap->phys_addrs));
	229	mutex_init(&adap->lock);
	230	INIT_LIST_HEAD(&adap->transmit_queue);
	231	INIT_LIST_HEAD(&adap->wait_queue);
	232	init_waitqueue_head(&adap->kthread_waitq);
	233
	234	adap->kthread = kthread_run(cec_thread_func, adap, "cec-%s", name);
	235	if (IS_ERR(adap->kthread)) {
	236	pr_err("cec-%s: kernel_thread() failed\n", name);
	237	res = PTR_ERR(adap->kthread);
	238	kfree(adap);
	239	return ERR_PTR(res);
	240	}
	241
	242	if (!(caps & CEC_CAP_RC))
	243	return adap;
	244
5bb2399a	245	#if IS_REACHABLE(CONFIG_RC_CORE)
a56960e8 HV	246	/* Prepare the RC input device */
	247	adap->rc = rc_allocate_device();
	248	if (!adap->rc) {
	249	pr_err("cec-%s: failed to allocate memory for rc_dev\n",
	250	name);
	251	kthread_stop(adap->kthread);
	252	kfree(adap);
	253	return ERR_PTR(-ENOMEM);
	254	}
	255
	256	snprintf(adap->input_name, sizeof(adap->input_name),
	257	"RC for %s", name);
	258	snprintf(adap->input_phys, sizeof(adap->input_phys),
	259	"%s/input0", name);
	260
	261	adap->rc->input_name = adap->input_name;
	262	adap->rc->input_phys = adap->input_phys;
	263	adap->rc->input_id.bustype = BUS_CEC;
	264	adap->rc->input_id.vendor = 0;
	265	adap->rc->input_id.product = 0;
	266	adap->rc->input_id.version = 1;
	267	adap->rc->dev.parent = parent;
	268	adap->rc->driver_type = RC_DRIVER_SCANCODE;
	269	adap->rc->driver_name = CEC_NAME;
	270	adap->rc->allowed_protocols = RC_BIT_CEC;
	271	adap->rc->priv = adap;
	272	adap->rc->map_name = RC_MAP_CEC;
	273	adap->rc->timeout = MS_TO_NS(100);
	274	#else
	275	adap->capabilities &= ~CEC_CAP_RC;
	276	#endif
	277	return adap;
	278	}
	279	EXPORT_SYMBOL_GPL(cec_allocate_adapter);
	280
	281	int cec_register_adapter(struct cec_adapter *adap)
	282	{
	283	int res;
	284
	285	if (IS_ERR_OR_NULL(adap))
	286	return 0;
	287
5bb2399a	288	#if IS_REACHABLE(CONFIG_RC_CORE)
a56960e8 HV	289	if (adap->capabilities & CEC_CAP_RC) {
	290	res = rc_register_device(adap->rc);
	291
	292	if (res) {
	293	pr_err("cec-%s: failed to prepare input device\n",
	294	adap->name);
	295	rc_free_device(adap->rc);
	296	adap->rc = NULL;
	297	return res;
	298	}
	299	}
	300	#endif
	301
	302	res = cec_devnode_register(&adap->devnode, adap->owner);
	303	if (res) {
5bb2399a	304	#if IS_REACHABLE(CONFIG_RC_CORE)
a56960e8 HV	305	/* Note: rc_unregister also calls rc_free */
	306	rc_unregister_device(adap->rc);
	307	adap->rc = NULL;
	308	#endif
	309	return res;
	310	}
	311
	312	dev_set_drvdata(&adap->devnode.dev, adap);
	313	#ifdef CONFIG_MEDIA_CEC_DEBUG
	314	if (!top_cec_dir)
	315	return 0;
	316
	317	adap->cec_dir = debugfs_create_dir(dev_name(&adap->devnode.dev), top_cec_dir);
	318	if (IS_ERR_OR_NULL(adap->cec_dir)) {
	319	pr_warn("cec-%s: Failed to create debugfs dir\n", adap->name);
	320	return 0;
	321	}
	322	adap->status_file = debugfs_create_devm_seqfile(&adap->devnode.dev,
	323	"status", adap->cec_dir, cec_adap_status);
	324	if (IS_ERR_OR_NULL(adap->status_file)) {
	325	pr_warn("cec-%s: Failed to create status file\n", adap->name);
	326	debugfs_remove_recursive(adap->cec_dir);
	327	adap->cec_dir = NULL;
	328	}
	329	#endif
	330	return 0;
	331	}
	332	EXPORT_SYMBOL_GPL(cec_register_adapter);
	333
	334	void cec_unregister_adapter(struct cec_adapter *adap)
	335	{
	336	if (IS_ERR_OR_NULL(adap))
	337	return;
	338
5bb2399a	339	#if IS_REACHABLE(CONFIG_RC_CORE)
a56960e8 HV	340	/* Note: rc_unregister also calls rc_free */
	341	rc_unregister_device(adap->rc);
	342	adap->rc = NULL;
	343	#endif
	344	debugfs_remove_recursive(adap->cec_dir);
	345	cec_devnode_unregister(&adap->devnode);
	346	}
	347	EXPORT_SYMBOL_GPL(cec_unregister_adapter);
	348
	349	void cec_delete_adapter(struct cec_adapter *adap)
	350	{
	351	if (IS_ERR_OR_NULL(adap))
	352	return;
	353	mutex_lock(&adap->lock);
	354	__cec_s_phys_addr(adap, CEC_PHYS_ADDR_INVALID, false);
	355	mutex_unlock(&adap->lock);
	356	kthread_stop(adap->kthread);
	357	if (adap->kthread_config)
	358	kthread_stop(adap->kthread_config);
5bb2399a	359	#if IS_REACHABLE(CONFIG_RC_CORE)
a56960e8 HV	360	if (adap->rc)
	361	rc_free_device(adap->rc);
	362	#endif
	363	kfree(adap);
	364	}
	365	EXPORT_SYMBOL_GPL(cec_delete_adapter);
	366
	367	/*
	368	* Initialise cec for linux
	369	*/
	370	static int __init cec_devnode_init(void)
	371	{
	372	int ret;
	373
	374	pr_info("Linux cec interface: v0.10\n");
	375	ret = alloc_chrdev_region(&cec_dev_t, 0, CEC_NUM_DEVICES,
	376	CEC_NAME);
	377	if (ret < 0) {
	378	pr_warn("cec: unable to allocate major\n");
	379	return ret;
	380	}
	381
	382	#ifdef CONFIG_MEDIA_CEC_DEBUG
	383	top_cec_dir = debugfs_create_dir("cec", NULL);
	384	if (IS_ERR_OR_NULL(top_cec_dir)) {
	385	pr_warn("cec: Failed to create debugfs cec dir\n");
	386	top_cec_dir = NULL;
	387	}
	388	#endif
	389
	390	ret = bus_register(&cec_bus_type);
	391	if (ret < 0) {
	392	unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
	393	pr_warn("cec: bus_register failed\n");
	394	return -EIO;
	395	}
	396
	397	return 0;
	398	}
	399
	400	static void __exit cec_devnode_exit(void)
	401	{
	402	debugfs_remove_recursive(top_cec_dir);
	403	bus_unregister(&cec_bus_type);
	404	unregister_chrdev_region(cec_dev_t, CEC_NUM_DEVICES);
	405	}
	406
	407	subsys_initcall(cec_devnode_init);
	408	module_exit(cec_devnode_exit)
	409
	410	MODULE_AUTHOR("Hans Verkuil <hans.verkuil@cisco.com>");
	411	MODULE_DESCRIPTION("Device node registration for cec drivers");
	412	MODULE_LICENSE("GPL");