dri-devel June 2016

dri-devel@lists.freedesktop.org

231 participants
1446 discussions

[Bug 96327] Assertion failure in radeon_drm_cs.c (Shadow of Mordor)
by bugzilla-daemon＠freedesktop.org 04 Jun '16

04 Jun '16

https://bugs.freedesktop.org/show_bug.cgi?id=96327 Bug ID: 96327 Summary: Assertion failure in radeon_drm_cs.c (Shadow of Mordor) Product: Mesa Version: git Hardware: x86-64 (AMD64) OS: Linux (All) Status: NEW Severity: normal Priority: medium Component: Drivers/Gallium/radeonsi Assignee: dri-devel(a)lists.freedesktop.org Reporter: 0xe2.0x9a.0x9b(a)gmail.com QA Contact: dri-devel(a)lists.freedesktop.org Mesa 12.1.0-devel (git-6c9a352) src/gallium/winsys/radeon/drm/radeon_drm_cs.c:388: radeon_drm_cs_check_space: Assertion `rcs->current.cdw <= rcs->current.max_dw' failed. I can try to generate a backtrace if needed. -- You are receiving this mail because: You are the assignee for the bug.

1 2

[PATCH] reservation: sprinkle some WARN_ON()s
by Rob Clark 04 Jun '16

04 Jun '16

