[linux-2.6-block.git] / drivers / media / cec / cec-api.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * cec-api.c - HDMI Consumer Electronics Control framework - API
 *
 * 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/ktime.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/version.h>

#include <media/cec-pin.h>
#include "cec-priv.h"
#include "cec-pin-priv.h"

static inline struct cec_devnode *cec_devnode_data(struct file *filp)
{
	struct cec_fh *fh = filp->private_data;

	return &fh->adap->devnode;
}

/* CEC file operations */

static __poll_t cec_poll(struct file *filp,
			     struct poll_table_struct *poll)
{
	struct cec_fh *fh = filp->private_data;
	struct cec_adapter *adap = fh->adap;
	__poll_t res = 0;

	if (!cec_is_registered(adap))
		return EPOLLERR | EPOLLHUP;
	mutex_lock(&adap->lock);
	if (adap->is_configured &&
	    adap->transmit_queue_sz < CEC_MAX_MSG_TX_QUEUE_SZ)
		res |= EPOLLOUT | EPOLLWRNORM;
	if (fh->queued_msgs)
		res |= EPOLLIN | EPOLLRDNORM;
	if (fh->total_queued_events)
		res |= EPOLLPRI;
	poll_wait(filp, &fh->wait, poll);
	mutex_unlock(&adap->lock);
	return res;
}

static bool cec_is_busy(const struct cec_adapter *adap,
			const struct cec_fh *fh)
{
	bool valid_initiator = adap->cec_initiator && adap->cec_initiator == fh;
	bool valid_follower = adap->cec_follower && adap->cec_follower == fh;

	/*
	 * Exclusive initiators and followers can always access the CEC adapter
	 */
	if (valid_initiator || valid_follower)
		return false;
	/*
	 * All others can only access the CEC adapter if there is no
	 * exclusive initiator and they are in INITIATOR mode.
	 */
	return adap->cec_initiator ||
	       fh->mode_initiator == CEC_MODE_NO_INITIATOR;
}

static long cec_adap_g_caps(struct cec_adapter *adap,
			    struct cec_caps __user *parg)
{
	struct cec_caps caps = {};

	strlcpy(caps.driver, adap->devnode.dev.parent->driver->name,
		sizeof(caps.driver));
	strlcpy(caps.name, adap->name, sizeof(caps.name));
	caps.available_log_addrs = adap->available_log_addrs;
	caps.capabilities = adap->capabilities;
	caps.version = LINUX_VERSION_CODE;
	if (copy_to_user(parg, &caps, sizeof(caps)))
		return -EFAULT;
	return 0;
}

static long cec_adap_g_phys_addr(struct cec_adapter *adap,
				 __u16 __user *parg)
{
	u16 phys_addr;

	mutex_lock(&adap->lock);
	phys_addr = adap->phys_addr;
	mutex_unlock(&adap->lock);
	if (copy_to_user(parg, &phys_addr, sizeof(phys_addr)))
		return -EFAULT;
	return 0;
}

static long cec_adap_s_phys_addr(struct cec_adapter *adap, struct cec_fh *fh,
				 bool block, __u16 __user *parg)
{
	u16 phys_addr;
	long err;

	if (!(adap->capabilities & CEC_CAP_PHYS_ADDR))
		return -ENOTTY;
	if (copy_from_user(&phys_addr, parg, sizeof(phys_addr)))
		return -EFAULT;

	err = cec_phys_addr_validate(phys_addr, NULL, NULL);
	if (err)
		return err;
	mutex_lock(&adap->lock);
	if (cec_is_busy(adap, fh))
		err = -EBUSY;
	else
		__cec_s_phys_addr(adap, phys_addr, block);
	mutex_unlock(&adap->lock);
	return err;
}

static long cec_adap_g_log_addrs(struct cec_adapter *adap,
				 struct cec_log_addrs __user *parg)
{
	struct cec_log_addrs log_addrs;

	mutex_lock(&adap->lock);
	log_addrs = adap->log_addrs;
	if (!adap->is_configured)
		memset(log_addrs.log_addr, CEC_LOG_ADDR_INVALID,
		       sizeof(log_addrs.log_addr));
	mutex_unlock(&adap->lock);

	if (copy_to_user(parg, &log_addrs, sizeof(log_addrs)))
		return -EFAULT;
	return 0;
}

static long cec_adap_s_log_addrs(struct cec_adapter *adap, struct cec_fh *fh,
				 bool block, struct cec_log_addrs __user *parg)
{
	struct cec_log_addrs log_addrs;
	long err = -EBUSY;

	if (!(adap->capabilities & CEC_CAP_LOG_ADDRS))
		return -ENOTTY;
	if (copy_from_user(&log_addrs, parg, sizeof(log_addrs)))
		return -EFAULT;
	log_addrs.flags &= CEC_LOG_ADDRS_FL_ALLOW_UNREG_FALLBACK |
			   CEC_LOG_ADDRS_FL_ALLOW_RC_PASSTHRU |
			   CEC_LOG_ADDRS_FL_CDC_ONLY;
	mutex_lock(&adap->lock);
	if (!adap->is_configuring &&
	    (!log_addrs.num_log_addrs || !adap->is_configured) &&
	    !cec_is_busy(adap, fh)) {
		err = __cec_s_log_addrs(adap, &log_addrs, block);
		if (!err)
			log_addrs = adap->log_addrs;
	}
	mutex_unlock(&adap->lock);
	if (err)
		return err;
	if (copy_to_user(parg, &log_addrs, sizeof(log_addrs)))
		return -EFAULT;
	return 0;
}

static long cec_transmit(struct cec_adapter *adap, struct cec_fh *fh,
			 bool block, struct cec_msg __user *parg)
{
	struct cec_msg msg = {};
	long err = 0;

	if (!(adap->capabilities & CEC_CAP_TRANSMIT))
		return -ENOTTY;
	if (copy_from_user(&msg, parg, sizeof(msg)))
		return -EFAULT;

	/* A CDC-Only device can only send CDC messages */
	if ((adap->log_addrs.flags & CEC_LOG_ADDRS_FL_CDC_ONLY) &&
	    (msg.len == 1 || msg.msg[1] != CEC_MSG_CDC_MESSAGE))
		return -EINVAL;

	mutex_lock(&adap->lock);
	if (adap->log_addrs.num_log_addrs == 0)
		err = -EPERM;
	else if (adap->is_configuring)
		err = -ENONET;
	else if (!adap->is_configured &&
		 (adap->needs_hpd || msg.msg[0] != 0xf0))
		err = -ENONET;
	else if (cec_is_busy(adap, fh))
		err = -EBUSY;
	else
		err = cec_transmit_msg_fh(adap, &msg, fh, block);
	mutex_unlock(&adap->lock);
	if (err)
		return err;
	if (copy_to_user(parg, &msg, sizeof(msg)))
		return -EFAULT;
	return 0;
}

