mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
Merge tag 'topic/drm-misc-2015-10-08' of git://anongit.freedesktop.org/drm-intel into drm-next
Another round of drm-misc. Unfortunately the DRM_UNLOCKED removal for DRIVER_MODESET isn't complete yet for lack of review on 1-2 patches. Otherwise just various stuff all over. * tag 'topic/drm-misc-2015-10-08' of git://anongit.freedesktop.org/drm-intel: drm: Stop using drm_vblank_count() as the hw frame counter drm/irq: Use unsigned int pipe in public API drm: Use DRM_ROTATE_MASK and DRM_REFLECT_MASK drm: Add DRM_ROTATE_MASK and DRM_REFLECT_MASK vga_switcheroo: Add missing locking vgaarb: use kzalloc in vga_arbiter_add_pci_device() drm: Don't zero vblank timestamps from the irq handler drm: Hack around CONFIG_AGP=m build failures drm/i915: Remove setparam ioctl drm: Remove dummy agp ioctl wrappers drm/vmwgfx: Stop checking for DRM_UNLOCKED drm/drm_ioctl.c: kerneldoc drm: Define a drm_invalid_op ioctl implementation drm: Remove __OS_HAS_AGP drm/doc: Update docs about device instance setup
This commit is contained in:
commit
6b62b3e134
79 changed files with 550 additions and 600 deletions
|
@ -138,14 +138,10 @@
|
|||
<para>
|
||||
At the core of every DRM driver is a <structname>drm_driver</structname>
|
||||
structure. Drivers typically statically initialize a drm_driver structure,
|
||||
and then pass it to one of the <function>drm_*_init()</function> functions
|
||||
to register it with the DRM subsystem.
|
||||
</para>
|
||||
<para>
|
||||
Newer drivers that no longer require a <structname>drm_bus</structname>
|
||||
structure can alternatively use the low-level device initialization and
|
||||
registration functions such as <function>drm_dev_alloc()</function> and
|
||||
<function>drm_dev_register()</function> directly.
|
||||
and then pass it to <function>drm_dev_alloc()</function> to allocate a
|
||||
device instance. After the device instance is fully initialized it can be
|
||||
registered (which makes it accessible from userspace) using
|
||||
<function>drm_dev_register()</function>.
|
||||
</para>
|
||||
<para>
|
||||
The <structname>drm_driver</structname> structure contains static
|
||||
|
@ -296,83 +292,12 @@ char *date;</synopsis>
|
|||
</sect3>
|
||||
</sect2>
|
||||
<sect2>
|
||||
<title>Device Registration</title>
|
||||
<para>
|
||||
A number of functions are provided to help with device registration.
|
||||
The functions deal with PCI and platform devices, respectively.
|
||||
</para>
|
||||
!Edrivers/gpu/drm/drm_pci.c
|
||||
!Edrivers/gpu/drm/drm_platform.c
|
||||
<para>
|
||||
New drivers that no longer rely on the services provided by the
|
||||
<structname>drm_bus</structname> structure can call the low-level
|
||||
device registration functions directly. The
|
||||
<function>drm_dev_alloc()</function> function can be used to allocate
|
||||
and initialize a new <structname>drm_device</structname> structure.
|
||||
Drivers will typically want to perform some additional setup on this
|
||||
structure, such as allocating driver-specific data and storing a
|
||||
pointer to it in the DRM device's <structfield>dev_private</structfield>
|
||||
field. Drivers should also set the device's unique name using the
|
||||
<function>drm_dev_set_unique()</function> function. After it has been
|
||||
set up a device can be registered with the DRM subsystem by calling
|
||||
<function>drm_dev_register()</function>. This will cause the device to
|
||||
be exposed to userspace and will call the driver's
|
||||
<structfield>.load()</structfield> implementation. When a device is
|
||||
removed, the DRM device can safely be unregistered and freed by calling
|
||||
<function>drm_dev_unregister()</function> followed by a call to
|
||||
<function>drm_dev_unref()</function>.
|
||||
</para>
|
||||
<title>Device Instance and Driver Handling</title>
|
||||
!Pdrivers/gpu/drm/drm_drv.c driver instance overview
|
||||
!Edrivers/gpu/drm/drm_drv.c
|
||||
</sect2>
|
||||
<sect2>
|
||||
<title>Driver Load</title>
|
||||
<para>
|
||||
The <methodname>load</methodname> method is the driver and device
|
||||
initialization entry point. The method is responsible for allocating and
|
||||
initializing driver private data, performing resource allocation and
|
||||
mapping (e.g. acquiring
|
||||
clocks, mapping registers or allocating command buffers), initializing
|
||||
the memory manager (<xref linkend="drm-memory-management"/>), installing
|
||||
the IRQ handler (<xref linkend="drm-irq-registration"/>), setting up
|
||||
vertical blanking handling (<xref linkend="drm-vertical-blank"/>), mode
|
||||
setting (<xref linkend="drm-mode-setting"/>) and initial output
|
||||
configuration (<xref linkend="drm-kms-init"/>).
|
||||
</para>
|
||||
<note><para>
|
||||
If compatibility is a concern (e.g. with drivers converted over from
|
||||
User Mode Setting to Kernel Mode Setting), care must be taken to prevent
|
||||
device initialization and control that is incompatible with currently
|
||||
active userspace drivers. For instance, if user level mode setting
|
||||
drivers are in use, it would be problematic to perform output discovery
|
||||
& configuration at load time. Likewise, if user-level drivers
|
||||
unaware of memory management are in use, memory management and command
|
||||
buffer setup may need to be omitted. These requirements are
|
||||
driver-specific, and care needs to be taken to keep both old and new
|
||||
applications and libraries working.
|
||||
</para></note>
|
||||
<synopsis>int (*load) (struct drm_device *, unsigned long flags);</synopsis>
|
||||
<para>
|
||||
The method takes two arguments, a pointer to the newly created
|
||||
<structname>drm_device</structname> and flags. The flags are used to
|
||||
pass the <structfield>driver_data</structfield> field of the device id
|
||||
corresponding to the device passed to <function>drm_*_init()</function>.
|
||||
Only PCI devices currently use this, USB and platform DRM drivers have
|
||||
their <methodname>load</methodname> method called with flags to 0.
|
||||
</para>
|
||||
<sect3>
|
||||
<title>Driver Private Data</title>
|
||||
<para>
|
||||
The driver private hangs off the main
|
||||
<structname>drm_device</structname> structure and can be used for
|
||||
tracking various device-specific bits of information, like register
|
||||
offsets, command buffer status, register state for suspend/resume, etc.
|
||||
At load time, a driver may simply allocate one and set
|
||||
<structname>drm_device</structname>.<structfield>dev_priv</structfield>
|
||||
appropriately; it should be freed and
|
||||
<structname>drm_device</structname>.<structfield>dev_priv</structfield>
|
||||
set to NULL when the driver is unloaded.
|
||||
</para>
|
||||
</sect3>
|
||||
<sect3 id="drm-irq-registration">
|
||||
<title>IRQ Registration</title>
|
||||
<para>
|
||||
|
@ -465,6 +390,18 @@ char *date;</synopsis>
|
|||
</para>
|
||||
</sect3>
|
||||
</sect2>
|
||||
<sect2>
|
||||
<title>Bus-specific Device Registration and PCI Support</title>
|
||||
<para>
|
||||
A number of functions are provided to help with device registration.
|
||||
The functions deal with PCI and platform devices respectively and are
|
||||
only provided for historical reasons. These are all deprecated and
|
||||
shouldn't be used in new drivers. Besides that there's a few
|
||||
helpers for pci drivers.
|
||||
</para>
|
||||
!Edrivers/gpu/drm/drm_pci.c
|
||||
!Edrivers/gpu/drm/drm_platform.c
|
||||
</sect2>
|
||||
</sect1>
|
||||
|
||||
<!-- Internals: memory management -->
|
||||
|
@ -3752,6 +3689,7 @@ int num_ioctls;</synopsis>
|
|||
</itemizedlist>
|
||||
</para>
|
||||
</para>
|
||||
!Edrivers/gpu/drm/drm_ioctl.c
|
||||
</sect2>
|
||||
</sect1>
|
||||
<sect1>
|
||||
|
|
|
@ -6,7 +6,7 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \
|
|||
drm_context.o drm_dma.o \
|
||||
drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
|
||||
drm_lock.o drm_memory.o drm_drv.o drm_vm.o \
|
||||
drm_agpsupport.o drm_scatter.o drm_pci.o \
|
||||
drm_scatter.o drm_pci.o \
|
||||
drm_platform.o drm_sysfs.o drm_hashtab.o drm_mm.o \
|
||||
drm_crtc.o drm_modes.o drm_edid.o \
|
||||
drm_info.o drm_debugfs.o drm_encoder_slave.o \
|
||||
|
@ -19,6 +19,9 @@ drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o
|
|||
drm-$(CONFIG_PCI) += ati_pcigart.o
|
||||
drm-$(CONFIG_DRM_PANEL) += drm_panel.o
|
||||
drm-$(CONFIG_OF) += drm_of.o
|
||||
drm-$(CONFIG_AGP) += drm_agpsupport.o
|
||||
|
||||
drm-y += $(drm-m)
|
||||
|
||||
drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \
|
||||
drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o
|
||||
|
|
|
@ -2362,10 +2362,10 @@ void amdgpu_driver_preclose_kms(struct drm_device *dev,
|
|||
struct drm_file *file_priv);
|
||||
int amdgpu_suspend_kms(struct drm_device *dev, bool suspend, bool fbcon);
|
||||
int amdgpu_resume_kms(struct drm_device *dev, bool resume, bool fbcon);
|
||||
u32 amdgpu_get_vblank_counter_kms(struct drm_device *dev, int crtc);
|
||||
int amdgpu_enable_vblank_kms(struct drm_device *dev, int crtc);
|
||||
void amdgpu_disable_vblank_kms(struct drm_device *dev, int crtc);
|
||||
int amdgpu_get_vblank_timestamp_kms(struct drm_device *dev, int crtc,
|
||||
u32 amdgpu_get_vblank_counter_kms(struct drm_device *dev, unsigned int pipe);
|
||||
int amdgpu_enable_vblank_kms(struct drm_device *dev, unsigned int pipe);
|
||||
void amdgpu_disable_vblank_kms(struct drm_device *dev, unsigned int pipe);
|
||||
int amdgpu_get_vblank_timestamp_kms(struct drm_device *dev, unsigned int pipe,
|
||||
int *max_error,
|
||||
struct timeval *vblank_time,
|
||||
unsigned flags);
|
||||
|
|
|
@ -721,7 +721,7 @@ bool amdgpu_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
|
|||
* an optional accurate timestamp of when query happened.
|
||||
*
|
||||
* \param dev Device to query.
|
||||
* \param crtc Crtc to query.
|
||||
* \param pipe Crtc to query.
|
||||
* \param flags Flags from caller (DRM_CALLED_FROM_VBLIRQ or 0).
|
||||
* \param *vpos Location where vertical scanout position should be stored.
|
||||
* \param *hpos Location where horizontal scanout position should go.
|
||||
|
@ -744,8 +744,9 @@ bool amdgpu_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
|
|||
* unknown small number of scanlines wrt. real scanout position.
|
||||
*
|
||||
*/
|
||||
int amdgpu_get_crtc_scanoutpos(struct drm_device *dev, int crtc, unsigned int flags,
|
||||
int *vpos, int *hpos, ktime_t *stime, ktime_t *etime,
|
||||
int amdgpu_get_crtc_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode)
|
||||
{
|
||||
u32 vbl = 0, position = 0;
|
||||
|
@ -760,7 +761,7 @@ int amdgpu_get_crtc_scanoutpos(struct drm_device *dev, int crtc, unsigned int fl
|
|||
if (stime)
|
||||
*stime = ktime_get();
|
||||
|
||||
if (amdgpu_display_page_flip_get_scanoutpos(adev, crtc, &vbl, &position) == 0)
|
||||
if (amdgpu_display_page_flip_get_scanoutpos(adev, pipe, &vbl, &position) == 0)
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
|
||||
/* Get optional system timestamp after query. */
|
||||
|
|
|
@ -600,36 +600,36 @@ void amdgpu_driver_preclose_kms(struct drm_device *dev,
|
|||
* amdgpu_get_vblank_counter_kms - get frame count
|
||||
*
|
||||
* @dev: drm dev pointer
|
||||
* @crtc: crtc to get the frame count from
|
||||
* @pipe: crtc to get the frame count from
|
||||
*
|
||||
* Gets the frame count on the requested crtc (all asics).
|
||||
* Returns frame count on success, -EINVAL on failure.
|
||||
*/
|
||||
u32 amdgpu_get_vblank_counter_kms(struct drm_device *dev, int crtc)
|
||||
u32 amdgpu_get_vblank_counter_kms(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct amdgpu_device *adev = dev->dev_private;
|
||||
|
||||
if (crtc < 0 || crtc >= adev->mode_info.num_crtc) {
|
||||
DRM_ERROR("Invalid crtc %d\n", crtc);
|
||||
if (pipe >= adev->mode_info.num_crtc) {
|
||||
DRM_ERROR("Invalid crtc %u\n", pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return amdgpu_display_vblank_get_counter(adev, crtc);
|
||||
return amdgpu_display_vblank_get_counter(adev, pipe);
|
||||
}
|
||||
|
||||
/**
|
||||
* amdgpu_enable_vblank_kms - enable vblank interrupt
|
||||
*
|
||||
* @dev: drm dev pointer
|
||||
* @crtc: crtc to enable vblank interrupt for
|
||||
* @pipe: crtc to enable vblank interrupt for
|
||||
*
|
||||
* Enable the interrupt on the requested crtc (all asics).
|
||||
* Returns 0 on success, -EINVAL on failure.
|
||||
*/
|
||||
int amdgpu_enable_vblank_kms(struct drm_device *dev, int crtc)
|
||||
int amdgpu_enable_vblank_kms(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct amdgpu_device *adev = dev->dev_private;
|
||||
int idx = amdgpu_crtc_idx_to_irq_type(adev, crtc);
|
||||
int idx = amdgpu_crtc_idx_to_irq_type(adev, pipe);
|
||||
|
||||
return amdgpu_irq_get(adev, &adev->crtc_irq, idx);
|
||||
}
|
||||
|
@ -638,14 +638,14 @@ int amdgpu_enable_vblank_kms(struct drm_device *dev, int crtc)
|
|||
* amdgpu_disable_vblank_kms - disable vblank interrupt
|
||||
*
|
||||
* @dev: drm dev pointer
|
||||
* @crtc: crtc to disable vblank interrupt for
|
||||
* @pipe: crtc to disable vblank interrupt for
|
||||
*
|
||||
* Disable the interrupt on the requested crtc (all asics).
|
||||
*/
|
||||
void amdgpu_disable_vblank_kms(struct drm_device *dev, int crtc)
|
||||
void amdgpu_disable_vblank_kms(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct amdgpu_device *adev = dev->dev_private;
|
||||
int idx = amdgpu_crtc_idx_to_irq_type(adev, crtc);
|
||||
int idx = amdgpu_crtc_idx_to_irq_type(adev, pipe);
|
||||
|
||||
amdgpu_irq_put(adev, &adev->crtc_irq, idx);
|
||||
}
|
||||
|
@ -663,26 +663,26 @@ void amdgpu_disable_vblank_kms(struct drm_device *dev, int crtc)
|
|||
* scanout position. (all asics).
|
||||
* Returns postive status flags on success, negative error on failure.
|
||||
*/
|
||||
int amdgpu_get_vblank_timestamp_kms(struct drm_device *dev, int crtc,
|
||||
int amdgpu_get_vblank_timestamp_kms(struct drm_device *dev, unsigned int pipe,
|
||||
int *max_error,
|
||||
struct timeval *vblank_time,
|
||||
unsigned flags)
|
||||
{
|
||||
struct drm_crtc *drmcrtc;
|
||||
struct drm_crtc *crtc;
|
||||
struct amdgpu_device *adev = dev->dev_private;
|
||||
|
||||
if (crtc < 0 || crtc >= dev->num_crtcs) {
|
||||
DRM_ERROR("Invalid crtc %d\n", crtc);
|
||||
if (pipe >= dev->num_crtcs) {
|
||||
DRM_ERROR("Invalid crtc %u\n", pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Get associated drm_crtc: */
|
||||
drmcrtc = &adev->mode_info.crtcs[crtc]->base;
|
||||
crtc = &adev->mode_info.crtcs[pipe]->base;
|
||||
|
||||
/* Helper routine in DRM core does all the work: */
|
||||
return drm_calc_vbltimestamp_from_scanoutpos(dev, crtc, max_error,
|
||||
return drm_calc_vbltimestamp_from_scanoutpos(dev, pipe, max_error,
|
||||
vblank_time, flags,
|
||||
&drmcrtc->hwmode);
|
||||
&crtc->hwmode);
|
||||
}
|
||||
|
||||
const struct drm_ioctl_desc amdgpu_ioctls_kms[] = {
|
||||
|
|
|
@ -544,11 +544,10 @@ bool amdgpu_ddc_probe(struct amdgpu_connector *amdgpu_connector, bool use_aux);
|
|||
|
||||
void amdgpu_encoder_set_active_device(struct drm_encoder *encoder);
|
||||
|
||||
int amdgpu_get_crtc_scanoutpos(struct drm_device *dev, int crtc,
|
||||
unsigned int flags,
|
||||
int *vpos, int *hpos, ktime_t *stime,
|
||||
ktime_t *etime,
|
||||
const struct drm_display_mode *mode);
|
||||
int amdgpu_get_crtc_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode);
|
||||
|
||||
int amdgpu_framebuffer_init(struct drm_device *dev,
|
||||
struct amdgpu_framebuffer *rfb,
|
||||
|
|
|
@ -149,17 +149,17 @@ static int armada_drm_unload(struct drm_device *dev)
|
|||
}
|
||||
|
||||
/* These are called under the vbl_lock. */
|
||||
static int armada_drm_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int armada_drm_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct armada_private *priv = dev->dev_private;
|
||||
armada_drm_crtc_enable_irq(priv->dcrtc[crtc], VSYNC_IRQ_ENA);
|
||||
armada_drm_crtc_enable_irq(priv->dcrtc[pipe], VSYNC_IRQ_ENA);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void armada_drm_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void armada_drm_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct armada_private *priv = dev->dev_private;
|
||||
armada_drm_crtc_disable_irq(priv->dcrtc[crtc], VSYNC_IRQ_ENA);
|
||||
armada_drm_crtc_disable_irq(priv->dcrtc[pipe], VSYNC_IRQ_ENA);
|
||||
}
|
||||
|
||||
static struct drm_ioctl_desc armada_ioctls[] = {
|
||||
|
@ -195,7 +195,7 @@ static struct drm_driver armada_drm_driver = {
|
|||
.lastclose = armada_drm_lastclose,
|
||||
.unload = armada_drm_unload,
|
||||
.set_busid = drm_platform_set_busid,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = armada_drm_enable_vblank,
|
||||
.disable_vblank = armada_drm_disable_vblank,
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
|
|
|
@ -656,7 +656,8 @@ static void atmel_hlcdc_dc_irq_uninstall(struct drm_device *dev)
|
|||
regmap_read(dc->hlcdc->regmap, ATMEL_HLCDC_ISR, &isr);
|
||||
}
|
||||
|
||||
static int atmel_hlcdc_dc_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int atmel_hlcdc_dc_enable_vblank(struct drm_device *dev,
|
||||
unsigned int pipe)
|
||||
{
|
||||
struct atmel_hlcdc_dc *dc = dev->dev_private;
|
||||
|
||||
|
@ -666,7 +667,8 @@ static int atmel_hlcdc_dc_enable_vblank(struct drm_device *dev, int crtc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void atmel_hlcdc_dc_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void atmel_hlcdc_dc_disable_vblank(struct drm_device *dev,
|
||||
unsigned int pipe)
|
||||
{
|
||||
struct atmel_hlcdc_dc *dc = dev->dev_private;
|
||||
|
||||
|
@ -697,7 +699,7 @@ static struct drm_driver atmel_hlcdc_dc_driver = {
|
|||
.irq_preinstall = atmel_hlcdc_dc_irq_uninstall,
|
||||
.irq_postinstall = atmel_hlcdc_dc_irq_postinstall,
|
||||
.irq_uninstall = atmel_hlcdc_dc_irq_uninstall,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = atmel_hlcdc_dc_enable_vblank,
|
||||
.disable_vblank = atmel_hlcdc_dc_disable_vblank,
|
||||
.gem_free_object = drm_gem_cma_free_object,
|
||||
|
|
|
@ -633,7 +633,7 @@ static int atmel_hlcdc_plane_atomic_check(struct drm_plane *p,
|
|||
if (!state->bpp[i])
|
||||
return -EINVAL;
|
||||
|
||||
switch (state->base.rotation & 0xf) {
|
||||
switch (state->base.rotation & DRM_ROTATE_MASK) {
|
||||
case BIT(DRM_ROTATE_90):
|
||||
offset = ((y_offset + state->src_y + patched_src_w - 1) /
|
||||
ydiv) * fb->pitches[i];
|
||||
|
|
|
@ -36,8 +36,6 @@
|
|||
#include <linux/slab.h>
|
||||
#include "drm_legacy.h"
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
|
||||
#include <asm/agp.h>
|
||||
|
||||
/**
|
||||
|
@ -502,5 +500,3 @@ drm_agp_bind_pages(struct drm_device *dev,
|
|||
return mem;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_agp_bind_pages);
|
||||
|
||||
#endif /* __OS_HAS_AGP */
|
||||
|
|
|
@ -582,7 +582,7 @@ static void drm_cleanup_buf_error(struct drm_device * dev,
|
|||
}
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
/**
|
||||
* Add AGP buffers for DMA transfers.
|
||||
*
|
||||
|
@ -756,7 +756,7 @@ int drm_legacy_addbufs_agp(struct drm_device *dev,
|
|||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_legacy_addbufs_agp);
|
||||
#endif /* __OS_HAS_AGP */
|
||||
#endif /* CONFIG_AGP */
|
||||
|
||||
int drm_legacy_addbufs_pci(struct drm_device *dev,
|
||||
struct drm_buf_desc *request)
|
||||
|
@ -1145,7 +1145,7 @@ int drm_legacy_addbufs(struct drm_device *dev, void *data,
|
|||
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
||||
return -EINVAL;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (request->flags & _DRM_AGP_BUFFER)
|
||||
ret = drm_legacy_addbufs_agp(dev, request);
|
||||
else
|
||||
|
|
|
@ -5629,7 +5629,8 @@ unsigned int drm_rotation_simplify(unsigned int rotation,
|
|||
{
|
||||
if (rotation & ~supported_rotations) {
|
||||
rotation ^= BIT(DRM_REFLECT_X) | BIT(DRM_REFLECT_Y);
|
||||
rotation = (rotation & ~0xf) | BIT((ffs(rotation & 0xf) + 1) % 4);
|
||||
rotation = (rotation & DRM_REFLECT_MASK) |
|
||||
BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
|
||||
}
|
||||
|
||||
return rotation;
|
||||
|
|
|
@ -396,16 +396,52 @@ void drm_minor_release(struct drm_minor *minor)
|
|||
drm_dev_unref(minor->dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* DOC: driver instance overview
|
||||
*
|
||||
* A device instance for a drm driver is represented by struct &drm_device. This
|
||||
* is allocated with drm_dev_alloc(), usually from bus-specific ->probe()
|
||||
* callbacks implemented by the driver. The driver then needs to initialize all
|
||||
* the various subsystems for the drm device like memory management, vblank
|
||||
* handling, modesetting support and intial output configuration plus obviously
|
||||
* initialize all the corresponding hardware bits. An important part of this is
|
||||
* also calling drm_dev_set_unique() to set the userspace-visible unique name of
|
||||
* this device instance. Finally when everything is up and running and ready for
|
||||
* userspace the device instance can be published using drm_dev_register().
|
||||
*
|
||||
* There is also deprecated support for initalizing device instances using
|
||||
* bus-specific helpers and the ->load() callback. But due to
|
||||
* backwards-compatibility needs the device instance have to be published too
|
||||
* early, which requires unpretty global locking to make safe and is therefore
|
||||
* only support for existing drivers not yet converted to the new scheme.
|
||||
*
|
||||
* When cleaning up a device instance everything needs to be done in reverse:
|
||||
* First unpublish the device instance with drm_dev_unregister(). Then clean up
|
||||
* any other resources allocated at device initialization and drop the driver's
|
||||
* reference to &drm_device using drm_dev_unref().
|
||||
*
|
||||
* Note that the lifetime rules for &drm_device instance has still a lot of
|
||||
* historical baggage. Hence use the reference counting provided by
|
||||
* drm_dev_ref() and drm_dev_unref() only carefully.
|
||||
*
|
||||
* Also note that embedding of &drm_device is currently not (yet) supported (but
|
||||
* it would be easy to add). Drivers can store driver-private data in the
|
||||
* dev_priv field of &drm_device.
|
||||
*/
|
||||
|
||||
/**
|
||||
* drm_put_dev - Unregister and release a DRM device
|
||||
* @dev: DRM device
|
||||
*
|
||||
* Called at module unload time or when a PCI device is unplugged.
|
||||
*
|
||||
* Use of this function is discouraged. It will eventually go away completely.
|
||||
* Please use drm_dev_unregister() and drm_dev_unref() explicitly instead.
|
||||
*
|
||||
* Cleans up all DRM device, calling drm_lastclose().
|
||||
*
|
||||
* Note: Use of this function is deprecated. It will eventually go away
|
||||
* completely. Please use drm_dev_unregister() and drm_dev_unref() explicitly
|
||||
* instead to make sure that the device isn't userspace accessible any more
|
||||
* while teardown is in progress, ensuring that userspace can't access an
|
||||
* inconsistent state.
|
||||
*/
|
||||
void drm_put_dev(struct drm_device *dev)
|
||||
{
|
||||
|
@ -518,7 +554,9 @@ static void drm_fs_inode_free(struct inode *inode)
|
|||
*
|
||||
* Allocate and initialize a new DRM device. No device registration is done.
|
||||
* Call drm_dev_register() to advertice the device to user space and register it
|
||||
* with other core subsystems.
|
||||
* with other core subsystems. This should be done last in the device
|
||||
* initialization sequence to make sure userspace can't access an inconsistent
|
||||
* state.
|
||||
*
|
||||
* The initial ref-count of the object is 1. Use drm_dev_ref() and
|
||||
* drm_dev_unref() to take and drop further ref-counts.
|
||||
|
@ -673,6 +711,12 @@ EXPORT_SYMBOL(drm_dev_unref);
|
|||
*
|
||||
* Never call this twice on any device!
|
||||
*
|
||||
* NOTE: To ensure backward compatibility with existing drivers method this
|
||||
* function calls the ->load() method after registering the device nodes,
|
||||
* creating race conditions. Usage of the ->load() methods is therefore
|
||||
* deprecated, drivers must perform all initialization before calling
|
||||
* drm_dev_register().
|
||||
*
|
||||
* RETURNS:
|
||||
* 0 on success, negative error code on failure.
|
||||
*/
|
||||
|
@ -720,6 +764,9 @@ EXPORT_SYMBOL(drm_dev_register);
|
|||
* Unregister the DRM device from the system. This does the reverse of
|
||||
* drm_dev_register() but does not deallocate the device. The caller must call
|
||||
* drm_dev_unref() to drop their final reference.
|
||||
*
|
||||
* This should be called first in the device teardown code to make sure
|
||||
* userspace can't access the device instance any more.
|
||||
*/
|
||||
void drm_dev_unregister(struct drm_device *dev)
|
||||
{
|
||||
|
|
|
@ -720,7 +720,7 @@ static int compat_drm_dma(struct file *file, unsigned int cmd,
|
|||
return 0;
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
typedef struct drm_agp_mode32 {
|
||||
u32 mode; /**< AGP mode */
|
||||
} drm_agp_mode32_t;
|
||||
|
@ -882,7 +882,7 @@ static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,
|
|||
|
||||
return drm_ioctl(file, DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
|
||||
}
|
||||
#endif /* __OS_HAS_AGP */
|
||||
#endif /* CONFIG_AGP */
|
||||
|
||||
typedef struct drm_scatter_gather32 {
|
||||
u32 size; /**< In bytes -- will round to page boundary */
|
||||
|
@ -1090,7 +1090,7 @@ static drm_ioctl_compat_t *drm_compat_ioctls[] = {
|
|||
[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX32)] = compat_drm_getsareactx,
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RES_CTX32)] = compat_drm_resctx,
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_DMA32)] = compat_drm_dma,
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE32)] = compat_drm_agp_enable,
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO32)] = compat_drm_agp_info,
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC32)] = compat_drm_agp_alloc,
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
static int drm_version(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
/**
|
||||
/*
|
||||
* Get the bus id.
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -75,7 +75,7 @@ drm_unset_busid(struct drm_device *dev,
|
|||
master->unique_len = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Set the bus id.
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -149,7 +149,7 @@ static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Get a mapping information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -201,7 +201,7 @@ static int drm_getmap(struct drm_device *dev, void *data,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Get client information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -244,7 +244,7 @@ static int drm_getclient(struct drm_device *dev, void *data,
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Get statistics information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -265,7 +265,7 @@ static int drm_getstats(struct drm_device *dev, void *data,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Get device/driver capabilities
|
||||
*/
|
||||
static int drm_getcap(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
|
@ -318,7 +318,7 @@ static int drm_getcap(struct drm_device *dev, void *data, struct drm_file *file_
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Set device/driver capabilities
|
||||
*/
|
||||
static int
|
||||
|
@ -352,7 +352,7 @@ drm_setclientcap(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Setversion ioctl.
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -406,7 +406,18 @@ static int drm_setversion(struct drm_device *dev, void *data, struct drm_file *f
|
|||
return retcode;
|
||||
}
|
||||
|
||||
/** No-op ioctl. */
|
||||
/**
|
||||
* drm_noop - DRM no-op ioctl implemntation
|
||||
* @dev: DRM device for the ioctl
|
||||
* @data: data pointer for the ioctl
|
||||
* @file_priv: DRM file for the ioctl call
|
||||
*
|
||||
* This no-op implementation for drm ioctls is useful for deprecated
|
||||
* functionality where we can't return a failure code because existing userspace
|
||||
* checks the result of the ioctl, but doesn't care about the action.
|
||||
*
|
||||
* Always returns successfully with 0.
|
||||
*/
|
||||
int drm_noop(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
|
@ -416,6 +427,28 @@ int drm_noop(struct drm_device *dev, void *data,
|
|||
EXPORT_SYMBOL(drm_noop);
|
||||
|
||||
/**
|
||||
* drm_invalid_op - DRM invalid ioctl implemntation
|
||||
* @dev: DRM device for the ioctl
|
||||
* @data: data pointer for the ioctl
|
||||
* @file_priv: DRM file for the ioctl call
|
||||
*
|
||||
* This no-op implementation for drm ioctls is useful for deprecated
|
||||
* functionality where we really don't want to allow userspace to call the ioctl
|
||||
* any more. This is the case for old ums interfaces for drivers that
|
||||
* transitioned to kms gradually and so kept the old legacy tables around. This
|
||||
* only applies to radeon and i915 kms drivers, other drivers shouldn't need to
|
||||
* use this function.
|
||||
*
|
||||
* Always fails with a return value of -EINVAL.
|
||||
*/
|
||||
int drm_invalid_op(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_invalid_op);
|
||||
|
||||
/*
|
||||
* Copy and IOCTL return string to user space
|
||||
*/
|
||||
static int drm_copy_field(char __user *buf, size_t *buf_len, const char *value)
|
||||
|
@ -438,7 +471,7 @@ static int drm_copy_field(char __user *buf, size_t *buf_len, const char *value)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* Get version information
|
||||
*
|
||||
* \param inode device inode.
|
||||
|
@ -470,7 +503,7 @@ static int drm_version(struct drm_device *dev, void *data,
|
|||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
/*
|
||||
* drm_ioctl_permit - Check ioctl permissions against caller
|
||||
*
|
||||
* @flags: ioctl permission flags.
|
||||
|
@ -518,7 +551,7 @@ EXPORT_SYMBOL(drm_ioctl_permit);
|
|||
.name = #ioctl \
|
||||
}
|
||||
|
||||
/** Ioctl table */
|
||||
/* Ioctl table */
|
||||
static const struct drm_ioctl_desc drm_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version,
|
||||
DRM_UNLOCKED|DRM_RENDER_ALLOW|DRM_CONTROL_ALLOW),
|
||||
|
@ -571,7 +604,7 @@ static const struct drm_ioctl_desc drm_ioctls[] = {
|
|||
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
@ -635,16 +668,16 @@ static const struct drm_ioctl_desc drm_ioctls[] = {
|
|||
#define DRM_CORE_IOCTL_COUNT ARRAY_SIZE( drm_ioctls )
|
||||
|
||||
/**
|
||||
* Called whenever a process performs an ioctl on /dev/drm.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument.
|
||||
* \return zero on success or negative number on failure.
|
||||
* drm_ioctl - ioctl callback implementation for DRM drivers
|
||||
* @filp: file this ioctl is called on
|
||||
* @cmd: ioctl cmd number
|
||||
* @arg: user argument
|
||||
*
|
||||
* Looks up the ioctl function in the ::ioctls table, checking for root
|
||||
* previleges if so required, and dispatches to the respective function.
|
||||
*
|
||||
* Returns:
|
||||
* Zero on success, negative error code on failure.
|
||||
*/
|
||||
long drm_ioctl(struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
|
@ -754,9 +787,15 @@ EXPORT_SYMBOL(drm_ioctl);
|
|||
|
||||
/**
|
||||
* drm_ioctl_flags - Check for core ioctl and return ioctl permission flags
|
||||
* @nr: ioctl number
|
||||
* @flags: where to return the ioctl permission flags
|
||||
*
|
||||
* @nr: Ioctl number.
|
||||
* @flags: Where to return the ioctl permission flags
|
||||
* This ioctl is only used by the vmwgfx driver to augment the access checks
|
||||
* done by the drm core and insofar a pretty decent layering violation. This
|
||||
* shouldn't be used by any drivers.
|
||||
*
|
||||
* Returns:
|
||||
* True if the @nr corresponds to a DRM core ioctl numer, false otherwise.
|
||||
*/
|
||||
bool drm_ioctl_flags(unsigned int nr, unsigned int *flags)
|
||||
{
|
||||
|
|
|
@ -232,10 +232,11 @@ static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,
|
|||
|
||||
/*
|
||||
* Only reinitialize corresponding vblank timestamp if high-precision query
|
||||
* available and didn't fail. Otherwise reinitialize delayed at next vblank
|
||||
* interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.
|
||||
* available and didn't fail, or we were called from the vblank interrupt.
|
||||
* Otherwise reinitialize delayed at next vblank interrupt and assign 0
|
||||
* for now, to mark the vblanktimestamp as invalid.
|
||||
*/
|
||||
if (!rc)
|
||||
if (!rc && (flags & DRM_CALLED_FROM_VBLIRQ) == 0)
|
||||
t_vblank = (struct timeval) {0, 0};
|
||||
|
||||
store_vblank(dev, pipe, diff, &t_vblank, cur_vblank);
|
||||
|
@ -876,7 +877,7 @@ drm_get_last_vbltimestamp(struct drm_device *dev, unsigned int pipe,
|
|||
* Returns:
|
||||
* The software vblank counter.
|
||||
*/
|
||||
u32 drm_vblank_count(struct drm_device *dev, int pipe)
|
||||
u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_vblank_crtc *vblank = &dev->vblank[pipe];
|
||||
|
||||
|
@ -1797,3 +1798,20 @@ bool drm_crtc_handle_vblank(struct drm_crtc *crtc)
|
|||
return drm_handle_vblank(crtc->dev, drm_crtc_index(crtc));
|
||||
}
|
||||
EXPORT_SYMBOL(drm_crtc_handle_vblank);
|
||||
|
||||
/**
|
||||
* drm_vblank_no_hw_counter - "No hw counter" implementation of .get_vblank_counter()
|
||||
* @dev: DRM device
|
||||
* @pipe: CRTC for which to read the counter
|
||||
*
|
||||
* Drivers can plug this into the .get_vblank_counter() function if
|
||||
* there is no useable hardware frame counter available.
|
||||
*
|
||||
* Returns:
|
||||
* 0
|
||||
*/
|
||||
u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_vblank_no_hw_counter);
|
||||
|
|
|
@ -38,7 +38,7 @@
|
|||
#include <drm/drmP.h>
|
||||
#include "drm_legacy.h"
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
|
||||
#ifdef HAVE_PAGE_AGP
|
||||
# include <asm/agp.h>
|
||||
|
@ -111,14 +111,14 @@ int drm_unbind_agp(struct agp_memory * handle)
|
|||
return agp_unbind_memory(handle);
|
||||
}
|
||||
|
||||
#else /* __OS_HAS_AGP */
|
||||
#else /* CONFIG_AGP */
|
||||
static inline void *agp_remap(unsigned long offset, unsigned long size,
|
||||
struct drm_device * dev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#endif /* agp */
|
||||
#endif /* CONFIG_AGP */
|
||||
|
||||
void drm_legacy_ioremap(struct drm_local_map *map, struct drm_device *dev)
|
||||
{
|
||||
|
|
|
@ -266,6 +266,9 @@ void drm_pci_agp_destroy(struct drm_device *dev)
|
|||
* then register the character device and inter module information.
|
||||
* Try and register, if we fail to register, backout previous work.
|
||||
*
|
||||
* NOTE: This function is deprecated, please use drm_dev_alloc() and
|
||||
* drm_dev_register() instead and remove your ->load() callback.
|
||||
*
|
||||
* Return: 0 on success or a negative error code on failure.
|
||||
*/
|
||||
int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
|
||||
|
@ -326,6 +329,10 @@ EXPORT_SYMBOL(drm_get_pci_dev);
|
|||
* Initializes a drm_device structures, registering the stubs and initializing
|
||||
* the AGP device.
|
||||
*
|
||||
* NOTE: This function is deprecated. Modern modesetting drm drivers should use
|
||||
* pci_register_driver() directly, this function only provides shadow-binding
|
||||
* support for old legacy drivers on top of that core pci function.
|
||||
*
|
||||
* Return: 0 on success or a negative error code on failure.
|
||||
*/
|
||||
int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver)
|
||||
|
@ -435,6 +442,10 @@ EXPORT_SYMBOL(drm_pci_init);
|
|||
*
|
||||
* Unregisters one or more devices matched by a PCI driver from the DRM
|
||||
* subsystem.
|
||||
*
|
||||
* NOTE: This function is deprecated. Modern modesetting drm drivers should use
|
||||
* pci_unregister_driver() directly, this function only provides shadow-binding
|
||||
* support for old legacy drivers on top of that core pci function.
|
||||
*/
|
||||
void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver)
|
||||
{
|
||||
|
|
|
@ -95,6 +95,9 @@ EXPORT_SYMBOL(drm_platform_set_busid);
|
|||
* subsystem, initializing a drm_device structure and calling the driver's
|
||||
* .load() function.
|
||||
*
|
||||
* NOTE: This function is deprecated, please use drm_dev_alloc() and
|
||||
* drm_dev_register() instead and remove your ->load() callback.
|
||||
*
|
||||
* Return: 0 on success or a negative error code on failure.
|
||||
*/
|
||||
int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device)
|
||||
|
|
|
@ -330,7 +330,7 @@ void drm_rect_rotate(struct drm_rect *r,
|
|||
}
|
||||
}
|
||||
|
||||
switch (rotation & 0xf) {
|
||||
switch (rotation & DRM_ROTATE_MASK) {
|
||||
case BIT(DRM_ROTATE_0):
|
||||
break;
|
||||
case BIT(DRM_ROTATE_90):
|
||||
|
@ -390,7 +390,7 @@ void drm_rect_rotate_inv(struct drm_rect *r,
|
|||
{
|
||||
struct drm_rect tmp;
|
||||
|
||||
switch (rotation & 0xf) {
|
||||
switch (rotation & DRM_ROTATE_MASK) {
|
||||
case BIT(DRM_ROTATE_0):
|
||||
break;
|
||||
case BIT(DRM_ROTATE_90):
|
||||
|
|
|
@ -95,7 +95,7 @@ static pgprot_t drm_dma_prot(uint32_t map_type, struct vm_area_struct *vma)
|
|||
* Find the right map and if it's AGP memory find the real physical page to
|
||||
* map, get the page, increment the use count and return it.
|
||||
*/
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|
||||
{
|
||||
struct drm_file *priv = vma->vm_file->private_data;
|
||||
|
@ -168,12 +168,12 @@ static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|
|||
vm_fault_error:
|
||||
return VM_FAULT_SIGBUS; /* Disallow mremap */
|
||||
}
|
||||
#else /* __OS_HAS_AGP */
|
||||
#else
|
||||
static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|
||||
{
|
||||
return VM_FAULT_SIGBUS;
|
||||
}
|
||||
#endif /* __OS_HAS_AGP */
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \c nopage method for shared virtual memory.
|
||||
|
@ -556,7 +556,7 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
|
|||
* --BenH.
|
||||
*/
|
||||
if (!vma->vm_pgoff
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
&& (!dev->agp
|
||||
|| dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
|
||||
#endif
|
||||
|
|
|
@ -167,7 +167,7 @@ struct exynos_drm_crtc *exynos_drm_crtc_create(struct drm_device *drm_dev,
|
|||
return ERR_PTR(ret);
|
||||
}
|
||||
|
||||
int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int pipe)
|
||||
int exynos_drm_crtc_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct exynos_drm_private *private = dev->dev_private;
|
||||
struct exynos_drm_crtc *exynos_crtc =
|
||||
|
@ -179,7 +179,7 @@ int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int pipe)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int pipe)
|
||||
void exynos_drm_crtc_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct exynos_drm_private *private = dev->dev_private;
|
||||
struct exynos_drm_crtc *exynos_crtc =
|
||||
|
|
|
@ -23,8 +23,8 @@ struct exynos_drm_crtc *exynos_drm_crtc_create(struct drm_device *drm_dev,
|
|||
enum exynos_drm_output_type type,
|
||||
const struct exynos_drm_crtc_ops *ops,
|
||||
void *context);
|
||||
int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int pipe);
|
||||
void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int pipe);
|
||||
int exynos_drm_crtc_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void exynos_drm_crtc_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void exynos_drm_crtc_wait_pending_update(struct exynos_drm_crtc *exynos_crtc);
|
||||
void exynos_drm_crtc_finish_update(struct exynos_drm_crtc *exynos_crtc,
|
||||
struct exynos_drm_plane *exynos_plane);
|
||||
|
|
|
@ -447,7 +447,7 @@ static struct drm_driver exynos_drm_driver = {
|
|||
.lastclose = exynos_drm_lastclose,
|
||||
.postclose = exynos_drm_postclose,
|
||||
.set_busid = drm_platform_set_busid,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = exynos_drm_crtc_enable_vblank,
|
||||
.disable_vblank = exynos_drm_crtc_disable_vblank,
|
||||
.gem_free_object = exynos_drm_gem_free_object,
|
||||
|
|
|
@ -140,7 +140,7 @@ static irqreturn_t fsl_dcu_drm_irq(int irq, void *arg)
|
|||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int fsl_dcu_drm_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int fsl_dcu_drm_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct fsl_dcu_drm_device *fsl_dev = dev->dev_private;
|
||||
unsigned int value;
|
||||
|
@ -156,7 +156,8 @@ static int fsl_dcu_drm_enable_vblank(struct drm_device *dev, int crtc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void fsl_dcu_drm_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void fsl_dcu_drm_disable_vblank(struct drm_device *dev,
|
||||
unsigned int pipe)
|
||||
{
|
||||
struct fsl_dcu_drm_device *fsl_dev = dev->dev_private;
|
||||
unsigned int value;
|
||||
|
@ -192,7 +193,7 @@ static struct drm_driver fsl_dcu_drm_driver = {
|
|||
.unload = fsl_dcu_unload,
|
||||
.preclose = fsl_dcu_drm_preclose,
|
||||
.irq_handler = fsl_dcu_drm_irq,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = fsl_dcu_drm_enable_vblank,
|
||||
.disable_vblank = fsl_dcu_drm_disable_vblank,
|
||||
.gem_free_object = drm_gem_cma_free_object,
|
||||
|
|
|
@ -687,15 +687,15 @@ extern void psb_irq_turn_off_dpst(struct drm_device *dev);
|
|||
extern void psb_irq_uninstall_islands(struct drm_device *dev, int hw_islands);
|
||||
extern int psb_vblank_wait2(struct drm_device *dev, unsigned int *sequence);
|
||||
extern int psb_vblank_wait(struct drm_device *dev, unsigned int *sequence);
|
||||
extern int psb_enable_vblank(struct drm_device *dev, int crtc);
|
||||
extern void psb_disable_vblank(struct drm_device *dev, int crtc);
|
||||
extern int psb_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern void psb_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void
|
||||
psb_enable_pipestat(struct drm_psb_private *dev_priv, int pipe, u32 mask);
|
||||
|
||||
void
|
||||
psb_disable_pipestat(struct drm_psb_private *dev_priv, int pipe, u32 mask);
|
||||
|
||||
extern u32 psb_get_vblank_counter(struct drm_device *dev, int crtc);
|
||||
extern u32 psb_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
/* framebuffer.c */
|
||||
extern int psbfb_probed(struct drm_device *dev);
|
||||
|
|
|
@ -510,7 +510,7 @@ int psb_irq_disable_dpst(struct drm_device *dev)
|
|||
/*
|
||||
* It is used to enable VBLANK interrupt
|
||||
*/
|
||||
int psb_enable_vblank(struct drm_device *dev, int pipe)
|
||||
int psb_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_psb_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -549,7 +549,7 @@ int psb_enable_vblank(struct drm_device *dev, int pipe)
|
|||
/*
|
||||
* It is used to disable VBLANK interrupt
|
||||
*/
|
||||
void psb_disable_vblank(struct drm_device *dev, int pipe)
|
||||
void psb_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_psb_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -622,7 +622,7 @@ void mdfld_disable_te(struct drm_device *dev, int pipe)
|
|||
/* Called from drm generic code, passed a 'crtc', which
|
||||
* we use as a pipe index
|
||||
*/
|
||||
u32 psb_get_vblank_counter(struct drm_device *dev, int pipe)
|
||||
u32 psb_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
uint32_t high_frame = PIPEAFRAMEHIGH;
|
||||
uint32_t low_frame = PIPEAFRAMEPIXEL;
|
||||
|
@ -654,7 +654,7 @@ u32 psb_get_vblank_counter(struct drm_device *dev, int pipe)
|
|||
reg_val = REG_READ(pipeconf_reg);
|
||||
|
||||
if (!(reg_val & PIPEACONF_ENABLE)) {
|
||||
dev_err(dev->dev, "trying to get vblank count for disabled pipe %d\n",
|
||||
dev_err(dev->dev, "trying to get vblank count for disabled pipe %u\n",
|
||||
pipe);
|
||||
goto psb_get_vblank_counter_exit;
|
||||
}
|
||||
|
|
|
@ -38,9 +38,9 @@ int psb_irq_enable_dpst(struct drm_device *dev);
|
|||
int psb_irq_disable_dpst(struct drm_device *dev);
|
||||
void psb_irq_turn_on_dpst(struct drm_device *dev);
|
||||
void psb_irq_turn_off_dpst(struct drm_device *dev);
|
||||
int psb_enable_vblank(struct drm_device *dev, int pipe);
|
||||
void psb_disable_vblank(struct drm_device *dev, int pipe);
|
||||
u32 psb_get_vblank_counter(struct drm_device *dev, int pipe);
|
||||
int psb_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void psb_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
u32 psb_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
int mdfld_enable_te(struct drm_device *dev, int pipe);
|
||||
void mdfld_disable_te(struct drm_device *dev, int pipe);
|
||||
|
|
|
@ -952,7 +952,6 @@ static int i915_gem_fence_regs_info(struct seq_file *m, void *data)
|
|||
if (ret)
|
||||
return ret;
|
||||
|
||||
seq_printf(m, "Reserved fences = %d\n", dev_priv->fence_reg_start);
|
||||
seq_printf(m, "Total fences = %d\n", dev_priv->num_fence_regs);
|
||||
for (i = 0; i < dev_priv->num_fence_regs; i++) {
|
||||
struct drm_i915_gem_object *obj = dev_priv->fence_regs[i].obj;
|
||||
|
|
|
@ -75,7 +75,7 @@ static int i915_getparam(struct drm_device *dev, void *data,
|
|||
value = 1;
|
||||
break;
|
||||
case I915_PARAM_NUM_FENCES_AVAIL:
|
||||
value = dev_priv->num_fence_regs - dev_priv->fence_reg_start;
|
||||
value = dev_priv->num_fence_regs;
|
||||
break;
|
||||
case I915_PARAM_HAS_OVERLAY:
|
||||
value = dev_priv->overlay ? 1 : 0;
|
||||
|
@ -183,35 +183,6 @@ static int i915_getparam(struct drm_device *dev, void *data,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i915_setparam(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
drm_i915_setparam_t *param = data;
|
||||
|
||||
switch (param->param) {
|
||||
case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
|
||||
case I915_SETPARAM_TEX_LRU_LOG_GRANULARITY:
|
||||
case I915_SETPARAM_ALLOW_BATCHBUFFER:
|
||||
/* Reject all old ums/dri params. */
|
||||
return -ENODEV;
|
||||
|
||||
case I915_SETPARAM_NUM_USED_FENCES:
|
||||
if (param->value > dev_priv->num_fence_regs ||
|
||||
param->value < 0)
|
||||
return -EINVAL;
|
||||
/* Userspace can use first N regs */
|
||||
dev_priv->fence_reg_start = param->value;
|
||||
break;
|
||||
default:
|
||||
DRM_DEBUG_DRIVER("unknown parameter %d\n",
|
||||
param->param);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i915_get_bridge_dev(struct drm_device *dev)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
|
@ -1246,7 +1217,7 @@ const struct drm_ioctl_desc i915_ioctls[] = {
|
|||
DRM_IOCTL_DEF_DRV(I915_IRQ_EMIT, drm_noop, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(I915_IRQ_WAIT, drm_noop, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(I915_GETPARAM, i915_getparam, DRM_AUTH|DRM_RENDER_ALLOW),
|
||||
DRM_IOCTL_DEF_DRV(I915_SETPARAM, i915_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(I915_SETPARAM, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(I915_ALLOC, drm_noop, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(I915_FREE, drm_noop, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(I915_INIT_HEAP, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
|
|
@ -1802,7 +1802,6 @@ struct drm_i915_private {
|
|||
struct mutex pps_mutex;
|
||||
|
||||
struct drm_i915_fence_reg fence_regs[I915_MAX_NUM_FENCES]; /* assume 965 */
|
||||
int fence_reg_start; /* 4 if userland hasn't ioctl'd us yet */
|
||||
int num_fence_regs; /* 8 on pre-965, 16 otherwise */
|
||||
|
||||
unsigned int fsb_freq, mem_freq, is_ddr3;
|
||||
|
|
|
@ -322,7 +322,7 @@ i915_find_fence_reg(struct drm_device *dev)
|
|||
|
||||
/* First try to find a free reg */
|
||||
avail = NULL;
|
||||
for (i = dev_priv->fence_reg_start; i < dev_priv->num_fence_regs; i++) {
|
||||
for (i = 0; i < dev_priv->num_fence_regs; i++) {
|
||||
reg = &dev_priv->fence_regs[i];
|
||||
if (!reg->obj)
|
||||
return reg;
|
||||
|
|
|
@ -649,7 +649,7 @@ static void i915_enable_asle_pipestat(struct drm_device *dev)
|
|||
* of horizontal active on the first line of vertical active
|
||||
*/
|
||||
|
||||
static u32 i8xx_get_vblank_counter(struct drm_device *dev, int pipe)
|
||||
static u32 i8xx_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
/* Gen2 doesn't have a hardware frame counter */
|
||||
return 0;
|
||||
|
@ -658,7 +658,7 @@ static u32 i8xx_get_vblank_counter(struct drm_device *dev, int pipe)
|
|||
/* Called from drm generic code, passed a 'crtc', which
|
||||
* we use as a pipe index
|
||||
*/
|
||||
static u32 i915_get_vblank_counter(struct drm_device *dev, int pipe)
|
||||
static u32 i915_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long high_frame;
|
||||
|
@ -706,7 +706,7 @@ static u32 i915_get_vblank_counter(struct drm_device *dev, int pipe)
|
|||
return (((high1 << 8) | low) + (pixel >= vbl_start)) & 0xffffff;
|
||||
}
|
||||
|
||||
static u32 gm45_get_vblank_counter(struct drm_device *dev, int pipe)
|
||||
static u32 gm45_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
int reg = PIPE_FRMCOUNT_GM45(pipe);
|
||||
|
@ -767,7 +767,7 @@ static int __intel_get_crtc_scanline(struct intel_crtc *crtc)
|
|||
return (position + crtc->scanline_offset) % vtotal;
|
||||
}
|
||||
|
||||
static int i915_get_crtc_scanoutpos(struct drm_device *dev, int pipe,
|
||||
static int i915_get_crtc_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode)
|
||||
|
@ -904,27 +904,27 @@ int intel_get_crtc_scanline(struct intel_crtc *crtc)
|
|||
return position;
|
||||
}
|
||||
|
||||
static int i915_get_vblank_timestamp(struct drm_device *dev, int pipe,
|
||||
static int i915_get_vblank_timestamp(struct drm_device *dev, unsigned int pipe,
|
||||
int *max_error,
|
||||
struct timeval *vblank_time,
|
||||
unsigned flags)
|
||||
{
|
||||
struct drm_crtc *crtc;
|
||||
|
||||
if (pipe < 0 || pipe >= INTEL_INFO(dev)->num_pipes) {
|
||||
DRM_ERROR("Invalid crtc %d\n", pipe);
|
||||
if (pipe >= INTEL_INFO(dev)->num_pipes) {
|
||||
DRM_ERROR("Invalid crtc %u\n", pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Get drm_crtc to timestamp: */
|
||||
crtc = intel_get_crtc_for_pipe(dev, pipe);
|
||||
if (crtc == NULL) {
|
||||
DRM_ERROR("Invalid crtc %d\n", pipe);
|
||||
DRM_ERROR("Invalid crtc %u\n", pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!crtc->hwmode.crtc_clock) {
|
||||
DRM_DEBUG_KMS("crtc %d is disabled\n", pipe);
|
||||
DRM_DEBUG_KMS("crtc %u is disabled\n", pipe);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
|
@ -2611,7 +2611,7 @@ void i915_handle_error(struct drm_device *dev, bool wedged,
|
|||
/* Called from drm generic code, passed 'crtc' which
|
||||
* we use as a pipe index
|
||||
*/
|
||||
static int i915_enable_vblank(struct drm_device *dev, int pipe)
|
||||
static int i915_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2628,7 +2628,7 @@ static int i915_enable_vblank(struct drm_device *dev, int pipe)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int ironlake_enable_vblank(struct drm_device *dev, int pipe)
|
||||
static int ironlake_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2642,7 +2642,7 @@ static int ironlake_enable_vblank(struct drm_device *dev, int pipe)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int valleyview_enable_vblank(struct drm_device *dev, int pipe)
|
||||
static int valleyview_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2655,7 +2655,7 @@ static int valleyview_enable_vblank(struct drm_device *dev, int pipe)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int gen8_enable_vblank(struct drm_device *dev, int pipe)
|
||||
static int gen8_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2671,7 +2671,7 @@ static int gen8_enable_vblank(struct drm_device *dev, int pipe)
|
|||
/* Called from drm generic code, passed 'crtc' which
|
||||
* we use as a pipe index
|
||||
*/
|
||||
static void i915_disable_vblank(struct drm_device *dev, int pipe)
|
||||
static void i915_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2683,7 +2683,7 @@ static void i915_disable_vblank(struct drm_device *dev, int pipe)
|
|||
spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
|
||||
}
|
||||
|
||||
static void ironlake_disable_vblank(struct drm_device *dev, int pipe)
|
||||
static void ironlake_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2695,7 +2695,7 @@ static void ironlake_disable_vblank(struct drm_device *dev, int pipe)
|
|||
spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
|
||||
}
|
||||
|
||||
static void valleyview_disable_vblank(struct drm_device *dev, int pipe)
|
||||
static void valleyview_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
@ -2706,7 +2706,7 @@ static void valleyview_disable_vblank(struct drm_device *dev, int pipe)
|
|||
spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
|
||||
}
|
||||
|
||||
static void gen8_disable_vblank(struct drm_device *dev, int pipe)
|
||||
static void gen8_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dev->dev_private;
|
||||
unsigned long irqflags;
|
||||
|
|
|
@ -145,10 +145,10 @@ void imx_drm_handle_vblank(struct imx_drm_crtc *imx_drm_crtc)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(imx_drm_handle_vblank);
|
||||
|
||||
static int imx_drm_enable_vblank(struct drm_device *drm, int crtc)
|
||||
static int imx_drm_enable_vblank(struct drm_device *drm, unsigned int pipe)
|
||||
{
|
||||
struct imx_drm_device *imxdrm = drm->dev_private;
|
||||
struct imx_drm_crtc *imx_drm_crtc = imxdrm->crtc[crtc];
|
||||
struct imx_drm_crtc *imx_drm_crtc = imxdrm->crtc[pipe];
|
||||
int ret;
|
||||
|
||||
if (!imx_drm_crtc)
|
||||
|
@ -163,10 +163,10 @@ static int imx_drm_enable_vblank(struct drm_device *drm, int crtc)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static void imx_drm_disable_vblank(struct drm_device *drm, int crtc)
|
||||
static void imx_drm_disable_vblank(struct drm_device *drm, unsigned int pipe)
|
||||
{
|
||||
struct imx_drm_device *imxdrm = drm->dev_private;
|
||||
struct imx_drm_crtc *imx_drm_crtc = imxdrm->crtc[crtc];
|
||||
struct imx_drm_crtc *imx_drm_crtc = imxdrm->crtc[pipe];
|
||||
|
||||
if (!imx_drm_crtc)
|
||||
return;
|
||||
|
@ -487,7 +487,7 @@ static struct drm_driver imx_drm_driver = {
|
|||
.gem_prime_vmap = drm_gem_cma_prime_vmap,
|
||||
.gem_prime_vunmap = drm_gem_cma_prime_vunmap,
|
||||
.gem_prime_mmap = drm_gem_cma_prime_mmap,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = imx_drm_enable_vblank,
|
||||
.disable_vblank = imx_drm_disable_vblank,
|
||||
.ioctls = imx_drm_ioctls,
|
||||
|
|
|
@ -416,7 +416,7 @@ int mga_driver_load(struct drm_device *dev, unsigned long flags)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
/**
|
||||
* Bootstrap the driver for AGP DMA.
|
||||
*
|
||||
|
@ -947,7 +947,7 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
|
|||
drm_legacy_ioremapfree(dev->agp_buffer_map, dev);
|
||||
|
||||
if (dev_priv->used_new_dma_init) {
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->agp_handle != 0) {
|
||||
struct drm_agp_binding unbind_req;
|
||||
struct drm_agp_buffer free_req;
|
||||
|
|
|
@ -183,9 +183,9 @@ extern int mga_warp_install_microcode(drm_mga_private_t *dev_priv);
|
|||
extern int mga_warp_init(drm_mga_private_t *dev_priv);
|
||||
|
||||
/* mga_irq.c */
|
||||
extern int mga_enable_vblank(struct drm_device *dev, int crtc);
|
||||
extern void mga_disable_vblank(struct drm_device *dev, int crtc);
|
||||
extern u32 mga_get_vblank_counter(struct drm_device *dev, int crtc);
|
||||
extern int mga_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern void mga_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern u32 mga_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
extern int mga_driver_fence_wait(struct drm_device *dev, unsigned int *sequence);
|
||||
extern int mga_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence);
|
||||
extern irqreturn_t mga_driver_irq_handler(int irq, void *arg);
|
||||
|
|
|
@ -35,12 +35,12 @@
|
|||
#include <drm/mga_drm.h>
|
||||
#include "mga_drv.h"
|
||||
|
||||
u32 mga_get_vblank_counter(struct drm_device *dev, int crtc)
|
||||
u32 mga_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
const drm_mga_private_t *const dev_priv =
|
||||
(drm_mga_private_t *) dev->dev_private;
|
||||
|
||||
if (crtc != 0)
|
||||
if (pipe != 0)
|
||||
return 0;
|
||||
|
||||
return atomic_read(&dev_priv->vbl_received);
|
||||
|
@ -88,13 +88,13 @@ irqreturn_t mga_driver_irq_handler(int irq, void *arg)
|
|||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
int mga_enable_vblank(struct drm_device *dev, int crtc)
|
||||
int mga_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
|
||||
|
||||
if (crtc != 0) {
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
|
||||
crtc);
|
||||
if (pipe != 0) {
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %u\n",
|
||||
pipe);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -103,11 +103,11 @@ int mga_enable_vblank(struct drm_device *dev, int crtc)
|
|||
}
|
||||
|
||||
|
||||
void mga_disable_vblank(struct drm_device *dev, int crtc)
|
||||
void mga_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
if (crtc != 0) {
|
||||
DRM_ERROR("tried to disable vblank on non-existent crtc %d\n",
|
||||
crtc);
|
||||
if (pipe != 0) {
|
||||
DRM_ERROR("tried to disable vblank on non-existent crtc %u\n",
|
||||
pipe);
|
||||
}
|
||||
|
||||
/* Do *NOT* disable the vertical refresh interrupt. MGA doesn't have
|
||||
|
|
|
@ -531,24 +531,24 @@ static void msm_irq_uninstall(struct drm_device *dev)
|
|||
kms->funcs->irq_uninstall(kms);
|
||||
}
|
||||
|
||||
static int msm_enable_vblank(struct drm_device *dev, int crtc_id)
|
||||
static int msm_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct msm_drm_private *priv = dev->dev_private;
|
||||
struct msm_kms *kms = priv->kms;
|
||||
if (!kms)
|
||||
return -ENXIO;
|
||||
DBG("dev=%p, crtc=%d", dev, crtc_id);
|
||||
return vblank_ctrl_queue_work(priv, crtc_id, true);
|
||||
DBG("dev=%p, crtc=%u", dev, pipe);
|
||||
return vblank_ctrl_queue_work(priv, pipe, true);
|
||||
}
|
||||
|
||||
static void msm_disable_vblank(struct drm_device *dev, int crtc_id)
|
||||
static void msm_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct msm_drm_private *priv = dev->dev_private;
|
||||
struct msm_kms *kms = priv->kms;
|
||||
if (!kms)
|
||||
return;
|
||||
DBG("dev=%p, crtc=%d", dev, crtc_id);
|
||||
vblank_ctrl_queue_work(priv, crtc_id, false);
|
||||
DBG("dev=%p, crtc=%u", dev, pipe);
|
||||
vblank_ctrl_queue_work(priv, pipe, false);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -978,7 +978,7 @@ static struct drm_driver msm_driver = {
|
|||
.irq_preinstall = msm_irq_preinstall,
|
||||
.irq_postinstall = msm_irq_postinstall,
|
||||
.irq_uninstall = msm_irq_uninstall,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = msm_enable_vblank,
|
||||
.disable_vblank = msm_disable_vblank,
|
||||
.gem_free_object = msm_gem_free_object,
|
||||
|
|
|
@ -574,7 +574,7 @@ static struct ttm_tt *
|
|||
nouveau_ttm_tt_create(struct ttm_bo_device *bdev, unsigned long size,
|
||||
uint32_t page_flags, struct page *dummy_read)
|
||||
{
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
struct nouveau_drm *drm = nouveau_bdev(bdev);
|
||||
|
||||
if (drm->agp.bridge) {
|
||||
|
@ -1366,7 +1366,7 @@ nouveau_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
|
|||
/* System memory */
|
||||
return 0;
|
||||
case TTM_PL_TT:
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (drm->agp.bridge) {
|
||||
mem->bus.offset = mem->start << PAGE_SHIFT;
|
||||
mem->bus.base = drm->agp.base;
|
||||
|
@ -1496,7 +1496,7 @@ nouveau_ttm_tt_populate(struct ttm_tt *ttm)
|
|||
ttm->caching_state == tt_uncached)
|
||||
return ttm_dma_populate(ttm_dma, dev->dev);
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (drm->agp.bridge) {
|
||||
return ttm_agp_tt_populate(ttm);
|
||||
}
|
||||
|
@ -1563,7 +1563,7 @@ nouveau_ttm_tt_unpopulate(struct ttm_tt *ttm)
|
|||
return;
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (drm->agp.bridge) {
|
||||
ttm_agp_tt_unpopulate(ttm);
|
||||
return;
|
||||
|
|
|
@ -51,12 +51,12 @@ nouveau_display_vblank_handler(struct nvif_notify *notify)
|
|||
}
|
||||
|
||||
int
|
||||
nouveau_display_vblank_enable(struct drm_device *dev, int head)
|
||||
nouveau_display_vblank_enable(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_crtc *crtc;
|
||||
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
||||
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
||||
if (nv_crtc->index == head) {
|
||||
if (nv_crtc->index == pipe) {
|
||||
nvif_notify_get(&nv_crtc->vblank);
|
||||
return 0;
|
||||
}
|
||||
|
@ -65,12 +65,12 @@ nouveau_display_vblank_enable(struct drm_device *dev, int head)
|
|||
}
|
||||
|
||||
void
|
||||
nouveau_display_vblank_disable(struct drm_device *dev, int head)
|
||||
nouveau_display_vblank_disable(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct drm_crtc *crtc;
|
||||
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
||||
struct nouveau_crtc *nv_crtc = nouveau_crtc(crtc);
|
||||
if (nv_crtc->index == head) {
|
||||
if (nv_crtc->index == pipe) {
|
||||
nvif_notify_put(&nv_crtc->vblank);
|
||||
return;
|
||||
}
|
||||
|
@ -132,14 +132,15 @@ nouveau_display_scanoutpos_head(struct drm_crtc *crtc, int *vpos, int *hpos,
|
|||
}
|
||||
|
||||
int
|
||||
nouveau_display_scanoutpos(struct drm_device *dev, int head, unsigned int flags,
|
||||
int *vpos, int *hpos, ktime_t *stime, ktime_t *etime,
|
||||
nouveau_display_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode)
|
||||
{
|
||||
struct drm_crtc *crtc;
|
||||
|
||||
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
||||
if (nouveau_crtc(crtc)->index == head) {
|
||||
if (nouveau_crtc(crtc)->index == pipe) {
|
||||
return nouveau_display_scanoutpos_head(crtc, vpos, hpos,
|
||||
stime, etime);
|
||||
}
|
||||
|
@ -149,15 +150,15 @@ nouveau_display_scanoutpos(struct drm_device *dev, int head, unsigned int flags,
|
|||
}
|
||||
|
||||
int
|
||||
nouveau_display_vblstamp(struct drm_device *dev, int head, int *max_error,
|
||||
struct timeval *time, unsigned flags)
|
||||
nouveau_display_vblstamp(struct drm_device *dev, unsigned int pipe,
|
||||
int *max_error, struct timeval *time, unsigned flags)
|
||||
{
|
||||
struct drm_crtc *crtc;
|
||||
|
||||
list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
|
||||
if (nouveau_crtc(crtc)->index == head) {
|
||||
if (nouveau_crtc(crtc)->index == pipe) {
|
||||
return drm_calc_vbltimestamp_from_scanoutpos(dev,
|
||||
head, max_error, time, flags,
|
||||
pipe, max_error, time, flags,
|
||||
&crtc->hwmode);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -65,12 +65,12 @@ int nouveau_display_init(struct drm_device *dev);
|
|||
void nouveau_display_fini(struct drm_device *dev);
|
||||
int nouveau_display_suspend(struct drm_device *dev, bool runtime);
|
||||
void nouveau_display_resume(struct drm_device *dev, bool runtime);
|
||||
int nouveau_display_vblank_enable(struct drm_device *, int);
|
||||
void nouveau_display_vblank_disable(struct drm_device *, int);
|
||||
int nouveau_display_scanoutpos(struct drm_device *, int, unsigned int,
|
||||
int *, int *, ktime_t *, ktime_t *,
|
||||
const struct drm_display_mode *);
|
||||
int nouveau_display_vblstamp(struct drm_device *, int, int *,
|
||||
int nouveau_display_vblank_enable(struct drm_device *, unsigned int);
|
||||
void nouveau_display_vblank_disable(struct drm_device *, unsigned int);
|
||||
int nouveau_display_scanoutpos(struct drm_device *, unsigned int,
|
||||
unsigned int, int *, int *, ktime_t *,
|
||||
ktime_t *, const struct drm_display_mode *);
|
||||
int nouveau_display_vblstamp(struct drm_device *, unsigned int, int *,
|
||||
struct timeval *, unsigned);
|
||||
|
||||
int nouveau_crtc_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb,
|
||||
|
|
|
@ -934,7 +934,7 @@ driver_stub = {
|
|||
.debugfs_cleanup = nouveau_debugfs_takedown,
|
||||
#endif
|
||||
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = nouveau_display_vblank_enable,
|
||||
.disable_vblank = nouveau_display_vblank_disable,
|
||||
.get_scanout_position = nouveau_display_scanoutpos,
|
||||
|
|
|
@ -839,7 +839,7 @@ static struct drm_driver omap_drm_driver = {
|
|||
.preclose = dev_preclose,
|
||||
.postclose = dev_postclose,
|
||||
.set_busid = drm_platform_set_busid,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = omap_irq_enable_vblank,
|
||||
.disable_vblank = omap_irq_disable_vblank,
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
|
|
|
@ -129,8 +129,8 @@ void omap_gem_describe_objects(struct list_head *list, struct seq_file *m);
|
|||
int omap_gem_resume(struct device *dev);
|
||||
#endif
|
||||
|
||||
int omap_irq_enable_vblank(struct drm_device *dev, int crtc_id);
|
||||
void omap_irq_disable_vblank(struct drm_device *dev, int crtc_id);
|
||||
int omap_irq_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void omap_irq_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void __omap_irq_register(struct drm_device *dev, struct omap_drm_irq *irq);
|
||||
void __omap_irq_unregister(struct drm_device *dev, struct omap_drm_irq *irq);
|
||||
void omap_irq_register(struct drm_device *dev, struct omap_drm_irq *irq);
|
||||
|
|
|
@ -171,7 +171,7 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
|
|||
uint32_t w = win->src_w;
|
||||
uint32_t h = win->src_h;
|
||||
|
||||
switch (win->rotation & 0xf) {
|
||||
switch (win->rotation & DRM_ROTATE_MASK) {
|
||||
default:
|
||||
dev_err(fb->dev->dev, "invalid rotation: %02x",
|
||||
(uint32_t)win->rotation);
|
||||
|
@ -209,7 +209,7 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb,
|
|||
info->rotation_type = OMAP_DSS_ROT_TILER;
|
||||
info->screen_width = omap_gem_tiled_stride(plane->bo, orient);
|
||||
} else {
|
||||
switch (win->rotation & 0xf) {
|
||||
switch (win->rotation & DRM_ROTATE_MASK) {
|
||||
case 0:
|
||||
case BIT(DRM_ROTATE_0):
|
||||
/* OK */
|
||||
|
|
|
@ -134,7 +134,7 @@ int omap_irq_wait(struct drm_device *dev, struct omap_irq_wait *wait,
|
|||
/**
|
||||
* enable_vblank - enable vblank interrupt events
|
||||
* @dev: DRM device
|
||||
* @crtc: which irq to enable
|
||||
* @pipe: which irq to enable
|
||||
*
|
||||
* Enable vblank interrupts for @crtc. If the device doesn't have
|
||||
* a hardware vblank counter, this routine should be a no-op, since
|
||||
|
@ -144,13 +144,13 @@ int omap_irq_wait(struct drm_device *dev, struct omap_irq_wait *wait,
|
|||
* Zero on success, appropriate errno if the given @crtc's vblank
|
||||
* interrupt cannot be enabled.
|
||||
*/
|
||||
int omap_irq_enable_vblank(struct drm_device *dev, int crtc_id)
|
||||
int omap_irq_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct omap_drm_private *priv = dev->dev_private;
|
||||
struct drm_crtc *crtc = priv->crtcs[crtc_id];
|
||||
struct drm_crtc *crtc = priv->crtcs[pipe];
|
||||
unsigned long flags;
|
||||
|
||||
DBG("dev=%p, crtc=%d", dev, crtc_id);
|
||||
DBG("dev=%p, crtc=%u", dev, pipe);
|
||||
|
||||
spin_lock_irqsave(&list_lock, flags);
|
||||
priv->vblank_mask |= pipe2vbl(crtc);
|
||||
|
@ -163,19 +163,19 @@ int omap_irq_enable_vblank(struct drm_device *dev, int crtc_id)
|
|||
/**
|
||||
* disable_vblank - disable vblank interrupt events
|
||||
* @dev: DRM device
|
||||
* @crtc: which irq to enable
|
||||
* @pipe: which irq to enable
|
||||
*
|
||||
* Disable vblank interrupts for @crtc. If the device doesn't have
|
||||
* a hardware vblank counter, this routine should be a no-op, since
|
||||
* interrupts will have to stay on to keep the count accurate.
|
||||
*/
|
||||
void omap_irq_disable_vblank(struct drm_device *dev, int crtc_id)
|
||||
void omap_irq_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct omap_drm_private *priv = dev->dev_private;
|
||||
struct drm_crtc *crtc = priv->crtcs[crtc_id];
|
||||
struct drm_crtc *crtc = priv->crtcs[pipe];
|
||||
unsigned long flags;
|
||||
|
||||
DBG("dev=%p, crtc=%d", dev, crtc_id);
|
||||
DBG("dev=%p, crtc=%u", dev, pipe);
|
||||
|
||||
spin_lock_irqsave(&list_lock, flags);
|
||||
priv->vblank_mask &= ~pipe2vbl(crtc);
|
||||
|
|
|
@ -108,7 +108,7 @@ static void omap_plane_atomic_update(struct drm_plane *plane,
|
|||
win.src_x = state->src_x >> 16;
|
||||
win.src_y = state->src_y >> 16;
|
||||
|
||||
switch (state->rotation & 0xf) {
|
||||
switch (state->rotation & DRM_ROTATE_MASK) {
|
||||
case BIT(DRM_ROTATE_90):
|
||||
case BIT(DRM_ROTATE_270):
|
||||
win.src_w = state->src_h >> 16;
|
||||
|
|
|
@ -196,17 +196,18 @@ static int qxl_pm_restore(struct device *dev)
|
|||
return qxl_drm_resume(drm_dev, false);
|
||||
}
|
||||
|
||||
static u32 qxl_noop_get_vblank_counter(struct drm_device *dev, int crtc)
|
||||
static u32 qxl_noop_get_vblank_counter(struct drm_device *dev,
|
||||
unsigned int pipe)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int qxl_noop_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int qxl_noop_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void qxl_noop_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void qxl_noop_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -311,7 +311,7 @@ static void r128_cce_init_ring_buffer(struct drm_device *dev,
|
|||
/* The manual (p. 2) says this address is in "VM space". This
|
||||
* means it's an offset from the start of AGP space.
|
||||
*/
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (!dev_priv->is_pci)
|
||||
ring_start = dev_priv->cce_ring->offset - dev->agp->base;
|
||||
else
|
||||
|
@ -505,7 +505,7 @@ static int r128_do_init_cce(struct drm_device *dev, drm_r128_init_t *init)
|
|||
(drm_r128_sarea_t *) ((u8 *) dev_priv->sarea->handle +
|
||||
init->sarea_priv_offset);
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (!dev_priv->is_pci) {
|
||||
drm_legacy_ioremap_wc(dev_priv->cce_ring, dev);
|
||||
drm_legacy_ioremap_wc(dev_priv->ring_rptr, dev);
|
||||
|
@ -529,7 +529,7 @@ static int r128_do_init_cce(struct drm_device *dev, drm_r128_init_t *init)
|
|||
(void *)(unsigned long)dev->agp_buffer_map->offset;
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (!dev_priv->is_pci)
|
||||
dev_priv->cce_buffers_offset = dev->agp->base;
|
||||
else
|
||||
|
@ -552,7 +552,7 @@ static int r128_do_init_cce(struct drm_device *dev, drm_r128_init_t *init)
|
|||
dev_priv->sarea_priv->last_dispatch = 0;
|
||||
R128_WRITE(R128_LAST_DISPATCH_REG, dev_priv->sarea_priv->last_dispatch);
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->is_pci) {
|
||||
#endif
|
||||
dev_priv->gart_info.table_mask = DMA_BIT_MASK(32);
|
||||
|
@ -568,7 +568,7 @@ static int r128_do_init_cce(struct drm_device *dev, drm_r128_init_t *init)
|
|||
return -ENOMEM;
|
||||
}
|
||||
R128_WRITE(R128_PCI_GART_PAGE, dev_priv->gart_info.bus_addr);
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -600,7 +600,7 @@ int r128_do_cleanup_cce(struct drm_device *dev)
|
|||
if (dev->dev_private) {
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (!dev_priv->is_pci) {
|
||||
if (dev_priv->cce_ring != NULL)
|
||||
drm_legacy_ioremapfree(dev_priv->cce_ring, dev);
|
||||
|
|
|
@ -154,9 +154,9 @@ extern int r128_wait_ring(drm_r128_private_t *dev_priv, int n);
|
|||
extern int r128_do_cce_idle(drm_r128_private_t *dev_priv);
|
||||
extern int r128_do_cleanup_cce(struct drm_device *dev);
|
||||
|
||||
extern int r128_enable_vblank(struct drm_device *dev, int crtc);
|
||||
extern void r128_disable_vblank(struct drm_device *dev, int crtc);
|
||||
extern u32 r128_get_vblank_counter(struct drm_device *dev, int crtc);
|
||||
extern int r128_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern void r128_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern u32 r128_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
extern irqreturn_t r128_driver_irq_handler(int irq, void *arg);
|
||||
extern void r128_driver_irq_preinstall(struct drm_device *dev);
|
||||
extern int r128_driver_irq_postinstall(struct drm_device *dev);
|
||||
|
|
|
@ -34,11 +34,11 @@
|
|||
#include <drm/r128_drm.h>
|
||||
#include "r128_drv.h"
|
||||
|
||||
u32 r128_get_vblank_counter(struct drm_device *dev, int crtc)
|
||||
u32 r128_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
const drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
if (crtc != 0)
|
||||
if (pipe != 0)
|
||||
return 0;
|
||||
|
||||
return atomic_read(&dev_priv->vbl_received);
|
||||
|
@ -62,12 +62,12 @@ irqreturn_t r128_driver_irq_handler(int irq, void *arg)
|
|||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
int r128_enable_vblank(struct drm_device *dev, int crtc)
|
||||
int r128_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
if (crtc != 0) {
|
||||
DRM_ERROR("%s: bad crtc %d\n", __func__, crtc);
|
||||
if (pipe != 0) {
|
||||
DRM_ERROR("%s: bad crtc %u\n", __func__, pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
@ -75,10 +75,10 @@ int r128_enable_vblank(struct drm_device *dev, int crtc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void r128_disable_vblank(struct drm_device *dev, int crtc)
|
||||
void r128_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
if (crtc != 0)
|
||||
DRM_ERROR("%s: bad crtc %d\n", __func__, crtc);
|
||||
if (pipe != 0)
|
||||
DRM_ERROR("%s: bad crtc %u\n", __func__, pipe);
|
||||
|
||||
/*
|
||||
* FIXME: implement proper interrupt disable by using the vblank
|
||||
|
|
|
@ -1837,7 +1837,7 @@ static void r600_cp_init_ring_buffer(struct drm_device *dev,
|
|||
SET_RING_HEAD(dev_priv, 0);
|
||||
dev_priv->ring.tail = 0;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
rptr_addr = dev_priv->ring_rptr->offset
|
||||
- dev->agp->base +
|
||||
|
@ -1863,7 +1863,7 @@ static void r600_cp_init_ring_buffer(struct drm_device *dev,
|
|||
dev_priv->ring.size_l2qw);
|
||||
#endif
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
/* XXX */
|
||||
radeon_write_agp_base(dev_priv, dev->agp->base);
|
||||
|
@ -1946,7 +1946,7 @@ int r600_do_cleanup_cp(struct drm_device *dev)
|
|||
if (dev->irq_enabled)
|
||||
drm_irq_uninstall(dev);
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
if (dev_priv->cp_ring != NULL) {
|
||||
drm_legacy_ioremapfree(dev_priv->cp_ring, dev);
|
||||
|
@ -2089,7 +2089,7 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
}
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
/* XXX */
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
drm_legacy_ioremap_wc(dev_priv->cp_ring, dev);
|
||||
|
@ -2148,7 +2148,7 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
* location in the card and on the bus, though we have to
|
||||
* align it down.
|
||||
*/
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
/* XXX */
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
base = dev->agp->base;
|
||||
|
@ -2175,7 +2175,7 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
base, dev_priv->gart_vm_start);
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
/* XXX */
|
||||
if (dev_priv->flags & RADEON_IS_AGP)
|
||||
dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
|
||||
|
@ -2212,7 +2212,7 @@ int r600_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
|
||||
dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
/* XXX turn off pcie gart */
|
||||
} else
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
#include "radeon.h"
|
||||
#include <drm/radeon_drm.h>
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
|
||||
struct radeon_agpmode_quirk {
|
||||
u32 hostbridge_vendor;
|
||||
|
@ -123,7 +123,7 @@ static struct radeon_agpmode_quirk radeon_agpmode_quirk_list[] = {
|
|||
|
||||
int radeon_agp_init(struct radeon_device *rdev)
|
||||
{
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
struct radeon_agpmode_quirk *p = radeon_agpmode_quirk_list;
|
||||
struct drm_agp_mode mode;
|
||||
struct drm_agp_info info;
|
||||
|
@ -257,7 +257,7 @@ int radeon_agp_init(struct radeon_device *rdev)
|
|||
|
||||
void radeon_agp_resume(struct radeon_device *rdev)
|
||||
{
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
int r;
|
||||
if (rdev->flags & RADEON_IS_AGP) {
|
||||
r = radeon_agp_init(rdev);
|
||||
|
@ -269,7 +269,7 @@ void radeon_agp_resume(struct radeon_device *rdev)
|
|||
|
||||
void radeon_agp_fini(struct radeon_device *rdev)
|
||||
{
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (rdev->ddev->agp && rdev->ddev->agp->acquired) {
|
||||
drm_agp_release(rdev->ddev);
|
||||
}
|
||||
|
|
|
@ -762,7 +762,7 @@ static void radeon_cp_init_ring_buffer(struct drm_device * dev,
|
|||
((dev_priv->gart_vm_start - 1) & 0xffff0000)
|
||||
| (dev_priv->fb_location >> 16));
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
radeon_write_agp_base(dev_priv, dev->agp->base);
|
||||
|
||||
|
@ -791,7 +791,7 @@ static void radeon_cp_init_ring_buffer(struct drm_device * dev,
|
|||
SET_RING_HEAD(dev_priv, cur_read_ptr);
|
||||
dev_priv->ring.tail = cur_read_ptr;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
RADEON_WRITE(RADEON_CP_RB_RPTR_ADDR,
|
||||
dev_priv->ring_rptr->offset
|
||||
|
@ -1335,7 +1335,7 @@ static int radeon_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
}
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
drm_legacy_ioremap_wc(dev_priv->cp_ring, dev);
|
||||
drm_legacy_ioremap_wc(dev_priv->ring_rptr, dev);
|
||||
|
@ -1394,7 +1394,7 @@ static int radeon_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
* location in the card and on the bus, though we have to
|
||||
* align it down.
|
||||
*/
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
base = dev->agp->base;
|
||||
/* Check if valid */
|
||||
|
@ -1424,7 +1424,7 @@ static int radeon_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
RADEON_READ(RADEON_CONFIG_APER_SIZE);
|
||||
}
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP)
|
||||
dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
|
||||
- dev->agp->base
|
||||
|
@ -1455,7 +1455,7 @@ static int radeon_do_init_cp(struct drm_device *dev, drm_radeon_init_t *init,
|
|||
|
||||
dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
/* Turn off PCI GART */
|
||||
radeon_set_pcigart(dev_priv, 0);
|
||||
|
@ -1566,7 +1566,7 @@ static int radeon_do_cleanup_cp(struct drm_device * dev)
|
|||
if (dev->irq_enabled)
|
||||
drm_irq_uninstall(dev);
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
if (dev_priv->cp_ring != NULL) {
|
||||
drm_legacy_ioremapfree(dev_priv->cp_ring, dev);
|
||||
|
@ -1625,7 +1625,7 @@ static int radeon_do_resume_cp(struct drm_device *dev, struct drm_file *file_pri
|
|||
|
||||
DRM_DEBUG("Starting radeon_do_resume_cp()\n");
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (dev_priv->flags & RADEON_IS_AGP) {
|
||||
/* Turn off PCI GART */
|
||||
radeon_set_pcigart(dev_priv, 0);
|
||||
|
|
|
@ -1799,8 +1799,9 @@ bool radeon_crtc_scaling_mode_fixup(struct drm_crtc *crtc,
|
|||
* unknown small number of scanlines wrt. real scanout position.
|
||||
*
|
||||
*/
|
||||
int radeon_get_crtc_scanoutpos(struct drm_device *dev, int crtc, unsigned int flags,
|
||||
int *vpos, int *hpos, ktime_t *stime, ktime_t *etime,
|
||||
int radeon_get_crtc_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode)
|
||||
{
|
||||
u32 stat_crtc = 0, vbl = 0, position = 0;
|
||||
|
@ -1816,42 +1817,42 @@ int radeon_get_crtc_scanoutpos(struct drm_device *dev, int crtc, unsigned int fl
|
|||
*stime = ktime_get();
|
||||
|
||||
if (ASIC_IS_DCE4(rdev)) {
|
||||
if (crtc == 0) {
|
||||
if (pipe == 0) {
|
||||
vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
|
||||
EVERGREEN_CRTC0_REGISTER_OFFSET);
|
||||
position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
|
||||
EVERGREEN_CRTC0_REGISTER_OFFSET);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 1) {
|
||||
if (pipe == 1) {
|
||||
vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
|
||||
EVERGREEN_CRTC1_REGISTER_OFFSET);
|
||||
position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
|
||||
EVERGREEN_CRTC1_REGISTER_OFFSET);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 2) {
|
||||
if (pipe == 2) {
|
||||
vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
|
||||
EVERGREEN_CRTC2_REGISTER_OFFSET);
|
||||
position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
|
||||
EVERGREEN_CRTC2_REGISTER_OFFSET);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 3) {
|
||||
if (pipe == 3) {
|
||||
vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
|
||||
EVERGREEN_CRTC3_REGISTER_OFFSET);
|
||||
position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
|
||||
EVERGREEN_CRTC3_REGISTER_OFFSET);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 4) {
|
||||
if (pipe == 4) {
|
||||
vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
|
||||
EVERGREEN_CRTC4_REGISTER_OFFSET);
|
||||
position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
|
||||
EVERGREEN_CRTC4_REGISTER_OFFSET);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 5) {
|
||||
if (pipe == 5) {
|
||||
vbl = RREG32(EVERGREEN_CRTC_V_BLANK_START_END +
|
||||
EVERGREEN_CRTC5_REGISTER_OFFSET);
|
||||
position = RREG32(EVERGREEN_CRTC_STATUS_POSITION +
|
||||
|
@ -1859,19 +1860,19 @@ int radeon_get_crtc_scanoutpos(struct drm_device *dev, int crtc, unsigned int fl
|
|||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
} else if (ASIC_IS_AVIVO(rdev)) {
|
||||
if (crtc == 0) {
|
||||
if (pipe == 0) {
|
||||
vbl = RREG32(AVIVO_D1CRTC_V_BLANK_START_END);
|
||||
position = RREG32(AVIVO_D1CRTC_STATUS_POSITION);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 1) {
|
||||
if (pipe == 1) {
|
||||
vbl = RREG32(AVIVO_D2CRTC_V_BLANK_START_END);
|
||||
position = RREG32(AVIVO_D2CRTC_STATUS_POSITION);
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
} else {
|
||||
/* Pre-AVIVO: Different encoding of scanout pos and vblank interval. */
|
||||
if (crtc == 0) {
|
||||
if (pipe == 0) {
|
||||
/* Assume vbl_end == 0, get vbl_start from
|
||||
* upper 16 bits.
|
||||
*/
|
||||
|
@ -1885,7 +1886,7 @@ int radeon_get_crtc_scanoutpos(struct drm_device *dev, int crtc, unsigned int fl
|
|||
|
||||
ret |= DRM_SCANOUTPOS_VALID;
|
||||
}
|
||||
if (crtc == 1) {
|
||||
if (pipe == 1) {
|
||||
vbl = (RREG32(RADEON_CRTC2_V_TOTAL_DISP) &
|
||||
RADEON_CRTC_V_DISP) >> RADEON_CRTC_V_DISP_SHIFT;
|
||||
position = (RREG32(RADEON_CRTC2_VLINE_CRNT_VLINE) >> 16) & RADEON_CRTC_V_TOTAL;
|
||||
|
|
|
@ -105,10 +105,10 @@ void radeon_driver_preclose_kms(struct drm_device *dev,
|
|||
struct drm_file *file_priv);
|
||||
int radeon_suspend_kms(struct drm_device *dev, bool suspend, bool fbcon);
|
||||
int radeon_resume_kms(struct drm_device *dev, bool resume, bool fbcon);
|
||||
u32 radeon_get_vblank_counter_kms(struct drm_device *dev, int crtc);
|
||||
int radeon_enable_vblank_kms(struct drm_device *dev, int crtc);
|
||||
void radeon_disable_vblank_kms(struct drm_device *dev, int crtc);
|
||||
int radeon_get_vblank_timestamp_kms(struct drm_device *dev, int crtc,
|
||||
u32 radeon_get_vblank_counter_kms(struct drm_device *dev, unsigned int pipe);
|
||||
int radeon_enable_vblank_kms(struct drm_device *dev, unsigned int pipe);
|
||||
void radeon_disable_vblank_kms(struct drm_device *dev, unsigned int pipe);
|
||||
int radeon_get_vblank_timestamp_kms(struct drm_device *dev, unsigned int pipe,
|
||||
int *max_error,
|
||||
struct timeval *vblank_time,
|
||||
unsigned flags);
|
||||
|
@ -124,9 +124,8 @@ void radeon_gem_object_close(struct drm_gem_object *obj,
|
|||
struct dma_buf *radeon_gem_prime_export(struct drm_device *dev,
|
||||
struct drm_gem_object *gobj,
|
||||
int flags);
|
||||
extern int radeon_get_crtc_scanoutpos(struct drm_device *dev, int crtc,
|
||||
unsigned int flags,
|
||||
int *vpos, int *hpos,
|
||||
extern int radeon_get_crtc_scanoutpos(struct drm_device *dev, unsigned int crtc,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode);
|
||||
extern bool radeon_is_px(struct drm_device *dev);
|
||||
|
|
|
@ -404,9 +404,9 @@ extern int radeon_irq_emit(struct drm_device *dev, void *data, struct drm_file *
|
|||
extern int radeon_irq_wait(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
|
||||
extern void radeon_do_release(struct drm_device * dev);
|
||||
extern u32 radeon_get_vblank_counter(struct drm_device *dev, int crtc);
|
||||
extern int radeon_enable_vblank(struct drm_device *dev, int crtc);
|
||||
extern void radeon_disable_vblank(struct drm_device *dev, int crtc);
|
||||
extern u32 radeon_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
extern int radeon_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern void radeon_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern irqreturn_t radeon_driver_irq_handler(int irq, void *arg);
|
||||
extern void radeon_driver_irq_preinstall(struct drm_device * dev);
|
||||
extern int radeon_driver_irq_postinstall(struct drm_device *dev);
|
||||
|
|
|
@ -62,12 +62,12 @@ static void r500_vbl_irq_set_state(struct drm_device *dev, u32 mask, int state)
|
|||
RADEON_WRITE(R500_DxMODE_INT_MASK, dev_priv->r500_disp_irq_reg);
|
||||
}
|
||||
|
||||
int radeon_enable_vblank(struct drm_device *dev, int crtc)
|
||||
int radeon_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_RS600) {
|
||||
switch (crtc) {
|
||||
switch (pipe) {
|
||||
case 0:
|
||||
r500_vbl_irq_set_state(dev, R500_D1MODE_INT_MASK, 1);
|
||||
break;
|
||||
|
@ -75,12 +75,12 @@ int radeon_enable_vblank(struct drm_device *dev, int crtc)
|
|||
r500_vbl_irq_set_state(dev, R500_D2MODE_INT_MASK, 1);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
|
||||
crtc);
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %u\n",
|
||||
pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
switch (crtc) {
|
||||
switch (pipe) {
|
||||
case 0:
|
||||
radeon_irq_set_state(dev, RADEON_CRTC_VBLANK_MASK, 1);
|
||||
break;
|
||||
|
@ -88,8 +88,8 @@ int radeon_enable_vblank(struct drm_device *dev, int crtc)
|
|||
radeon_irq_set_state(dev, RADEON_CRTC2_VBLANK_MASK, 1);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
|
||||
crtc);
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %u\n",
|
||||
pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
@ -97,12 +97,12 @@ int radeon_enable_vblank(struct drm_device *dev, int crtc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void radeon_disable_vblank(struct drm_device *dev, int crtc)
|
||||
void radeon_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_RS600) {
|
||||
switch (crtc) {
|
||||
switch (pipe) {
|
||||
case 0:
|
||||
r500_vbl_irq_set_state(dev, R500_D1MODE_INT_MASK, 0);
|
||||
break;
|
||||
|
@ -110,12 +110,12 @@ void radeon_disable_vblank(struct drm_device *dev, int crtc)
|
|||
r500_vbl_irq_set_state(dev, R500_D2MODE_INT_MASK, 0);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
|
||||
crtc);
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %u\n",
|
||||
pipe);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (crtc) {
|
||||
switch (pipe) {
|
||||
case 0:
|
||||
radeon_irq_set_state(dev, RADEON_CRTC_VBLANK_MASK, 0);
|
||||
break;
|
||||
|
@ -123,8 +123,8 @@ void radeon_disable_vblank(struct drm_device *dev, int crtc)
|
|||
radeon_irq_set_state(dev, RADEON_CRTC2_VBLANK_MASK, 0);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %d\n",
|
||||
crtc);
|
||||
DRM_ERROR("tried to enable vblank on non-existent crtc %u\n",
|
||||
pipe);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -255,7 +255,7 @@ static int radeon_wait_irq(struct drm_device * dev, int swi_nr)
|
|||
return ret;
|
||||
}
|
||||
|
||||
u32 radeon_get_vblank_counter(struct drm_device *dev, int crtc)
|
||||
u32 radeon_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
|
@ -264,18 +264,18 @@ u32 radeon_get_vblank_counter(struct drm_device *dev, int crtc)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (crtc < 0 || crtc > 1) {
|
||||
DRM_ERROR("Invalid crtc %d\n", crtc);
|
||||
if (pipe > 1) {
|
||||
DRM_ERROR("Invalid crtc %u\n", pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if ((dev_priv->flags & RADEON_FAMILY_MASK) >= CHIP_RS600) {
|
||||
if (crtc == 0)
|
||||
if (pipe == 0)
|
||||
return RADEON_READ(R500_D1CRTC_FRAME_COUNT);
|
||||
else
|
||||
return RADEON_READ(R500_D2CRTC_FRAME_COUNT);
|
||||
} else {
|
||||
if (crtc == 0)
|
||||
if (pipe == 0)
|
||||
return RADEON_READ(RADEON_CRTC_CRNT_FRAME);
|
||||
else
|
||||
return RADEON_READ(RADEON_CRTC2_CRNT_FRAME);
|
||||
|
|
|
@ -844,74 +844,34 @@ int radeon_get_vblank_timestamp_kms(struct drm_device *dev, int crtc,
|
|||
&drmcrtc->hwmode);
|
||||
}
|
||||
|
||||
#define KMS_INVALID_IOCTL(name) \
|
||||
static int name(struct drm_device *dev, void *data, struct drm_file \
|
||||
*file_priv) \
|
||||
{ \
|
||||
DRM_ERROR("invalid ioctl with kms %s\n", __func__); \
|
||||
return -EINVAL; \
|
||||
}
|
||||
|
||||
/*
|
||||
* All these ioctls are invalid in kms world.
|
||||
*/
|
||||
KMS_INVALID_IOCTL(radeon_cp_init_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_start_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_stop_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_reset_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_idle_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_resume_kms)
|
||||
KMS_INVALID_IOCTL(radeon_engine_reset_kms)
|
||||
KMS_INVALID_IOCTL(radeon_fullscreen_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_swap_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_clear_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_vertex_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_indices_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_texture_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_stipple_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_indirect_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_vertex2_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_cmdbuf_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_getparam_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_flip_kms)
|
||||
KMS_INVALID_IOCTL(radeon_mem_alloc_kms)
|
||||
KMS_INVALID_IOCTL(radeon_mem_free_kms)
|
||||
KMS_INVALID_IOCTL(radeon_mem_init_heap_kms)
|
||||
KMS_INVALID_IOCTL(radeon_irq_emit_kms)
|
||||
KMS_INVALID_IOCTL(radeon_irq_wait_kms)
|
||||
KMS_INVALID_IOCTL(radeon_cp_setparam_kms)
|
||||
KMS_INVALID_IOCTL(radeon_surface_alloc_kms)
|
||||
KMS_INVALID_IOCTL(radeon_surface_free_kms)
|
||||
|
||||
|
||||
const struct drm_ioctl_desc radeon_ioctls_kms[] = {
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_INIT, radeon_cp_init_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_START, radeon_cp_start_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_STOP, radeon_cp_stop_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_RESET, radeon_cp_reset_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_IDLE, radeon_cp_idle_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_RESUME, radeon_cp_resume_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_RESET, radeon_engine_reset_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_FULLSCREEN, radeon_fullscreen_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SWAP, radeon_cp_swap_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CLEAR, radeon_cp_clear_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_VERTEX, radeon_cp_vertex_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_INDICES, radeon_cp_indices_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_TEXTURE, radeon_cp_texture_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_STIPPLE, radeon_cp_stipple_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_INDIRECT, radeon_cp_indirect_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_VERTEX2, radeon_cp_vertex2_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CMDBUF, radeon_cp_cmdbuf_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_GETPARAM, radeon_cp_getparam_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_FLIP, radeon_cp_flip_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_ALLOC, radeon_mem_alloc_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_FREE, radeon_mem_free_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_INIT_HEAP, radeon_mem_init_heap_kms, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_IRQ_EMIT, radeon_irq_emit_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_IRQ_WAIT, radeon_irq_wait_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SETPARAM, radeon_cp_setparam_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SURF_ALLOC, radeon_surface_alloc_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SURF_FREE, radeon_surface_free_kms, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_INIT, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_START, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_STOP, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_RESET, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_IDLE, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CP_RESUME, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_RESET, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_FULLSCREEN, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SWAP, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CLEAR, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_VERTEX, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_INDICES, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_TEXTURE, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_STIPPLE, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_INDIRECT, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_VERTEX2, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_CMDBUF, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_GETPARAM, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_FLIP, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_ALLOC, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_FREE, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_INIT_HEAP, drm_invalid_op, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_IRQ_EMIT, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_IRQ_WAIT, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SETPARAM, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SURF_ALLOC, drm_invalid_op, DRM_AUTH),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_SURF_FREE, drm_invalid_op, DRM_AUTH),
|
||||
/* KMS */
|
||||
DRM_IOCTL_DEF_DRV(RADEON_GEM_INFO, radeon_gem_info_ioctl, DRM_AUTH|DRM_UNLOCKED|DRM_RENDER_ALLOW),
|
||||
DRM_IOCTL_DEF_DRV(RADEON_GEM_CREATE, radeon_gem_create_ioctl, DRM_AUTH|DRM_UNLOCKED|DRM_RENDER_ALLOW),
|
||||
|
|
|
@ -874,9 +874,8 @@ extern int radeon_crtc_cursor_move(struct drm_crtc *crtc,
|
|||
int x, int y);
|
||||
extern void radeon_cursor_reset(struct drm_crtc *crtc);
|
||||
|
||||
extern int radeon_get_crtc_scanoutpos(struct drm_device *dev, int crtc,
|
||||
unsigned int flags,
|
||||
int *vpos, int *hpos,
|
||||
extern int radeon_get_crtc_scanoutpos(struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode);
|
||||
|
||||
|
|
|
@ -144,7 +144,7 @@ static int radeon_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
|
|||
man->available_caching = TTM_PL_MASK_CACHING;
|
||||
man->default_caching = TTM_PL_FLAG_CACHED;
|
||||
man->flags = TTM_MEMTYPE_FLAG_MAPPABLE | TTM_MEMTYPE_FLAG_CMA;
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (rdev->flags & RADEON_IS_AGP) {
|
||||
if (!rdev->ddev->agp) {
|
||||
DRM_ERROR("AGP is not enabled for memory type %u\n",
|
||||
|
@ -461,7 +461,7 @@ static int radeon_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_
|
|||
/* system memory */
|
||||
return 0;
|
||||
case TTM_PL_TT:
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (rdev->flags & RADEON_IS_AGP) {
|
||||
/* RADEON_IS_AGP is set only if AGP is active */
|
||||
mem->bus.offset = mem->start << PAGE_SHIFT;
|
||||
|
@ -680,7 +680,7 @@ static struct ttm_tt *radeon_ttm_tt_create(struct ttm_bo_device *bdev,
|
|||
struct radeon_ttm_tt *gtt;
|
||||
|
||||
rdev = radeon_get_rdev(bdev);
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (rdev->flags & RADEON_IS_AGP) {
|
||||
return ttm_agp_tt_create(bdev, rdev->ddev->agp->bridge,
|
||||
size, page_flags, dummy_read_page);
|
||||
|
@ -736,7 +736,7 @@ static int radeon_ttm_tt_populate(struct ttm_tt *ttm)
|
|||
}
|
||||
|
||||
rdev = radeon_get_rdev(ttm->bdev);
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (rdev->flags & RADEON_IS_AGP) {
|
||||
return ttm_agp_tt_populate(ttm);
|
||||
}
|
||||
|
@ -787,7 +787,7 @@ static void radeon_ttm_tt_unpopulate(struct ttm_tt *ttm)
|
|||
return;
|
||||
|
||||
rdev = radeon_get_rdev(ttm->bdev);
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
if (rdev->flags & RADEON_IS_AGP) {
|
||||
ttm_agp_tt_unpopulate(ttm);
|
||||
return;
|
||||
|
|
|
@ -221,20 +221,20 @@ static void rcar_du_lastclose(struct drm_device *dev)
|
|||
drm_fbdev_cma_restore_mode(rcdu->fbdev);
|
||||
}
|
||||
|
||||
static int rcar_du_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int rcar_du_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct rcar_du_device *rcdu = dev->dev_private;
|
||||
|
||||
rcar_du_crtc_enable_vblank(&rcdu->crtcs[crtc], true);
|
||||
rcar_du_crtc_enable_vblank(&rcdu->crtcs[pipe], true);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void rcar_du_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void rcar_du_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct rcar_du_device *rcdu = dev->dev_private;
|
||||
|
||||
rcar_du_crtc_enable_vblank(&rcdu->crtcs[crtc], false);
|
||||
rcar_du_crtc_enable_vblank(&rcdu->crtcs[pipe], false);
|
||||
}
|
||||
|
||||
static const struct file_operations rcar_du_fops = {
|
||||
|
@ -259,7 +259,7 @@ static struct drm_driver rcar_du_driver = {
|
|||
.preclose = rcar_du_preclose,
|
||||
.lastclose = rcar_du_lastclose,
|
||||
.set_busid = drm_platform_set_busid,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = rcar_du_enable_vblank,
|
||||
.disable_vblank = rcar_du_disable_vblank,
|
||||
.gem_free_object = drm_gem_cma_free_object,
|
||||
|
|
|
@ -103,7 +103,8 @@ static struct drm_crtc *rockchip_crtc_from_pipe(struct drm_device *drm,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static int rockchip_drm_crtc_enable_vblank(struct drm_device *dev, int pipe)
|
||||
static int rockchip_drm_crtc_enable_vblank(struct drm_device *dev,
|
||||
unsigned int pipe)
|
||||
{
|
||||
struct rockchip_drm_private *priv = dev->dev_private;
|
||||
struct drm_crtc *crtc = rockchip_crtc_from_pipe(dev, pipe);
|
||||
|
@ -115,7 +116,8 @@ static int rockchip_drm_crtc_enable_vblank(struct drm_device *dev, int pipe)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void rockchip_drm_crtc_disable_vblank(struct drm_device *dev, int pipe)
|
||||
static void rockchip_drm_crtc_disable_vblank(struct drm_device *dev,
|
||||
unsigned int pipe)
|
||||
{
|
||||
struct rockchip_drm_private *priv = dev->dev_private;
|
||||
struct drm_crtc *crtc = rockchip_crtc_from_pipe(dev, pipe);
|
||||
|
@ -277,7 +279,7 @@ static struct drm_driver rockchip_drm_driver = {
|
|||
.load = rockchip_drm_load,
|
||||
.unload = rockchip_drm_unload,
|
||||
.lastclose = rockchip_drm_lastclose,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = rockchip_drm_crtc_enable_vblank,
|
||||
.disable_vblank = rockchip_drm_crtc_disable_vblank,
|
||||
.gem_vm_ops = &rockchip_drm_vm_ops,
|
||||
|
|
|
@ -231,7 +231,7 @@ static irqreturn_t shmob_drm_irq(int irq, void *arg)
|
|||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int shmob_drm_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int shmob_drm_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct shmob_drm_device *sdev = dev->dev_private;
|
||||
|
||||
|
@ -240,7 +240,7 @@ static int shmob_drm_enable_vblank(struct drm_device *dev, int crtc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void shmob_drm_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void shmob_drm_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct shmob_drm_device *sdev = dev->dev_private;
|
||||
|
||||
|
@ -269,7 +269,7 @@ static struct drm_driver shmob_drm_driver = {
|
|||
.preclose = shmob_drm_preclose,
|
||||
.set_busid = drm_platform_set_busid,
|
||||
.irq_handler = shmob_drm_irq,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = shmob_drm_enable_vblank,
|
||||
.disable_vblank = shmob_drm_disable_vblank,
|
||||
.gem_free_object = drm_gem_cma_free_object,
|
||||
|
|
|
@ -299,7 +299,7 @@ int sti_crtc_vblank_cb(struct notifier_block *nb,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int sti_crtc_enable_vblank(struct drm_device *dev, int crtc)
|
||||
int sti_crtc_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
struct sti_private *dev_priv = dev->dev_private;
|
||||
struct sti_compositor *compo = dev_priv->compo;
|
||||
|
@ -307,9 +307,9 @@ int sti_crtc_enable_vblank(struct drm_device *dev, int crtc)
|
|||
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
|
||||
if (sti_vtg_register_client(crtc == STI_MIXER_MAIN ?
|
||||
if (sti_vtg_register_client(pipe == STI_MIXER_MAIN ?
|
||||
compo->vtg_main : compo->vtg_aux,
|
||||
vtg_vblank_nb, crtc)) {
|
||||
vtg_vblank_nb, pipe)) {
|
||||
DRM_ERROR("Cannot register VTG notifier\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
@ -318,7 +318,7 @@ int sti_crtc_enable_vblank(struct drm_device *dev, int crtc)
|
|||
}
|
||||
EXPORT_SYMBOL(sti_crtc_enable_vblank);
|
||||
|
||||
void sti_crtc_disable_vblank(struct drm_device *drm_dev, int crtc)
|
||||
void sti_crtc_disable_vblank(struct drm_device *drm_dev, unsigned int pipe)
|
||||
{
|
||||
struct sti_private *priv = drm_dev->dev_private;
|
||||
struct sti_compositor *compo = priv->compo;
|
||||
|
@ -326,14 +326,14 @@ void sti_crtc_disable_vblank(struct drm_device *drm_dev, int crtc)
|
|||
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
|
||||
if (sti_vtg_unregister_client(crtc == STI_MIXER_MAIN ?
|
||||
if (sti_vtg_unregister_client(pipe == STI_MIXER_MAIN ?
|
||||
compo->vtg_main : compo->vtg_aux, vtg_vblank_nb))
|
||||
DRM_DEBUG_DRIVER("Warning: cannot unregister VTG notifier\n");
|
||||
|
||||
/* free the resources of the pending requests */
|
||||
if (compo->mixer[crtc]->pending_event) {
|
||||
drm_vblank_put(drm_dev, crtc);
|
||||
compo->mixer[crtc]->pending_event = NULL;
|
||||
if (compo->mixer[pipe]->pending_event) {
|
||||
drm_vblank_put(drm_dev, pipe);
|
||||
compo->mixer[pipe]->pending_event = NULL;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(sti_crtc_disable_vblank);
|
||||
|
|
|
@ -13,8 +13,8 @@ struct sti_mixer;
|
|||
|
||||
int sti_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer,
|
||||
struct drm_plane *primary, struct drm_plane *cursor);
|
||||
int sti_crtc_enable_vblank(struct drm_device *dev, int crtc);
|
||||
void sti_crtc_disable_vblank(struct drm_device *dev, int crtc);
|
||||
int sti_crtc_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void sti_crtc_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
int sti_crtc_vblank_cb(struct notifier_block *nb,
|
||||
unsigned long event, void *data);
|
||||
bool sti_crtc_is_main(struct drm_crtc *drm_crtc);
|
||||
|
|
|
@ -201,7 +201,7 @@ static struct drm_driver sti_driver = {
|
|||
.dumb_destroy = drm_gem_dumb_destroy,
|
||||
.fops = &sti_driver_fops,
|
||||
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = sti_crtc_enable_vblank,
|
||||
.disable_vblank = sti_crtc_disable_vblank,
|
||||
|
||||
|
|
|
@ -822,7 +822,8 @@ static struct drm_crtc *tegra_crtc_from_pipe(struct drm_device *drm,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static u32 tegra_drm_get_vblank_counter(struct drm_device *drm, int pipe)
|
||||
static u32 tegra_drm_get_vblank_counter(struct drm_device *drm,
|
||||
unsigned int pipe)
|
||||
{
|
||||
struct drm_crtc *crtc = tegra_crtc_from_pipe(drm, pipe);
|
||||
struct tegra_dc *dc = to_tegra_dc(crtc);
|
||||
|
@ -833,7 +834,7 @@ static u32 tegra_drm_get_vblank_counter(struct drm_device *drm, int pipe)
|
|||
return tegra_dc_get_vblank_counter(dc);
|
||||
}
|
||||
|
||||
static int tegra_drm_enable_vblank(struct drm_device *drm, int pipe)
|
||||
static int tegra_drm_enable_vblank(struct drm_device *drm, unsigned int pipe)
|
||||
{
|
||||
struct drm_crtc *crtc = tegra_crtc_from_pipe(drm, pipe);
|
||||
struct tegra_dc *dc = to_tegra_dc(crtc);
|
||||
|
@ -846,7 +847,7 @@ static int tegra_drm_enable_vblank(struct drm_device *drm, int pipe)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void tegra_drm_disable_vblank(struct drm_device *drm, int pipe)
|
||||
static void tegra_drm_disable_vblank(struct drm_device *drm, unsigned int pipe)
|
||||
{
|
||||
struct drm_crtc *crtc = tegra_crtc_from_pipe(drm, pipe);
|
||||
struct tegra_dc *dc = to_tegra_dc(crtc);
|
||||
|
|
|
@ -425,13 +425,13 @@ static void enable_vblank(struct drm_device *dev, bool enable)
|
|||
tilcdc_clear(dev, reg, mask);
|
||||
}
|
||||
|
||||
static int tilcdc_enable_vblank(struct drm_device *dev, int crtc)
|
||||
static int tilcdc_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
enable_vblank(dev, true);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tilcdc_disable_vblank(struct drm_device *dev, int crtc)
|
||||
static void tilcdc_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
enable_vblank(dev, false);
|
||||
}
|
||||
|
@ -563,7 +563,7 @@ static struct drm_driver tilcdc_driver = {
|
|||
.irq_preinstall = tilcdc_irq_preinstall,
|
||||
.irq_postinstall = tilcdc_irq_postinstall,
|
||||
.irq_uninstall = tilcdc_irq_uninstall,
|
||||
.get_vblank_counter = drm_vblank_count,
|
||||
.get_vblank_counter = drm_vblank_no_hw_counter,
|
||||
.enable_vblank = tilcdc_enable_vblank,
|
||||
.disable_vblank = tilcdc_disable_vblank,
|
||||
.gem_free_object = drm_gem_cma_free_object,
|
||||
|
|
|
@ -136,9 +136,9 @@ extern int via_init_context(struct drm_device *dev, int context);
|
|||
extern int via_final_context(struct drm_device *dev, int context);
|
||||
|
||||
extern int via_do_cleanup_map(struct drm_device *dev);
|
||||
extern u32 via_get_vblank_counter(struct drm_device *dev, int crtc);
|
||||
extern int via_enable_vblank(struct drm_device *dev, int crtc);
|
||||
extern void via_disable_vblank(struct drm_device *dev, int crtc);
|
||||
extern u32 via_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
extern int via_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
extern void via_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
extern irqreturn_t via_driver_irq_handler(int irq, void *arg);
|
||||
extern void via_driver_irq_preinstall(struct drm_device *dev);
|
||||
|
|
|
@ -95,10 +95,11 @@ static unsigned time_diff(struct timeval *now, struct timeval *then)
|
|||
1000000 - (then->tv_usec - now->tv_usec);
|
||||
}
|
||||
|
||||
u32 via_get_vblank_counter(struct drm_device *dev, int crtc)
|
||||
u32 via_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_via_private_t *dev_priv = dev->dev_private;
|
||||
if (crtc != 0)
|
||||
|
||||
if (pipe != 0)
|
||||
return 0;
|
||||
|
||||
return atomic_read(&dev_priv->vbl_received);
|
||||
|
@ -170,13 +171,13 @@ static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t *dev_priv)
|
|||
}
|
||||
}
|
||||
|
||||
int via_enable_vblank(struct drm_device *dev, int crtc)
|
||||
int via_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_via_private_t *dev_priv = dev->dev_private;
|
||||
u32 status;
|
||||
|
||||
if (crtc != 0) {
|
||||
DRM_ERROR("%s: bad crtc %d\n", __func__, crtc);
|
||||
if (pipe != 0) {
|
||||
DRM_ERROR("%s: bad crtc %u\n", __func__, pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
@ -189,7 +190,7 @@ int via_enable_vblank(struct drm_device *dev, int crtc)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void via_disable_vblank(struct drm_device *dev, int crtc)
|
||||
void via_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
drm_via_private_t *dev_priv = dev->dev_private;
|
||||
u32 status;
|
||||
|
@ -200,8 +201,8 @@ void via_disable_vblank(struct drm_device *dev, int crtc)
|
|||
VIA_WRITE8(0x83d4, 0x11);
|
||||
VIA_WRITE8(0x83d5, VIA_READ8(0x83d5) & ~0x30);
|
||||
|
||||
if (crtc != 0)
|
||||
DRM_ERROR("%s: bad crtc %d\n", __func__, crtc);
|
||||
if (pipe != 0)
|
||||
DRM_ERROR("%s: bad crtc %u\n", __func__, pipe);
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
|
@ -1061,14 +1061,6 @@ static struct vmw_master *vmw_master_check(struct drm_device *dev,
|
|||
}
|
||||
mutex_unlock(&dev->master_mutex);
|
||||
|
||||
/*
|
||||
* Taking the drm_global_mutex after the TTM lock might deadlock
|
||||
*/
|
||||
if (!(flags & DRM_UNLOCKED)) {
|
||||
DRM_ERROR("Refusing locked ioctl access.\n");
|
||||
return ERR_PTR(-EDEADLK);
|
||||
}
|
||||
|
||||
/*
|
||||
* Take the TTM lock. Possibly sleep waiting for the authenticating
|
||||
* master to become master again, or for a SIGTERM if the
|
||||
|
|
|
@ -914,9 +914,9 @@ void vmw_kms_idle_workqueues(struct vmw_master *vmaster);
|
|||
bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
|
||||
uint32_t pitch,
|
||||
uint32_t height);
|
||||
u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc);
|
||||
int vmw_enable_vblank(struct drm_device *dev, int crtc);
|
||||
void vmw_disable_vblank(struct drm_device *dev, int crtc);
|
||||
u32 vmw_get_vblank_counter(struct drm_device *dev, unsigned int pipe);
|
||||
int vmw_enable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
void vmw_disable_vblank(struct drm_device *dev, unsigned int pipe);
|
||||
int vmw_kms_present(struct vmw_private *dev_priv,
|
||||
struct drm_file *file_priv,
|
||||
struct vmw_framebuffer *vfb,
|
||||
|
|
|
@ -1263,7 +1263,7 @@ bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
|
|||
/**
|
||||
* Function called by DRM code called with vbl_lock held.
|
||||
*/
|
||||
u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc)
|
||||
u32 vmw_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
@ -1271,7 +1271,7 @@ u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc)
|
|||
/**
|
||||
* Function called by DRM code called with vbl_lock held.
|
||||
*/
|
||||
int vmw_enable_vblank(struct drm_device *dev, int crtc)
|
||||
int vmw_enable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
@ -1279,7 +1279,7 @@ int vmw_enable_vblank(struct drm_device *dev, int crtc)
|
|||
/**
|
||||
* Function called by DRM code called with vbl_lock held.
|
||||
*/
|
||||
void vmw_disable_vblank(struct drm_device *dev, int crtc)
|
||||
void vmw_disable_vblank(struct drm_device *dev, unsigned int pipe)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -347,13 +347,18 @@ find_active_client(struct list_head *head)
|
|||
int vga_switcheroo_get_client_state(struct pci_dev *pdev)
|
||||
{
|
||||
struct vga_switcheroo_client *client;
|
||||
enum vga_switcheroo_state ret;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
client = find_client_from_pci(&vgasr_priv.clients, pdev);
|
||||
if (!client)
|
||||
return VGA_SWITCHEROO_NOT_FOUND;
|
||||
if (!vgasr_priv.active)
|
||||
return VGA_SWITCHEROO_INIT;
|
||||
return client->pwr_state;
|
||||
ret = VGA_SWITCHEROO_NOT_FOUND;
|
||||
else if (!vgasr_priv.active)
|
||||
ret = VGA_SWITCHEROO_INIT;
|
||||
else
|
||||
ret = client->pwr_state;
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_get_client_state);
|
||||
|
||||
|
@ -845,15 +850,16 @@ void vga_switcheroo_set_dynamic_switch(struct pci_dev *pdev,
|
|||
{
|
||||
struct vga_switcheroo_client *client;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
client = find_client_from_pci(&vgasr_priv.clients, pdev);
|
||||
if (!client)
|
||||
return;
|
||||
|
||||
if (!client->driver_power_control)
|
||||
if (!client || !client->driver_power_control) {
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return;
|
||||
}
|
||||
|
||||
client->pwr_state = dynamic;
|
||||
set_audio_state(client->id, dynamic);
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL(vga_switcheroo_set_dynamic_switch);
|
||||
|
||||
|
@ -866,9 +872,11 @@ static int vga_switcheroo_runtime_suspend(struct device *dev)
|
|||
ret = dev->bus->pm->runtime_suspend(dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
mutex_lock(&vgasr_mutex);
|
||||
if (vgasr_priv.handler->switchto)
|
||||
vgasr_priv.handler->switchto(VGA_SWITCHEROO_IGD);
|
||||
vga_switcheroo_power_switch(pdev, VGA_SWITCHEROO_OFF);
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -877,7 +885,9 @@ static int vga_switcheroo_runtime_resume(struct device *dev)
|
|||
struct pci_dev *pdev = to_pci_dev(dev);
|
||||
int ret;
|
||||
|
||||
mutex_lock(&vgasr_mutex);
|
||||
vga_switcheroo_power_switch(pdev, VGA_SWITCHEROO_ON);
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
ret = dev->bus->pm->runtime_resume(dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
@ -923,29 +933,33 @@ EXPORT_SYMBOL(vga_switcheroo_fini_domain_pm_ops);
|
|||
static int vga_switcheroo_runtime_resume_hdmi_audio(struct device *dev)
|
||||
{
|
||||
struct pci_dev *pdev = to_pci_dev(dev);
|
||||
struct vga_switcheroo_client *client;
|
||||
struct device *video_dev = NULL;
|
||||
int ret;
|
||||
struct vga_switcheroo_client *client, *found = NULL;
|
||||
|
||||
/* we need to check if we have to switch back on the video
|
||||
device so the audio device can come back */
|
||||
mutex_lock(&vgasr_mutex);
|
||||
list_for_each_entry(client, &vgasr_priv.clients, list) {
|
||||
if (PCI_SLOT(client->pdev->devfn) == PCI_SLOT(pdev->devfn) &&
|
||||
client_is_vga(client)) {
|
||||
found = client;
|
||||
ret = pm_runtime_get_sync(&client->pdev->dev);
|
||||
if (ret) {
|
||||
if (ret != 1)
|
||||
return ret;
|
||||
}
|
||||
video_dev = &client->pdev->dev;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&vgasr_mutex);
|
||||
|
||||
if (video_dev) {
|
||||
ret = pm_runtime_get_sync(video_dev);
|
||||
if (ret && ret != 1)
|
||||
return ret;
|
||||
}
|
||||
ret = dev->bus->pm->runtime_resume(dev);
|
||||
|
||||
/* put the reference for the gpu */
|
||||
if (found) {
|
||||
pm_runtime_mark_last_busy(&found->pdev->dev);
|
||||
pm_runtime_put_autosuspend(&found->pdev->dev);
|
||||
if (video_dev) {
|
||||
pm_runtime_mark_last_busy(video_dev);
|
||||
pm_runtime_put_autosuspend(video_dev);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -531,7 +531,7 @@ static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
|
|||
return false;
|
||||
|
||||
/* Allocate structure */
|
||||
vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
|
||||
vgadev = kzalloc(sizeof(struct vga_device), GFP_KERNEL);
|
||||
if (vgadev == NULL) {
|
||||
pr_err("failed to allocate pci device\n");
|
||||
/*
|
||||
|
@ -541,8 +541,6 @@ static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
|
|||
return false;
|
||||
}
|
||||
|
||||
memset(vgadev, 0, sizeof(*vgadev));
|
||||
|
||||
/* Take lock & check for duplicates */
|
||||
spin_lock_irqsave(&vga_lock, flags);
|
||||
if (vgadev_find(pdev) != NULL) {
|
||||
|
|
|
@ -412,7 +412,7 @@ struct drm_driver {
|
|||
/**
|
||||
* get_vblank_counter - get raw hardware vblank counter
|
||||
* @dev: DRM device
|
||||
* @crtc: counter to fetch
|
||||
* @pipe: counter to fetch
|
||||
*
|
||||
* Driver callback for fetching a raw hardware vblank counter for @crtc.
|
||||
* If a device doesn't have a hardware counter, the driver can simply
|
||||
|
@ -426,12 +426,12 @@ struct drm_driver {
|
|||
* RETURNS
|
||||
* Raw vblank counter value.
|
||||
*/
|
||||
u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
|
||||
u32 (*get_vblank_counter) (struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
/**
|
||||
* enable_vblank - enable vblank interrupt events
|
||||
* @dev: DRM device
|
||||
* @crtc: which irq to enable
|
||||
* @pipe: which irq to enable
|
||||
*
|
||||
* Enable vblank interrupts for @crtc. If the device doesn't have
|
||||
* a hardware vblank counter, this routine should be a no-op, since
|
||||
|
@ -441,18 +441,18 @@ struct drm_driver {
|
|||
* Zero on success, appropriate errno if the given @crtc's vblank
|
||||
* interrupt cannot be enabled.
|
||||
*/
|
||||
int (*enable_vblank) (struct drm_device *dev, int crtc);
|
||||
int (*enable_vblank) (struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
/**
|
||||
* disable_vblank - disable vblank interrupt events
|
||||
* @dev: DRM device
|
||||
* @crtc: which irq to enable
|
||||
* @pipe: which irq to enable
|
||||
*
|
||||
* Disable vblank interrupts for @crtc. If the device doesn't have
|
||||
* a hardware vblank counter, this routine should be a no-op, since
|
||||
* interrupts will have to stay on to keep the count accurate.
|
||||
*/
|
||||
void (*disable_vblank) (struct drm_device *dev, int crtc);
|
||||
void (*disable_vblank) (struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
/**
|
||||
* Called by \c drm_device_is_agp. Typically used to determine if a
|
||||
|
@ -474,7 +474,7 @@ struct drm_driver {
|
|||
* optional accurate ktime_get timestamp of when position was measured.
|
||||
*
|
||||
* \param dev DRM device.
|
||||
* \param crtc Id of the crtc to query.
|
||||
* \param pipe Id of the crtc to query.
|
||||
* \param flags Flags from the caller (DRM_CALLED_FROM_VBLIRQ or 0).
|
||||
* \param *vpos Target location for current vertical scanout position.
|
||||
* \param *hpos Target location for current horizontal scanout position.
|
||||
|
@ -498,9 +498,8 @@ struct drm_driver {
|
|||
* but unknown small number of scanlines wrt. real scanout position.
|
||||
*
|
||||
*/
|
||||
int (*get_scanout_position) (struct drm_device *dev, int crtc,
|
||||
unsigned int flags,
|
||||
int *vpos, int *hpos,
|
||||
int (*get_scanout_position) (struct drm_device *dev, unsigned int pipe,
|
||||
unsigned int flags, int *vpos, int *hpos,
|
||||
ktime_t *stime, ktime_t *etime,
|
||||
const struct drm_display_mode *mode);
|
||||
|
||||
|
@ -518,7 +517,7 @@ struct drm_driver {
|
|||
* to the OpenML OML_sync_control extension specification.
|
||||
*
|
||||
* \param dev dev DRM device handle.
|
||||
* \param crtc crtc for which timestamp should be returned.
|
||||
* \param pipe crtc for which timestamp should be returned.
|
||||
* \param *max_error Maximum allowable timestamp error in nanoseconds.
|
||||
* Implementation should strive to provide timestamp
|
||||
* with an error of at most *max_error nanoseconds.
|
||||
|
@ -534,7 +533,7 @@ struct drm_driver {
|
|||
* negative number on failure. A positive status code on success,
|
||||
* which describes how the vblank_time timestamp was computed.
|
||||
*/
|
||||
int (*get_vblank_timestamp) (struct drm_device *dev, int crtc,
|
||||
int (*get_vblank_timestamp) (struct drm_device *dev, unsigned int pipe,
|
||||
int *max_error,
|
||||
struct timeval *vblank_time,
|
||||
unsigned flags);
|
||||
|
@ -910,6 +909,8 @@ extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
|
|||
/* Misc. IOCTL support (drm_ioctl.c) */
|
||||
int drm_noop(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
int drm_invalid_op(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
/* Cache management (drm_cache.c) */
|
||||
void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
|
||||
|
@ -928,7 +929,7 @@ extern int drm_irq_uninstall(struct drm_device *dev);
|
|||
extern int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs);
|
||||
extern int drm_wait_vblank(struct drm_device *dev, void *data,
|
||||
struct drm_file *filp);
|
||||
extern u32 drm_vblank_count(struct drm_device *dev, int pipe);
|
||||
extern u32 drm_vblank_count(struct drm_device *dev, unsigned int pipe);
|
||||
extern u32 drm_crtc_vblank_count(struct drm_crtc *crtc);
|
||||
extern u32 drm_vblank_count_and_time(struct drm_device *dev, unsigned int pipe,
|
||||
struct timeval *vblanktime);
|
||||
|
@ -952,6 +953,7 @@ extern void drm_crtc_vblank_off(struct drm_crtc *crtc);
|
|||
extern void drm_crtc_vblank_reset(struct drm_crtc *crtc);
|
||||
extern void drm_crtc_vblank_on(struct drm_crtc *crtc);
|
||||
extern void drm_vblank_cleanup(struct drm_device *dev);
|
||||
extern u32 drm_vblank_no_hw_counter(struct drm_device *dev, unsigned int pipe);
|
||||
|
||||
extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
|
||||
unsigned int pipe, int *max_error,
|
||||
|
|
|
@ -12,9 +12,6 @@
|
|||
struct drm_device;
|
||||
struct drm_file;
|
||||
|
||||
#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && \
|
||||
defined(MODULE)))
|
||||
|
||||
struct drm_agp_head {
|
||||
struct agp_kern_info agp_info;
|
||||
struct list_head memory;
|
||||
|
@ -28,7 +25,7 @@ struct drm_agp_head {
|
|||
unsigned long page_mask;
|
||||
};
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
#if IS_ENABLED(CONFIG_AGP)
|
||||
|
||||
void drm_free_agp(struct agp_memory * handle, int pages);
|
||||
int drm_bind_agp(struct agp_memory * handle, unsigned int start);
|
||||
|
@ -66,7 +63,7 @@ int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
|
|||
int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
#else /* __OS_HAS_AGP */
|
||||
#else /* CONFIG_AGP */
|
||||
|
||||
static inline void drm_free_agp(struct agp_memory * handle, int pages)
|
||||
{
|
||||
|
@ -105,95 +102,47 @@ static inline int drm_agp_acquire(struct drm_device *dev)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_release(struct drm_device *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_release_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_enable(struct drm_device *dev,
|
||||
struct drm_agp_mode mode)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_info(struct drm_device *dev,
|
||||
struct drm_agp_info *info)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_info_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_alloc(struct drm_device *dev,
|
||||
struct drm_agp_buffer *request)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_free(struct drm_device *dev,
|
||||
struct drm_agp_buffer *request)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_free_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_unbind(struct drm_device *dev,
|
||||
struct drm_agp_binding *request)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_bind(struct drm_device *dev,
|
||||
struct drm_agp_binding *request)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static inline int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
#endif /* __OS_HAS_AGP */
|
||||
#endif /* CONFIG_AGP */
|
||||
|
||||
#endif /* _DRM_AGPSUPPORT_H_ */
|
||||
|
|
|
@ -86,10 +86,12 @@ static inline uint64_t I642U64(int64_t val)
|
|||
}
|
||||
|
||||
/* rotation property bits */
|
||||
#define DRM_ROTATE_MASK 0x0f
|
||||
#define DRM_ROTATE_0 0
|
||||
#define DRM_ROTATE_90 1
|
||||
#define DRM_ROTATE_180 2
|
||||
#define DRM_ROTATE_270 3
|
||||
#define DRM_REFLECT_MASK (~DRM_ROTATE_MASK)
|
||||
#define DRM_REFLECT_X 4
|
||||
#define DRM_REFLECT_Y 5
|
||||
|
||||
|
|
Loading…
Reference in a new issue