Merge remote-tracking branch 'airlied/drm-next' into drm-intel-next-queued

Silicon Image SiI8620 HDMI/MHL bridge bindings

Required properties:

	- compatible: "sil,sii8620"

	- reg: i2c address of the bridge

	- cvcc10-supply: Digital Core Supply Voltage (1.0V)

	- iovcc18-supply: I/O Supply Voltage (1.8V)

	- interrupts, interrupt-parent: interrupt specifier of INT pin

	- reset-gpios: gpio specifier of RESET pin

	- clocks, clock-names: specification and name of "xtal" clock

	- video interfaces: Device node can contain video interface port

			    node for HDMI encoder according to [1].

[1]: Documentation/devicetree/bindings/media/video-interfaces.txt

Example:

	sii8620@39 {

		reg = <0x39>;

		compatible = "sil,sii8620";

		cvcc10-supply = <&ldo36_reg>;

		iovcc18-supply = <&ldo34_reg>;

		interrupt-parent = <&gpf0>;

		interrupts = <2 0>;

		reset-gpio = <&gpv7 0 0>;

		clocks = <&pmu_system_controller 0>;

		clock-names = "xtal";

		port {

			mhl_to_hdmi: endpoint {

				remote-endpoint = <&hdmi_to_mhl>;

			};

		};

	};

This document serves as a guide for device drivers writers on what the

sync_file API is, and how drivers can support it. Sync file is the carrier of

the fences(struct fence) that are needed to synchronize between drivers or

the fences(struct dma_fence) that are needed to synchronize between drivers or

across process boundaries.

The sync_file API is meant to be used to send and receive fence information

Sync files can go either to or from userspace. When a sync_file is sent from

the driver to userspace we call the fences it contains 'out-fences'. They are

related to a buffer that the driver is processing or is going to process, so

the driver creates an out-fence to be able to notify, through fence_signal(),

when it has finished using (or processing) that buffer. Out-fences are fences

that the driver creates.

the driver creates an out-fence to be able to notify, through

dma_fence_signal(), when it has finished using (or processing) that buffer.

Out-fences are fences that the driver creates.

On the other hand if the driver receives fence(s) through a sync_file from

userspace we call these fence(s) 'in-fences'. Receiveing in-fences means that

When a driver needs to send an out-fence userspace it creates a sync_file.

Interface:

	struct sync_file *sync_file_create(struct fence *fence);

	struct sync_file *sync_file_create(struct dma_fence *fence);

The caller pass the out-fence and gets back the sync_file. That is just the

first step, next it needs to install an fd on sync_file->file. So it gets an

from it.

Interface:

	struct fence *sync_file_get_fence(int fd);

	struct dma_fence *sync_file_get_fence(int fd);

The returned reference is owned by the caller and must be disposed of

afterwards using fence_put(). In case of error, a NULL is returned instead.

afterwards using dma_fence_put(). In case of error, a NULL is returned instead.

References:

[1] struct sync_file in include/linux/sync_file.h

	  APIs extension; the file's descriptor can then be passed on to other

	  driver.

config FENCE_TRACE

	bool "Enable verbose FENCE_TRACE messages"

config DMA_FENCE_TRACE

	bool "Enable verbose DMA_FENCE_TRACE messages"

	depends on DMA_SHARED_BUFFER

	help

	  Enable the FENCE_TRACE printks. This will add extra

	  Enable the DMA_FENCE_TRACE printks. This will add extra

	  spam to the console log, but will make it easier to diagnose

	  lockup related problems for dma-buffers shared across multiple

	  devices.

	select DMA_SHARED_BUFFER

	---help---

	  The Sync File Framework adds explicit syncronization via

	  userspace. It enables send/receive 'struct fence' objects to/from

	  userspace. It enables send/receive 'struct dma_fence' objects to/from

	  userspace via Sync File fds for synchronization between drivers via

	  userspace components. It has been ported from Android.

obj-y := dma-buf.o fence.o reservation.o seqno-fence.o fence-array.o

obj-y := dma-buf.o dma-fence.o dma-fence-array.o reservation.o seqno-fence.o

obj-$(CONFIG_SYNC_FILE)		+= sync_file.o

obj-$(CONFIG_SW_SYNC)		+= sw_sync.o sync_debug.o