/* Called by CEC_RECEIVE: wait for a message to arrive */
static int cec_receive_msg(struct cec_fh *fh, struct cec_msg *msg, bool block)
{
	u32 timeout = msg->timeout;
	int res;

	do {
		mutex_lock(&fh->lock);
		/* Are there received messages queued up? */
		if (fh->queued_msgs) {
			/* Yes, return the first one */
			struct cec_msg_entry *entry =
				list_first_entry(&fh->msgs,
						 struct cec_msg_entry, list);

			list_del(&entry->list);
			*msg = entry->msg;
			kfree(entry);
			fh->queued_msgs--;
			mutex_unlock(&fh->lock);
			/* restore original timeout value */
			msg->timeout = timeout;
			return 0;
		}

		/* No, return EAGAIN in non-blocking mode or wait */
		mutex_unlock(&fh->lock);

		/* Return when in non-blocking mode */
		if (!block)
			return -EAGAIN;

		if (msg->timeout) {
			/* The user specified a timeout */
			res = wait_event_interruptible_timeout(fh->wait,
							       fh->queued_msgs,
				msecs_to_jiffies(msg->timeout));
			if (res == 0)
				res = -ETIMEDOUT;
			else if (res > 0)
				res = 0;
		} else {
			/* Wait indefinitely */
			res = wait_event_interruptible(fh->wait,
						       fh->queued_msgs);
		}
		/* Exit on error, otherwise loop to get the new message */
	} while (!res);
	return res;
}

static long cec_receive(struct cec_adapter *adap, struct cec_fh *fh,
			bool block, struct cec_msg __user *parg)
{
	struct cec_msg msg = {};
	long err;

	if (copy_from_user(&msg, parg, sizeof(msg)))
		return -EFAULT;

	err = cec_receive_msg(fh, &msg, block);
	if (err)
		return err;
	msg.flags = 0;
	if (copy_to_user(parg, &msg, sizeof(msg)))
		return -EFAULT;
	return 0;
}

static long cec_dqevent(struct cec_adapter *adap, struct cec_fh *fh,
			bool block, struct cec_event __user *parg)
{
	struct cec_event_entry *ev = NULL;
	u64 ts = ~0ULL;
	unsigned int i;
	unsigned int ev_idx;
	long err = 0;

	mutex_lock(&fh->lock);
	while (!fh->total_queued_events && block) {
		mutex_unlock(&fh->lock);
		err = wait_event_interruptible(fh->wait,
					       fh->total_queued_events);
		if (err)
			return err;
		mutex_lock(&fh->lock);
	}

	/* Find the oldest event */
	for (i = 0; i < CEC_NUM_EVENTS; i++) {
		struct cec_event_entry *entry =
			list_first_entry_or_null(&fh->events[i],
						 struct cec_event_entry, list);

		if (entry && entry->ev.ts <= ts) {
			ev = entry;
			ev_idx = i;
			ts = ev->ev.ts;
		}
	}

	if (!ev) {
		err = -EAGAIN;
		goto unlock;
	}
	list_del(&ev->list);

	if (copy_to_user(parg, &ev->ev, sizeof(ev->ev)))
		err = -EFAULT;
	if (ev_idx >= CEC_NUM_CORE_EVENTS)
		kfree(ev);
	fh->queued_events[ev_idx]--;
	fh->total_queued_events--;

unlock:
	mutex_unlock(&fh->lock);
	return err;
}

static long cec_g_mode(struct cec_adapter *adap, struct cec_fh *fh,
		       u32 __user *parg)
{
	u32 mode = fh->mode_initiator | fh->mode_follower;

	if (copy_to_user(parg, &mode, sizeof(mode)))
		return -EFAULT;
	return 0;
}