A bit overkill since, for example, the rcu_dereference_protected() in reservation_object_get_list() will WARN. But this is much less subtle for folks reading the code. v2: use reservation_object_held() instead of ww_mutex_is_locked() Signed-off-by: Rob Clark <robdclark(a)gmail.com> --- drivers/dma-buf/reservation.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/drivers/dma-buf/reservation.c b/drivers/dma-buf/reservation.c index c0bd572..439af82 100644 --- a/drivers/dma-buf/reservation.c +++ b/drivers/dma-buf/reservation.c @@ -52,6 +52,8 @@ int reservation_object_reserve_shared(struct reservation_object *obj) struct reservation_object_list *fobj, *old; u32 max; + WARN_ON(!reservation_object_held(obj)); + old = reservation_object_get_list(obj); if (old && old->shared_max) { @@ -189,6 +191,8 @@ void reservation_object_add_shared_fence(struct reservation_object *obj, { struct reservation_object_list *old, *fobj = obj->staged; + WARN_ON(!reservation_object_held(obj)); + old = reservation_object_get_list(obj); obj->staged = NULL; @@ -207,6 +211,8 @@ void reservation_object_add_excl_fence(struct reservation_object *obj, struct reservation_object_list *old; u32 i = 0; + WARN_ON(!reservation_object_held(obj)); + old = reservation_object_get_list(obj); if (old) i = old->shared_count; -- 2.5.5

2 2

[PATCH 1/4] drm/fb-helper: Support deferred setup
by Thierry Reding 04 Jun '16

04 Jun '16

From: Thierry Reding <treding(a)nvidia.com> FB helper code falls back to a 1024x768 mode if no outputs are connected or don't report back any modes upon initialization. This can be annoying because outputs that are added to FB helper later on can't be used with FB helper if they don't support a matching mode. The fallback is in place because VGA connectors can happen to report an unknown connection status even when they are in fact connected. Some drivers have custom solutions in place to defer FB helper setup until at least one output is connected. But the logic behind these solutions is always the same and there is nothing driver-specific about it, so a better alterative is to fix the FB helper core and add support for all drivers automatically. This patch adds support for deferred FB helper setup. It checks all the connectors for their connection status, and if all of them report to be disconnected marks the FB helper as needing deferred setup. Whet setup is deferred, the FB helper core will automatically retry setup after a hotplug event, and it will keep trying until it succeeds. Signed-off-by: Thierry Reding <treding(a)nvidia.com> --- drivers/gpu/drm/drm_fb_helper.c | 36 ++++++++++++++++++++++++++++++++++++ include/drm/drm_fb_helper.h | 21 +++++++++++++++++++++ 2 files changed, 57 insertions(+) diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index 7c2eb75db60f..4f334f9cab28 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -442,6 +442,9 @@ int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper) if (!drm_fbdev_emulation) return -ENODEV; + if (fb_helper->deferred_setup) + return 0; + drm_modeset_lock_all(dev); ret = restore_fbdev_mode(fb_helper); @@ -1398,6 +1401,23 @@ unlock: } EXPORT_SYMBOL(drm_fb_helper_pan_display); +static bool drm_fb_helper_maybe_connected(struct drm_fb_helper *helper) +{ + bool connected = false; + unsigned int i; + + for (i = 0; i < helper->connector_count; i++) { + struct drm_fb_helper_connector *fb = helper->connector_info[i]; + + if (fb->connector->status != connector_status_disconnected) { + connected = true; + break; + } + } + + return connected; +} + /* * Allocates the backing storage and sets up the fbdev info structure through * the ->fb_probe callback and then registers the fbdev and sets up the panic @@ -1499,6 +1519,17 @@ static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height); } + /* + * If everything's disconnected, there's no use in attempting to set + * up fbdev. + */ + if (!drm_fb_helper_maybe_connected(fb_helper)) { + DRM_INFO("No outputs connected, deferring setup\n"); + fb_helper->preferred_bpp = preferred_bpp; + fb_helper->deferred_setup = true; + return 0; + } + if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) { /* hmm everyone went away - assume VGA cable just fell out and will come back later. */ @@ -1539,6 +1570,7 @@ static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list); + fb_helper->deferred_setup = false; return 0; } @@ -2237,6 +2269,10 @@ int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper) if (!drm_fbdev_emulation) return 0; + if (fb_helper->deferred_setup) + return drm_fb_helper_initial_config(fb_helper, + fb_helper->preferred_bpp); + mutex_lock(&fb_helper->dev->mode_config.mutex); if (!fb_helper->fb || !drm_fb_helper_is_bound(fb_helper)) { fb_helper->delayed_hotplug = true; diff --git a/include/drm/drm_fb_helper.h b/include/drm/drm_fb_helper.h index 5b4aa35026a3..25446690b2c1 100644 --- a/include/drm/drm_fb_helper.h +++ b/include/drm/drm_fb_helper.h @@ -214,6 +214,27 @@ struct drm_fb_helper { bool delayed_hotplug; /** + * @deferred_setup: + * + * If no outputs are connected (disconnected or unknown) the FB helper + * code will defer setup until at least one of the outputs shows up. + * This field keeps track of the status so that setup can be retried + * at every hotplug event until it succeeds eventually. + */ + bool deferred_setup; + + /** + * @preferred_bpp: + * + * Temporary storage for the driver's preferred BPP setting passed to + * FB helper initialization. This needs to be tracked so that deferred + * FB helper setup can pass this on. + * + * See also: @deferred_setup + */ + int preferred_bpp; + + /** * @atomic: * * Use atomic updates for restore_fbdev_mode(), etc. This defaults to -- 2.8.3

3 6

[PATCH] drm/fsl-dcu: use flat regmap cache
by Stefan Agner 04 Jun '16

04 Jun '16

Using flat regmap cache instead of RB-tree to avoid the following lockdep warning on driver load: WARNING: CPU: 0 PID: 1 at kernel/locking/lockdep.c:2755 lockdep_trace_alloc+0x15c/0x160() DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags)) The RB-tree regmap cache needs to allocate new space on first writes. However, allocations in an atomic context (e.g. when a spinlock is held) are not allowed. The function regmap_write calls map->lock, which acquires a spinlock in the fast_io case. Since the FSL DCU driver uses MMIO, the regmap bus of type regmap_mmio is being used which has fast_io set to true. Use flat regmap cache and specify max register to be large enouth to cover all registers available in LS1021a and Vybrids register space. Signed-off-by: Stefan Agner <stefan(a)agner.ch> Cc: Mark Brown <broonie(a)kernel.org> Cc: stable(a)vger.kernel.org --- While regmap cache is used for suspend/resume only (which is broken in its current state) Mark noted that using the RB regmap cache can also cause issues during initialization of the driver. This patch migrates to flat regmap cache (which we can also use to fix the issue in stable kernels), and yet another patchset moves to the atomic suspend/resume helpers (which will not go into stable...) Dave, I saw that you just sent out the pull for rc2, will send a pull request for rc3 early next week... -- Stefan drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c index 0ec1ad9..dc723f7 100644 --- a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c +++ b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c @@ -42,9 +42,10 @@ static const struct regmap_config fsl_dcu_regmap_config = { .reg_bits = 32, .reg_stride = 4, .val_bits = 32, - .cache_type = REGCACHE_RBTREE, + .cache_type = REGCACHE_FLAT, .volatile_reg = fsl_dcu_drm_is_volatile_reg, + .max_register = 0x11fc, }; static int fsl_dcu_drm_irq_init(struct drm_device *dev) -- 2.8.2

2 3

[Bug 95527] [radeonsi][CIK][VDPAU] Unable to use VDPAU locks up X
by bugzilla-daemon＠freedesktop.org 04 Jun '16

04 Jun '16

https://bugs.freedesktop.org/show_bug.cgi?id=95527 Bug ID: 95527 Summary: [radeonsi][CIK][VDPAU] Unable to use VDPAU locks up X Product: Mesa Version: unspecified Hardware: Other OS: All Status: NEW Severity: normal Priority: medium Component: Drivers/Gallium/radeonsi Assignee: dri-devel(a)lists.freedesktop.org Reporter: shawn.starr(a)rogers.com QA Contact: dri-devel(a)lists.freedesktop.org I am currently using kernel module AMDGPU with CIK enabled: Attached is Xorg.log - Mesa is git master from 2016-05-20 - LLVM 3.9 trunk is from same date - Kernel compiled is 4.7.0-0.rc0.git2.3.fc23.x86_64 (Fedora) w/ AMDGPU CIK enabled When using VLC, if it attempts to use VDPAU it shows nothing, if I close VLC it crashes X, I can ssh into system however. -- You are receiving this mail because: You are the assignee for the bug.

1 5

[PATCH v2] drm: Add Grain Media GM12U320 kms driver
by Hans de Goede 03 Jun '16

03 Jun '16

Grain-media GM12U320 based devices are mini video projectors using USB for both power and video data transport. This commit adds a kms driver for these devices, including prime support. This driver is based on the existing udl kms driver, and the gm12u320 fb driver by Viacheslav Nurmekhamitov <slavrn(a)yandex.ru>. Signed-off-by: Hans de Goede <hdegoede(a)redhat.com> --- Changes in v2: -Rebase on 4.7-rc1 -Sync with udl, bring in any fixes done to udl since v1 --- MAINTAINERS | 6 + drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/gm12u320/Kconfig | 16 + drivers/gpu/drm/gm12u320/Makefile | 7 + drivers/gpu/drm/gm12u320/gm12u320_connector.c | 151 ++++++++ drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c | 283 ++++++++++++++ drivers/gpu/drm/gm12u320/gm12u320_drv.c | 160 ++++++++ drivers/gpu/drm/gm12u320/gm12u320_drv.h | 129 +++++++ drivers/gpu/drm/gm12u320/gm12u320_encoder.c | 75 ++++ drivers/gpu/drm/gm12u320/gm12u320_fb.c | 345 ++++++++++++++++++ drivers/gpu/drm/gm12u320/gm12u320_gem.c | 237 ++++++++++++ drivers/gpu/drm/gm12u320/gm12u320_main.c | 507 ++++++++++++++++++++++++++ drivers/gpu/drm/gm12u320/gm12u320_modeset.c | 144 ++++++++ 14 files changed, 2063 insertions(+) create mode 100644 drivers/gpu/drm/gm12u320/Kconfig create mode 100644 drivers/gpu/drm/gm12u320/Makefile create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_connector.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_drv.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_drv.h create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_encoder.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_fb.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_gem.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_main.c create mode 100644 drivers/gpu/drm/gm12u320/gm12u320_modeset.c diff --git a/MAINTAINERS b/MAINTAINERS index 216d447..5c05af2 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3904,6 +3904,12 @@ S: Supported F: drivers/gpu/drm/nouveau/ F: include/uapi/drm/nouveau_drm.h +DRM DRIVERS FOR GRAIN-MEDIA GM12U320 +M: Hans de Goede <hdegoede(a)redhat.com> +L: dri-devel(a)lists.freedesktop.org +S: Supported +F: drivers/gpu/drm/gm12u320/ + DRM DRIVERS FOR NVIDIA TEGRA M: Thierry Reding <thierry.reding(a)gmail.com> L: dri-devel(a)lists.freedesktop.org diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index fc35731..1380e4a 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -290,3 +290,5 @@ source "drivers/gpu/drm/arc/Kconfig" source "drivers/gpu/drm/hisilicon/Kconfig" source "drivers/gpu/drm/mediatek/Kconfig" + +source "drivers/gpu/drm/gm12u320/Kconfig" diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index be43afb..2e06396 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -75,6 +75,7 @@ obj-$(CONFIG_DRM_TEGRA) += tegra/ obj-$(CONFIG_DRM_STI) += sti/ obj-$(CONFIG_DRM_IMX) += imx/ obj-$(CONFIG_DRM_MEDIATEK) += mediatek/ +obj-$(CONFIG_DRM_GM12U320) += gm12u320/ obj-y += i2c/ obj-y += panel/ obj-y += bridge/ diff --git a/drivers/gpu/drm/gm12u320/Kconfig b/drivers/gpu/drm/gm12u320/Kconfig new file mode 100644 index 0000000..cfecaac --- /dev/null +++ b/drivers/gpu/drm/gm12u320/Kconfig @@ -0,0 +1,16 @@ +config DRM_GM12U320 + tristate "Grain Media GM12U320 based mini projectors" + depends on DRM + depends on USB_SUPPORT + depends on USB_ARCH_HAS_HCD + select USB + select FB_SYS_FILLRECT + select FB_SYS_COPYAREA + select FB_SYS_IMAGEBLIT + select FB_DEFERRED_IO + select DRM_KMS_HELPER + select DRM_KMS_FB_HELPER + help + This is a KMS driver for Grain Media GM12U320 based usb mini video + projectors, such as the Acer C120. + Say M/Y to add support for these devices via drm/kms interfaces. diff --git a/drivers/gpu/drm/gm12u320/Makefile b/drivers/gpu/drm/gm12u320/Makefile new file mode 100644 index 0000000..6234473 --- /dev/null +++ b/drivers/gpu/drm/gm12u320/Makefile @@ -0,0 +1,7 @@ +ccflags-y := -Iinclude/drm + +gm12u320-y := gm12u320_drv.o gm12u320_modeset.o gm12u320_connector.o \ + gm12u320_encoder.o gm12u320_main.o gm12u320_fb.o \ + gm12u320_gem.o gm12u320_dmabuf.o + +obj-$(CONFIG_DRM_GM12U320) += gm12u320.o diff --git a/drivers/gpu/drm/gm12u320/gm12u320_connector.c b/drivers/gpu/drm/gm12u320/gm12u320_connector.c new file mode 100644 index 0000000..1a31915 --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_connector.c @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver: + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn(a)yandex.ru> + * Copyright (C) 2009 Roberto De Ioris <roberto(a)unbit.it> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml(a)gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie(a)plugable.com> + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ + +#include <drm/drmP.h> +#include <drm/drm_crtc.h> +#include <drm/drm_edid.h> +#include <drm/drm_crtc_helper.h> +#include "gm12u320_drv.h" + +/* + * Note this assumes this driver is only ever used with the Acer C120, if we + * add support for other devices the vendor and model should be parameterized. + */ +static struct edid gm12u320_edid = { + .header = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }, + .mfg_id = { 0x04, 0x72 }, /* "ACR" */ + .prod_code = { 0x20, 0xc1 }, /* C120h */ + .mfg_week = 1, + .mfg_year = 1, + .version = 1, /* EDID 1.3 */ + .revision = 3, /* EDID 1.3 */ + .input = 0x80, /* Digital input */ + .features = 0x02, /* Pref timing in DTD 1 */ + .standard_timings = { { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, + { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 } }, + .detailed_timings = { { + .pixel_clock = 3383, + /* hactive = 852, hblank = 256 */ + .data.pixel_data.hactive_lo = 0x54, + .data.pixel_data.hblank_lo = 0x00, + .data.pixel_data.hactive_hblank_hi = 0x31, + /* vactive = 480, vblank = 28 */ + .data.pixel_data.vactive_lo = 0xe0, + .data.pixel_data.vblank_lo = 0x1c, + .data.pixel_data.vactive_vblank_hi = 0x10, + /* hsync offset 40 pw 128, vsync offset 1 pw 4 */ + .data.pixel_data.hsync_offset_lo = 0x28, + .data.pixel_data.hsync_pulse_width_lo = 0x80, + .data.pixel_data.vsync_offset_pulse_width_lo = 0x14, + .data.pixel_data.hsync_vsync_offset_pulse_width_hi = 0x00, + /* Digital separate syncs, hsync+, vsync+ */ + .data.pixel_data.misc = 0x1e, + }, { + .pixel_clock = 0, + .data.other_data.type = 0xfd, /* Monitor ranges */ + .data.other_data.data.range.min_vfreq = 59, + .data.other_data.data.range.max_vfreq = 61, + .data.other_data.data.range.min_hfreq_khz = 29, + .data.other_data.data.range.max_hfreq_khz = 32, + .data.other_data.data.range.pixel_clock_mhz = 4, /* 40 MHz */ + .data.other_data.data.range.flags = 0, + .data.other_data.data.range.formula.cvt = { + 0xa0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }, + }, { + .pixel_clock = 0, + .data.other_data.type = 0xfc, /* Model string */ + .data.other_data.data.str.str = { + 'C', '1', '2', '0', 'P', 'r', 'o', 'j', 'e', 'c', + 't', 'o', 'r' }, + }, { + .pixel_clock = 0, + .data.other_data.type = 0xfe, /* Unspecified text / padding */ + .data.other_data.data.str.str = { + '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ' }, + } }, + .checksum = 0x40, +}; + +static int gm12u320_get_modes(struct drm_connector *connector) +{ + drm_mode_connector_update_edid_property(connector, &gm12u320_edid); + return drm_add_edid_modes(connector, &gm12u320_edid); +} + +static enum drm_connector_status +gm12u320_detect(struct drm_connector *connector, bool force) +{ + if (drm_device_is_unplugged(connector->dev)) + return connector_status_disconnected; + + return connector_status_connected; +} + +static struct drm_encoder* +gm12u320_best_single_encoder(struct drm_connector *connector) +{ + int enc_id = connector->encoder_ids[0]; + + return drm_encoder_find(connector->dev, enc_id); +} + +static int gm12u320_connector_set_property(struct drm_connector *connector, + struct drm_property *property, + uint64_t val) +{ + return 0; +} + +static void gm12u320_connector_destroy(struct drm_connector *connector) +{ + drm_connector_unregister(connector); + drm_connector_cleanup(connector); + kfree(connector); +} + +static const struct drm_connector_helper_funcs gm12u320_helper_funcs = { + .get_modes = gm12u320_get_modes, + .best_encoder = gm12u320_best_single_encoder, +}; + +static const struct drm_connector_funcs gm12u320_connector_funcs = { + .dpms = drm_helper_connector_dpms, + .detect = gm12u320_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = gm12u320_connector_destroy, + .set_property = gm12u320_connector_set_property, +}; + +int gm12u320_connector_init(struct drm_device *dev, + struct drm_encoder *encoder) +{ + struct drm_connector *connector; + + connector = kzalloc(sizeof(struct drm_connector), GFP_KERNEL); + if (!connector) + return -ENOMEM; + + drm_connector_init(dev, connector, &gm12u320_connector_funcs, + DRM_MODE_CONNECTOR_Unknown); + drm_connector_helper_add(connector, &gm12u320_helper_funcs); + + drm_connector_register(connector); + drm_mode_connector_attach_encoder(connector, encoder); + + drm_object_attach_property(&connector->base, + dev->mode_config.dirty_info_property, 1); + + return 0; +} diff --git a/drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c b/drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c new file mode 100644 index 0000000..c15ad4b --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_dmabuf.c @@ -0,0 +1,283 @@ +/* + * Based on the udl dmabuf code: + * + * Copyright (c) 2014 The Chromium OS Authors + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <drm/drmP.h> +#include "gm12u320_drv.h" +#include <linux/shmem_fs.h> +#include <linux/dma-buf.h> + +struct gm12u320_drm_dmabuf_attachment { + struct sg_table sgt; + enum dma_data_direction dir; + bool is_mapped; +}; + +static int gm12u320_attach_dma_buf(struct dma_buf *dmabuf, + struct device *dev, + struct dma_buf_attachment *attach) +{ + struct gm12u320_drm_dmabuf_attachment *gm12u320_attach; + + DRM_DEBUG_PRIME("[DEV:%s] size:%zd\n", dev_name(attach->dev), + attach->dmabuf->size); + + gm12u320_attach = kzalloc(sizeof(*gm12u320_attach), GFP_KERNEL); + if (!gm12u320_attach) + return -ENOMEM; + + gm12u320_attach->dir = DMA_NONE; + attach->priv = gm12u320_attach; + + return 0; +} + +static void gm12u320_detach_dma_buf(struct dma_buf *dmabuf, + struct dma_buf_attachment *attach) +{ + struct gm12u320_drm_dmabuf_attachment *gm12u320_attach = attach->priv; + struct sg_table *sgt; + + if (!gm12u320_attach) + return; + + DRM_DEBUG_PRIME("[DEV:%s] size:%zd\n", dev_name(attach->dev), + attach->dmabuf->size); + + sgt = &gm12u320_attach->sgt; + + if (gm12u320_attach->dir != DMA_NONE) + dma_unmap_sg(attach->dev, sgt->sgl, sgt->nents, + gm12u320_attach->dir); + + sg_free_table(sgt); + kfree(gm12u320_attach); + attach->priv = NULL; +} + +static struct sg_table *gm12u320_map_dma_buf(struct dma_buf_attachment *attach, + enum dma_data_direction dir) +{ + struct gm12u320_drm_dmabuf_attachment *gm12u320_attach = attach->priv; + struct gm12u320_gem_object *obj = to_gm12u320_bo(attach->dmabuf->priv); + struct drm_device *dev = obj->base.dev; + struct scatterlist *rd, *wr; + struct sg_table *sgt = NULL; + unsigned int i; + int page_count; + int nents, ret; + + DRM_DEBUG_PRIME("[DEV:%s] size:%zd dir=%d\n", dev_name(attach->dev), + attach->dmabuf->size, dir); + + /* just return current sgt if already requested. */ + if (gm12u320_attach->dir == dir && gm12u320_attach->is_mapped) + return &gm12u320_attach->sgt; + + if (!obj->pages) { + ret = gm12u320_gem_get_pages(obj); + if (ret) { + DRM_ERROR("failed to map pages.\n"); + return ERR_PTR(ret); + } + } + + page_count = obj->base.size / PAGE_SIZE; + obj->sg = drm_prime_pages_to_sg(obj->pages, page_count); + if (IS_ERR(obj->sg)) { + DRM_ERROR("failed to allocate sgt.\n"); + return ERR_CAST(obj->sg); + } + + sgt = &gm12u320_attach->sgt; + + ret = sg_alloc_table(sgt, obj->sg->orig_nents, GFP_KERNEL); + if (ret) { + DRM_ERROR("failed to alloc sgt.\n"); + return ERR_PTR(-ENOMEM); + } + + mutex_lock(&dev->struct_mutex); + + rd = obj->sg->sgl; + wr = sgt->sgl; + for (i = 0; i < sgt->orig_nents; ++i) { + sg_set_page(wr, sg_page(rd), rd->length, rd->offset); + rd = sg_next(rd); + wr = sg_next(wr); + } + + if (dir != DMA_NONE) { + nents = dma_map_sg(attach->dev, sgt->sgl, sgt->orig_nents, dir); + if (!nents) { + DRM_ERROR("failed to map sgl with iommu.\n"); + sg_free_table(sgt); + sgt = ERR_PTR(-EIO); + goto err_unlock; + } + } + + gm12u320_attach->is_mapped = true; + gm12u320_attach->dir = dir; + attach->priv = gm12u320_attach; + +err_unlock: + mutex_unlock(&dev->struct_mutex); + return sgt; +} + +static void gm12u320_unmap_dma_buf(struct dma_buf_attachment *attach, + struct sg_table *sgt, + enum dma_data_direction dir) +{ + /* Nothing to do. */ + DRM_DEBUG_PRIME("[DEV:%s] size:%zd dir:%d\n", dev_name(attach->dev), + attach->dmabuf->size, dir); +} + +static void *gm12u320_dmabuf_kmap(struct dma_buf *dma_buf, + unsigned long page_num) +{ + /* TODO */ + + return NULL; +} + +static void *gm12u320_dmabuf_kmap_atomic(struct dma_buf *dma_buf, + unsigned long page_num) +{ + /* TODO */ + + return NULL; +} + +static void gm12u320_dmabuf_kunmap(struct dma_buf *dma_buf, + unsigned long page_num, void *addr) +{ + /* TODO */ +} + +static void gm12u320_dmabuf_kunmap_atomic(struct dma_buf *dma_buf, + unsigned long page_num, + void *addr) +{ + /* TODO */ +} + +static int gm12u320_dmabuf_mmap(struct dma_buf *dma_buf, + struct vm_area_struct *vma) +{ + /* TODO */ + + return -EINVAL; +} + +static struct dma_buf_ops gm12u320_dmabuf_ops = { + .attach = gm12u320_attach_dma_buf, + .detach = gm12u320_detach_dma_buf, + .map_dma_buf = gm12u320_map_dma_buf, + .unmap_dma_buf = gm12u320_unmap_dma_buf, + .kmap = gm12u320_dmabuf_kmap, + .kmap_atomic = gm12u320_dmabuf_kmap_atomic, + .kunmap = gm12u320_dmabuf_kunmap, + .kunmap_atomic = gm12u320_dmabuf_kunmap_atomic, + .mmap = gm12u320_dmabuf_mmap, + .release = drm_gem_dmabuf_release, +}; + +struct dma_buf *gm12u320_gem_prime_export(struct drm_device *dev, + struct drm_gem_object *obj, int flags) +{ + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + + exp_info.ops = &gm12u320_dmabuf_ops; + exp_info.size = obj->size; + exp_info.flags = flags; + exp_info.priv = obj; + + return dma_buf_export(&exp_info); +} + +static int gm12u320_prime_create(struct drm_device *dev, + size_t size, struct sg_table *sg, + struct gm12u320_gem_object **obj_p) +{ + struct gm12u320_gem_object *obj; + int npages; + + npages = size / PAGE_SIZE; + + *obj_p = NULL; + obj = gm12u320_gem_alloc_object(dev, npages * PAGE_SIZE); + if (!obj) + return -ENOMEM; + + obj->sg = sg; + obj->pages = drm_malloc_ab(npages, sizeof(struct page *)); + if (obj->pages == NULL) { + DRM_ERROR("obj pages is NULL %d\n", npages); + return -ENOMEM; + } + + drm_prime_sg_to_page_addr_arrays(sg, obj->pages, NULL, npages); + + *obj_p = obj; + return 0; +} + +struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev, + struct dma_buf *dma_buf) +{ + struct dma_buf_attachment *attach; + struct sg_table *sg; + struct gm12u320_gem_object *uobj; + int ret; + + /* need to attach */ + get_device(dev->dev); + attach = dma_buf_attach(dma_buf, dev->dev); + if (IS_ERR(attach)) { + put_device(dev->dev); + return ERR_CAST(attach); + } + + get_dma_buf(dma_buf); + + sg = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL); + if (IS_ERR(sg)) { + ret = PTR_ERR(sg); + goto fail_detach; + } + + ret = gm12u320_prime_create(dev, dma_buf->size, sg, &uobj); + if (ret) + goto fail_unmap; + + uobj->base.import_attach = attach; + uobj->flags = GM12U320_BO_WC; + + return &uobj->base; + +fail_unmap: + dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL); +fail_detach: + dma_buf_detach(dma_buf, attach); + dma_buf_put(dma_buf); + put_device(dev->dev); + return ERR_PTR(ret); +} diff --git a/drivers/gpu/drm/gm12u320/gm12u320_drv.c b/drivers/gpu/drm/gm12u320/gm12u320_drv.c new file mode 100644 index 0000000..eff3a44 --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_drv.c @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ + +#include <linux/module.h> +#include <drm/drmP.h> +#include <drm/drm_crtc_helper.h> +#include "gm12u320_drv.h" + +static int gm12u320_driver_set_busid(struct drm_device *d, struct drm_master *m) +{ + return 0; +} + +static const struct vm_operations_struct gm12u320_gem_vm_ops = { + .fault = gm12u320_gem_fault, + .open = drm_gem_vm_open, + .close = drm_gem_vm_close, +}; + +static const struct file_operations gm12u320_driver_fops = { + .owner = THIS_MODULE, + .open = drm_open, + .mmap = gm12u320_drm_gem_mmap, + .poll = drm_poll, + .read = drm_read, + .unlocked_ioctl = drm_ioctl, + .release = drm_release, +#ifdef CONFIG_COMPAT + .compat_ioctl = drm_compat_ioctl, +#endif + .llseek = noop_llseek, +}; + +static struct drm_driver driver = { + .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME, + .load = gm12u320_driver_load, + .unload = gm12u320_driver_unload, + .set_busid = gm12u320_driver_set_busid, + + /* gem hooks */ + .gem_free_object = gm12u320_gem_free_object, + .gem_vm_ops = &gm12u320_gem_vm_ops, + + .dumb_create = gm12u320_dumb_create, + .dumb_map_offset = gm12u320_gem_mmap, + .dumb_destroy = drm_gem_dumb_destroy, + .fops = &gm12u320_driver_fops, + + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, + .gem_prime_export = gm12u320_gem_prime_export, + .gem_prime_import = gm12u320_gem_prime_import, + + .name = DRIVER_NAME, + .desc = DRIVER_DESC, + .date = DRIVER_DATE, + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, + .patchlevel = DRIVER_PATCHLEVEL, +}; + +static int gm12u320_usb_probe(struct usb_interface *interface, + const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(interface); + struct drm_device *dev; + int r; + + /* + * The gm12u320 presents itself to the system as 2 usb mass-storage + * interfaces, for the second one we proceed successully with binding, + * but otherwise ignore it. + */ + if (interface->cur_altsetting->desc.bInterfaceNumber != 0) + return 0; + + dev = drm_dev_alloc(&driver, &interface->dev); + if (!dev) + return -ENOMEM; + + r = drm_dev_register(dev, (unsigned long)udev); + if (r) + goto err_free; + + usb_set_intfdata(interface, dev); + DRM_INFO("Initialized gm12u320 on minor %d\n", dev->primary->index); + + return 0; + +err_free: + drm_dev_unref(dev); + return r; +} + +static void gm12u320_usb_disconnect(struct usb_interface *interface) +{ + struct drm_device *dev = usb_get_intfdata(interface); + + if (!dev) + return; + + drm_kms_helper_poll_disable(dev); + drm_connector_unregister_all(dev); + gm12u320_fbdev_unplug(dev); + gm12u320_stop_fb_update(dev); + drm_unplug_dev(dev); +} + +#ifdef CONFIG_PM + +int gm12u320_suspend(struct usb_interface *interface, pm_message_t message) +{ + struct drm_device *dev = usb_get_intfdata(interface); + + if (!dev) + return 0; + + gm12u320_stop_fb_update(dev); + return 0; +} + +int gm12u320_resume(struct usb_interface *interface) +{ + struct drm_device *dev = usb_get_intfdata(interface); + + if (!dev) + return 0; + + gm12u320_set_ecomode(dev); + gm12u320_start_fb_update(dev); + return 0; +} +#endif + +static struct usb_device_id id_table[] = { + { USB_DEVICE(0x1de1, 0xc102) }, + {}, +}; +MODULE_DEVICE_TABLE(usb, id_table); + +static struct usb_driver gm12u320_driver = { + .name = "gm12u320", + .probe = gm12u320_usb_probe, + .disconnect = gm12u320_usb_disconnect, + .id_table = id_table, +#ifdef CONFIG_PM + .suspend = gm12u320_suspend, + .resume = gm12u320_resume, + .reset_resume = gm12u320_resume, +#endif +}; + +module_usb_driver(gm12u320_driver); +MODULE_AUTHOR("Hans de Goede <hdegoede(a)redhat.com>"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/gm12u320/gm12u320_drv.h b/drivers/gpu/drm/gm12u320/gm12u320_drv.h new file mode 100644 index 0000000..84df491 --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_drv.h @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver: + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn(a)yandex.ru> + * Copyright (C) 2009 Roberto De Ioris <roberto(a)unbit.it> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml(a)gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie(a)plugable.com> + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ + +#ifndef GM12U320_DRV_H +#define GM12U320_DRV_H + +#include <linux/usb.h> +#include <linux/spinlock.h> +#include <drm/drm_gem.h> + +#define DRIVER_NAME "gm12u320" +#define DRIVER_DESC "Grain Media GM12U320 USB projector display" +#define DRIVER_DATE "20150107" + +#define DRIVER_MAJOR 0 +#define DRIVER_MINOR 0 +#define DRIVER_PATCHLEVEL 1 + +#define GM12U320_BO_CACHEABLE (1 << 0) +#define GM12U320_BO_WC (1 << 1) + +/* + * The DLP has an actual width of 854 pixels, but that is not a multiple + * of 4, breaking things left and right, so we export a width of 852. + */ +#define GM12U320_USER_WIDTH 852 +#define GM12U320_REAL_WIDTH 854 +#define GM12U320_HEIGHT 480 + +#define GM12U320_BLOCK_COUNT 20 + +struct gm12u320_device; + +struct gm12u320_fbdev; + +struct gm12u320_device { + struct device *dev; + struct usb_device *udev; + struct drm_device *ddev; + struct gm12u320_fbdev *fbdev; + unsigned char *cmd_buf; + unsigned char *data_buf[GM12U320_BLOCK_COUNT]; + struct { + bool run; + struct workqueue_struct *workq; + struct work_struct work; + wait_queue_head_t waitq; + struct mutex lock; + struct gm12u320_framebuffer *fb; + int x1; + int x2; + int y1; + int y2; + } fb_update; +}; + +struct gm12u320_gem_object { + struct drm_gem_object base; + struct page **pages; + void *vmapping; + struct sg_table *sg; + unsigned int flags; +}; + +#define to_gm12u320_bo(x) container_of(x, struct gm12u320_gem_object, base) + +struct gm12u320_framebuffer { + struct drm_framebuffer base; + struct gm12u320_gem_object *obj; +}; + +#define to_gm12u320_fb(x) container_of(x, struct gm12u320_framebuffer, base) + +/* modeset */ +int gm12u320_modeset_init(struct drm_device *dev); +void gm12u320_modeset_cleanup(struct drm_device *dev); +int gm12u320_connector_init(struct drm_device *dev, + struct drm_encoder *encoder); + +struct drm_encoder *gm12u320_encoder_init(struct drm_device *dev); + +int gm12u320_driver_load(struct drm_device *dev, unsigned long flags); +int gm12u320_driver_unload(struct drm_device *dev); + +int gm12u320_fbdev_init(struct drm_device *dev); +void gm12u320_fbdev_cleanup(struct drm_device *dev); +void gm12u320_fbdev_unplug(struct drm_device *dev); +struct drm_framebuffer * +gm12u320_fb_user_fb_create(struct drm_device *dev, struct drm_file *file, + const struct drm_mode_fb_cmd2 *mode_cmd); + +int gm12u320_dumb_create(struct drm_file *file_priv, struct drm_device *dev, + struct drm_mode_create_dumb *args); +int gm12u320_gem_mmap(struct drm_file *file_priv, struct drm_device *dev, + uint32_t handle, uint64_t *offset); + +struct gm12u320_gem_object * +gm12u320_gem_alloc_object(struct drm_device *dev, size_t size); +void gm12u320_gem_free_object(struct drm_gem_object *gem_obj); +struct dma_buf *gm12u320_gem_prime_export(struct drm_device *dev, + struct drm_gem_object *obj, int flags); +struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev, + struct dma_buf *dma_buf); + +int gm12u320_gem_get_pages(struct gm12u320_gem_object *obj); +void gm12u320_gem_put_pages(struct gm12u320_gem_object *obj); +int gm12u320_gem_vmap(struct gm12u320_gem_object *obj); +void gm12u320_gem_vunmap(struct gm12u320_gem_object *obj); +int gm12u320_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); +int gm12u320_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf); + +void gm12u320_fb_mark_dirty(struct gm12u320_framebuffer *fb, + int x1, int x2, int y1, int y2); +void gm12u320_start_fb_update(struct drm_device *dev); +void gm12u320_stop_fb_update(struct drm_device *dev); +int gm12u320_set_ecomode(struct drm_device *dev); + +#endif diff --git a/drivers/gpu/drm/gm12u320/gm12u320_encoder.c b/drivers/gpu/drm/gm12u320/gm12u320_encoder.c new file mode 100644 index 0000000..085f05b --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_encoder.c @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver: + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn(a)yandex.ru> + * Copyright (C) 2009 Roberto De Ioris <roberto(a)unbit.it> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml(a)gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie(a)plugable.com> + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ + +#include <drm/drmP.h> +#include <drm/drm_crtc.h> +#include <drm/drm_crtc_helper.h> +#include "gm12u320_drv.h" + +/* dummy encoder */ +static void gm12u320_enc_destroy(struct drm_encoder *encoder) +{ + drm_encoder_cleanup(encoder); + kfree(encoder); +} + +static void gm12u320_encoder_disable(struct drm_encoder *encoder) +{ +} + +static void gm12u320_encoder_prepare(struct drm_encoder *encoder) +{ +} + +static void gm12u320_encoder_commit(struct drm_encoder *encoder) +{ +} + +static void gm12u320_encoder_mode_set(struct drm_encoder *encoder, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ +} + +static void +gm12u320_encoder_dpms(struct drm_encoder *encoder, int mode) +{ +} + +static const struct drm_encoder_helper_funcs gm12u320_helper_funcs = { + .dpms = gm12u320_encoder_dpms, + .prepare = gm12u320_encoder_prepare, + .mode_set = gm12u320_encoder_mode_set, + .commit = gm12u320_encoder_commit, + .disable = gm12u320_encoder_disable, +}; + +static const struct drm_encoder_funcs gm12u320_enc_funcs = { + .destroy = gm12u320_enc_destroy, +}; + +struct drm_encoder *gm12u320_encoder_init(struct drm_device *dev) +{ + struct drm_encoder *encoder; + + encoder = kzalloc(sizeof(struct drm_encoder), GFP_KERNEL); + if (!encoder) + return NULL; + + drm_encoder_init(dev, encoder, &gm12u320_enc_funcs, + DRM_MODE_ENCODER_TMDS, NULL); + drm_encoder_helper_add(encoder, &gm12u320_helper_funcs); + encoder->possible_crtcs = 1; + return encoder; +} diff --git a/drivers/gpu/drm/gm12u320/gm12u320_fb.c b/drivers/gpu/drm/gm12u320/gm12u320_fb.c new file mode 100644 index 0000000..d62de5b --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_fb.c @@ -0,0 +1,345 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver: + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn(a)yandex.ru> + * Copyright (C) 2009 Roberto De Ioris <roberto(a)unbit.it> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml(a)gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie(a)plugable.com> + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/fb.h> + +#include <drm/drmP.h> +#include <drm/drm_crtc.h> +#include <drm/drm_crtc_helper.h> +#include "gm12u320_drv.h" + +#include <drm/drm_fb_helper.h> + +struct gm12u320_fbdev { + struct drm_fb_helper helper; + struct gm12u320_framebuffer fb; +}; + +void gm12u320_fb_mark_dirty(struct gm12u320_framebuffer *fb, + int x1, int x2, int y1, int y2) +{ + struct drm_device *dev = fb->base.dev; + struct gm12u320_device *gm12u320 = dev->dev_private; + struct gm12u320_framebuffer *old_fb = NULL; + bool wakeup = false; + + mutex_lock(&gm12u320->fb_update.lock); + + if (gm12u320->fb_update.fb != fb) { + gm12u320->fb_update.x1 = x1; + gm12u320->fb_update.x2 = x2; + gm12u320->fb_update.y1 = y1; + gm12u320->fb_update.y2 = y2; + old_fb = gm12u320->fb_update.fb; + gm12u320->fb_update.fb = fb; + drm_framebuffer_reference(&gm12u320->fb_update.fb->base); + wakeup = true; + } else { + gm12u320->fb_update.x1 = min(gm12u320->fb_update.x1, x1); + gm12u320->fb_update.x2 = max(gm12u320->fb_update.x2, x2); + gm12u320->fb_update.y1 = min(gm12u320->fb_update.y1, y1); + gm12u320->fb_update.y2 = max(gm12u320->fb_update.y2, y2); + } + + mutex_unlock(&gm12u320->fb_update.lock); + + if (wakeup) + wake_up(&gm12u320->fb_update.waitq); + + if (old_fb) + drm_framebuffer_unreference(&old_fb->base); +} + +static int gm12u320_fb_open(struct fb_info *info, int user) +{ + struct gm12u320_fbdev *fbdev = info->par; + struct drm_device *ddev = fbdev->fb.base.dev; + + /* If the USB device is gone, we don't accept new opens */ + if (drm_device_is_unplugged(ddev)) + return -ENODEV; + + return 0; +} + +static struct fb_ops gm12u320_fb_ops = { + .owner = THIS_MODULE, + .fb_check_var = drm_fb_helper_check_var, + .fb_set_par = drm_fb_helper_set_par, + .fb_fillrect = drm_fb_helper_sys_fillrect, + .fb_copyarea = drm_fb_helper_sys_copyarea, + .fb_imageblit = drm_fb_helper_sys_imageblit, + .fb_pan_display = drm_fb_helper_pan_display, + .fb_blank = drm_fb_helper_blank, + .fb_setcmap = drm_fb_helper_setcmap, + .fb_debug_enter = drm_fb_helper_debug_enter, + .fb_debug_leave = drm_fb_helper_debug_leave, + .fb_open = gm12u320_fb_open, +}; + +static struct fb_deferred_io gm12u320_fb_defio = { + .delay = HZ / 30, + .deferred_io = drm_fb_helper_deferred_io, +}; + +static int gm12u320_user_framebuffer_dirty(struct drm_framebuffer *drm_fb, + struct drm_file *file, + unsigned flags, unsigned color, + struct drm_clip_rect *clips, + unsigned num_clips) +{ + struct gm12u320_framebuffer *fb = to_gm12u320_fb(drm_fb); + int x1, x2, y1, y2; + + if (num_clips == 0) + return 0; + + x1 = clips->x1; + x2 = clips->x2; + y1 = clips->y1; + y2 = clips->y2; + + while (--num_clips) { + clips++; + x1 = min_t(int, x1, (int)clips->x1); + x2 = max_t(int, x2, (int)clips->x2); + y1 = min_t(int, y1, (int)clips->y1); + y2 = max_t(int, y2, (int)clips->y2); + } + + gm12u320_fb_mark_dirty(fb, x1, x2, y1, y2); + + return 0; +} + +static void gm12u320_user_framebuffer_destroy(struct drm_framebuffer *drm_fb) +{ + struct gm12u320_framebuffer *fb = to_gm12u320_fb(drm_fb); + + if (fb->obj) + drm_gem_object_unreference_unlocked(&fb->obj->base); + + drm_framebuffer_cleanup(drm_fb); + kfree(fb); +} + +static const struct drm_framebuffer_funcs gm12u320fb_funcs = { + .destroy = gm12u320_user_framebuffer_destroy, + .dirty = gm12u320_user_framebuffer_dirty, +}; + +static int +gm12u320_framebuffer_init(struct drm_device *dev, + struct gm12u320_framebuffer *fb, + const struct drm_mode_fb_cmd2 *mode_cmd, + struct gm12u320_gem_object *obj) +{ + int ret; + + fb->obj = obj; + drm_helper_mode_fill_fb_struct(&fb->base, mode_cmd); + ret = drm_framebuffer_init(dev, &fb->base, &gm12u320fb_funcs); + return ret; +} + +static int gm12u320fb_create(struct drm_fb_helper *helper, + struct drm_fb_helper_surface_size *sizes) +{ + struct gm12u320_fbdev *fbdev = + container_of(helper, struct gm12u320_fbdev, helper); + struct drm_device *dev = fbdev->helper.dev; + struct fb_info *info; + struct drm_framebuffer *drm_fb; + struct drm_mode_fb_cmd2 mode_cmd; + struct gm12u320_gem_object *obj; + uint32_t size; + int ret = 0; + + if (sizes->surface_bpp == 24) + sizes->surface_bpp = 32; + + mode_cmd.width = sizes->surface_width; + mode_cmd.height = sizes->surface_height; + mode_cmd.pitches[0] = mode_cmd.width * ((sizes->surface_bpp + 7) / 8); + + mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp, + sizes->surface_depth); + + size = mode_cmd.pitches[0] * mode_cmd.height; + size = ALIGN(size, PAGE_SIZE); + + obj = gm12u320_gem_alloc_object(dev, size); + if (!obj) + goto out; + + ret = gm12u320_gem_vmap(obj); + if (ret) { + DRM_ERROR("failed to vmap fb\n"); + goto out_gfree; + } + + info = drm_fb_helper_alloc_fbi(helper); + if (IS_ERR(info)) { + ret = PTR_ERR(info); + goto out_gfree; + } + info->par = fbdev; + + ret = gm12u320_framebuffer_init(dev, &fbdev->fb, &mode_cmd, obj); + if (ret) + goto out_destroy_fbi; + + drm_fb = &fbdev->fb.base; + + fbdev->helper.fb = drm_fb; + + strcpy(info->fix.id, "gm12u320drmfb"); + + info->screen_base = fbdev->fb.obj->vmapping; + info->fix.smem_len = size; + info->fix.smem_start = (unsigned long)fbdev->fb.obj->vmapping; + + info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT; + info->fbops = &gm12u320_fb_ops; + info->fbdefio = &gm12u320_fb_defio; + drm_fb_helper_fill_fix(info, drm_fb->pitches[0], drm_fb->depth); + drm_fb_helper_fill_var(info, &fbdev->helper, + sizes->fb_width, sizes->fb_height); + fb_deferred_io_init(info); + + DRM_DEBUG_KMS("allocated %dx%d vmal %p\n", + drm_fb->width, drm_fb->height, + fbdev->fb.obj->vmapping); + + return ret; + +out_destroy_fbi: + drm_fb_helper_release_fbi(helper); +out_gfree: + drm_gem_object_unreference_unlocked(&fbdev->fb.obj->base); +out: + return ret; +} + +static const struct drm_fb_helper_funcs gm12u320_fb_helper_funcs = { + .fb_probe = gm12u320fb_create, +}; + +static void gm12u320_fbdev_destroy(struct drm_device *dev, + struct gm12u320_fbdev *fbdev) +{ + drm_fb_helper_unregister_fbi(&fbdev->helper); + drm_fb_helper_release_fbi(&fbdev->helper); + drm_fb_helper_fini(&fbdev->helper); + drm_framebuffer_unregister_private(&fbdev->fb.base); + drm_framebuffer_cleanup(&fbdev->fb.base); + drm_gem_object_unreference_unlocked(&fbdev->fb.obj->base); +} + +int gm12u320_fbdev_init(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + struct gm12u320_fbdev *fbdev; + int ret; + + fbdev = kzalloc(sizeof(struct gm12u320_fbdev), GFP_KERNEL); + if (!fbdev) + return -ENOMEM; + + gm12u320->fbdev = fbdev; + + drm_fb_helper_prepare(dev, &fbdev->helper, &gm12u320_fb_helper_funcs); + + ret = drm_fb_helper_init(dev, &fbdev->helper, 1, 1); + if (ret) + goto free; + + ret = drm_fb_helper_single_add_all_connectors(&fbdev->helper); + if (ret) + goto fini; + + /* disable all the possible outputs/crtcs before entering KMS mode */ + drm_helper_disable_unused_functions(dev); + + ret = drm_fb_helper_initial_config(&fbdev->helper, 32); + if (ret) + goto fini; + + return 0; + +fini: + drm_fb_helper_fini(&fbdev->helper); +free: + kfree(fbdev); + return ret; +} + +void gm12u320_fbdev_cleanup(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + + if (!gm12u320->fbdev) + return; + + gm12u320_fbdev_destroy(dev, gm12u320->fbdev); + kfree(gm12u320->fbdev); + gm12u320->fbdev = NULL; +} + +void gm12u320_fbdev_unplug(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + + if (!gm12u320->fbdev) + return; + + drm_fb_helper_unlink_fbi(&gm12u320->fbdev->helper); +} + +struct drm_framebuffer * +gm12u320_fb_user_fb_create(struct drm_device *dev, + struct drm_file *file, + const struct drm_mode_fb_cmd2 *mode_cmd) +{ + struct drm_gem_object *obj; + struct gm12u320_framebuffer *fb; + int ret; + uint32_t size; + + obj = drm_gem_object_lookup(file, mode_cmd->handles[0]); + if (obj == NULL) + return ERR_PTR(-ENOENT); + + size = mode_cmd->pitches[0] * mode_cmd->height; + size = ALIGN(size, PAGE_SIZE); + + if (size > obj->size) { + DRM_ERROR("object size not sufficient for fb %d %zu %d %d\n", + size, obj->size, mode_cmd->pitches[0], + mode_cmd->height); + return ERR_PTR(-ENOMEM); + } + + fb = kzalloc(sizeof(*fb), GFP_KERNEL); + if (fb == NULL) + return ERR_PTR(-ENOMEM); + + ret = gm12u320_framebuffer_init(dev, fb, mode_cmd, to_gm12u320_bo(obj)); + if (ret) { + kfree(fb); + return ERR_PTR(-EINVAL); + } + return &fb->base; +} diff --git a/drivers/gpu/drm/gm12u320/gm12u320_gem.c b/drivers/gpu/drm/gm12u320/gm12u320_gem.c new file mode 100644 index 0000000..d6784bf --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_gem.c @@ -0,0 +1,237 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ + +#include <drm/drmP.h> +#include "gm12u320_drv.h" +#include <linux/shmem_fs.h> +#include <linux/dma-buf.h> + +struct gm12u320_gem_object * +gm12u320_gem_alloc_object(struct drm_device *dev, size_t size) +{ + struct gm12u320_gem_object *obj; + + obj = kzalloc(sizeof(*obj), GFP_KERNEL); + if (obj == NULL) + return NULL; + + if (drm_gem_object_init(dev, &obj->base, size) != 0) { + kfree(obj); + return NULL; + } + + obj->flags = GM12U320_BO_CACHEABLE; + return obj; +} + +static int gm12u320_gem_create(struct drm_file *file, struct drm_device *dev, + uint64_t size, uint32_t *handle_p) +{ + struct gm12u320_gem_object *obj; + int ret; + u32 handle; + + size = roundup(size, PAGE_SIZE); + + obj = gm12u320_gem_alloc_object(dev, size); + if (obj == NULL) + return -ENOMEM; + + ret = drm_gem_handle_create(file, &obj->base, &handle); + if (ret) { + drm_gem_object_release(&obj->base); + kfree(obj); + return ret; + } + + drm_gem_object_unreference_unlocked(&obj->base); + *handle_p = handle; + return 0; +} + +static void update_vm_cache_attr(struct gm12u320_gem_object *obj, + struct vm_area_struct *vma) +{ + DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags); + + /* non-cacheable as default. */ + if (obj->flags & GM12U320_BO_CACHEABLE) { + vma->vm_page_prot = vm_get_page_prot(vma->vm_flags); + } else if (obj->flags & GM12U320_BO_WC) { + vma->vm_page_prot = + pgprot_writecombine(vm_get_page_prot(vma->vm_flags)); + } else { + vma->vm_page_prot = + pgprot_noncached(vm_get_page_prot(vma->vm_flags)); + } +} + +int gm12u320_dumb_create(struct drm_file *file, struct drm_device *dev, + struct drm_mode_create_dumb *args) +{ + args->pitch = args->width * DIV_ROUND_UP(args->bpp, 8); + args->size = args->pitch * args->height; + return gm12u320_gem_create(file, dev, + args->size, &args->handle); +} + +int gm12u320_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma) +{ + int ret; + + ret = drm_gem_mmap(filp, vma); + if (ret) + return ret; + + vma->vm_flags &= ~VM_PFNMAP; + vma->vm_flags |= VM_MIXEDMAP; + + update_vm_cache_attr(to_gm12u320_bo(vma->vm_private_data), vma); + + return ret; +} + +int gm12u320_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf) +{ + struct gm12u320_gem_object *obj = to_gm12u320_bo(vma->vm_private_data); + struct page *page; + unsigned int page_offset; + int ret = 0; + + page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >> + PAGE_SHIFT; + + if (!obj->pages) + return VM_FAULT_SIGBUS; + + page = obj->pages[page_offset]; + ret = vm_insert_page(vma, (unsigned long)vmf->virtual_address, page); + switch (ret) { + case -EAGAIN: + case 0: + case -ERESTARTSYS: + return VM_FAULT_NOPAGE; + case -ENOMEM: + return VM_FAULT_OOM; + default: + return VM_FAULT_SIGBUS; + } +} + +int gm12u320_gem_get_pages(struct gm12u320_gem_object *obj) +{ + struct page **pages; + + if (obj->pages) + return 0; + + pages = drm_gem_get_pages(&obj->base); + if (IS_ERR(pages)) + return PTR_ERR(pages); + + obj->pages = pages; + + return 0; +} + +void gm12u320_gem_put_pages(struct gm12u320_gem_object *obj) +{ + if (obj->base.import_attach) { + drm_free_large(obj->pages); + obj->pages = NULL; + return; + } + + drm_gem_put_pages(&obj->base, obj->pages, false, false); + obj->pages = NULL; +} + +int gm12u320_gem_vmap(struct gm12u320_gem_object *obj) +{ + int page_count = obj->base.size / PAGE_SIZE; + int ret; + + if (obj->base.import_attach) { + obj->vmapping = dma_buf_vmap(obj->base.import_attach->dmabuf); + if (!obj->vmapping) + return -ENOMEM; + return 0; + } + + ret = gm12u320_gem_get_pages(obj); + if (ret) + return ret; + + obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL); + if (!obj->vmapping) + return -ENOMEM; + return 0; +} + +void gm12u320_gem_vunmap(struct gm12u320_gem_object *obj) +{ + if (obj->base.import_attach) { + dma_buf_vunmap(obj->base.import_attach->dmabuf, obj->vmapping); + return; + } + + vunmap(obj->vmapping); + + gm12u320_gem_put_pages(obj); +} + +void gm12u320_gem_free_object(struct drm_gem_object *gem_obj) +{ + struct gm12u320_gem_object *obj = to_gm12u320_bo(gem_obj); + + if (obj->vmapping) + gm12u320_gem_vunmap(obj); + + if (gem_obj->import_attach) { + drm_prime_gem_destroy(gem_obj, obj->sg); + put_device(gem_obj->dev->dev); + } + + if (obj->pages) + gm12u320_gem_put_pages(obj); + + drm_gem_free_mmap_offset(gem_obj); +} + +/* the dumb interface doesn't work with the GEM straight MMAP + interface, it expects to do MMAP on the drm fd, like normal */ +int gm12u320_gem_mmap(struct drm_file *file, struct drm_device *dev, + uint32_t handle, uint64_t *offset) +{ + struct gm12u320_gem_object *gobj; + struct drm_gem_object *obj; + int ret = 0; + + mutex_lock(&dev->struct_mutex); + obj = drm_gem_object_lookup(file, handle); + if (obj == NULL) { + ret = -ENOENT; + goto unlock; + } + gobj = to_gm12u320_bo(obj); + + ret = gm12u320_gem_get_pages(gobj); + if (ret) + goto out; + ret = drm_gem_create_mmap_offset(obj); + if (ret) + goto out; + + *offset = drm_vma_node_offset_addr(&gobj->base.vma_node); + +out: + drm_gem_object_unreference(&gobj->base); +unlock: + mutex_unlock(&dev->struct_mutex); + return ret; +} diff --git a/drivers/gpu/drm/gm12u320/gm12u320_main.c b/drivers/gpu/drm/gm12u320/gm12u320_main.c new file mode 100644 index 0000000..c28d138 --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_main.c @@ -0,0 +1,507 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver: + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn(a)yandex.ru> + * Copyright (C) 2009 Roberto De Ioris <roberto(a)unbit.it> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml(a)gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie(a)plugable.com> + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ +#include <drm/drmP.h> +#include <linux/dma-buf.h> +#include "gm12u320_drv.h" + +static bool eco_mode; +module_param(eco_mode, bool, 0644); +MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)"); + +#define MISC_RCV_EPT 1 +#define DATA_RCV_EPT 2 +#define DATA_SND_EPT 3 +#define MISC_SND_EPT 4 + +#define DATA_BLOCK_HEADER_SIZE 84 +#define DATA_BLOCK_CONTENT_SIZE 64512 +#define DATA_BLOCK_FOOTER_SIZE 20 +#define DATA_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \ + DATA_BLOCK_CONTENT_SIZE + \ + DATA_BLOCK_FOOTER_SIZE) +#define DATA_LAST_BLOCK_CONTENT_SIZE 4032 +#define DATA_LAST_BLOCK_SIZE (DATA_BLOCK_HEADER_SIZE + \ + DATA_LAST_BLOCK_CONTENT_SIZE + \ + DATA_BLOCK_FOOTER_SIZE) + +#define CMD_SIZE 31 +#define READ_STATUS_SIZE 13 +#define MISC_VALUE_SIZE 4 + +#define CMD_TIMEOUT msecs_to_jiffies(200) +#define DATA_TIMEOUT msecs_to_jiffies(1000) +#define IDLE_TIMEOUT msecs_to_jiffies(2000) +#define FIRST_FRAME_TIMEOUT msecs_to_jiffies(2000) + +#define MISC_REQ_GET_SET_ECO_A 0xff +#define MISC_REQ_GET_SET_ECO_B 0x35 +/* Windows driver does once evert second, with with arg d = 1, others 0 */ +#define MISC_REQ_UNKNOWN1_A 0xff +#define MISC_REQ_UNKNOWN1_B 0x38 +/* Windows driver does this on init, with arg a, b = 0, c = 0xa0, d = 4 */ +#define MISC_REQ_UNKNOWN2_A 0xa5 +#define MISC_REQ_UNKNOWN2_B 0x00 + +static const char cmd_data[CMD_SIZE] = { + 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, + 0x68, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x10, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static const char cmd_draw[CMD_SIZE] = { + 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xfe, + 0x00, 0x00, 0x00, 0xc0, 0xd1, 0x05, 0x00, 0x40, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static const char cmd_misc[CMD_SIZE] = { + 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x80, 0x01, 0x10, 0xfd, + 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static const char data_block_header[DATA_BLOCK_HEADER_SIZE] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x04, 0x15, 0x00, 0x00, 0xfc, 0x00, 0x00, + 0x01, 0x00, 0x00, 0xdb +}; + +static const char data_last_block_header[DATA_BLOCK_HEADER_SIZE] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfb, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x20, 0x00, 0xc0, 0x0f, 0x00, 0x00, + 0x01, 0x00, 0x00, 0xd7 +}; + +static const char data_block_footer[DATA_BLOCK_FOOTER_SIZE] = { + 0xfb, 0x14, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x4f +}; + +static int gm12u320_usb_alloc(struct gm12u320_device *gm12u320) +{ + int i, block_size; + const char *hdr; + + gm12u320->cmd_buf = kmalloc(CMD_SIZE, GFP_KERNEL); + if (!gm12u320->cmd_buf) + return -ENOMEM; + + for (i = 0; i < GM12U320_BLOCK_COUNT; i++) { + if (i == GM12U320_BLOCK_COUNT - 1) { + block_size = DATA_LAST_BLOCK_SIZE; + hdr = data_last_block_header; + } else { + block_size = DATA_BLOCK_SIZE; + hdr = data_block_header; + } + + gm12u320->data_buf[i] = kzalloc(block_size, GFP_KERNEL); + if (!gm12u320->data_buf[i]) + return -ENOMEM; + + memcpy(gm12u320->data_buf[i], hdr, DATA_BLOCK_HEADER_SIZE); + memcpy(gm12u320->data_buf[i] + + (block_size - DATA_BLOCK_FOOTER_SIZE), + data_block_footer, DATA_BLOCK_FOOTER_SIZE); + } + + return 0; +} + +static void gm12u320_usb_free(struct gm12u320_device *gm12u320) +{ + int i; + + for (i = 0; i < GM12U320_BLOCK_COUNT; i++) + kfree(gm12u320->data_buf[i]); + + kfree(gm12u320->cmd_buf); +} + +static int gm12u320_misc_request(struct gm12u320_device *gm12u320, + u8 req_a, u8 req_b, + u8 arg_a, u8 arg_b, u8 arg_c, u8 arg_d) +{ + int ret, len; + u8 *buf, val; + + buf = kmalloc(CMD_SIZE, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + memcpy(buf, &cmd_misc, CMD_SIZE); + buf[20] = req_a; + buf[21] = req_b; + buf[22] = arg_a; + buf[23] = arg_b; + buf[24] = arg_c; + buf[25] = arg_d; + + /* Send request */ + ret = usb_bulk_msg(gm12u320->udev, + usb_sndbulkpipe(gm12u320->udev, MISC_SND_EPT), + buf, CMD_SIZE, &len, CMD_TIMEOUT); + if (ret || len != CMD_SIZE) { + dev_err(&gm12u320->udev->dev, "Misc. req. error %d\n", ret); + ret = -EIO; + goto leave; + } + + /* Read value */ + ret = usb_bulk_msg(gm12u320->udev, + usb_rcvbulkpipe(gm12u320->udev, MISC_RCV_EPT), + buf, MISC_VALUE_SIZE, &len, DATA_TIMEOUT); + if (ret || len != MISC_VALUE_SIZE) { + dev_err(&gm12u320->udev->dev, "Misc. value error %d\n", ret); + ret = -EIO; + goto leave; + } + val = buf[0]; + + /* Read status */ + ret = usb_bulk_msg(gm12u320->udev, + usb_rcvbulkpipe(gm12u320->udev, MISC_RCV_EPT), + buf, READ_STATUS_SIZE, &len, CMD_TIMEOUT); + if (ret || len != READ_STATUS_SIZE) { + dev_err(&gm12u320->udev->dev, "Misc. status error %d\n", ret); + ret = -EIO; + goto leave; + } + + ret = val; +leave: + kfree(buf); + return ret; +} + +void gm12u320_32bpp_to_24bpp_packed(u8 *dst, u8 *src, int len) +{ + while (len--) { + *dst++ = *src++; + *dst++ = *src++; + *dst++ = *src++; + src++; + } +} + +static void gm12u320_copy_fb_to_blocks(struct gm12u320_framebuffer *fb, + int x1, int x2, int y1, int y2) +{ + struct drm_device *dev = fb->base.dev; + struct gm12u320_device *gm12u320 = dev->dev_private; + int block, dst_offset, len, remain, ret; + u8 *src; + + if (fb->obj->base.import_attach) { + ret = dma_buf_begin_cpu_access( + fb->obj->base.import_attach->dmabuf, DMA_FROM_DEVICE); + if (ret) { + DRM_ERROR("dma_buf_begin_cpu_access err: %d\n", ret); + return; + } + } + + if (!fb->obj->vmapping) { + ret = gm12u320_gem_vmap(fb->obj); + if (ret) { + DRM_ERROR("failed to vmap fb: %d\n", ret); + goto end_cpu_access; + } + } + + src = fb->obj->vmapping + y1 * fb->base.pitches[0] + x1 * 4; + + x1 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2; + x2 += (GM12U320_REAL_WIDTH - GM12U320_USER_WIDTH) / 2; + + for (; y1 < y2; y1++) { + remain = 0; + len = (x2 - x1) * 3; + dst_offset = (y1 * GM12U320_REAL_WIDTH + x1) * 3; + block = dst_offset / DATA_BLOCK_CONTENT_SIZE; + dst_offset %= DATA_BLOCK_CONTENT_SIZE; + + if ((dst_offset + len) > DATA_BLOCK_CONTENT_SIZE) { + remain = dst_offset + len - DATA_BLOCK_CONTENT_SIZE; + len = DATA_BLOCK_CONTENT_SIZE - dst_offset; + } + + dst_offset += DATA_BLOCK_HEADER_SIZE; + len /= 3; + + gm12u320_32bpp_to_24bpp_packed( + gm12u320->data_buf[block] + dst_offset, + src, len); + + if (remain) { + block++; + dst_offset = DATA_BLOCK_HEADER_SIZE; + gm12u320_32bpp_to_24bpp_packed( + gm12u320->data_buf[block] + dst_offset, + src + len * 4, remain / 3); + } + src += fb->base.pitches[0]; + } + +end_cpu_access: + if (fb->obj->base.import_attach) { + ret = dma_buf_end_cpu_access( + fb->obj->base.import_attach->dmabuf, DMA_FROM_DEVICE); + if (ret) + DRM_ERROR("dma_buf_end_cpu_access err: %d\n", ret); + } +} + +static int gm12u320_fb_update_ready(struct gm12u320_device *gm12u320) +{ + int ret; + + mutex_lock(&gm12u320->fb_update.lock); + ret = !gm12u320->fb_update.run || gm12u320->fb_update.fb != NULL; + mutex_unlock(&gm12u320->fb_update.lock); + + return ret; +} + +static void gm12u320_fb_update_work(struct work_struct *work) +{ + struct gm12u320_device *gm12u320 = + container_of(work, struct gm12u320_device, fb_update.work); + int draw_status_timeout = FIRST_FRAME_TIMEOUT; + int block, block_size, len, x1, x2, y1, y2; + struct gm12u320_framebuffer *fb; + int frame = 0; + int ret = 0; + + while (gm12u320->fb_update.run) { + mutex_lock(&gm12u320->fb_update.lock); + fb = gm12u320->fb_update.fb; + x1 = gm12u320->fb_update.x1; + x2 = gm12u320->fb_update.x2; + y1 = gm12u320->fb_update.y1; + y2 = gm12u320->fb_update.y2; + gm12u320->fb_update.fb = NULL; + mutex_unlock(&gm12u320->fb_update.lock); + + if (fb) { + gm12u320_copy_fb_to_blocks(fb, x1, x2, y1, y2); + drm_framebuffer_unreference(&fb->base); + } + + for (block = 0; block < GM12U320_BLOCK_COUNT; block++) { + if (block == GM12U320_BLOCK_COUNT - 1) + block_size = DATA_LAST_BLOCK_SIZE; + else + block_size = DATA_BLOCK_SIZE; + + /* Send data command to device */ + memcpy(gm12u320->cmd_buf, cmd_data, CMD_SIZE); + gm12u320->cmd_buf[8] = block_size & 0xff; + gm12u320->cmd_buf[9] = block_size >> 8; + gm12u320->cmd_buf[20] = 0xfc - block * 4; + gm12u320->cmd_buf[21] = block | (frame << 7); + + ret = usb_bulk_msg(gm12u320->udev, + usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT), + gm12u320->cmd_buf, CMD_SIZE, &len, + CMD_TIMEOUT); + if (ret || len != CMD_SIZE) + goto err; + + /* Send data block to device */ + ret = usb_bulk_msg(gm12u320->udev, + usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT), + gm12u320->data_buf[block], block_size, + &len, DATA_TIMEOUT); + if (ret || len != block_size) + goto err; + + /* Read status */ + ret = usb_bulk_msg(gm12u320->udev, + usb_rcvbulkpipe(gm12u320->udev, DATA_RCV_EPT), + gm12u320->cmd_buf, READ_STATUS_SIZE, &len, + CMD_TIMEOUT); + if (ret || len != READ_STATUS_SIZE) + goto err; + } + + /* Send draw command to device */ + memcpy(gm12u320->cmd_buf, cmd_draw, CMD_SIZE); + ret = usb_bulk_msg(gm12u320->udev, + usb_sndbulkpipe(gm12u320->udev, DATA_SND_EPT), + gm12u320->cmd_buf, CMD_SIZE, &len, CMD_TIMEOUT); + if (ret || len != CMD_SIZE) + goto err; + + /* Read status */ + ret = usb_bulk_msg(gm12u320->udev, + usb_rcvbulkpipe(gm12u320->udev, DATA_RCV_EPT), + gm12u320->cmd_buf, READ_STATUS_SIZE, &len, + draw_status_timeout); + if (ret || len != READ_STATUS_SIZE) + goto err; + + draw_status_timeout = CMD_TIMEOUT; + frame = !frame; + + /* + * We must draw a frame every 2s otherwise the projector + * switches back to showing its logo. + */ + wait_event_timeout(gm12u320->fb_update.waitq, + gm12u320_fb_update_ready(gm12u320), + IDLE_TIMEOUT); + } + return; +err: + /* Do not log errors caused by module unload or device unplug */ + if (ret != -ECONNRESET && ret != -ESHUTDOWN) + dev_err(&gm12u320->udev->dev, "Frame update error: %d\n", ret); +} + +void gm12u320_start_fb_update(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + + mutex_lock(&gm12u320->fb_update.lock); + gm12u320->fb_update.run = true; + mutex_unlock(&gm12u320->fb_update.lock); + + queue_work(gm12u320->fb_update.workq, &gm12u320->fb_update.work); +} + +void gm12u320_stop_fb_update(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + + mutex_lock(&gm12u320->fb_update.lock); + gm12u320->fb_update.run = false; + mutex_unlock(&gm12u320->fb_update.lock); + + wake_up(&gm12u320->fb_update.waitq); + cancel_work_sync(&gm12u320->fb_update.work); + + mutex_lock(&gm12u320->fb_update.lock); + if (gm12u320->fb_update.fb) { + drm_framebuffer_unreference(&gm12u320->fb_update.fb->base); + gm12u320->fb_update.fb = NULL; + } + mutex_unlock(&gm12u320->fb_update.lock); +} + +int gm12u320_driver_load(struct drm_device *dev, unsigned long flags) +{ + struct usb_device *udev = (void *)flags; + struct gm12u320_device *gm12u320; + int ret = -ENOMEM; + + DRM_DEBUG("\n"); + gm12u320 = kzalloc(sizeof(struct gm12u320_device), GFP_KERNEL); + if (!gm12u320) + return -ENOMEM; + + gm12u320->udev = udev; + gm12u320->ddev = dev; + dev->dev_private = gm12u320; + + INIT_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work); + mutex_init(&gm12u320->fb_update.lock); + init_waitqueue_head(&gm12u320->fb_update.waitq); + + ret = gm12u320_set_ecomode(dev); + if (ret) + goto err; + + gm12u320->fb_update.workq = create_singlethread_workqueue(DRIVER_NAME); + if (!gm12u320->fb_update.workq) { + ret = -ENOMEM; + goto err; + } + + ret = gm12u320_usb_alloc(gm12u320); + if (ret) + goto err_wq; + + DRM_DEBUG("\n"); + ret = gm12u320_modeset_init(dev); + if (ret) + goto err_usb; + + ret = gm12u320_fbdev_init(dev); + if (ret) + goto err_modeset; + + ret = drm_vblank_init(dev, 1); + if (ret) + goto err_fb; + + gm12u320_start_fb_update(dev); + + return 0; + +err_fb: + gm12u320_fbdev_cleanup(dev); +err_modeset: + gm12u320_modeset_cleanup(dev); +err_usb: + gm12u320_usb_free(gm12u320); +err_wq: + destroy_workqueue(gm12u320->fb_update.workq); +err: + kfree(gm12u320); + DRM_ERROR("%d\n", ret); + return ret; +} + +int gm12u320_driver_unload(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + + drm_vblank_cleanup(dev); + gm12u320_fbdev_cleanup(dev); + gm12u320_modeset_cleanup(dev); + gm12u320_usb_free(gm12u320); + destroy_workqueue(gm12u320->fb_update.workq); + kfree(gm12u320); + return 0; +} + +int gm12u320_set_ecomode(struct drm_device *dev) +{ + struct gm12u320_device *gm12u320 = dev->dev_private; + + return gm12u320_misc_request(gm12u320, MISC_REQ_GET_SET_ECO_A, + MISC_REQ_GET_SET_ECO_B, 0x01 /* set */, + eco_mode ? 0x01 : 0x00, 0x00, 0x01); +} diff --git a/drivers/gpu/drm/gm12u320/gm12u320_modeset.c b/drivers/gpu/drm/gm12u320/gm12u320_modeset.c new file mode 100644 index 0000000..4b6c767 --- /dev/null +++ b/drivers/gpu/drm/gm12u320/gm12u320_modeset.c @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2012-2016 Red Hat Inc. + * + * Based in parts on the udl code. Based in parts on the gm12u320 fb driver: + * Copyright (C) 2013 Viacheslav Nurmekhamitov <slavrn(a)yandex.ru> + * Copyright (C) 2009 Roberto De Ioris <roberto(a)unbit.it> + * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml(a)gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie(a)plugable.com> + * + * This file is subject to the terms and conditions of the GNU General Public + * License v2. See the file COPYING in the main directory of this archive for + * more details. + */ + +#include <drm/drmP.h> +#include <drm/drm_crtc.h> +#include <drm/drm_crtc_helper.h> +#include <drm/drm_plane_helper.h> +#include "gm12u320_drv.h" + +static void gm12u320_crtc_dpms(struct drm_crtc *crtc, int mode) +{ +} + +static int gm12u320_crtc_mode_set(struct drm_crtc *crtc, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode, + int x, int y, + struct drm_framebuffer *old_fb) + +{ + struct gm12u320_framebuffer *fb = to_gm12u320_fb(crtc->primary->fb); + + gm12u320_fb_mark_dirty(fb, 0, GM12U320_USER_WIDTH, 0, GM12U320_HEIGHT); + return 0; +} + + +static void gm12u320_crtc_disable(struct drm_crtc *crtc) +{ +} + +static void gm12u320_crtc_destroy(struct drm_crtc *crtc) +{ + drm_crtc_cleanup(crtc); + kfree(crtc); +} + +static int gm12u320_crtc_page_flip(struct drm_crtc *crtc, + struct drm_framebuffer *drm_fb, + struct drm_pending_vblank_event *event, + uint32_t page_flip_flags) +{ + struct gm12u320_framebuffer *fb = to_gm12u320_fb(drm_fb); + struct drm_device *dev = crtc->dev; + unsigned long flags; + + gm12u320_fb_mark_dirty(fb, 0, GM12U320_USER_WIDTH, 0, GM12U320_HEIGHT); + + spin_lock_irqsave(&dev->event_lock, flags); + if (event) + drm_send_vblank_event(dev, 0, event); + spin_unlock_irqrestore(&dev->event_lock, flags); + + crtc->primary->fb = drm_fb; + + return 0; +} + +static void gm12u320_crtc_prepare(struct drm_crtc *crtc) +{ +} + +static void gm12u320_crtc_commit(struct drm_crtc *crtc) +{ + gm12u320_crtc_dpms(crtc, DRM_MODE_DPMS_ON); +} + +static const struct drm_crtc_helper_funcs gm12u320_helper_funcs = { + .dpms = gm12u320_crtc_dpms, + .mode_set = gm12u320_crtc_mode_set, + .prepare = gm12u320_crtc_prepare, + .commit = gm12u320_crtc_commit, + .disable = gm12u320_crtc_disable, +}; + +static const struct drm_crtc_funcs gm12u320_crtc_funcs = { + .set_config = drm_crtc_helper_set_config, + .destroy = gm12u320_crtc_destroy, + .page_flip = gm12u320_crtc_page_flip, +}; + +static int gm12u320_crtc_init(struct drm_device *dev) +{ + struct drm_crtc *crtc; + + crtc = kzalloc(sizeof(struct drm_crtc) + + sizeof(struct drm_connector *), GFP_KERNEL); + if (crtc == NULL) + return -ENOMEM; + + drm_crtc_init(dev, crtc, &gm12u320_crtc_funcs); + drm_crtc_helper_add(crtc, &gm12u320_helper_funcs); + + return 0; +} + +static const struct drm_mode_config_funcs gm12u320_mode_funcs = { + .fb_create = gm12u320_fb_user_fb_create, + .output_poll_changed = NULL, +}; + +int gm12u320_modeset_init(struct drm_device *dev) +{ + struct drm_encoder *encoder; + + drm_mode_config_init(dev); + + dev->mode_config.min_width = GM12U320_USER_WIDTH; + dev->mode_config.min_height = GM12U320_HEIGHT; + + dev->mode_config.max_width = 2048; + dev->mode_config.max_height = 2048; + + dev->mode_config.prefer_shadow = 0; + dev->mode_config.preferred_depth = 24; + + dev->mode_config.funcs = &gm12u320_mode_funcs; + + drm_mode_create_dirty_info_property(dev); + + gm12u320_crtc_init(dev); + + encoder = gm12u320_encoder_init(dev); + + gm12u320_connector_init(dev, encoder); + + return 0; +} + +void gm12u320_modeset_cleanup(struct drm_device *dev) +{ + drm_mode_config_cleanup(dev); +} -- 2.7.4

