[PATCH] Diffs between the upcoming v19 series and the cec-topic branch

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Mauro,

This patch is the diff between the cec-topic branch and the upcoming v19 patch series,
but without the split up of cec.c since that's not a functional change (and that would
make this diff impossible to review).

Besides fixing your comments about cec.c and cec-edid.c, it also makes some documentation
improvements and a few additional fixes:

- new messages were queued at the beginning of the message queue instead of at the end.
  I hadn't noticed before because normally there is at most only one message queued up.
- adap->timeout wasn't zeroed in cec_transmit_done if the transmit failed or the adapter
  is no longer configured. This caused the result of such a transmit to be unnecessarily
  delayed by 'timeout' ms.
- adap->rc->driver_name wasn't set, which caused a (null) driver name when running ir-keymap.

I also double-checked with the USB CEC dongle that unplugging the usb device while /dev/cec0
was still open works correctly and that the cec_adapter struct is freed only when the last
open file handle is closed.

Regards,

	Hans

diff --git a/Documentation/DocBook/media/v4l/cec-ioc-dqevent.xml b/Documentation/DocBook/media/v4l/cec-ioc-dqevent.xml
index 87d4f29..697dde5 100644
--- a/Documentation/DocBook/media/v4l/cec-ioc-dqevent.xml
+++ b/Documentation/DocBook/media/v4l/cec-ioc-dqevent.xml
@@ -61,7 +61,7 @@
     <para>The internal event queues are per-filehandle and per-event type. If there is
     no more room in a queue then the last event is overwritten with the new one. This
     means that intermediate results can be thrown away but that the latest event is always
-    available. This also mean that is it possible to read two successive events that have
+    available. This also means that is it possible to read two successive events that have
     the same value (e.g. two CEC_EVENT_STATE_CHANGE events with the same state). In that
     case the intermediate state changes were lost but it is guaranteed that the state
     did change in between the two events.</para>
@@ -95,7 +95,14 @@
 	    <entry><structfield>lost_msgs</structfield></entry>
 	    <entry>Set to the number of lost messages since the filehandle
 	    was opened or since the last time this event was dequeued for
-	    this filehandle.</entry>
+	    this filehandle. The messages lost are the oldest messages. So
+	    when a new message arrives and there is no more room, then the
+	    oldest message is discarded to make room for the new one. The
+	    internal size of the message queue guarantees that all messages
+	    received in the last two seconds will be stored. Since messages
+	    should be replied to within a second according to the CEC
+	    specification, this is more than enough.
+	    </entry>
 	  </row>
 	</tbody>
       </tgroup>
diff --git a/Documentation/DocBook/media/v4l/cec-ioc-receive.xml b/Documentation/DocBook/media/v4l/cec-ioc-receive.xml
index 4da7239..fde9f86 100644
--- a/Documentation/DocBook/media/v4l/cec-ioc-receive.xml
+++ b/Documentation/DocBook/media/v4l/cec-ioc-receive.xml
@@ -96,9 +96,12 @@
 	  <row>
 	    <entry>__u32</entry>
 	    <entry><structfield>timeout</structfield></entry>
-	    <entry>The timeout in milliseconds. This is the time we wait for a message to
-	    be received. If it is set to 0, then we wait indefinitely.
-	    It is ignored by <constant>CEC_TRANSMIT</constant>.</entry>
+	    <entry>The timeout in milliseconds. This is the time the device will wait for a message to
+	    be received before timing out. If it is set to 0, then it will wait indefinitely when it
+	    is called by <constant>CEC_RECEIVE</constant>. If it is 0 and it is called by
+	    <constant>CEC_TRANSMIT</constant>, then it will be replaced by 1000 if the
+	    <structfield>reply</structfield> is non-zero or ignored if <structfield>reply</structfield>
+	    is 0.</entry>
 	  </row>
 	  <row>
 	    <entry>__u32</entry>
@@ -143,10 +146,16 @@
 	    <entry>__u8</entry>
 	    <entry><structfield>reply</structfield></entry>
 	    <entry>Wait until this message is replied. If <structfield>reply</structfield>
-	    is 0, then don't wait for a reply but return after transmitting the
-	    message. If there was an error as indicated by a non-zero <structfield>status</structfield>
-	    field, then <structfield>reply</structfield> is set to 0 by the driver.
-	    Ignored by <constant>CEC_RECEIVE</constant>.</entry>
+	    is 0 and the <structfield>timeout</structfield> is 0, then don't wait for a reply but
+	    return after transmitting the message. If there was an error as indicated by a non-zero
+	    <structfield>tx_status</structfield> field, then <structfield>reply</structfield> and
+	    <structfield>timeout</structfield> are both set to 0 by the driver. Ignored by
+	    <constant>CEC_RECEIVE</constant>. The case where <structfield>reply</structfield> is 0
+	    (this is the opcode for the Feature Abort message) and <structfield>timeout</structfield>
+	    is non-zero is specifically allowed to send a message and wait up to <structfield>timeout</structfield>
+	    milliseconds for a Feature Abort reply. In this case <structfield>rx_status</structfield>
+	    will either be set to <constant>CEC_RX_STATUS_TIMEOUT</constant> or
+	    <constant>CEC_RX_STATUS_FEATURE_ABORT</constant>.</entry>
 	  </row>
 	  <row>
 	    <entry>__u8</entry>