static long cec_s_mode(struct cec_adapter *adap, struct cec_fh *fh,
		       u32 __user *parg)
{
	u32 mode;
	u8 mode_initiator;
	u8 mode_follower;
	bool send_pin_event = false;
	long err = 0;

	if (copy_from_user(&mode, parg, sizeof(mode)))
		return -EFAULT;
	if (mode & ~(CEC_MODE_INITIATOR_MSK | CEC_MODE_FOLLOWER_MSK)) {
		dprintk(1, "%s: invalid mode bits set\n", __func__);
		return -EINVAL;
	}

	mode_initiator = mode & CEC_MODE_INITIATOR_MSK;
	mode_follower = mode & CEC_MODE_FOLLOWER_MSK;

	if (mode_initiator > CEC_MODE_EXCL_INITIATOR ||
	    mode_follower > CEC_MODE_MONITOR_ALL) {
		dprintk(1, "%s: unknown mode\n", __func__);
		return -EINVAL;
	}

	if (mode_follower == CEC_MODE_MONITOR_ALL &&
	    !(adap->capabilities & CEC_CAP_MONITOR_ALL)) {
		dprintk(1, "%s: MONITOR_ALL not supported\n", __func__);
		return -EINVAL;
	}

	if (mode_follower == CEC_MODE_MONITOR_PIN &&
	    !(adap->capabilities & CEC_CAP_MONITOR_PIN)) {
		dprintk(1, "%s: MONITOR_PIN not supported\n", __func__);
		return -EINVAL;
	}

	/* Follower modes should always be able to send CEC messages */
	if ((mode_initiator == CEC_MODE_NO_INITIATOR ||
	     !(adap->capabilities & CEC_CAP_TRANSMIT)) &&
	    mode_follower >= CEC_MODE_FOLLOWER &&
	    mode_follower <= CEC_MODE_EXCL_FOLLOWER_PASSTHRU) {
		dprintk(1, "%s: cannot transmit\n", __func__);
		return -EINVAL;
	}

	/* Monitor modes require CEC_MODE_NO_INITIATOR */
	if (mode_initiator && mode_follower >= CEC_MODE_MONITOR_PIN) {
		dprintk(1, "%s: monitor modes require NO_INITIATOR\n",
			__func__);
		return -EINVAL;
	}

	/* Monitor modes require CAP_NET_ADMIN */
	if (mode_follower >= CEC_MODE_MONITOR_PIN && !capable(CAP_NET_ADMIN))
		return -EPERM;

	mutex_lock(&adap->lock);
	/*
	 * You can't become exclusive follower if someone else already
	 * has that job.
	 */
	if ((mode_follower == CEC_MODE_EXCL_FOLLOWER ||
	     mode_follower == CEC_MODE_EXCL_FOLLOWER_PASSTHRU) &&
	    adap->cec_follower && adap->cec_follower != fh)
		err = -EBUSY;
	/*
	 * You can't become exclusive initiator if someone else already
	 * has that job.
	 */
	if (mode_initiator == CEC_MODE_EXCL_INITIATOR &&
	    adap->cec_initiator && adap->cec_initiator != fh)
		err = -EBUSY;

	if (!err) {
		bool old_mon_all = fh->mode_follower == CEC_MODE_MONITOR_ALL;
		bool new_mon_all = mode_follower == CEC_MODE_MONITOR_ALL;

		if (old_mon_all != new_mon_all) {
			if (new_mon_all)
				err = cec_monitor_all_cnt_inc(adap);
			else
				cec_monitor_all_cnt_dec(adap);
		}
	}

	if (!err) {
		bool old_mon_pin = fh->mode_follower == CEC_MODE_MONITOR_PIN;
		bool new_mon_pin = mode_follower == CEC_MODE_MONITOR_PIN;

		if (old_mon_pin != new_mon_pin) {
			send_pin_event = new_mon_pin;
			if (new_mon_pin)
				err = cec_monitor_pin_cnt_inc(adap);
			else
				cec_monitor_pin_cnt_dec(adap);
		}
	}

	if (err) {
		mutex_unlock(&adap->lock);
		return err;
	}

	if (fh->mode_follower == CEC_MODE_FOLLOWER)
		adap->follower_cnt--;
	if (mode_follower == CEC_MODE_FOLLOWER)
		adap->follower_cnt++;
	if (send_pin_event) {
		struct cec_event ev = {
			.flags = CEC_EVENT_FL_INITIAL_STATE,
		};

		ev.event = adap->cec_pin_is_high ? CEC_EVENT_PIN_CEC_HIGH :
						   CEC_EVENT_PIN_CEC_LOW;
		cec_queue_event_fh(fh, &ev, 0);
	}
	if (mode_follower == CEC_MODE_EXCL_FOLLOWER ||
	    mode_follower == CEC_MODE_EXCL_FOLLOWER_PASSTHRU) {
		adap->passthrough =
			mode_follower == CEC_MODE_EXCL_FOLLOWER_PASSTHRU;
		adap->cec_follower = fh;
	} else if (adap->cec_follower == fh) {
		adap->passthrough = false;
		adap->cec_follower = NULL;
	}
	if (mode_initiator == CEC_MODE_EXCL_INITIATOR)
		adap->cec_initiator = fh;
	else if (adap->cec_initiator == fh)
		adap->cec_initiator = NULL;
	fh->mode_initiator = mode_initiator;
	fh->mode_follower = mode_follower;
	mutex_unlock(&adap->lock);
	return 0;
}

static long cec_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct cec_fh *fh = filp->private_data;
	struct cec_adapter *adap = fh->adap;
	bool block = !(filp->f_flags & O_NONBLOCK);
	void __user *parg = (void __user *)arg;

	if (!cec_is_registered(adap))
		return -ENODEV;

	switch (cmd) {
	case CEC_ADAP_G_CAPS:
		return cec_adap_g_caps(adap, parg);

	case CEC_ADAP_G_PHYS_ADDR:
		return cec_adap_g_phys_addr(adap, parg);

	case CEC_ADAP_S_PHYS_ADDR:
		return cec_adap_s_phys_addr(adap, fh, block, parg);

	case CEC_ADAP_G_LOG_ADDRS:
		return cec_adap_g_log_addrs(adap, parg);

	case CEC_ADAP_S_LOG_ADDRS:
		return cec_adap_s_log_addrs(adap, fh, block, parg);

	case CEC_TRANSMIT:
		return cec_transmit(adap, fh, block, parg);

	case CEC_RECEIVE:
		return cec_receive(adap, fh, block, parg);

	case CEC_DQEVENT:
		return cec_dqevent(adap, fh, block, parg);

	case CEC_G_MODE:
		return cec_g_mode(adap, fh, parg);

	case CEC_S_MODE:
		return cec_s_mode(adap, fh, parg);

	default:
		return -ENOTTY;
	}
}

static int cec_open(struct inode *inode, struct file *filp)
{
	struct cec_devnode *devnode =
		container_of(inode->i_cdev, struct cec_devnode, cdev);
	struct cec_adapter *adap = to_cec_adapter(devnode);
	struct cec_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
	/*
	 * Initial events that are automatically sent when the cec device is
	 * opened.
	 */
	struct cec_event ev = {
		.event = CEC_EVENT_STATE_CHANGE,
		.flags = CEC_EVENT_FL_INITIAL_STATE,
	};
	unsigned int i;
	int err;

	if (!fh)
		return -ENOMEM;

	INIT_LIST_HEAD(&fh->msgs);
	INIT_LIST_HEAD(&fh->xfer_list);
	for (i = 0; i < CEC_NUM_EVENTS; i++)
		INIT_LIST_HEAD(&fh->events[i]);
	mutex_init(&fh->lock);
	init_waitqueue_head(&fh->wait);

	fh->mode_initiator = CEC_MODE_INITIATOR;
	fh->adap = adap;

	err = cec_get_device(devnode);
	if (err) {
		kfree(fh);
		return err;
	}

	mutex_lock(&devnode->lock);
	if (list_empty(&devnode->fhs) &&
	    !adap->needs_hpd &&
	    adap->phys_addr == CEC_PHYS_ADDR_INVALID) {
		err = adap->ops->adap_enable(adap, true);
		if (err) {
			mutex_unlock(&devnode->lock);
			kfree(fh);
			return err;
		}
	}
	filp->private_data = fh;

	/* Queue up initial state events */
	ev.state_change.phys_addr = adap->phys_addr;
	ev.state_change.log_addr_mask = adap->log_addrs.log_addr_mask;
	cec_queue_event_fh(fh, &ev, 0);
#ifdef CONFIG_CEC_PIN
	if (adap->pin && adap->pin->ops->read_hpd) {
		err = adap->pin->ops->read_hpd(adap);
		if (err >= 0) {
			ev.event = err ? CEC_EVENT_PIN_HPD_HIGH :
					 CEC_EVENT_PIN_HPD_LOW;
			cec_queue_event_fh(fh, &ev, 0);
		}
	}
#endif

	list_add(&fh->list, &devnode->fhs);
	mutex_unlock(&devnode->lock);

	return 0;
}

/* Override for the release function */
static int cec_release(struct inode *inode, struct file *filp)
{
	struct cec_devnode *devnode = cec_devnode_data(filp);
	struct cec_adapter *adap = to_cec_adapter(devnode);
	struct cec_fh *fh = filp->private_data;
	unsigned int i;

	mutex_lock(&adap->lock);
	if (adap->cec_initiator == fh)
		adap->cec_initiator = NULL;
	if (adap->cec_follower == fh) {
		adap->cec_follower = NULL;
		adap->passthrough = false;
	}
	if (fh->mode_follower == CEC_MODE_FOLLOWER)
		adap->follower_cnt--;
	if (fh->mode_follower == CEC_MODE_MONITOR_PIN)
		cec_monitor_pin_cnt_dec(adap);
	if (fh->mode_follower == CEC_MODE_MONITOR_ALL)
		cec_monitor_all_cnt_dec(adap);
	mutex_unlock(&adap->lock);

	mutex_lock(&devnode->lock);
	list_del(&fh->list);
	if (cec_is_registered(adap) && list_empty(&devnode->fhs) &&
	    !adap->needs_hpd && adap->phys_addr == CEC_PHYS_ADDR_INVALID) {
		WARN_ON(adap->ops->adap_enable(adap, false));
	}
	mutex_unlock(&devnode->lock);

	/* Unhook pending transmits from this filehandle. */
	mutex_lock(&adap->lock);
	while (!list_empty(&fh->xfer_list)) {
		struct cec_data *data =
			list_first_entry(&fh->xfer_list, struct cec_data, xfer_list);

		data->blocking = false;
		data->fh = NULL;
		list_del(&data->xfer_list);
	}
	mutex_unlock(&adap->lock);
	while (!list_empty(&fh->msgs)) {
		struct cec_msg_entry *entry =
			list_first_entry(&fh->msgs, struct cec_msg_entry, list);

		list_del(&entry->list);
		kfree(entry);
	}
	for (i = CEC_NUM_CORE_EVENTS; i < CEC_NUM_EVENTS; i++) {
		while (!list_empty(&fh->events[i])) {
			struct cec_event_entry *entry =
				list_first_entry(&fh->events[i],
						 struct cec_event_entry, list);

			list_del(&entry->list);
			kfree(entry);
		}
	}
	kfree(fh);

	cec_put_device(devnode);
	filp->private_data = NULL;
	return 0;
}

const struct file_operations cec_devnode_fops = {
	.owner = THIS_MODULE,
	.open = cec_open,
	.unlocked_ioctl = cec_ioctl,
	.release = cec_release,
	.poll = cec_poll,
	.llseek = no_llseek,
};
Commit	Line	Data
b4e30a9e	1	// SPDX-License-Identifier: GPL-2.0-only
ca684386 HV	2	/*
	3	* cec-api.c - HDMI Consumer Electronics Control framework - API
	4	*
	5	* Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
ca684386 HV	6	*/
	7
	8	#include <linux/errno.h>
	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/kernel.h>
	12	#include <linux/kmod.h>
	13	#include <linux/ktime.h>
	14	#include <linux/slab.h>
	15	#include <linux/mm.h>
	16	#include <linux/string.h>
	17	#include <linux/types.h>
	18	#include <linux/uaccess.h>
	19	#include <linux/version.h>
	20
ea5c8ef2	21	#include <media/cec-pin.h>
ca684386	22	#include "cec-priv.h"
5bf24e08	23	#include "cec-pin-priv.h"
ca684386 HV	24
	25	static inline struct cec_devnode cec_devnode_data(struct file filp)
	26	{
	27	struct cec_fh *fh = filp->private_data;
	28
	29	return &fh->adap->devnode;
	30	}
	31
	32	/* CEC file operations */
	33
