Re: [PATCH] media: vivid: add signal-free time for cec message xfer

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

 



Hi Deb,

Some comments below:

On 24/08/2021 06:29, Deborah Brouwer wrote:
> Currently, the vivid emulation of cec message transmission does not force
> adapters to wait until the cec bus has been signal-free for a certain
> number of bit periods before transmitting or re-transmitting a message.
> Without enforcing the signal-free time requirements, adapters do not share
> the bus very well and some messages are sent too quickly while other
> messages are lost. By emulating a signal-free time and forcing adapters
> to wait their turn to transmit, the vivid emulation of cec transmission
> is much more reliable.
> 
> Signed-off-by: Deborah Brouwer <deborahbrouwer3563@xxxxxxxxx>
> ---
>  drivers/media/test-drivers/vivid/vivid-cec.c  | 332 ++++++++++--------
>  drivers/media/test-drivers/vivid/vivid-cec.h  |   9 +-
>  drivers/media/test-drivers/vivid/vivid-core.c |  37 +-
>  drivers/media/test-drivers/vivid/vivid-core.h |  22 +-
>  4 files changed, 209 insertions(+), 191 deletions(-)
> 
> diff --git a/drivers/media/test-drivers/vivid/vivid-cec.c b/drivers/media/test-drivers/vivid/vivid-cec.c
> index 4d2413e87730..a832cdac941c 100644
> --- a/drivers/media/test-drivers/vivid/vivid-cec.c
> +++ b/drivers/media/test-drivers/vivid/vivid-cec.c
> @@ -5,40 +5,23 @@
>   * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
>   */
>  
> +#include <linux/delay.h>
>  #include <media/cec.h>
>  
>  #include "vivid-core.h"
>  #include "vivid-cec.h"
>  
> -#define CEC_TIM_START_BIT_TOTAL		4500
> -#define CEC_TIM_START_BIT_LOW		3700
> -#define CEC_TIM_START_BIT_HIGH		800
> -#define CEC_TIM_DATA_BIT_TOTAL		2400
> -#define CEC_TIM_DATA_BIT_0_LOW		1500
> -#define CEC_TIM_DATA_BIT_0_HIGH		900
> -#define CEC_TIM_DATA_BIT_1_LOW		600
> -#define CEC_TIM_DATA_BIT_1_HIGH		1800
> +#define CEC_START_BIT_US		4500
> +#define CEC_DATA_BIT_US			2400
> +#define CEC_MARGIN_US			350
>  
> -void vivid_cec_bus_free_work(struct vivid_dev *dev)
> -{
> -	spin_lock(&dev->cec_slock);
> -	while (!list_empty(&dev->cec_work_list)) {
> -		struct vivid_cec_work *cw =
> -			list_first_entry(&dev->cec_work_list,
> -					 struct vivid_cec_work, list);
> -
> -		spin_unlock(&dev->cec_slock);
> -		cancel_delayed_work_sync(&cw->work);
> -		spin_lock(&dev->cec_slock);
> -		list_del(&cw->list);
> -		cec_transmit_attempt_done(cw->adap, CEC_TX_STATUS_LOW_DRIVE);
> -		kfree(cw);
> -	}
> -	spin_unlock(&dev->cec_slock);
> -}
> +struct xfer_on_bus {
> +	struct cec_adapter	*adap;
> +	u8			status;
> +};
>  
> -static bool vivid_cec_find_dest_adap(struct vivid_dev *dev,
> -				     struct cec_adapter *adap, u8 dest)
> +static bool find_dest_adap(struct vivid_dev *dev,
> +			   struct cec_adapter *adap, u8 dest)
>  {
>  	unsigned int i;
>  
> @@ -61,116 +44,186 @@ static bool vivid_cec_find_dest_adap(struct vivid_dev *dev,
>  	return false;
>  }
>  
> -static void vivid_cec_pin_adap_events(struct cec_adapter *adap, ktime_t ts,
> -				      const struct cec_msg *msg, bool nacked)
> +static bool xfer_ready(struct vivid_dev *dev)
>  {
> -	unsigned int len = nacked ? 1 : msg->len;
>  	unsigned int i;
> -	bool bit;
> +	bool ready = false;
>  
> -	if (adap == NULL)
> -		return;
> -
> -	/*
> -	 * Suffix ULL on constant 10 makes the expression
> -	 * CEC_TIM_START_BIT_TOTAL + 10ULL * len * CEC_TIM_DATA_BIT_TOTAL
> -	 * to be evaluated using 64-bit unsigned arithmetic (u64), which
> -	 * is what ktime_sub_us expects as second argument.
> -	 */
> -	ts = ktime_sub_us(ts, CEC_TIM_START_BIT_TOTAL +
> -			       10ULL * len * CEC_TIM_DATA_BIT_TOTAL);
> -	cec_queue_pin_cec_event(adap, false, false, ts);
> -	ts = ktime_add_us(ts, CEC_TIM_START_BIT_LOW);
> -	cec_queue_pin_cec_event(adap, true, false, ts);
> -	ts = ktime_add_us(ts, CEC_TIM_START_BIT_HIGH);
> -
> -	for (i = 0; i < 10 * len; i++) {
> -		switch (i % 10) {
> -		case 0 ... 7:
> -			bit = msg->msg[i / 10] & (0x80 >> (i % 10));
> -			break;
> -		case 8: /* EOM */
> -			bit = i / 10 == msg->len - 1;
> -			break;
> -		case 9: /* ACK */
> -			bit = cec_msg_is_broadcast(msg) ^ nacked;
> +	spin_lock(&dev->cec_xfers_slock);
> +	for (i = 0; i < ARRAY_SIZE(dev->xfers); i++) {
> +		if (dev->xfers[i].sft &&
> +		    dev->xfers[i].sft <= dev->cec_sft) {
> +			ready = true;
>  			break;
>  		}
> -		cec_queue_pin_cec_event(adap, false, false, ts);
> -		if (bit)
> -			ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_1_LOW);
> -		else
> -			ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_0_LOW);
> -		cec_queue_pin_cec_event(adap, true, false, ts);
> -		if (bit)
> -			ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_1_HIGH);
> -		else
> -			ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_0_HIGH);
>  	}
> -}
> -
> -static void vivid_cec_pin_events(struct vivid_dev *dev,
> -				 const struct cec_msg *msg, bool nacked)
> -{
> -	ktime_t ts = ktime_get();
> -	unsigned int i;
> +	spin_unlock(&dev->cec_xfers_slock);
>  
> -	vivid_cec_pin_adap_events(dev->cec_rx_adap, ts, msg, nacked);
> -	for (i = 0; i < MAX_OUTPUTS; i++)
> -		vivid_cec_pin_adap_events(dev->cec_tx_adap[i], ts, msg, nacked);
> +	return ready;
>  }
>  
> -static void vivid_cec_xfer_done_worker(struct work_struct *work)
> +/*
> + * If an adapter tries to send successive messages, it must wait for the
> + * longest signal-free time between its transmissions. But, if another
> + * adapter sends a message in the interim, then the wait can be reduced
> + * because the messages are no longer successive. Make these adjustments
> + * if necessary.
> + */
> +static void adjust_sfts(struct vivid_dev *dev, u8 last_initiator)
>  {
> -	struct vivid_cec_work *cw =
> -		container_of(work, struct vivid_cec_work, work.work);
> -	struct vivid_dev *dev = cw->dev;
> -	struct cec_adapter *adap = cw->adap;
> -	u8 dest = cec_msg_destination(&cw->msg);
> -	bool valid_dest;
>  	unsigned int i;
> +	u8 initiator;
>  
> -	valid_dest = cec_msg_is_broadcast(&cw->msg);
> -	if (!valid_dest)
> -		valid_dest = vivid_cec_find_dest_adap(dev, adap, dest);
> -
> -	cw->tx_status = valid_dest ? CEC_TX_STATUS_OK : CEC_TX_STATUS_NACK;
> -	spin_lock(&dev->cec_slock);
> -	dev->cec_xfer_time_jiffies = 0;
> -	dev->cec_xfer_start_jiffies = 0;
> -	list_del(&cw->list);
> -	spin_unlock(&dev->cec_slock);
> -	vivid_cec_pin_events(dev, &cw->msg, !valid_dest);
> -	cec_transmit_attempt_done(cw->adap, cw->tx_status);
> -
> -	/* Broadcast message */
> -	if (adap != dev->cec_rx_adap)
> -		cec_received_msg(dev->cec_rx_adap, &cw->msg);
> -	for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++)
> -		if (adap != dev->cec_tx_adap[i])
> -			cec_received_msg(dev->cec_tx_adap[i], &cw->msg);
> -	kfree(cw);
> +	spin_lock(&dev->cec_xfers_slock);
> +	for (i = 0; i < ARRAY_SIZE(dev->xfers); i++) {
> +		if (dev->xfers[i].sft <= CEC_SIGNAL_FREE_TIME_RETRY)
> +			continue;
> +		initiator = dev->xfers[i].msg[0] >> 4;
> +		if (initiator == last_initiator)
> +			dev->xfers[i].sft = CEC_SIGNAL_FREE_TIME_NEXT_XFER;
> +		else
> +			dev->xfers[i].sft = CEC_SIGNAL_FREE_TIME_NEW_INITIATOR;
> +	}
> +	spin_unlock(&dev->cec_xfers_slock);
>  }
>  
> -static void vivid_cec_xfer_try_worker(struct work_struct *work)
> +/*
> + * The main emulation of the bus on which CEC adapters attempt to send
> + * messages to each other. The bus keeps track of how long it has been
> + * signal-free and accepts a pending transmission only if the state of
> + * the bus matches the transmission's signal-free requirements. It calls
> + * cec_transmit_attempt_done() for all transmits that enter the bus and
> + * cec_received_msg() for successful transmits.
> + */
> +int vivid_cec_bus_thread(void *_dev)
>  {
> -	struct vivid_cec_work *cw =
> -		container_of(work, struct vivid_cec_work, work.work);
> -	struct vivid_dev *dev = cw->dev;
> -
> -	spin_lock(&dev->cec_slock);
> -	if (dev->cec_xfer_time_jiffies) {
> -		list_del(&cw->list);
> -		spin_unlock(&dev->cec_slock);
> -		cec_transmit_attempt_done(cw->adap, CEC_TX_STATUS_ARB_LOST);
> -		kfree(cw);
> -	} else {
> -		INIT_DELAYED_WORK(&cw->work, vivid_cec_xfer_done_worker);
> -		dev->cec_xfer_start_jiffies = jiffies;
> -		dev->cec_xfer_time_jiffies = usecs_to_jiffies(cw->usecs);
> -		spin_unlock(&dev->cec_slock);
> -		schedule_delayed_work(&cw->work, dev->cec_xfer_time_jiffies);
> +	u32 last_sft;
> +	unsigned int i;
> +	unsigned int dest;
> +	u8 last_initiator;
> +	ktime_t start, end;
> +	s64 delta_us, retry_us;
> +	unsigned int first_idx;
> +	unsigned int first_status;
> +	struct vivid_dev *dev = _dev;
> +
> +	dev->cec_sft = CEC_SIGNAL_FREE_TIME_NEXT_XFER;
> +	for (;;) {
> +		bool first = true;
> +		int wait_xfer_us = 0;
> +		bool valid_dest = false;
> +		int wait_arb_lost_us = 0;
> +		struct cec_msg first_msg = {};
> +		struct xfer_on_bus xfers_on_bus[MAX_OUTPUTS] = {};
> +
> +		wait_event_interruptible(dev->kthread_waitq_cec, xfer_ready(dev) ||
> +					 kthread_should_stop());
> +		if (kthread_should_stop())
> +			break;
> +		last_sft = dev->cec_sft;
> +		dev->cec_sft = 0;
> +		/*
> +		 * Move the messages that are ready onto the bus. The adapter with
> +		 * the most leading zeros will win control of the bus and any other
> +		 * adapters will lose arbitration.
> +		 */
> +		spin_lock(&dev->cec_xfers_slock);
> +		for (i = 0; i < ARRAY_SIZE(dev->xfers); i++) {
> +			if (!dev->xfers[i].sft || dev->xfers[i].sft > last_sft)
> +				continue;
> +			if (first) {
> +				first = false;
> +				first_idx = i;
> +				xfers_on_bus[first_idx].adap = dev->xfers[i].adap;
> +				memcpy(first_msg.msg, dev->xfers[i].msg, CEC_MAX_MSG_SIZE);

Instead of MAX_MSG_SIZE you can use the actual length.

> +				first_msg.len = dev->xfers[i].len;
> +			} else {
> +				xfers_on_bus[i].adap = dev->xfers[i].adap;
> +				xfers_on_bus[i].status = CEC_TX_STATUS_ARB_LOST;
> +				/*
> +				 * For simplicity wait for all 4 bits of the initiator's
> +				 * address even though HDMI specification uses bit-level
> +				 * precision.
> +				 */
> +				wait_arb_lost_us = 4 * CEC_DATA_BIT_US + CEC_START_BIT_US;
> +			}
> +			dev->xfers[i].sft = 0;
> +		}

You can update the last_initiator state information here (see comments below) and call
adjust_sfts(). Since adjust_sfts() is called with the spinlock held, you can drop the
locking in that function.

> +		spin_unlock(&dev->cec_xfers_slock);
> +
> +		dest = cec_msg_destination(&first_msg);
> +		valid_dest = cec_msg_is_broadcast(&first_msg);
> +		if (!valid_dest)
> +			valid_dest = find_dest_adap(dev, xfers_on_bus[first_idx].adap, dest);
> +		if (valid_dest) {
> +			first_status = CEC_TX_STATUS_OK;
> +			/*
> +			 * Message length is in bytes, but each byte is transmitted in
> +			 * a block of 10 bits.
> +			 */
> +			wait_xfer_us = first_msg.len * 10 * CEC_DATA_BIT_US;
> +		} else {
> +			first_status = CEC_TX_STATUS_NACK;
> +			/*
> +			 * A message that is not acknowledged stops transmitting after
> +			 * the header block of 10 bits.
> +			 */
> +			wait_xfer_us = 10 * CEC_DATA_BIT_US;
> +		}
> +		wait_xfer_us += CEC_START_BIT_US;
> +		xfers_on_bus[first_idx].status = first_status;
> +
> +		/* Sleep as if sending messages on a real hardware bus. */
> +		start = ktime_get();
> +		if (wait_arb_lost_us) {
> +			usleep_range(wait_arb_lost_us - CEC_MARGIN_US, wait_arb_lost_us);
> +			for (i = 0; i < ARRAY_SIZE(xfers_on_bus); i++) {
> +				if (xfers_on_bus[i].status != CEC_TX_STATUS_ARB_LOST)
> +					continue;
> +				cec_transmit_attempt_done(xfers_on_bus[i].adap,
> +							  CEC_TX_STATUS_ARB_LOST);
> +			}

Check for kthread_should_stop() here...

> +		}
> +		wait_xfer_us -= wait_arb_lost_us;
> +		usleep_range(wait_xfer_us - CEC_MARGIN_US, wait_xfer_us);
> +		cec_transmit_attempt_done(xfers_on_bus[first_idx].adap, first_status);

and here.

> +		if (first_status == CEC_TX_STATUS_OK) {
> +			if (xfers_on_bus[first_idx].adap != dev->cec_rx_adap)
> +				cec_received_msg(dev->cec_rx_adap, &first_msg);
> +			for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++)
> +				if (xfers_on_bus[first_idx].adap != dev->cec_tx_adap[i])
> +					cec_received_msg(dev->cec_tx_adap[i], &first_msg);
> +		}
> +		end = ktime_get();
> +		/*
> +		 * If the emulated transfer took more or less time than it should
> +		 * have, then compensate by adjusting the wait time needed for the
> +		 * bus to be signal-free for 3 bit periods (the retry time).
> +		 */
> +		delta_us = (end - start) / 1000ULL;
> +		delta_us -= wait_xfer_us + wait_arb_lost_us;
> +		retry_us = CEC_SIGNAL_FREE_TIME_RETRY * CEC_DATA_BIT_US - delta_us;
> +		if (retry_us > CEC_MARGIN_US)
> +			usleep_range(retry_us - CEC_MARGIN_US, retry_us);
> +		dev->cec_sft = CEC_SIGNAL_FREE_TIME_RETRY;
> +		last_initiator = cec_msg_initiator(&first_msg);

Shouldn't adjust_sfts() be called here before entering the while-loop?

Also, as pointed out above, you know the last_initiator earlier, so you can do
this as soon as it is known.

I think the last_initiator should also be stored in the vivid state, so adap_transmit
can use it as well (see my comment below).

> +		/*
> +		 * If there are no messages that need to be retried, check if any
> +		 * adapters that did not just transmit a message are ready to
> +		 * transmit. If none of these adapters are ready, then increase
> +		 * the signal-free time so that the bus is available to all
> +		 * adapters and go back to waiting for a transmission.
> +		 */
> +		while (dev->cec_sft >= CEC_SIGNAL_FREE_TIME_RETRY &&
> +		       dev->cec_sft < CEC_SIGNAL_FREE_TIME_NEXT_XFER &&
> +		       !xfer_ready(dev)) {

Check for kthread_should_stop() as well.

> +			adjust_sfts(dev, last_initiator);
> +			usleep_range(2 * CEC_DATA_BIT_US - CEC_MARGIN_US,
> +				     2 * CEC_DATA_BIT_US);
> +			dev->cec_sft += 2;
> +		}
>  	}
> +	return 0;
>  }
>  
>  static int vivid_cec_adap_enable(struct cec_adapter *adap, bool enable)
> @@ -184,41 +237,20 @@ static int vivid_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
>  	return 0;
>  }
>  
> -/*
> - * One data bit takes 2400 us, each byte needs 10 bits so that's 24000 us
> - * per byte.
> - */
> -#define USECS_PER_BYTE 24000
> -
>  static int vivid_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
>  				   u32 signal_free_time, struct cec_msg *msg)
>  {
>  	struct vivid_dev *dev = cec_get_drvdata(adap);
> -	struct vivid_cec_work *cw = kzalloc(sizeof(*cw), GFP_KERNEL);
> -	long delta_jiffies = 0;
> +	u8 idx = cec_msg_initiator(msg);
>  
> -	if (cw == NULL)
> -		return -ENOMEM;
> -	cw->dev = dev;
> -	cw->adap = adap;
> -	cw->usecs = CEC_FREE_TIME_TO_USEC(signal_free_time) +
> -		    msg->len * USECS_PER_BYTE;
> -	cw->msg = *msg;
> +	spin_lock(&dev->cec_xfers_slock);
> +	dev->xfers[idx].adap = adap;
> +	memcpy(dev->xfers[idx].msg, msg->msg, CEC_MAX_MSG_SIZE);
> +	dev->xfers[idx].len = msg->len;
> +	dev->xfers[idx].sft = signal_free_time;

This is directly using the signal_free_time passed in from the framework.

But if the last_initiator as seen by the emulated CEC bus is stored in the vivid
state, then this function can take that into account. Basically if signal_free_time
is > RETRY, then use the last_initiator information to set the sft to NEXT_XFER or
NEW_INITIATOR. The bus emulation has better information about this than the framework.

> +	spin_unlock(&dev->cec_xfers_slock);
> +	wake_up_interruptible(&dev->kthread_waitq_cec);
>  
> -	spin_lock(&dev->cec_slock);
> -	list_add(&cw->list, &dev->cec_work_list);
> -	if (dev->cec_xfer_time_jiffies == 0) {
> -		INIT_DELAYED_WORK(&cw->work, vivid_cec_xfer_done_worker);
> -		dev->cec_xfer_start_jiffies = jiffies;
> -		dev->cec_xfer_time_jiffies = usecs_to_jiffies(cw->usecs);
> -		delta_jiffies = dev->cec_xfer_time_jiffies;
> -	} else {
> -		INIT_DELAYED_WORK(&cw->work, vivid_cec_xfer_try_worker);
> -		delta_jiffies = dev->cec_xfer_start_jiffies +
> -			dev->cec_xfer_time_jiffies - jiffies;
> -	}
> -	spin_unlock(&dev->cec_slock);
> -	schedule_delayed_work(&cw->work, delta_jiffies < 0 ? 0 : delta_jiffies);
>  	return 0;
>  }
>  
> diff --git a/drivers/media/test-drivers/vivid/vivid-cec.h b/drivers/media/test-drivers/vivid/vivid-cec.h
> index 7524ed48a914..b2bcddb50b83 100644
> --- a/drivers/media/test-drivers/vivid/vivid-cec.h
> +++ b/drivers/media/test-drivers/vivid/vivid-cec.h
> @@ -9,12 +9,5 @@
>  struct cec_adapter *vivid_cec_alloc_adap(struct vivid_dev *dev,
>  					 unsigned int idx,
>  					 bool is_source);
> -void vivid_cec_bus_free_work(struct vivid_dev *dev);
> -
> -#else
> -
> -static inline void vivid_cec_bus_free_work(struct vivid_dev *dev)
> -{
> -}
> -
> +int vivid_cec_bus_thread(void *_dev);
>  #endif
> diff --git a/drivers/media/test-drivers/vivid/vivid-core.c b/drivers/media/test-drivers/vivid/vivid-core.c
> index d2bd2653cf54..1973e08953ab 100644
> --- a/drivers/media/test-drivers/vivid/vivid-core.c
> +++ b/drivers/media/test-drivers/vivid/vivid-core.c
> @@ -1878,18 +1878,7 @@ static int vivid_create_instance(struct platform_device *pdev, int inst)
>  	INIT_LIST_HEAD(&dev->meta_out_active);
>  	INIT_LIST_HEAD(&dev->touch_cap_active);
>  
> -	INIT_LIST_HEAD(&dev->cec_work_list);
> -	spin_lock_init(&dev->cec_slock);
> -	/*
> -	 * Same as create_singlethread_workqueue, but now I can use the
> -	 * string formatting of alloc_ordered_workqueue.
> -	 */
> -	dev->cec_workqueue = alloc_ordered_workqueue("vivid-%03d-cec",
> -						     WQ_MEM_RECLAIM, inst);
> -	if (!dev->cec_workqueue) {
> -		ret = -ENOMEM;
> -		goto unreg_dev;
> -	}
> +	spin_lock_init(&dev->cec_xfers_slock);
>  
>  	if (allocators[inst] == 1)
>  		dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
> @@ -1929,6 +1918,18 @@ static int vivid_create_instance(struct platform_device *pdev, int inst)
>  			cec_tx_bus_cnt++;
>  		}
>  	}
> +
> +	if (dev->cec_rx_adap || cec_tx_bus_cnt) {
> +		init_waitqueue_head(&dev->kthread_waitq_cec);
> +		dev->kthread_cec = kthread_run(vivid_cec_bus_thread, dev,
> +					       "vivid_cec-%s", dev->v4l2_dev.name);
> +		if (IS_ERR(dev->kthread_cec)) {
> +			dev->kthread_cec = NULL;
> +			v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
> +			goto unreg_dev;
> +		}
> +	}
> +
>  #endif
>  
>  	v4l2_ctrl_handler_setup(&dev->ctrl_hdl_vid_cap);
> @@ -1968,10 +1969,8 @@ static int vivid_create_instance(struct platform_device *pdev, int inst)
>  	cec_unregister_adapter(dev->cec_rx_adap);
>  	for (i = 0; i < MAX_OUTPUTS; i++)
>  		cec_unregister_adapter(dev->cec_tx_adap[i]);
> -	if (dev->cec_workqueue) {
> -		vivid_cec_bus_free_work(dev);
> -		destroy_workqueue(dev->cec_workqueue);
> -	}
> +	if (dev->kthread_cec)
> +		kthread_stop(dev->kthread_cec);
>  free_dev:
>  	v4l2_device_put(&dev->v4l2_dev);
>  	return ret;
> @@ -2093,10 +2092,8 @@ static int vivid_remove(struct platform_device *pdev)
>  		cec_unregister_adapter(dev->cec_rx_adap);
>  		for (j = 0; j < MAX_OUTPUTS; j++)
>  			cec_unregister_adapter(dev->cec_tx_adap[j]);
> -		if (dev->cec_workqueue) {
> -			vivid_cec_bus_free_work(dev);
> -			destroy_workqueue(dev->cec_workqueue);
> -		}
> +		if (dev->kthread_cec)
> +			kthread_stop(dev->kthread_cec);
>  		v4l2_device_put(&dev->v4l2_dev);
>  		vivid_devs[i] = NULL;
>  	}
> diff --git a/drivers/media/test-drivers/vivid/vivid-core.h b/drivers/media/test-drivers/vivid/vivid-core.h
> index 1e3c4f5a9413..19e70c5cccc8 100644
> --- a/drivers/media/test-drivers/vivid/vivid-core.h
> +++ b/drivers/media/test-drivers/vivid/vivid-core.h
> @@ -110,15 +110,11 @@ enum vivid_colorspace {
>  #define VIVID_INVALID_SIGNAL(mode) \
>  	((mode) == NO_SIGNAL || (mode) == NO_LOCK || (mode) == OUT_OF_RANGE)
>  
> -struct vivid_cec_work {
> -	struct list_head	list;
> -	struct delayed_work	work;
> +struct vivid_cec_xfer {
>  	struct cec_adapter	*adap;
> -	struct vivid_dev	*dev;
> -	unsigned int		usecs;
> -	unsigned int		timeout_ms;
> -	u8			tx_status;
> -	struct cec_msg		msg;
> +	u8			msg[CEC_MAX_MSG_SIZE];
> +	u32			len;
> +	u32			sft;
>  };
>  
>  struct vivid_dev {
> @@ -560,12 +556,12 @@ struct vivid_dev {
>  	/* CEC */
>  	struct cec_adapter		*cec_rx_adap;
>  	struct cec_adapter		*cec_tx_adap[MAX_OUTPUTS];
> -	struct workqueue_struct		*cec_workqueue;
> -	spinlock_t			cec_slock;
> -	struct list_head		cec_work_list;
> -	unsigned int			cec_xfer_time_jiffies;
> -	unsigned long			cec_xfer_start_jiffies;
>  	u8				cec_output2bus_map[MAX_OUTPUTS];
> +	struct task_struct		*kthread_cec;
> +	wait_queue_head_t		kthread_waitq_cec;
> +	struct vivid_cec_xfer	xfers[MAX_OUTPUTS];
> +	spinlock_t			cec_xfers_slock; /* read and write cec messages */
> +	u32				cec_sft; /* bus signal free time, in bit periods */
>  
>  	/* CEC OSD String */
>  	char				osd[14];
> 

Regards,

	Hans



[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