diff --git a/drivers/media/cec-edid.c b/drivers/media/cec-edid.c
index ce3b915..7001824 100644
--- a/drivers/media/cec-edid.c
+++ b/drivers/media/cec-edid.c
@@ -22,30 +22,59 @@
 #include <linux/types.h>
 #include <media/cec-edid.h>

+/*
+ * This EDID is expected to be a CEA-861 compliant, which means that there are
+ * at least two blocks and one or more of the extensions blocks are CEA-861
+ * blocks.
+ *
+ * The returned location is guaranteed to be < size - 1.
+ */
 static unsigned int cec_get_edid_spa_location(const u8 *edid, unsigned int size)
 {
+	unsigned int blocks = size / 128;
+	unsigned int block;
 	u8 d;

-	if (size < 256)
-		return 0;
-
-	if (edid[0x7e] != 1 || edid[0x80] != 0x02 || edid[0x81] != 0x03)
+	/* Sanity check: at least 2 blocks and a multiple of the block size */
+	if (blocks < 2 || size % 128)
 		return 0;

-	/* search Vendor Specific Data Block (tag 3) */
-	d = edid[0x82] & 0x7f;
-	if (d > 4) {
-		int i = 0x84;
-		int end = 0x80 + d;
-
-		do {
-			u8 tag = edid[i] >> 5;
-			u8 len = edid[i] & 0x1f;
-
-			if (tag == 3 && len >= 5)
-				return i + 4;
-			i += len + 1;
-		} while (i < end);
+	/*
+	 * If there are fewer extension blocks than the size, then update
+	 * 'blocks'. It is allowed to have more extension blocks than the size,
+	 * since some hardware can only read e.g. 256 bytes of the EDID, even
+	 * though more blocks are present. The first CEA-861 extension block
+	 * should normally be in block 1 anyway.
+	 */
+	if (edid[0x7e] + 1 < blocks)
+		blocks = edid[0x7e] + 1;
+
+	for (block = 1; block < blocks; block++) {
+		unsigned int offset = block * 128;
+
+		/* Skip any non-CEA-861 extension blocks */
+		if (edid[offset] != 0x02 || edid[offset + 1] != 0x03)
+			continue;
+
+		/* search Vendor Specific Data Block (tag 3) */
+		d = edid[offset + 2] & 0x7f;
+		/* Check if there are Data Blocks */
+		if (d <= 4)
+			continue;
+		if (d > 4) {
+			unsigned int i = offset + 4;
+			unsigned int end = offset + d;
+
+			/* Note: 'end' is always < 'size' */
+			do {
+				u8 tag = edid[i] >> 5;
+				u8 len = edid[i] & 0x1f;
+
+				if (tag == 3 && len >= 5 && i + len <= end)
+					return i + 4;
+				i += len + 1;
+			} while (i < end);
+		}
 	}
 	return 0;
 }
diff --git a/drivers/staging/media/cec/Kconfig b/drivers/staging/media/cec/Kconfig
index 3297a54..8a7acee 100644
--- a/drivers/staging/media/cec/Kconfig
+++ b/drivers/staging/media/cec/Kconfig
@@ -6,3 +6,9 @@ config MEDIA_CEC

 	  To compile this driver as a module, choose M here: the
 	  module will be called cec.
+
+config MEDIA_CEC_DEBUG
+	bool "CEC debugfs interface (EXPERIMENTAL)"
+	depends on MEDIA_CEC && DEBUG_FS
+	---help---
+	  Turns on the DebugFS interface for CEC devices.
diff --git a/drivers/staging/media/cec/TODO b/drivers/staging/media/cec/TODO
index e3c384a..a8f4b7d 100644
--- a/drivers/staging/media/cec/TODO
+++ b/drivers/staging/media/cec/TODO
@@ -19,5 +19,9 @@ Other TODOs:
   is only sent to the filehandle that transmitted the original message
   and not to any followers. Should this behavior change or perhaps
   controlled through a cec_msg flag?
+- Should CEC_LOG_ADDR_TYPE_SPECIFIC be replaced by TYPE_2ND_TV and TYPE_PROCESSOR?
+  And also TYPE_SWITCH and TYPE_CDC_ONLY in addition to the TYPE_UNREGISTERED?
+  This should give the framework more information about the device type
+  since SPECIFIC and UNREGISTERED give no useful information.

 Hans Verkuil <hans.verkuil@xxxxxxxxx>
diff --git a/drivers/staging/media/cec/cec.c b/drivers/staging/media/cec/cec.c
index 8634773..4eb087e 100644
--- a/drivers/staging/media/cec/cec.c
+++ b/drivers/staging/media/cec/cec.c
@@ -104,64 +104,48 @@ static unsigned int cec_log_addr2dev(const struct cec_adapter *adap, u8 log_addr
 	return adap->log_addrs.primary_device_type[i < 0 ? 0 : i];
 }

-/* Initialize the event queues for the filehandle. */
-static int cec_queue_event_init(struct cec_fh *fh)
-{
-	/* This has the size of the event queue for each event type. */
-	static const unsigned int queue_sizes[CEC_NUM_EVENTS] = {
-		2,	/* CEC_EVENT_STATE_CHANGE */
-		1,	/* CEC_EVENT_LOST_MSGS */
-	};
-	unsigned int i;
-
-	for (i = 0; i < CEC_NUM_EVENTS; i++) {
-		fh->evqueue[i].events = kcalloc(queue_sizes[i],
-				sizeof(struct cec_event), GFP_KERNEL);
-		if (!fh->evqueue[i].events) {
-			while (i--) {
-				kfree(fh->evqueue[i].events);
-				fh->evqueue[i].events = NULL;
-				fh->evqueue[i].elems = 0;
-			}
-			return -ENOMEM;
-		}
-		fh->evqueue[i].elems = queue_sizes[i];
-	}
-	return 0;
-}
-
-static void cec_queue_event_free(struct cec_fh *fh)
-{
-	unsigned int i;
-
-	for (i = 0; i < CEC_NUM_EVENTS; i++)
-		kfree(fh->evqueue[i].events);
-}
-
 /*
  * Queue a new event for this filehandle. If ts == 0, then set it
  * to the current time.
+ *
+ * The two events that are currently defined do not need to keep track
+ * of intermediate events, so no actual queue of events is needed,
+ * instead just store the latest state and the total number of lost
+ * messages.
+ *
+ * Should new events be added in the future that require intermediate
+ * results to be queued as well, then a proper queue data structure is
+ * required. But until then, just keep it simple.
  */
 static void cec_queue_event_fh(struct cec_fh *fh,
 			       const struct cec_event *new_ev, u64 ts)
 {
-	struct cec_event_queue *evq = &fh->evqueue[new_ev->event - 1];
-	struct cec_event *ev;
+	struct cec_event *ev = &fh->events[new_ev->event - 1];

 	if (ts == 0)
 		ts = ktime_get_ns();

 	mutex_lock(&fh->lock);
-	ev = evq->events + evq->num_events;
-	/* Overwrite the last event if there is no more room for the new event */
-	if (evq->num_events == evq->elems) {
-		ev--;
-	} else {
-		evq->num_events++;
-		fh->events++;
+	if (new_ev->event == CEC_EVENT_LOST_MSGS &&
+	    fh->pending_events & (1 << new_ev->event)) {
+		/*
+		 * If there is already a lost_msgs event, then just
+		 * update the lost_msgs count. This effectively
+		 * merges the old and new events into one.
+		 */
+		ev->lost_msgs.lost_msgs += new_ev->lost_msgs.lost_msgs;
+		goto unlock;
 	}
+
+	/*
+	 * Intermediate states are not interesting, so just
+	 * overwrite any older event.
+	 */
 	*ev = *new_ev;
 	ev->ts = ts;
+	fh->pending_events |= 1 << new_ev->event;
+
+unlock:
 	mutex_unlock(&fh->lock);
 	wake_up_interruptible(&fh->wait);
 }
@@ -185,27 +169,35 @@ static void cec_queue_event(struct cec_adapter *adap,
  */
 static void cec_queue_msg_fh(struct cec_fh *fh, const struct cec_msg *msg)
 {
-	struct cec_event ev_lost_msg = {
+	static const struct cec_event ev_lost_msg = {
 		.event = CEC_EVENT_LOST_MSGS,
+		.lost_msgs.lost_msgs = 1,
 	};
 	struct cec_msg_entry *entry;

 	mutex_lock(&fh->lock);
-	if (fh->queued_msgs == CEC_MAX_MSG_QUEUE_SZ)
-		goto lost_msgs;
 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 	if (!entry)
 		goto lost_msgs;

 	entry->msg = *msg;
-	list_add(&entry->list, &fh->msgs);
+	/* Add new msg at the end of the queue */
+	list_add_tail(&entry->list, &fh->msgs);
+
+	/*
+	 * if the queue now has more than CEC_MAX_MSG_QUEUE_SZ
+	 * messages, drop the oldest one and send a lost message event.
+	 */
+	if (fh->queued_msgs == CEC_MAX_MSG_QUEUE_SZ) {
+		list_del(&entry->list);
+		goto lost_msgs;
+	}
 	fh->queued_msgs++;
 	mutex_unlock(&fh->lock);
 	wake_up_interruptible(&fh->wait);
 	return;

 lost_msgs:
-	ev_lost_msg.lost_msgs.lost_msgs = ++fh->lost_msgs;
 	mutex_unlock(&fh->lock);
 	cec_queue_event_fh(fh, &ev_lost_msg, 0);
 }
@@ -548,12 +540,13 @@ void cec_transmit_done(struct cec_adapter *adap, u8 status, u8 arb_lost_cnt,
 	cec_queue_msg_monitor(adap, msg, 1);

 	/*
-	 * Clear reply on error of if the adapter is no longer
-	 * configured. It makes no sense to wait for a reply in
-	 * this case.
+	 * Clear reply and timeout on error or if the adapter is no longer
+	 * configured. It makes no sense to wait for a reply in that case.
 	 */
-	if (!(status & CEC_TX_STATUS_OK) || !adap->is_configured)
+	if (!(status & CEC_TX_STATUS_OK) || !adap->is_configured) {
 		msg->reply = 0;
+		msg->timeout = 0;
+	}

 	if (msg->timeout) {
 		/*
@@ -908,7 +901,7 @@ static int cec_report_features(struct cec_adapter *adap, unsigned int la_idx)
 	msg.msg[3] = las->all_device_types[la_idx];

 	/* Write RC Profiles first, then Device Features */
-	for (idx = 0; idx < sizeof(las->features[0]); idx++) {
+	for (idx = 0; idx < ARRAY_SIZE(las->features[0]); idx++) {
 		msg.msg[msg.len++] = features[idx];
 		if ((features[idx] & CEC_OP_FEAT_EXT) == 0) {
 			if (op_is_dev_features)
@@ -1543,14 +1536,15 @@ static int __cec_s_log_addrs(struct cec_adapter *adap,
 		if (log_addrs->cec_version < CEC_OP_CEC_VERSION_2_0)
 			continue;

-		for (i = 0; i < sizeof(log_addrs->features[0]); i++) {
+		for (i = 0; i < ARRAY_SIZE(log_addrs->features[0]); i++) {
 			if ((features[i] & 0x80) == 0) {
 				if (op_is_dev_features)
 					break;
 				op_is_dev_features = true;
 			}
 		}
-		if (!op_is_dev_features || i == sizeof(log_addrs->features[0])) {
+		if (!op_is_dev_features ||
+		    i == ARRAY_SIZE(log_addrs->features[0])) {
 			dprintk(1, "malformed features\n");
 			return -EINVAL;
 		}
@@ -1596,6 +1590,7 @@ int cec_s_log_addrs(struct cec_adapter *adap,
 }
 EXPORT_SYMBOL_GPL(cec_s_log_addrs);

+#ifdef CONFIG_MEDIA_CEC_DEBUG
 /*
  * Log the current state of the CEC adapter.
  * Very useful for debugging.
@@ -1637,6 +1632,7 @@ static int cec_status(struct seq_file *file, void *priv)
 	mutex_unlock(&adap->lock);
 	return 0;
 }
+#endif

 /* CEC file operations */

@@ -1655,7 +1651,7 @@ static unsigned int cec_poll(struct file *filp,
 		res |= POLLOUT | POLLWRNORM;
 	if (fh->queued_msgs)
 		res |= POLLIN | POLLRDNORM;
-	if (fh->events)
+	if (fh->pending_events)
 		res |= POLLPRI;
 	poll_wait(filp, &fh->wait, poll);
 	mutex_unlock(&adap->lock);
@@ -1685,6 +1681,149 @@ static void cec_monitor_all_cnt_dec(struct cec_adapter *adap)
 		WARN_ON(call_op(adap, adap_monitor_all_enable, 0));
 }

+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.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 = 0;
+	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;
+	mutex_lock(&adap->lock);
+	if (!adap->is_configured) {
+		err = -ENONET;
+	} else if (cec_is_busy(adap, fh)) {
+		err = -EBUSY;
+	} else {
+		if (!block || !msg.reply)
+			fh = NULL;
+		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)
 {
@@ -1703,15 +1842,16 @@ static int cec_receive_msg(struct cec_fh *fh, struct cec_msg *msg, bool block)
 			*msg = entry->msg;
 			kfree(entry);
 			fh->queued_msgs--;
-			res = 0;
-		} else {
-			/* No, return EAGAIN in non-blocking mode or wait */
-			res = -EAGAIN;
+			mutex_unlock(&fh->lock);
+			return 0;
 		}
+
+		/* No, return EAGAIN in non-blocking mode or wait */
 		mutex_unlock(&fh->lock);
-		/* Return when in non-blocking mode or if we have a message */
-		if (!block || !res)
-			break;
+
+		/* Return when in non-blocking mode */
+		if (!block)
+			return -EAGAIN;

 		if (msg->timeout) {
 			/* The user specified a timeout */
@@ -1732,322 +1872,222 @@ static int cec_receive_msg(struct cec_fh *fh, struct cec_msg *msg, bool block)
 	return res;
 }

-static bool cec_is_busy(const struct cec_adapter *adap,
-			const struct cec_fh *fh)
+static long cec_receive(struct cec_adapter *adap, struct cec_fh *fh,
+			bool block, struct cec_msg __user *parg)
 {
-	bool valid_initiator = adap->cec_initiator && adap->cec_initiator == fh;
-	bool valid_follower = adap->cec_follower && adap->cec_follower == fh;
+	struct cec_msg msg = {};
+	long err = 0;

-	/*
-	 * 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;
+	if (copy_from_user(&msg, parg, sizeof(msg)))
+		return -EFAULT;
+	mutex_lock(&adap->lock);
+	if (!adap->is_configured)
+		err = -ENONET;
+	mutex_unlock(&adap->lock);
+	if (err)
+		return err;
+
+	err = cec_receive_msg(fh, &msg, block);
+	if (err)
+		return err;
+	if (copy_to_user(parg, &msg, sizeof(msg)))
+		return -EFAULT;
+	return 0;
 }

-static long cec_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+static long cec_dqevent(struct cec_adapter *adap, struct cec_fh *fh,
+			bool block, struct cec_event __user *parg)
 {
-	struct cec_devnode *devnode = cec_devnode_data(filp);
-	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;
-	int err = 0;
-
-	if (!devnode->registered)
-		return -EIO;
+	struct cec_event *ev = NULL;
+	u64 ts = ~0ULL;
+	unsigned int i;
+	long err = 0;

-	switch (cmd) {
-	case CEC_ADAP_G_CAPS: {
-		struct cec_caps caps = {};
-
-		strlcpy(caps.driver, adap->devnode.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;
-		break;
+	mutex_lock(&fh->lock);
+	while (!fh->pending_events && block) {
+		mutex_unlock(&fh->lock);
+		err = wait_event_interruptible(fh->wait, fh->pending_events);
+		if (err)
+			return err;
+		mutex_lock(&fh->lock);
 	}

-	case CEC_TRANSMIT: {
-		struct cec_msg msg = {};
-
-		if (!(adap->capabilities & CEC_CAP_TRANSMIT))
-			return -ENOTTY;
-		if (copy_from_user(&msg, parg, sizeof(msg)))
-			return -EFAULT;
-		mutex_lock(&adap->lock);
-		if (!adap->is_configured) {
-			err = -ENONET;
-		} else if (cec_is_busy(adap, fh)) {
-			err = -EBUSY;
-		} else {
-			if (!block || !msg.reply)
-				fh = NULL;
-			err = cec_transmit_msg_fh(adap, &msg, fh, block);
+	/* Find the oldest event */
+	for (i = 0; i < CEC_NUM_EVENTS; i++) {
+		if (fh->pending_events & (1 << (i + 1)) &&
+		    fh->events[i].ts <= ts) {
+			ev = &fh->events[i];
+			ts = ev->ts;
 		}
-		mutex_unlock(&adap->lock);
-		if (err)
-			return err;
-		if (copy_to_user(parg, &msg, sizeof(msg)))
-			return -EFAULT;
-		break;
+	}
+	if (!ev) {
+		err = -EAGAIN;
+		goto unlock;
 	}

-	case CEC_RECEIVE: {
-		struct cec_msg msg = {};
+	if (copy_to_user(parg, ev, sizeof(*ev))) {
+		err = -EFAULT;
+		goto unlock;
+	}

-		if (copy_from_user(&msg, parg, sizeof(msg)))
-			return -EFAULT;
-		mutex_lock(&adap->lock);
-		if (!adap->is_configured)
-			err = -ENONET;
-		mutex_unlock(&adap->lock);
-		if (err)
-			return err;
+	fh->pending_events &= ~(1 << ev->event);

-		err = cec_receive_msg(fh, &msg, block);
-		if (err)
-			return err;
-		if (copy_to_user(parg, &msg, sizeof(msg)))
-			return -EFAULT;
-		break;
-	}
+unlock:
+	mutex_unlock(&fh->lock);
+	return err;
+}

-	case CEC_DQEVENT: {
-		struct cec_event_queue *evq = NULL;
-		struct cec_event *ev = NULL;
-		u64 ts = ~0ULL;
-		unsigned int i;
+static long cec_g_mode(struct cec_adapter *adap, struct cec_fh *fh,
+		       u32 __user *parg)
+{
+	u32 mode = fh->mode_initiator | fh->mode_follower;

-		mutex_lock(&fh->lock);
-		while (!fh->events && block) {
-			mutex_unlock(&fh->lock);
-			err = wait_event_interruptible(fh->wait, fh->events);
-			if (err)
-				return err;
-			mutex_lock(&fh->lock);
-		}
+	if (copy_to_user(parg, &mode, sizeof(mode)))
+		return -EFAULT;
+	return 0;
+}

-		/* Find the oldest event */
-		for (i = 0; i < CEC_NUM_EVENTS; i++) {
-			struct cec_event_queue *q = fh->evqueue + i;
+static long cec_s_mode(struct cec_adapter *adap, struct cec_fh *fh,
+		       u32 __user *parg)
+{
+	u32 mode;
+	u8 mode_initiator;
+	u8 mode_follower;
+	long err = 0;
+
+	if (copy_from_user(&mode, parg, sizeof(mode)))
+		return -EFAULT;
+	if (mode & ~(CEC_MODE_INITIATOR_MSK | CEC_MODE_FOLLOWER_MSK))
+		return -EINVAL;

-			if (q->num_events && q->events->ts <= ts) {
-				evq = q;
-				ev = q->events;
-				ts = ev->ts;
-			}
-		}
-		err = -EAGAIN;
-		if (ev) {
-			if (copy_to_user(parg, ev, sizeof(*ev))) {
-				err = -EFAULT;
-			} else {
-				unsigned int j;
-
-				evq->num_events--;
-				fh->events--;
-				/*
-				 * Reset lost message counter after returning
-				 * this event.
-				 */
-				if (ev->event == CEC_EVENT_LOST_MSGS)
-					fh->lost_msgs = 0;
-				for (j = 0; j < evq->num_events; j++)
-					evq->events[j] = evq->events[j + 1];
-				err = 0;
-			}
-		}
-		mutex_unlock(&fh->lock);
-		return err;
-	}
+	mode_initiator = mode & CEC_MODE_INITIATOR_MSK;
+	mode_follower = mode & CEC_MODE_FOLLOWER_MSK;

-	case CEC_ADAP_G_PHYS_ADDR: {
-		u16 phys_addr;
+	if (mode_initiator > CEC_MODE_EXCL_INITIATOR ||
+	    mode_follower > CEC_MODE_MONITOR_ALL)
+		return -EINVAL;

-		mutex_lock(&adap->lock);
-		phys_addr = adap->phys_addr;
-		if (copy_to_user(parg, &phys_addr, sizeof(adap->phys_addr)))
-			err = -EFAULT;
-		mutex_unlock(&adap->lock);
-		break;
-	}
+	if (mode_follower == CEC_MODE_MONITOR_ALL &&
+	    !(adap->capabilities & CEC_CAP_MONITOR_ALL))
+		return -EINVAL;

-	case CEC_ADAP_S_PHYS_ADDR: {
-		u16 phys_addr;
+	/* 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)
+		return -EINVAL;

-		if (!(adap->capabilities & CEC_CAP_PHYS_ADDR))
-			return -ENOTTY;
-		if (copy_from_user(&phys_addr, parg, sizeof(phys_addr)))
-			return -EFAULT;
+	/* Monitor modes require CEC_MODE_NO_INITIATOR */
+	if (mode_initiator && mode_follower >= CEC_MODE_MONITOR)
+		return -EINVAL;

-		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);
-		break;
-	}
+	/* Monitor modes require CAP_NET_ADMIN */
+	if (mode_follower >= CEC_MODE_MONITOR && !capable(CAP_NET_ADMIN))
+		return -EPERM;

-	case CEC_ADAP_G_LOG_ADDRS: {
-		struct cec_log_addrs log_addrs;
+	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;

-		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 (!err) {
+		bool old_mon_all = fh->mode_follower == CEC_MODE_MONITOR_ALL;
+		bool new_mon_all = mode_follower == CEC_MODE_MONITOR_ALL;

-		if (copy_to_user(parg, &log_addrs, sizeof(log_addrs)))
-			return -EFAULT;
-		break;
+		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);
+		}
 	}

-	case CEC_ADAP_S_LOG_ADDRS: {
-		struct cec_log_addrs log_addrs;
-
-		if (!(adap->capabilities & CEC_CAP_LOG_ADDRS))
-			return -ENOTTY;
-		if (copy_from_user(&log_addrs, parg, sizeof(log_addrs)))
-			return -EFAULT;
-		log_addrs.flags = 0;
-		mutex_lock(&adap->lock);
-		if (adap->is_configuring)
-			err = -EBUSY;
-		else if (log_addrs.num_log_addrs && adap->is_configured)
-			err = -EBUSY;
-		else if (cec_is_busy(adap, fh))
-			err = -EBUSY;
-		else
-			err = __cec_s_log_addrs(adap, &log_addrs, block);
-		if (!err)
-			log_addrs = adap->log_addrs;
+	if (err) {
 		mutex_unlock(&adap->lock);
-		if (!err && copy_to_user(parg, &log_addrs, sizeof(log_addrs)))
-			return -EFAULT;
-		break;
+		return err;
 	}

-	case CEC_G_MODE: {
-		u32 mode = fh->mode_initiator | fh->mode_follower;
-
-		if (copy_to_user(parg, &mode, sizeof(mode)))
-			return -EFAULT;
-		break;
+	if (fh->mode_follower == CEC_MODE_FOLLOWER)
+		adap->follower_cnt--;
+	if (mode_follower == CEC_MODE_FOLLOWER)
+		adap->follower_cnt++;
+	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;
+}

-	case CEC_S_MODE: {
-		u32 mode;
-		u8 mode_initiator;
-		u8 mode_follower;
+static long cec_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+	struct cec_devnode *devnode = cec_devnode_data(filp);
+	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 (copy_from_user(&mode, parg, sizeof(mode)))
-			return -EFAULT;
-		if (mode & ~(CEC_MODE_INITIATOR_MSK | CEC_MODE_FOLLOWER_MSK))
-			return -EINVAL;
+	if (!devnode->registered)
+		return -EIO;

-		mode_initiator = mode & CEC_MODE_INITIATOR_MSK;
-		mode_follower = mode & CEC_MODE_FOLLOWER_MSK;
+	switch (cmd) {
+	case CEC_ADAP_G_CAPS:
+		return cec_adap_g_caps(adap, parg);

-		if (mode_initiator > CEC_MODE_EXCL_INITIATOR ||
-		    mode_follower > CEC_MODE_MONITOR_ALL)
-			return -EINVAL;
+	case CEC_ADAP_G_PHYS_ADDR:
+		return cec_adap_g_phys_addr(adap, parg);

-		if (mode_follower == CEC_MODE_MONITOR_ALL &&
-		    !(adap->capabilities & CEC_CAP_MONITOR_ALL))
-			return -EINVAL;
+	case CEC_ADAP_S_PHYS_ADDR:
+		return cec_adap_s_phys_addr(adap, fh, block, parg);

-		/* 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)
-			return -EINVAL;
+	case CEC_ADAP_G_LOG_ADDRS:
+		return cec_adap_g_log_addrs(adap, parg);

-		/* Monitor modes require CEC_MODE_NO_INITIATOR */
-		if (mode_initiator && mode_follower >= CEC_MODE_MONITOR)
-			return -EINVAL;
+	case CEC_ADAP_S_LOG_ADDRS:
+		return cec_adap_s_log_addrs(adap, fh, block, parg);

-		/* Monitor modes require CAP_NET_ADMIN */
-		if (mode_follower >= CEC_MODE_MONITOR && !capable(CAP_NET_ADMIN))
-			return -EPERM;
+	case CEC_TRANSMIT:
+		return cec_transmit(adap, fh, block, parg);

-		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);
-			}
-		}
+	case CEC_RECEIVE:
+		return cec_receive(adap, fh, block, parg);

-		if (err) {
-			mutex_unlock(&adap->lock);
-			break;
-		}
+	case CEC_DQEVENT:
+		return cec_dqevent(adap, fh, block, parg);

-		if (fh->mode_follower == CEC_MODE_FOLLOWER)
-			adap->follower_cnt--;
-		if (mode_follower == CEC_MODE_FOLLOWER)
-			adap->follower_cnt++;
-		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);
-		break;
-	}
+	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;
 	}
-	return err;
 }

 static int cec_open(struct inode *inode, struct file *filp)
@@ -2064,18 +2104,10 @@ static int cec_open(struct inode *inode, struct file *filp)
 		.event = CEC_EVENT_STATE_CHANGE,
 		.flags = CEC_EVENT_FL_INITIAL_STATE,
 	};
-	int ret;

 	if (!fh)
 		return -ENOMEM;

-	ret = cec_queue_event_init(fh);
-
-	if (ret) {
-		kfree(fh);
-		return ret;
-	}
-
 	INIT_LIST_HEAD(&fh->msgs);
 	INIT_LIST_HEAD(&fh->xfer_list);
 	mutex_init(&fh->lock);
@@ -2098,7 +2130,6 @@ static int cec_open(struct inode *inode, struct file *filp)
 	 */
 	if (!devnode->registered) {
 		mutex_unlock(&cec_devnode_lock);
-		cec_queue_event_free(fh);
 		kfree(fh);
 		return -ENXIO;
 	}
@@ -2162,7 +2193,6 @@ static int cec_release(struct inode *inode, struct file *filp)
 		list_del(&entry->list);
 		kfree(entry);
 	}
-	cec_queue_event_free(fh);
 	kfree(fh);

 	/*
@@ -2201,9 +2231,8 @@ static struct bus_type cec_bus_type = {
 	.name = CEC_NAME,
 };

-/**
- * cec_devnode_register - register a cec device node
- * @devnode: cec device node structure we want to register
+/*
+ * 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,
@@ -2267,13 +2296,11 @@ cdev_del:
 	cdev_del(&devnode->cdev);
 clr_bit:
 	clear_bit(devnode->minor, cec_devnode_nums);
-	put_device(&devnode->dev);
 	return ret;
 }

-/**
- * cec_devnode_unregister - unregister a cec device node
- * @devnode: the device node to unregister
+/*
+ * Unregister a cec device node
  *
  * This unregisters the passed device. Future open calls will be met with
  * errors.
@@ -2371,6 +2398,7 @@ struct cec_adapter *cec_allocate_adapter(const struct cec_adap_ops *ops,
 	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;
@@ -2404,16 +2432,17 @@ int cec_register_adapter(struct cec_adapter *adap)
 #endif

 	res = cec_devnode_register(&adap->devnode, adap->owner);
-#if IS_ENABLED(CONFIG_RC_CORE)
 	if (res) {
+#if IS_ENABLED(CONFIG_RC_CORE)
 		/* Note: rc_unregister also calls rc_free */
 		rc_unregister_device(adap->rc);
 		adap->rc = NULL;
+#endif
 		return res;
 	}
-#endif

 	dev_set_drvdata(&adap->devnode.dev, adap);
+#ifdef CONFIG_MEDIA_CEC_DEBUG
 	if (!top_cec_dir)
 		return 0;

@@ -2429,6 +2458,7 @@ int cec_register_adapter(struct cec_adapter *adap)
 		debugfs_remove_recursive(adap->cec_dir);
 		adap->cec_dir = NULL;
 	}
+#endif
 	return 0;
 }
 EXPORT_SYMBOL_GPL(cec_register_adapter);
@@ -2481,11 +2511,13 @@ static int __init cec_devnode_init(void)
 		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) {
diff --git a/include/linux/cec-funcs.h b/include/linux/cec-funcs.h
index 155f6b9..8ee1029 100644
--- a/include/linux/cec-funcs.h
+++ b/include/linux/cec-funcs.h
@@ -17,6 +17,12 @@
  * SOFTWARE.
  */

+/*
+ * Note: this framework is still in staging and it is likely the API
+ * will change before it goes out of staging.
+ *
+ * Once it is moved out of staging this header will move to uapi.
+ */
 #ifndef _CEC_UAPI_FUNCS_H
 #define _CEC_UAPI_FUNCS_H

diff --git a/include/linux/cec.h b/include/linux/cec.h
index 0fd0e31..40924e7 100644
--- a/include/linux/cec.h
+++ b/include/linux/cec.h
@@ -17,6 +17,12 @@
  * SOFTWARE.
  */

+/*
+ * Note: this framework is still in staging and it is likely the API
+ * will change before it goes out of staging.
+ *
+ * Once it is moved out of staging this header will move to uapi.
+ */
 #ifndef _CEC_UAPI_H
 #define _CEC_UAPI_H

diff --git a/include/media/cec.h b/include/media/cec.h
index 25d89b1..9a791c0 100644
--- a/include/media/cec.h
+++ b/include/media/cec.h
@@ -85,12 +85,6 @@ struct cec_msg_entry {

 #define CEC_NUM_EVENTS		CEC_EVENT_LOST_MSGS

-struct cec_event_queue {
-	unsigned int		elems;
-	unsigned int		num_events;
-	struct cec_event	*events;
-};
-
 struct cec_fh {
 	struct list_head	list;
 	struct list_head	xfer_list;
@@ -100,12 +94,11 @@ struct cec_fh {

 	/* Events */
 	wait_queue_head_t	wait;
-	unsigned int		events;
-	struct cec_event_queue	evqueue[CEC_NUM_EVENTS];
+	unsigned int		pending_events;
+	struct cec_event	events[CEC_NUM_EVENTS];
 	struct mutex		lock;
 	struct list_head	msgs; /* queued messages */
 	unsigned int		queued_msgs;
-	unsigned int		lost_msgs;
 };

 #define CEC_SIGNAL_FREE_TIME_RETRY		3
@@ -133,9 +126,12 @@ struct cec_adap_ops {
  * With a transfer rate of at most 36 bytes per second this makes 18 messages
  * per second worst case.
  *
- * We queue at most 10 seconds worth of messages.
+ * We queue at most 3 seconds worth of messages. The CEC specification requires
+ * that messages are replied to within a second, so 3 seconds should give more
+ * than enough margin. Since most messages are actually more than 2 bytes, this
+ * is in practice a lot more than 3 seconds.
  */
-#define CEC_MAX_MSG_QUEUE_SZ		(18 * 10)
+#define CEC_MAX_MSG_QUEUE_SZ		(18 * 3)

 struct cec_adapter {
 	struct module *owner;
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html



[Index of Archives]     [Linux Input]     [Video for Linux]     [Gstreamer Embedded]     [Mplayer Users]     [Linux USB Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux