Merge tag 'drm-misc-next-2017-06-02' of git://anongit.freedesktop.org/git/drm-misc into drm-next

Driver Load

-----------

IRQ Registration

~~~~~~~~~~~~~~~~

The DRM core tries to facilitate IRQ handler registration and

unregistration by providing :c:func:`drm_irq_install()` and

:c:func:`drm_irq_uninstall()` functions. Those functions only

support a single interrupt per device, devices that use more than one

IRQs need to be handled manually.

Managed IRQ Registration

''''''''''''''''''''''''

:c:func:`drm_irq_install()` starts by calling the irq_preinstall

driver operation. The operation is optional and must make sure that the

interrupt will not get fired by clearing all pending interrupt flags or

disabling the interrupt.

The passed-in IRQ will then be requested by a call to

:c:func:`request_irq()`. If the DRIVER_IRQ_SHARED driver feature

flag is set, a shared (IRQF_SHARED) IRQ handler will be requested.

The IRQ handler function must be provided as the mandatory irq_handler

driver operation. It will get passed directly to

:c:func:`request_irq()` and thus has the same prototype as all IRQ

handlers. It will get called with a pointer to the DRM device as the

second argument.

Finally the function calls the optional irq_postinstall driver

operation. The operation usually enables interrupts (excluding the

vblank interrupt, which is enabled separately), but drivers may choose

to enable/disable interrupts at a different time.

:c:func:`drm_irq_uninstall()` is similarly used to uninstall an

IRQ handler. It starts by waking up all processes waiting on a vblank

interrupt to make sure they don't hang, and then calls the optional

irq_uninstall driver operation. The operation must disable all hardware

interrupts. Finally the function frees the IRQ by calling

:c:func:`free_irq()`.

Manual IRQ Registration

'''''''''''''''''''''''

Drivers that require multiple interrupt handlers can't use the managed

IRQ registration functions. In that case IRQs must be registered and

unregistered manually (usually with the :c:func:`request_irq()` and

:c:func:`free_irq()` functions, or their :c:func:`devm_request_irq()` and

:c:func:`devm_free_irq()` equivalents).

When manually registering IRQs, drivers must not set the

DRIVER_HAVE_IRQ driver feature flag, and must not provide the

irq_handler driver operation. They must set the :c:type:`struct

drm_device <drm_device>` irq_enabled field to 1 upon

registration of the IRQs, and clear it to 0 after unregistering the

IRQs.

IRQ Helper Library

~~~~~~~~~~~~~~~~~~

.. kernel-doc:: drivers/gpu/drm/drm_irq.c

   :doc: irq helpers

.. kernel-doc:: drivers/gpu/drm/drm_irq.c

   :export:

Memory Manager Initialization

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Vertical Blanking and Interrupt Handling Functions Reference

------------------------------------------------------------

.. kernel-doc:: include/drm/drm_irq.h

.. kernel-doc:: include/drm/drm_vblank.h

   :internal:

.. kernel-doc:: drivers/gpu/drm/drm_irq.c

.. kernel-doc:: drivers/gpu/drm/drm_vblank.c

   :export:

Contact: Daniel Vetter, respective driver maintainers

Switch to drm_connector_list_iter for any connector_list walking

----------------------------------------------------------------

Connectors can be hotplugged, and we now have a special list of helpers to walk

the connector_list in a race-free fashion, without incurring deadlocks on

mutexes and other fun stuff.

Unfortunately most drivers are not converted yet. At least all those supporting

DP MST hotplug should be converted, since for those drivers the difference

matters. See drm_for_each_connector_iter() vs. drm_for_each_connector().

Contact: Daniel Vetter

Core refactorings

=================

		drm_framebuffer.o drm_connector.o drm_blend.o \

		drm_encoder.o drm_mode_object.o drm_property.o \

		drm_plane.o drm_color_mgmt.o drm_print.o \

		drm_dumb_buffers.o drm_mode_config.o

		drm_dumb_buffers.o drm_mode_config.o drm_vblank.o

drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o

drm-$(CONFIG_DRM_VM) += drm_vm.o

		arcpgu->fbdev = NULL;

	}

	drm_kms_helper_poll_fini(drm);

	drm_vblank_cleanup(drm);

	drm_mode_config_cleanup(drm);

	return 0;