c23e0cb8	34	static __poll_t cec_poll(struct file *filp,
ca684386 HV	35	struct poll_table_struct *poll)
ca684386 HV	36	{
ca684386 HV	37	struct cec_fh *fh = filp->private_data;
ca684386 HV	38	struct cec_adapter *adap = fh->adap;
c23e0cb8	39	__poll_t res = 0;
ca684386	40
c8959a39	41	if (!cec_is_registered(adap))
a9a08845	42	return EPOLLERR \| EPOLLHUP;
ca684386	43	mutex_lock(&adap->lock);
b7cbc892 HV	44	if (adap->is_configured &&
b7cbc892 HV	45	adap->transmit_queue_sz < CEC_MAX_MSG_TX_QUEUE_SZ)
a9a08845	46	res \|= EPOLLOUT \| EPOLLWRNORM;
ca684386	47	if (fh->queued_msgs)
a9a08845	48	res \|= EPOLLIN \| EPOLLRDNORM;
6b2bbb08	49	if (fh->total_queued_events)
a9a08845	50	res \|= EPOLLPRI;
ca684386 HV	51	poll_wait(filp, &fh->wait, poll);
	52	mutex_unlock(&adap->lock);
	53	return res;
	54	}
	55
	56	static bool cec_is_busy(const struct cec_adapter *adap,
	57	const struct cec_fh *fh)
	58	{
	59	bool valid_initiator = adap->cec_initiator && adap->cec_initiator == fh;
	60	bool valid_follower = adap->cec_follower && adap->cec_follower == fh;
	61
	62	/*
	63	* Exclusive initiators and followers can always access the CEC adapter
	64	*/
	65	if (valid_initiator \|\| valid_follower)
	66	return false;
	67	/*
	68	* All others can only access the CEC adapter if there is no
	69	* exclusive initiator and they are in INITIATOR mode.
	70	*/
	71	return adap->cec_initiator \|\|
	72	fh->mode_initiator == CEC_MODE_NO_INITIATOR;
	73	}
	74
	75	static long cec_adap_g_caps(struct cec_adapter *adap,
	76	struct cec_caps __user *parg)
	77	{
	78	struct cec_caps caps = {};
	79
f51e8080	80	strlcpy(caps.driver, adap->devnode.dev.parent->driver->name,
ca684386 HV	81	sizeof(caps.driver));
	82	strlcpy(caps.name, adap->name, sizeof(caps.name));
	83	caps.available_log_addrs = adap->available_log_addrs;
	84	caps.capabilities = adap->capabilities;
	85	caps.version = LINUX_VERSION_CODE;
	86	if (copy_to_user(parg, &caps, sizeof(caps)))
	87	return -EFAULT;
	88	return 0;
	89	}
	90
	91	static long cec_adap_g_phys_addr(struct cec_adapter *adap,
	92	__u16 __user *parg)
	93	{
	94	u16 phys_addr;
	95
	96	mutex_lock(&adap->lock);
	97	phys_addr = adap->phys_addr;
	98	mutex_unlock(&adap->lock);
	99	if (copy_to_user(parg, &phys_addr, sizeof(phys_addr)))
	100	return -EFAULT;
	101	return 0;
	102	}
	103
	104	static long cec_adap_s_phys_addr(struct cec_adapter adap, struct cec_fh fh,
	105	bool block, __u16 __user *parg)
	106	{
	107	u16 phys_addr;
	108	long err;
	109
	110	if (!(adap->capabilities & CEC_CAP_PHYS_ADDR))
	111	return -ENOTTY;
	112	if (copy_from_user(&phys_addr, parg, sizeof(phys_addr)))
	113	return -EFAULT;
	114
	115	err = cec_phys_addr_validate(phys_addr, NULL, NULL);
	116	if (err)
	117	return err;
	118	mutex_lock(&adap->lock);
	119	if (cec_is_busy(adap, fh))
	120	err = -EBUSY;
	121	else
	122	__cec_s_phys_addr(adap, phys_addr, block);
	123	mutex_unlock(&adap->lock);
	124	return err;
	125	}
	126
	127	static long cec_adap_g_log_addrs(struct cec_adapter *adap,
	128	struct cec_log_addrs __user *parg)
	129	{
	130	struct cec_log_addrs log_addrs;
	131
	132	mutex_lock(&adap->lock);
	133	log_addrs = adap->log_addrs;
	134	if (!adap->is_configured)
	135	memset(log_addrs.log_addr, CEC_LOG_ADDR_INVALID,
	136	sizeof(log_addrs.log_addr));
	137	mutex_unlock(&adap->lock);
	138
	139	if (copy_to_user(parg, &log_addrs, sizeof(log_addrs)))
	140	return -EFAULT;
	141	return 0;
	142	}
	143
	144	static long cec_adap_s_log_addrs(struct cec_adapter adap, struct cec_fh fh,
145	bool block, struct cec_log_addrs __user *parg)
146	{
147	struct cec_log_addrs log_addrs;
148	long err = -EBUSY;
149
150	if (!(adap->capabilities & CEC_CAP_LOG_ADDRS))
151	return -ENOTTY;
152	if (copy_from_user(&log_addrs, parg, sizeof(log_addrs)))
153	return -EFAULT;
f4062625	154	log_addrs.flags &= CEC_LOG_ADDRS_FL_ALLOW_UNREG_FALLBACK \|
a69a168a HV	155	CEC_LOG_ADDRS_FL_ALLOW_RC_PASSTHRU \|
a69a168a HV	156	CEC_LOG_ADDRS_FL_CDC_ONLY;
ca684386 HV	157	mutex_lock(&adap->lock);
	158	if (!adap->is_configuring &&
	159	(!log_addrs.num_log_addrs \|\| !adap->is_configured) &&
	160	!cec_is_busy(adap, fh)) {
	161	err = __cec_s_log_addrs(adap, &log_addrs, block);
	162	if (!err)
	163	log_addrs = adap->log_addrs;
	164	}
	165	mutex_unlock(&adap->lock);
	166	if (err)
	167	return err;
	168	if (copy_to_user(parg, &log_addrs, sizeof(log_addrs)))
	169	return -EFAULT;
	170	return 0;
	171	}
	172
	173	static long cec_transmit(struct cec_adapter adap, struct cec_fh fh,
	174	bool block, struct cec_msg __user *parg)
	175	{
	176	struct cec_msg msg = {};
	177	long err = 0;
	178
	179	if (!(adap->capabilities & CEC_CAP_TRANSMIT))
	180	return -ENOTTY;
	181	if (copy_from_user(&msg, parg, sizeof(msg)))
	182	return -EFAULT;
a69a168a HV	183
	184	/* A CDC-Only device can only send CDC messages */
	185	if ((adap->log_addrs.flags & CEC_LOG_ADDRS_FL_CDC_ONLY) &&
	186	(msg.len == 1 \|\| msg.msg[1] != CEC_MSG_CDC_MESSAGE))
	187	return -EINVAL;
	188
ca684386	189	mutex_lock(&adap->lock);
059d1460 HV	190	if (adap->log_addrs.num_log_addrs == 0)
	191	err = -EPERM;
	192	else if (adap->is_configuring)
533a3f7b	193	err = -ENONET;
f902c1e9 HV	194	else if (!adap->is_configured &&
f902c1e9 HV	195	(adap->needs_hpd \|\| msg.msg[0] != 0xf0))
ca684386	196	err = -ENONET;
4eef404f	197	else if (cec_is_busy(adap, fh))
ca684386	198	err = -EBUSY;
4eef404f	199	else
ca684386	200	err = cec_transmit_msg_fh(adap, &msg, fh, block);
ca684386 HV	201	mutex_unlock(&adap->lock);
	202	if (err)
	203	return err;
	204	if (copy_to_user(parg, &msg, sizeof(msg)))
	205	return -EFAULT;
	206	return 0;
	207	}
	208
	209	/* Called by CEC_RECEIVE: wait for a message to arrive */
	210	static int cec_receive_msg(struct cec_fh fh, struct cec_msg msg, bool block)
	211	{
e883b4d0	212	u32 timeout = msg->timeout;
ca684386 HV	213	int res;
	214
	215	do {
	216	mutex_lock(&fh->lock);
	217	/* Are there received messages queued up? */
	218	if (fh->queued_msgs) {
	219	/* Yes, return the first one */
	220	struct cec_msg_entry *entry =
	221	list_first_entry(&fh->msgs,
	222	struct cec_msg_entry, list);
	223
	224	list_del(&entry->list);
	225	*msg = entry->msg;
	226	kfree(entry);
	227	fh->queued_msgs--;
	228	mutex_unlock(&fh->lock);
e883b4d0 HV	229	/* restore original timeout value */
e883b4d0 HV	230	msg->timeout = timeout;
ca684386 HV	231	return 0;
	232	}
	233
	234	/* No, return EAGAIN in non-blocking mode or wait */
	235	mutex_unlock(&fh->lock);
	236
	237	/* Return when in non-blocking mode */
	238	if (!block)
	239	return -EAGAIN;
	240
	241	if (msg->timeout) {
	242	/* The user specified a timeout */
	243	res = wait_event_interruptible_timeout(fh->wait,
	244	fh->queued_msgs,
	245	msecs_to_jiffies(msg->timeout));
	246	if (res == 0)
	247	res = -ETIMEDOUT;
	248	else if (res > 0)
	249	res = 0;
	250	} else {
	251	/* Wait indefinitely */
	252	res = wait_event_interruptible(fh->wait,
	253	fh->queued_msgs);
	254	}
	255	/* Exit on error, otherwise loop to get the new message */
	256	} while (!res);
	257	return res;
	258	}
	259
	260	static long cec_receive(struct cec_adapter adap, struct cec_fh fh,
	261	bool block, struct cec_msg __user *parg)
	262	{
	263	struct cec_msg msg = {};
b94aac64	264	long err;
ca684386 HV	265
	266	if (copy_from_user(&msg, parg, sizeof(msg)))
	267	return -EFAULT;
ca684386 HV	268
	269	err = cec_receive_msg(fh, &msg, block);
	270	if (err)
	271	return err;
7ae2a888	272	msg.flags = 0;
ca684386 HV	273	if (copy_to_user(parg, &msg, sizeof(msg)))
	274	return -EFAULT;
	275	return 0;
	276	}
	277
	278	static long cec_dqevent(struct cec_adapter adap, struct cec_fh fh,
	279	bool block, struct cec_event __user *parg)
	280	{
6b2bbb08	281	struct cec_event_entry *ev = NULL;
ca684386 HV	282	u64 ts = ~0ULL;
ca684386 HV	283	unsigned int i;
6b2bbb08	284	unsigned int ev_idx;
ca684386 HV	285	long err = 0;
	286
	287	mutex_lock(&fh->lock);
6b2bbb08	288	while (!fh->total_queued_events && block) {
ca684386	289	mutex_unlock(&fh->lock);
6b2bbb08 HV	290	err = wait_event_interruptible(fh->wait,
6b2bbb08 HV	291	fh->total_queued_events);
ca684386 HV	292	if (err)
	293	return err;
	294	mutex_lock(&fh->lock);
	295	}
	296
	297	/* Find the oldest event */
	298	for (i = 0; i < CEC_NUM_EVENTS; i++) {
6b2bbb08 HV	299	struct cec_event_entry *entry =
	300	list_first_entry_or_null(&fh->events[i],
	301	struct cec_event_entry, list);
	302
	303	if (entry && entry->ev.ts <= ts) {
	304	ev = entry;
	305	ev_idx = i;
	306	ts = ev->ev.ts;
ca684386 HV	307	}
ca684386 HV	308	}
6b2bbb08	309
ca684386 HV	310	if (!ev) {
	311	err = -EAGAIN;
	312	goto unlock;
	313	}
6b2bbb08	314	list_del(&ev->list);
ca684386	315
6b2bbb08	316	if (copy_to_user(parg, &ev->ev, sizeof(ev->ev)))
ca684386	317	err = -EFAULT;
6b2bbb08 HV	318	if (ev_idx >= CEC_NUM_CORE_EVENTS)
	319	kfree(ev);
	320	fh->queued_events[ev_idx]--;
	321	fh->total_queued_events--;
ca684386 HV	322
	323	unlock:
	324	mutex_unlock(&fh->lock);
	325	return err;
	326	}
	327
	328	static long cec_g_mode(struct cec_adapter adap, struct cec_fh fh,
	329	u32 __user *parg)
	330	{
	331	u32 mode = fh->mode_initiator \| fh->mode_follower;
	332
	333	if (copy_to_user(parg, &mode, sizeof(mode)))
	334	return -EFAULT;
	335	return 0;
	336	}
	337
	338	static long cec_s_mode(struct cec_adapter adap, struct cec_fh fh,
	339	u32 __user *parg)
	340	{
	341	u32 mode;
	342	u8 mode_initiator;
	343	u8 mode_follower;
48ea2e92	344	bool send_pin_event = false;
ca684386 HV	345	long err = 0;
	346
	347	if (copy_from_user(&mode, parg, sizeof(mode)))
	348	return -EFAULT;
c33da628 HV	349	if (mode & ~(CEC_MODE_INITIATOR_MSK \| CEC_MODE_FOLLOWER_MSK)) {
c33da628 HV	350	dprintk(1, "%s: invalid mode bits set\n", __func__);
ca684386	351	return -EINVAL;
c33da628	352	}
ca684386 HV	353
	354	mode_initiator = mode & CEC_MODE_INITIATOR_MSK;
	355	mode_follower = mode & CEC_MODE_FOLLOWER_MSK;
	356
	357	if (mode_initiator > CEC_MODE_EXCL_INITIATOR \|\|
c33da628 HV	358	mode_follower > CEC_MODE_MONITOR_ALL) {
c33da628 HV	359	dprintk(1, "%s: unknown mode\n", __func__);
ca684386	360	return -EINVAL;
c33da628	361	}
ca684386 HV	362
ca684386 HV	363	if (mode_follower == CEC_MODE_MONITOR_ALL &&
c33da628 HV	364	!(adap->capabilities & CEC_CAP_MONITOR_ALL)) {
c33da628 HV	365	dprintk(1, "%s: MONITOR_ALL not supported\n", __func__);
ca684386	366	return -EINVAL;
c33da628	367	}
ca684386	368
b8d62f50	369	if (mode_follower == CEC_MODE_MONITOR_PIN &&
c33da628 HV	370	!(adap->capabilities & CEC_CAP_MONITOR_PIN)) {
c33da628 HV	371	dprintk(1, "%s: MONITOR_PIN not supported\n", __func__);
b8d62f50	372	return -EINVAL;
c33da628	373	}
b8d62f50	374
ca684386 HV	375	/* Follower modes should always be able to send CEC messages */
	376	if ((mode_initiator == CEC_MODE_NO_INITIATOR \|\|
	377	!(adap->capabilities & CEC_CAP_TRANSMIT)) &&
	378	mode_follower >= CEC_MODE_FOLLOWER &&
c33da628 HV	379	mode_follower <= CEC_MODE_EXCL_FOLLOWER_PASSTHRU) {
c33da628 HV	380	dprintk(1, "%s: cannot transmit\n", __func__);
ca684386	381	return -EINVAL;
c33da628	382	}
ca684386 HV	383
ca684386 HV	384	/* Monitor modes require CEC_MODE_NO_INITIATOR */
c33da628 HV	385	if (mode_initiator && mode_follower >= CEC_MODE_MONITOR_PIN) {
	386	dprintk(1, "%s: monitor modes require NO_INITIATOR\n",
	387	__func__);
ca684386	388	return -EINVAL;
c33da628	389	}
ca684386 HV	390
ca684386 HV	391	/* Monitor modes require CAP_NET_ADMIN */
b8d62f50	392	if (mode_follower >= CEC_MODE_MONITOR_PIN && !capable(CAP_NET_ADMIN))
ca684386 HV	393	return -EPERM;
	394
	395	mutex_lock(&adap->lock);
	396	/*
	397	* You can't become exclusive follower if someone else already
	398	* has that job.
	399	*/
	400	if ((mode_follower == CEC_MODE_EXCL_FOLLOWER \|\|
	401	mode_follower == CEC_MODE_EXCL_FOLLOWER_PASSTHRU) &&
	402	adap->cec_follower && adap->cec_follower != fh)
	403	err = -EBUSY;
	404	/*
	405	* You can't become exclusive initiator if someone else already
	406	* has that job.
	407	*/
	408	if (mode_initiator == CEC_MODE_EXCL_INITIATOR &&
	409	adap->cec_initiator && adap->cec_initiator != fh)
	410	err = -EBUSY;
	411
	412	if (!err) {
	413	bool old_mon_all = fh->mode_follower == CEC_MODE_MONITOR_ALL;
	414	bool new_mon_all = mode_follower == CEC_MODE_MONITOR_ALL;
	415
	416	if (old_mon_all != new_mon_all) {
	417	if (new_mon_all)
	418	err = cec_monitor_all_cnt_inc(adap);
	419	else
	420	cec_monitor_all_cnt_dec(adap);
	421	}
	422	}
	423
48ea2e92 HV	424	if (!err) {
	425	bool old_mon_pin = fh->mode_follower == CEC_MODE_MONITOR_PIN;
	426	bool new_mon_pin = mode_follower == CEC_MODE_MONITOR_PIN;
	427
	428	if (old_mon_pin != new_mon_pin) {
	429	send_pin_event = new_mon_pin;
	430	if (new_mon_pin)
	431	err = cec_monitor_pin_cnt_inc(adap);
	432	else
	433	cec_monitor_pin_cnt_dec(adap);
	434	}
	435	}
	436
ca684386 HV	437	if (err) {
	438	mutex_unlock(&adap->lock);
	439	return err;
	440	}
	441
	442	if (fh->mode_follower == CEC_MODE_FOLLOWER)
	443	adap->follower_cnt--;
	444	if (mode_follower == CEC_MODE_FOLLOWER)
	445	adap->follower_cnt++;
48ea2e92	446	if (send_pin_event) {
ea5c8ef2 HV	447	struct cec_event ev = {
	448	.flags = CEC_EVENT_FL_INITIAL_STATE,
	449	};
	450
28e11b15 HV	451	ev.event = adap->cec_pin_is_high ? CEC_EVENT_PIN_CEC_HIGH :
28e11b15 HV	452	CEC_EVENT_PIN_CEC_LOW;
ea5c8ef2	453	cec_queue_event_fh(fh, &ev, 0);
b8d62f50	454	}
ca684386 HV	455	if (mode_follower == CEC_MODE_EXCL_FOLLOWER \|\|
	456	mode_follower == CEC_MODE_EXCL_FOLLOWER_PASSTHRU) {
	457	adap->passthrough =
	458	mode_follower == CEC_MODE_EXCL_FOLLOWER_PASSTHRU;
	459	adap->cec_follower = fh;
	460	} else if (adap->cec_follower == fh) {
	461	adap->passthrough = false;
	462	adap->cec_follower = NULL;
	463	}
	464	if (mode_initiator == CEC_MODE_EXCL_INITIATOR)
	465	adap->cec_initiator = fh;
	466	else if (adap->cec_initiator == fh)
	467	adap->cec_initiator = NULL;
	468	fh->mode_initiator = mode_initiator;
	469	fh->mode_follower = mode_follower;
	470	mutex_unlock(&adap->lock);
	471	return 0;
	472	}
	473
	474	static long cec_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	475	{
ca684386 HV	476	struct cec_fh *fh = filp->private_data;
	477	struct cec_adapter *adap = fh->adap;
	478	bool block = !(filp->f_flags & O_NONBLOCK);
	479	void __user parg = (void __user )arg;
	480
c8959a39	481	if (!cec_is_registered(adap))
60815d4a	482	return -ENODEV;
ca684386 HV	483
	484	switch (cmd) {
	485	case CEC_ADAP_G_CAPS:
	486	return cec_adap_g_caps(adap, parg);
	487
	488	case CEC_ADAP_G_PHYS_ADDR:
	489	return cec_adap_g_phys_addr(adap, parg);
	490
	491	case CEC_ADAP_S_PHYS_ADDR:
	492	return cec_adap_s_phys_addr(adap, fh, block, parg);
	493
	494	case CEC_ADAP_G_LOG_ADDRS:
	495	return cec_adap_g_log_addrs(adap, parg);
	496
	497	case CEC_ADAP_S_LOG_ADDRS:
	498	return cec_adap_s_log_addrs(adap, fh, block, parg);
	499
	500	case CEC_TRANSMIT:
	501	return cec_transmit(adap, fh, block, parg);
	502
	503	case CEC_RECEIVE:
	504	return cec_receive(adap, fh, block, parg);
	505
	506	case CEC_DQEVENT:
	507	return cec_dqevent(adap, fh, block, parg);
	508
	509	case CEC_G_MODE:
	510	return cec_g_mode(adap, fh, parg);
	511
	512	case CEC_S_MODE:
	513	return cec_s_mode(adap, fh, parg);
	514
	515	default:
	516	return -ENOTTY;
	517	}
	518	}
	519
	520	static int cec_open(struct inode inode, struct file filp)
	521	{
	522	struct cec_devnode *devnode =
	523	container_of(inode->i_cdev, struct cec_devnode, cdev);
	524	struct cec_adapter *adap = to_cec_adapter(devnode);
	525	struct cec_fh fh = kzalloc(sizeof(fh), GFP_KERNEL);
	526	/*
	527	* Initial events that are automatically sent when the cec device is
	528	* opened.
	529	*/
333ef6bd	530	struct cec_event ev = {
ca684386 HV	531	.event = CEC_EVENT_STATE_CHANGE,
	532	.flags = CEC_EVENT_FL_INITIAL_STATE,
	533	};
6b2bbb08	534	unsigned int i;
ca684386 HV	535	int err;
	536
	537	if (!fh)
	538	return -ENOMEM;
	539
	540	INIT_LIST_HEAD(&fh->msgs);
	541	INIT_LIST_HEAD(&fh->xfer_list);
6b2bbb08 HV	542	for (i = 0; i < CEC_NUM_EVENTS; i++)
6b2bbb08 HV	543	INIT_LIST_HEAD(&fh->events[i]);
ca684386 HV	544	mutex_init(&fh->lock);
	545	init_waitqueue_head(&fh->wait);
	546
	547	fh->mode_initiator = CEC_MODE_INITIATOR;
	548	fh->adap = adap;
	549
	550	err = cec_get_device(devnode);
	551	if (err) {
	552	kfree(fh);
	553	return err;
	554	}
	555
533a3f7b HV	556	mutex_lock(&devnode->lock);
533a3f7b HV	557	if (list_empty(&devnode->fhs) &&
f902c1e9	558	!adap->needs_hpd &&
533a3f7b HV	559	adap->phys_addr == CEC_PHYS_ADDR_INVALID) {
	560	err = adap->ops->adap_enable(adap, true);
	561	if (err) {
	562	mutex_unlock(&devnode->lock);
	563	kfree(fh);
	564	return err;
	565	}
	566	}
ca684386 HV	567	filp->private_data = fh;
ca684386 HV	568
ca684386	569	/* Queue up initial state events */
333ef6bd HV	570	ev.state_change.phys_addr = adap->phys_addr;
	571	ev.state_change.log_addr_mask = adap->log_addrs.log_addr_mask;
	572	cec_queue_event_fh(fh, &ev, 0);
	573	#ifdef CONFIG_CEC_PIN
	574	if (adap->pin && adap->pin->ops->read_hpd) {
	575	err = adap->pin->ops->read_hpd(adap);
	576	if (err >= 0) {
	577	ev.event = err ? CEC_EVENT_PIN_HPD_HIGH :
	578	CEC_EVENT_PIN_HPD_LOW;
	579	cec_queue_event_fh(fh, &ev, 0);
	580	}
	581	}
	582	#endif
ca684386 HV	583
ca684386 HV	584	list_add(&fh->list, &devnode->fhs);
62148f09	585	mutex_unlock(&devnode->lock);
ca684386 HV	586
	587	return 0;
	588	}
	589
	590	/* Override for the release function */
	591	static int cec_release(struct inode inode, struct file filp)
	592	{
	593	struct cec_devnode *devnode = cec_devnode_data(filp);
	594	struct cec_adapter *adap = to_cec_adapter(devnode);
	595	struct cec_fh *fh = filp->private_data;
6b2bbb08	596	unsigned int i;
ca684386 HV	597
	598	mutex_lock(&adap->lock);
	599	if (adap->cec_initiator == fh)
	600	adap->cec_initiator = NULL;
	601	if (adap->cec_follower == fh) {
	602	adap->cec_follower = NULL;
	603	adap->passthrough = false;
	604	}
	605	if (fh->mode_follower == CEC_MODE_FOLLOWER)
	606	adap->follower_cnt--;
b8d62f50	607	if (fh->mode_follower == CEC_MODE_MONITOR_PIN)
48ea2e92	608	cec_monitor_pin_cnt_dec(adap);
ca684386 HV	609	if (fh->mode_follower == CEC_MODE_MONITOR_ALL)
	610	cec_monitor_all_cnt_dec(adap);
	611	mutex_unlock(&adap->lock);
	612
62148f09	613	mutex_lock(&devnode->lock);
ca684386	614	list_del(&fh->list);
c8959a39 HV	615	if (cec_is_registered(adap) && list_empty(&devnode->fhs) &&
c8959a39 HV	616	!adap->needs_hpd && adap->phys_addr == CEC_PHYS_ADDR_INVALID) {
533a3f7b HV	617	WARN_ON(adap->ops->adap_enable(adap, false));
533a3f7b HV	618	}
62148f09	619	mutex_unlock(&devnode->lock);
ca684386 HV	620
	621	/* Unhook pending transmits from this filehandle. */
	622	mutex_lock(&adap->lock);
	623	while (!list_empty(&fh->xfer_list)) {
	624	struct cec_data *data =
	625	list_first_entry(&fh->xfer_list, struct cec_data, xfer_list);
	626
	627	data->blocking = false;
	628	data->fh = NULL;
	629	list_del(&data->xfer_list);
	630	}
	631	mutex_unlock(&adap->lock);
	632	while (!list_empty(&fh->msgs)) {
	633	struct cec_msg_entry *entry =
	634	list_first_entry(&fh->msgs, struct cec_msg_entry, list);
	635
	636	list_del(&entry->list);
	637	kfree(entry);
	638	}
6b2bbb08 HV	639	for (i = CEC_NUM_CORE_EVENTS; i < CEC_NUM_EVENTS; i++) {
	640	while (!list_empty(&fh->events[i])) {
	641	struct cec_event_entry *entry =
	642	list_first_entry(&fh->events[i],
	643	struct cec_event_entry, list);
	644
	645	list_del(&entry->list);
	646	kfree(entry);
	647	}
	648	}
ca684386 HV	649	kfree(fh);
	650
	651	cec_put_device(devnode);
	652	filp->private_data = NULL;
	653	return 0;
	654	}
	655
	656	const struct file_operations cec_devnode_fops = {
	657	.owner = THIS_MODULE,
	658	.open = cec_open,
	659	.unlocked_ioctl = cec_ioctl,
	660	.release = cec_release,
	661	.poll = cec_poll,
	662	.llseek = no_llseek,
	663	};