Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 97448d5b authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://people.freedesktop.org/~airlied/linux 

Pull drm updates from Dave Airlie:
 "A bunch of fixes across drivers:

  radeon:
     disable two ended allocation for now, it breaks some stuff

  amdkfd:
     misc fixes

  nouveau:
     fix irq loop problem, add basic support for GM206 (new hw)

  i915:
     fix some WARNs people were seeing

  exynos:
     fix some iommu interactions causing boot failures"

* git://people.freedesktop.org/~airlied/linux:
  drm/radeon: drop ttm two ended allocation
  drm/exynos: fix the initialization order in FIMD
  drm/exynos: fix typo config name correctly.
  drm/exynos: Check for NULL dereference of crtc
  drm/exynos: IS_ERR() vs NULL bug
  drm/exynos: remove unused files
  drm/i915: Make sure the primary plane is enabled before reading out the fb state
  drm/nouveau/bios: fix i2c table parsing for dcb 4.1
  drm/nouveau/device/gm100: Basic GM206 bring up (as copy of GM204)
  drm/nouveau/device: post write to NV_PMC_BOOT_1 when flipping endian switch
  drm/nouveau/gr/gf100: fix some accidental or'ing of buffer addresses
  drm/nouveau/fifo/nv04: remove the loop from the interrupt handler
  drm/radeon: Changing number of compute pipe lines
  drm/amdkfd: Fix SDMA queue init. in non-HWS mode
  drm/amdkfd: destroy mqd when destroying kernel queue
  drm/i915: Ensure plane->state->fb stays in sync with plane->fb
parents bb8ef2fb 8265d448

drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c

+9 −1
Original line number Diff line number Diff line
@@ -645,6 +645,7 @@ static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm, 
	pr_debug("     sdma queue id: %d\n", q->properties.sdma_queue_id);

	pr_debug("     sdma engine id: %d\n", q->properties.sdma_engine_id);



	init_sdma_vm(dqm, q, qpd);

	retval = mqd->init_mqd(mqd, &q->mqd, &q->mqd_mem_obj,

				&q->gart_mqd_addr, &q->properties);

	if (retval != 0) {
@@ -652,7 +653,14 @@ static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm, 
		return retval;

	}



	init_sdma_vm(dqm, q, qpd);

	retval = mqd->load_mqd(mqd, q->mqd, 0,

				0, NULL);

	if (retval != 0) {

		deallocate_sdma_queue(dqm, q->sdma_id);

		mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);

		return retval;

	}



	return 0;

}

drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c

+13 −9
Original line number Diff line number Diff line
@@ -44,7 +44,7 @@ static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev, 
	BUG_ON(!kq || !dev);

	BUG_ON(type != KFD_QUEUE_TYPE_DIQ && type != KFD_QUEUE_TYPE_HIQ);



	pr_debug("kfd: In func %s initializing queue type %d size %d\n",

	pr_debug("amdkfd: In func %s initializing queue type %d size %d\n",

			__func__, KFD_QUEUE_TYPE_HIQ, queue_size);



	nop.opcode = IT_NOP;
@@ -69,12 +69,16 @@ static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev, 


	prop.doorbell_ptr = kfd_get_kernel_doorbell(dev, &prop.doorbell_off);



	if (prop.doorbell_ptr == NULL)

	if (prop.doorbell_ptr == NULL) {

		pr_err("amdkfd: error init doorbell");

		goto err_get_kernel_doorbell;

	}



	retval = kfd_gtt_sa_allocate(dev, queue_size, &kq->pq);

	if (retval != 0)

	if (retval != 0) {

		pr_err("amdkfd: error init pq queues size (%d)\n", queue_size);

		goto err_pq_allocate_vidmem;

	}



	kq->pq_kernel_addr = kq->pq->cpu_ptr;

	kq->pq_gpu_addr = kq->pq->gpu_addr;
@@ -165,10 +169,8 @@ static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev, 
err_eop_allocate_vidmem:

	kfd_gtt_sa_free(dev, kq->pq);

err_pq_allocate_vidmem:

	pr_err("kfd: error init pq\n");

	kfd_release_kernel_doorbell(dev, prop.doorbell_ptr);

err_get_kernel_doorbell:

	pr_err("kfd: error init doorbell");

	return false;



}
@@ -187,6 +189,8 @@ static void uninitialize(struct kernel_queue *kq) 
	else if (kq->queue->properties.type == KFD_QUEUE_TYPE_DIQ)

		kfd_gtt_sa_free(kq->dev, kq->fence_mem_obj);



	kq->mqd->uninit_mqd(kq->mqd, kq->queue->mqd, kq->queue->mqd_mem_obj);



	kfd_gtt_sa_free(kq->dev, kq->rptr_mem);

	kfd_gtt_sa_free(kq->dev, kq->wptr_mem);

	kq->ops_asic_specific.uninitialize(kq);
@@ -211,7 +215,7 @@ static int acquire_packet_buffer(struct kernel_queue *kq, 
	queue_address = (unsigned int *)kq->pq_kernel_addr;

	queue_size_dwords = kq->queue->properties.queue_size / sizeof(uint32_t);



	pr_debug("kfd: In func %s\nrptr: %d\nwptr: %d\nqueue_address 0x%p\n",

	pr_debug("amdkfd: In func %s\nrptr: %d\nwptr: %d\nqueue_address 0x%p\n",

			__func__, rptr, wptr, queue_address);



	available_size = (rptr - 1 - wptr + queue_size_dwords) %
@@ -296,7 +300,7 @@ struct kernel_queue *kernel_queue_init(struct kfd_dev *dev, 
	}



	if (kq->ops.initialize(kq, dev, type, KFD_KERNEL_QUEUE_SIZE) == false) {

		pr_err("kfd: failed to init kernel queue\n");

		pr_err("amdkfd: failed to init kernel queue\n");

		kfree(kq);

		return NULL;

	}
@@ -319,7 +323,7 @@ static __attribute__((unused)) void test_kq(struct kfd_dev *dev) 


	BUG_ON(!dev);



	pr_err("kfd: starting kernel queue test\n");

	pr_err("amdkfd: starting kernel queue test\n");



	kq = kernel_queue_init(dev, KFD_QUEUE_TYPE_HIQ);

	BUG_ON(!kq);
@@ -330,7 +334,7 @@ static __attribute__((unused)) void test_kq(struct kfd_dev *dev) 
		buffer[i] = kq->nop_packet;

	kq->ops.submit_packet(kq);



	pr_err("kfd: ending kernel queue test\n");

	pr_err("amdkfd: ending kernel queue test\n");

}

drivers/gpu/drm/exynos/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ config DRM_EXYNOS_DSI 


config DRM_EXYNOS_DP

	bool "EXYNOS DRM DP driver support"

	depends on (DRM_EXYNOS_FIMD || DRM_EXYNOS7DECON) && ARCH_EXYNOS && (DRM_PTN3460=n || DRM_PTN3460=y || DRM_PTN3460=DRM_EXYNOS)

	depends on (DRM_EXYNOS_FIMD || DRM_EXYNOS7_DECON) && ARCH_EXYNOS && (DRM_PTN3460=n || DRM_PTN3460=y || DRM_PTN3460=DRM_EXYNOS)

	default DRM_EXYNOS

	select DRM_PANEL

	help

drivers/gpu/drm/exynos/exynos7_drm_decon.c

+2 −2
Original line number Diff line number Diff line
@@ -888,8 +888,8 @@ static int decon_probe(struct platform_device *pdev) 
	of_node_put(i80_if_timings);



	ctx->regs = of_iomap(dev->of_node, 0);

	if (IS_ERR(ctx->regs)) {

		ret = PTR_ERR(ctx->regs);

	if (!ctx->regs) {

		ret = -ENOMEM;

		goto err_del_component;

	}

drivers/gpu/drm/exynos/exynos_drm_connector.c

deleted100644 → 0
+0 −245
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2011 Samsung Electronics Co., Ltd.

 * Authors:

 *	Inki Dae <inki.dae@samsung.com>

 *	Joonyoung Shim <jy0922.shim@samsung.com>

 *	Seung-Woo Kim <sw0312.kim@samsung.com>

 *

 * This program is free software; you can redistribute  it and/or modify it

 * under  the terms of  the GNU General  Public License as published by the

 * Free Software Foundation;  either version 2 of the  License, or (at your

 * option) any later version.

 */



#include <drm/drmP.h>

#include <drm/drm_crtc_helper.h>



#include <drm/exynos_drm.h>

#include "exynos_drm_drv.h"

#include "exynos_drm_encoder.h"

#include "exynos_drm_connector.h"



#define to_exynos_connector(x)	container_of(x, struct exynos_drm_connector,\

				drm_connector)



struct exynos_drm_connector {

	struct drm_connector		drm_connector;

	uint32_t			encoder_id;

	struct exynos_drm_display	*display;

};



static int exynos_drm_connector_get_modes(struct drm_connector *connector)

{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_display *display = exynos_connector->display;

	struct edid *edid = NULL;

	unsigned int count = 0;

	int ret;



	/*

	 * if get_edid() exists then get_edid() callback of hdmi side

	 * is called to get edid data through i2c interface else

	 * get timing from the FIMD driver(display controller).

	 *

	 * P.S. in case of lcd panel, count is always 1 if success

	 * because lcd panel has only one mode.

	 */

	if (display->ops->get_edid) {

		edid = display->ops->get_edid(display, connector);

		if (IS_ERR_OR_NULL(edid)) {

			ret = PTR_ERR(edid);

			edid = NULL;

			DRM_ERROR("Panel operation get_edid failed %d\n", ret);

			goto out;

		}



		count = drm_add_edid_modes(connector, edid);

		if (!count) {

			DRM_ERROR("Add edid modes failed %d\n", count);

			goto out;

		}



		drm_mode_connector_update_edid_property(connector, edid);

	} else {

		struct exynos_drm_panel_info *panel;

		struct drm_display_mode *mode = drm_mode_create(connector->dev);

		if (!mode) {

			DRM_ERROR("failed to create a new display mode.\n");

			return 0;

		}



		if (display->ops->get_panel)

			panel = display->ops->get_panel(display);

		else {

			drm_mode_destroy(connector->dev, mode);

			return 0;

		}



		drm_display_mode_from_videomode(&panel->vm, mode);

		mode->width_mm = panel->width_mm;

		mode->height_mm = panel->height_mm;

		connector->display_info.width_mm = mode->width_mm;

		connector->display_info.height_mm = mode->height_mm;



		mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;

		drm_mode_set_name(mode);

		drm_mode_probed_add(connector, mode);



		count = 1;

	}



out:

	kfree(edid);

	return count;

}



static int exynos_drm_connector_mode_valid(struct drm_connector *connector,

					    struct drm_display_mode *mode)

{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_display *display = exynos_connector->display;

	int ret = MODE_BAD;



	DRM_DEBUG_KMS("%s\n", __FILE__);



	if (display->ops->check_mode)

		if (!display->ops->check_mode(display, mode))

			ret = MODE_OK;



	return ret;

}



static struct drm_encoder *exynos_drm_best_encoder(

		struct drm_connector *connector)

{

	struct drm_device *dev = connector->dev;

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	return drm_encoder_find(dev, exynos_connector->encoder_id);

}



static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {

	.get_modes	= exynos_drm_connector_get_modes,

	.mode_valid	= exynos_drm_connector_mode_valid,

	.best_encoder	= exynos_drm_best_encoder,

};



static int exynos_drm_connector_fill_modes(struct drm_connector *connector,

				unsigned int max_width, unsigned int max_height)

{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_display *display = exynos_connector->display;

	unsigned int width, height;



	width = max_width;

	height = max_height;



	/*

	 * if specific driver want to find desired_mode using maxmum

	 * resolution then get max width and height from that driver.

	 */

	if (display->ops->get_max_resol)

		display->ops->get_max_resol(display, &width, &height);



	return drm_helper_probe_single_connector_modes(connector, width,

							height);

}



/* get detection status of display device. */

static enum drm_connector_status

exynos_drm_connector_detect(struct drm_connector *connector, bool force)

{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_display *display = exynos_connector->display;

	enum drm_connector_status status = connector_status_disconnected;



	if (display->ops->is_connected) {

		if (display->ops->is_connected(display))

			status = connector_status_connected;

		else

			status = connector_status_disconnected;

	}



	return status;

}



static void exynos_drm_connector_destroy(struct drm_connector *connector)

{

	struct exynos_drm_connector *exynos_connector =

		to_exynos_connector(connector);



	drm_connector_unregister(connector);

	drm_connector_cleanup(connector);

	kfree(exynos_connector);

}



static struct drm_connector_funcs exynos_connector_funcs = {

	.dpms		= drm_helper_connector_dpms,

	.fill_modes	= exynos_drm_connector_fill_modes,

	.detect		= exynos_drm_connector_detect,

	.destroy	= exynos_drm_connector_destroy,

};



struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,

						   struct drm_encoder *encoder)

{

	struct exynos_drm_connector *exynos_connector;

	struct exynos_drm_display *display = exynos_drm_get_display(encoder);

	struct drm_connector *connector;

	int type;

	int err;



	exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL);

	if (!exynos_connector)

		return NULL;



	connector = &exynos_connector->drm_connector;



	switch (display->type) {

	case EXYNOS_DISPLAY_TYPE_HDMI:

		type = DRM_MODE_CONNECTOR_HDMIA;

		connector->interlace_allowed = true;

		connector->polled = DRM_CONNECTOR_POLL_HPD;

		break;

	case EXYNOS_DISPLAY_TYPE_VIDI:

		type = DRM_MODE_CONNECTOR_VIRTUAL;

		connector->polled = DRM_CONNECTOR_POLL_HPD;

		break;

	default:

		type = DRM_MODE_CONNECTOR_Unknown;

		break;

	}



	drm_connector_init(dev, connector, &exynos_connector_funcs, type);

	drm_connector_helper_add(connector, &exynos_connector_helper_funcs);



	err = drm_connector_register(connector);

	if (err)

		goto err_connector;



	exynos_connector->encoder_id = encoder->base.id;

	exynos_connector->display = display;

	connector->dpms = DRM_MODE_DPMS_OFF;

	connector->encoder = encoder;



	err = drm_mode_connector_attach_encoder(connector, encoder);

	if (err) {

		DRM_ERROR("failed to attach a connector to a encoder\n");

		goto err_sysfs;

	}



	DRM_DEBUG_KMS("connector has been created\n");



	return connector;



err_sysfs:

	drm_connector_unregister(connector);

err_connector:

	drm_connector_cleanup(connector);

	kfree(exynos_connector);

	return NULL;

}