3 3

[PATCH v2 0/6] drm/fsl-dcu: suspend/resume rework using atomic helpers
by Stefan Agner 03 Jun '16

03 Jun '16

This implements suspend/resume using the atomic update supsend/resume helpers instead of the current implementation which uses regcache. The code has been tested on a Colibri VF61 using the freeze suspend mode. This version is a rebase ontop of the fix for the regmap cache issue: https://lists.freedesktop.org/archives/dri-devel/2016-June/109625.html Dave, Thierry: Could you have a look at patch 1? If that looks good for you I will take it through my tree... Changes since v1: - Rebase ontop of drm-next + regmap cache fix Stefan Agner (6): drm/fb_cma_helper: add suspend helper drm/fsl-dcu: store layer registers in soc_data drm/fsl-dcu: move layer initialization to plane file drm/fsl-dcu: use clk helpers drm/fsl-dcu: implement suspend/resume using atomic helpers drm/fsl-dcu: disable vblank events on CRTC disable drivers/gpu/drm/drm_fb_cma_helper.c | 15 +++++++++ drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_crtc.c | 21 ++++--------- drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.c | 47 +++++++++++++++++++++-------- drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_drv.h | 2 ++ drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_plane.c | 16 ++++++++++ drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_plane.h | 1 + include/drm/drm_fb_cma_helper.h | 1 + 7 files changed, 76 insertions(+), 27 deletions(-) -- 2.8.2

2 8

[PATCH 1/2] drm/amdgpu/gfx8: Tidy up various PG helpers
by Alex Deucher 03 Jun '16

03 Jun '16

From: Tom St Denis <tom.stdenis(a)amd.com> Signed-off-by: Tom St Denis <tom.stdenis(a)amd.com> Reviewed-by: Alex Deucher <alexander.deucher(a)amd.com> Signed-off-by: Alex Deucher <alexander.deucher(a)amd.com> --- drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c | 51 +++++++++++++---------------------- 1 file changed, 18 insertions(+), 33 deletions(-) diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c index 2848583..97862d3 100644 --- a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c +++ b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c @@ -5256,20 +5256,15 @@ static void gfx_v8_0_enable_gfx_static_mg_power_gating(struct amdgpu_device *ade enable ? AMD_PG_STATE_GATE : AMD_PG_STATE_UNGATE); - if (enable) { - /* Enable static MGPG */ - temp = data = RREG32(mmRLC_PG_CNTL); + temp = data = RREG32(mmRLC_PG_CNTL); + /* Enable static MGPG */ + if (enable) data |= RLC_PG_CNTL__STATIC_PER_CU_PG_ENABLE_MASK; - - if (temp != data) - WREG32(mmRLC_PG_CNTL, data); - } else { - temp = data = RREG32(mmRLC_PG_CNTL); + else data &= ~RLC_PG_CNTL__STATIC_PER_CU_PG_ENABLE_MASK; - if (temp != data) - WREG32(mmRLC_PG_CNTL, data); - } + if (temp != data) + WREG32(mmRLC_PG_CNTL, data); } static void gfx_v8_0_enable_gfx_dynamic_mg_power_gating(struct amdgpu_device *adev, @@ -5277,20 +5272,15 @@ static void gfx_v8_0_enable_gfx_dynamic_mg_power_gating(struct amdgpu_device *ad { uint32_t data, temp; - if (enable) { - /* Enable dynamic MGPG */ - temp = data = RREG32(mmRLC_PG_CNTL); + temp = data = RREG32(mmRLC_PG_CNTL); + /* Enable dynamic MGPG */ + if (enable) data |= RLC_PG_CNTL__DYN_PER_CU_PG_ENABLE_MASK; - - if (temp != data) - WREG32(mmRLC_PG_CNTL, data); - } else { - temp = data = RREG32(mmRLC_PG_CNTL); + else data &= ~RLC_PG_CNTL__DYN_PER_CU_PG_ENABLE_MASK; - if (temp != data) - WREG32(mmRLC_PG_CNTL, data); - } + if (temp != data) + WREG32(mmRLC_PG_CNTL, data); } static void polaris11_enable_gfx_quick_mg_power_gating(struct amdgpu_device *adev, @@ -5298,20 +5288,15 @@ static void polaris11_enable_gfx_quick_mg_power_gating(struct amdgpu_device *ade { uint32_t data, temp; - if (enable) { - /* Enable quick PG */ - temp = data = RREG32(mmRLC_PG_CNTL); + temp = data = RREG32(mmRLC_PG_CNTL); + /* Enable quick PG */ + if (enable) data |= 0x100000; - - if (temp != data) - WREG32(mmRLC_PG_CNTL, data); - } else { - temp = data = RREG32(mmRLC_PG_CNTL); + else data &= ~0x100000; - if (temp != data) - WREG32(mmRLC_PG_CNTL, data); - } + if (temp != data) + WREG32(mmRLC_PG_CNTL, data); } static void cz_enable_gfx_cg_power_gating(struct amdgpu_device *adev, -- 2.5.5

1 1

[PATCH 1/2] drm/amd/powerplay: fix bug visit array out of bounds
by Alex Deucher 03 Jun '16

03 Jun '16

From: Rex Zhu <Rex.Zhu(a)amd.com> Signed-off-by: Rex Zhu <Rex.Zhu(a)amd.com> Acked-by: Christian König <christian.koenig(a)amd.com> Reviewed-by: Alex Deucher <alexander.deucher(a)amd.com> Signed-off-by: Alex Deucher <alexander.deucher(a)amd.com> --- drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c | 2 +- drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c index 24a16e4..586f732 100644 --- a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c @@ -1830,7 +1830,7 @@ static uint16_t fiji_find_closest_vddci(struct pp_hwmgr *hwmgr, uint16_t vddci) PP_ASSERT_WITH_CODE(false, "VDDCI is larger than max VDDCI in VDDCI Voltage Table!", - return vddci_table->entries[i].value); + return vddci_table->entries[i-1].value); } static int fiji_get_dependency_volt_by_clk(struct pp_hwmgr *hwmgr, diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c index 910d56d..20f20e0 100644 --- a/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c +++ b/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c @@ -469,7 +469,7 @@ uint16_t phm_find_closest_vddci(struct pp_atomctrl_voltage_table *vddci_table, u PP_ASSERT_WITH_CODE(false, "VDDCI is larger than max VDDCI in VDDCI Voltage Table!", - return vddci_table->entries[i].value); + return vddci_table->entries[i-1].value); } int phm_find_boot_level(void *table, -- 2.5.5

1 1

[PATCH 1/4] drm/amdgpu: add amdgpu.cg_mask and amdgpu.pg_mask parameters
by Alex Deucher 03 Jun '16

03 Jun '16

From: Nicolai Hähnle <Nicolai.Haehnle(a)amd.com> They allow disabling clock and power gating from the kernel command line, which hopefully helps with diagnosing problems in the field. Reviewed-by: Alex Deucher <alexander.deucher(a)amd.com> Signed-off-by: Nicolai Hähnle <Nicolai.Haehnle(a)amd.com> Signed-off-by: Alex Deucher <alexander.deucher(a)amd.com> --- drivers/gpu/drm/amd/amdgpu/amdgpu.h | 2 ++ drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 3 +++ drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 8 ++++++++ 3 files changed, 13 insertions(+) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h index 7b65252..81de8b9 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h @@ -88,6 +88,8 @@ extern int amdgpu_powerplay; extern int amdgpu_powercontainment; extern unsigned amdgpu_pcie_gen_cap; extern unsigned amdgpu_pcie_lane_cap; +extern unsigned amdgpu_cg_mask; +extern unsigned amdgpu_pg_mask; #define AMDGPU_WAIT_IDLE_TIMEOUT_IN_MS 3000 #define AMDGPU_MAX_USEC_TIMEOUT 100000 /* 100 ms */ diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c index e1b2fe7..096114e 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c @@ -1213,6 +1213,9 @@ static int amdgpu_early_init(struct amdgpu_device *adev) } } + adev->cg_flags &= amdgpu_cg_mask; + adev->pg_flags &= amdgpu_pg_mask; + return 0; } diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c index e2bf4ef..17bf19b 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c @@ -85,6 +85,8 @@ int amdgpu_powerplay = -1; int amdgpu_powercontainment = 1; unsigned amdgpu_pcie_gen_cap = 0; unsigned amdgpu_pcie_lane_cap = 0; +unsigned amdgpu_cg_mask = 0xffffffff; +unsigned amdgpu_pg_mask = 0xffffffff; MODULE_PARM_DESC(vramlimit, "Restrict VRAM for testing, in megabytes"); module_param_named(vramlimit, amdgpu_vram_limit, int, 0600); @@ -172,6 +174,12 @@ module_param_named(pcie_gen_cap, amdgpu_pcie_gen_cap, uint, 0444); MODULE_PARM_DESC(pcie_lane_cap, "PCIE Lane Caps (0: autodetect (default))"); module_param_named(pcie_lane_cap, amdgpu_pcie_lane_cap, uint, 0444); +MODULE_PARM_DESC(cg_mask, "Clockgating flags mask (0 = disable clock gating)"); +module_param_named(cg_mask, amdgpu_cg_mask, uint, 0444); + +MODULE_PARM_DESC(pg_mask, "Powergating flags mask (0 = disable power gating)"); +module_param_named(pg_mask, amdgpu_pg_mask, uint, 0444); + static const struct pci_device_id pciidlist[] = { #ifdef CONFIG_DRM_AMDGPU_CIK /* Kaveri */ -- 2.5.5

1 3

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

dri-devel June 2016