From 995fbb8653ffecc9a8bb00eb392b113496c80a8e Mon Sep 17 00:00:00 2001 From: handsomeyingyan Date: Sat, 1 May 2021 22:04:05 +0800 Subject: [PATCH 07/17] DRAFT: LS2K Display --- arch/mips/boot/dts/loongson/loongson2k.dts | 1 + drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/loongson/Kconfig | 20 + drivers/gpu/drm/loongson/Makefile | 15 + drivers/gpu/drm/loongson/loongson_connector.c | 201 +++++ drivers/gpu/drm/loongson/loongson_crtc.c | 300 ++++++++ drivers/gpu/drm/loongson/loongson_drv.c | 726 ++++++++++++++++++ drivers/gpu/drm/loongson/loongson_drv.h | 280 +++++++ drivers/gpu/drm/loongson/loongson_encoder.c | 100 +++ drivers/gpu/drm/loongson/loongson_irq.c | 120 +++ drivers/gpu/drm/loongson/loongson_pll.c | 226 ++++++ drivers/gpu/drm/loongson/loongson_vbios.c | 259 +++++++ drivers/gpu/drm/loongson/loongson_vbios.h | 80 ++ 14 files changed, 2331 insertions(+) create mode 100755 drivers/gpu/drm/loongson/Kconfig create mode 100755 drivers/gpu/drm/loongson/Makefile create mode 100755 drivers/gpu/drm/loongson/loongson_connector.c create mode 100644 drivers/gpu/drm/loongson/loongson_crtc.c create mode 100755 drivers/gpu/drm/loongson/loongson_drv.c create mode 100755 drivers/gpu/drm/loongson/loongson_drv.h create mode 100755 drivers/gpu/drm/loongson/loongson_encoder.c create mode 100755 drivers/gpu/drm/loongson/loongson_irq.c create mode 100644 drivers/gpu/drm/loongson/loongson_pll.c create mode 100755 drivers/gpu/drm/loongson/loongson_vbios.c create mode 100755 drivers/gpu/drm/loongson/loongson_vbios.h diff --git a/arch/mips/boot/dts/loongson/loongson2k.dts b/arch/mips/boot/dts/loongson/loongson2k.dts index a6ae83bc6..547112418 100644 --- a/arch/mips/boot/dts/loongson/loongson2k.dts +++ b/arch/mips/boot/dts/loongson/loongson2k.dts @@ -248,6 +248,7 @@ interrupt-parent = <&liointc0>; }; + sata@8,0 { compatible = "pci0014,7a08.0", "pci0014,7a08", diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index ca868271f..7f9833d80 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -392,6 +392,8 @@ source "drivers/gpu/drm/tidss/Kconfig" source "drivers/gpu/drm/xlnx/Kconfig" +source "drivers/gpu/drm/loongson/Kconfig" + # Keep legacy drivers last menuconfig DRM_LEGACY diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 81569009f..cab1296f0 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -123,4 +123,5 @@ obj-$(CONFIG_DRM_PANFROST) += panfrost/ obj-$(CONFIG_DRM_ASPEED_GFX) += aspeed/ obj-$(CONFIG_DRM_MCDE) += mcde/ obj-$(CONFIG_DRM_TIDSS) += tidss/ +obj-$(CONFIG_DRM_LOONGSON) += loongson/ obj-y += xlnx/ diff --git a/drivers/gpu/drm/loongson/Kconfig b/drivers/gpu/drm/loongson/Kconfig new file mode 100755 index 000000000..bfba7fbb3 --- /dev/null +++ b/drivers/gpu/drm/loongson/Kconfig @@ -0,0 +1,20 @@ + +config DRM_LOONGSON + tristate "DRM support for LS2H/LS7A Display Controller" + depends on DRM && PCI + select FB_CFB_FILLRECT + select FB_CFB_COPYAREA + select FB_CFB_IMAGEBLIT + select DRM_KMS_HELPER + select DRM_KMS_FB_HELPER + select DRM_GEM_CMA_HELPER + select DRM_KMS_CMA_HELPER + select DRM_TTM + default MACH_LOONGSON64 + help + Support the display controllers found on the Loongson LS2H/LS7A + bridge. + + This driver provides no built-in acceleration; acceleration is + performed by Vivante GC1000. This driver provides kernel mode + setting and buffer management to userspace. diff --git a/drivers/gpu/drm/loongson/Makefile b/drivers/gpu/drm/loongson/Makefile new file mode 100755 index 000000000..b427f41fd --- /dev/null +++ b/drivers/gpu/drm/loongson/Makefile @@ -0,0 +1,15 @@ +# +# Makefile for the drm device driver. This driver provides support for the +# Direct Rendering Infrastructure (DRI) +# + +ccflags-y := -Iinclude/drm +loongson-y := loongson_drv.o \ + loongson_irq.o \ + loongson_encoder.o \ + loongson_crtc.o \ + loongson_connector.o \ + loongson_pll.o \ + loongson_vbios.o + +obj-$(CONFIG_DRM_LOONGSON) += loongson.o diff --git a/drivers/gpu/drm/loongson/loongson_connector.c b/drivers/gpu/drm/loongson/loongson_connector.c new file mode 100755 index 000000000..118433c8f --- /dev/null +++ b/drivers/gpu/drm/loongson/loongson_connector.c @@ -0,0 +1,201 @@ +/* + * Copyright (c) 2018 Loongson Technology Co., Ltd. + * Authors: + * Chen Zhu + * Yaling Fang + * Dandan Zhang + * Huacai Chen + * 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 +#include +#include +#include +#include +#include +//#include +#include + +#include "loongson_drv.h" + +#define DVO_I2C_NAME "loongson_dvo_i2c" +#define adapter_to_i2c_client(d) container_of(d, struct i2c_client, adapter) + +static struct eep_info{ + struct i2c_adapter *adapter; + unsigned short addr; +}eeprom_info[2]; + +static DEFINE_MUTEX(edid_lock); +struct i2c_client *loongson_drm_i2c_client[2]; + +/** + * loongson_connector_best_encoder + * + * @connector: point to the drm_connector structure + * + * Select the best encoder for the given connector. Used by both the helpers in + * drm_atomic_helper_check_modeset() and legacy CRTC helpers + */ +static struct drm_encoder *loongson_connector_best_encoder(struct drm_connector + *connector) +{ + int enc_id = drm_connector_index(connector); + /* pick the encoder ids */ + if (enc_id) + return drm_encoder_find(connector->dev, NULL, enc_id); + return NULL; +} + + +/** + * loongson_vga_get_modes + * + * @connetcor: central DRM connector control structure + * + * Fill in all modes currently valid for the sink into the connector->probed_modes list. + * It should also update the EDID property by calling drm_connector_update_edid_property(). + */ +static int loongson_vga_get_modes(struct drm_connector *connector) +{ + int ret; + if(drm_connector_index(connector) == 0){ + ret = drm_add_modes_noedid(connector, 1024, 768); + drm_set_preferred_mode(connector, 1024, 768); + } else { + ret = drm_add_modes_noedid(connector, 1024, 768); + drm_set_preferred_mode(connector, 1024, 768); + } + return ret; +} + +/** + * loongson_i2c_create + * + * @dev: point to drm_device structure + * + * Create i2c adapter + */ +struct loongson_i2c_chan *loongson_i2c_create(struct drm_device *dev) +{ + int ret, data, clock; + struct loongson_i2c_chan *i2c; + struct loongson_drm_device *ldev = dev->dev_private; + + return i2c; +} + +/** + * loongson_i2c_destroy + * + * @i2c: point to loongson_i2c_chan + * + * Destroy i2c adapter + */ +void loongson_i2c_destroy(struct loongson_i2c_chan *i2c) +{ + if (!i2c) + return; + i2c_del_adapter(&i2c->adapter); + kfree(i2c); +} + +/** + * loongson_vga_detect + * + * @connector: point to drm_connector + * @force: bool + * + * Check to see if anything is attached to the connector. + * The parameter force is set to false whilst polling, + * true when checking the connector due to a user request + */ +static enum drm_connector_status loongson_vga_detect(struct drm_connector + *connector, bool force) +{ + if (drm_connector_index(connector) == 0) + return connector_status_connected; + return connector_status_disconnected; +} + + +/** + * loongson_connector_destroy + * + * @connector: point to the drm_connector structure + * + * Clean up connector resources + */ +static void loongson_connector_destroy(struct drm_connector *connector) +{ + struct loongson_connector *loongson_connector = to_loongson_connector(connector); + drm_connector_cleanup(connector); + kfree(connector); +} + + +/** + * These provide the minimum set of functions required to handle a connector + * + * Helper operations for connectors.These functions are used + * by the atomic and legacy modeset helpers and by the probe helpers. + */ +static const struct drm_connector_helper_funcs loongson_vga_connector_helper_funcs = { + .get_modes = loongson_vga_get_modes, +}; + +/** + * These provide the minimum set of functions required to handle a connector + * + * Control connectors on a given device. + * The functions below allow the core DRM code to control connectors, + * enumerate available modes and so on. + */ +static const struct drm_connector_funcs loongson_vga_connector_funcs = { +// .dpms = drm_helper_connector_dpms, + .detect = loongson_vga_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = drm_connector_cleanup, + .reset = drm_atomic_helper_connector_reset, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +/** + * loongson_vga_init + * + * @dev: drm device + * @connector_id: + * + * Vga is the interface between host and monitor + * This function is to init vga + */ +struct drm_connector *loongson_vga_init(struct drm_device *dev, unsigned int connector_id) +{ + struct i2c_adapter *i2c_adap; + struct i2c_board_info i2c_info; + struct drm_connector *connector; + struct loongson_connector *loongson_connector; + struct loongson_drm_device *ldev = (struct loongson_drm_device*)dev->dev_private; + + loongson_connector = kzalloc(sizeof(struct loongson_connector), GFP_KERNEL); + if (!loongson_connector) + return NULL; + + pr_info("Connector INIT ID: %d\n", connector_id); + + connector = &loongson_connector->base; + + drm_connector_helper_add(connector, &loongson_vga_connector_helper_funcs); + + drm_connector_init(dev, connector, + &loongson_vga_connector_funcs, DRM_MODE_CONNECTOR_VGA); + + drm_connector_register(connector); + + return connector; +} diff --git a/drivers/gpu/drm/loongson/loongson_crtc.c b/drivers/gpu/drm/loongson/loongson_crtc.c new file mode 100644 index 000000000..469091320 --- /dev/null +++ b/drivers/gpu/drm/loongson/loongson_crtc.c @@ -0,0 +1,300 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2019 Lemote Inc. + * Authors: + * Jiaxun Yang + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "loongson_drv.h" + +static const uint32_t loongson_primary_formats[] = { + DRM_FORMAT_RGB565, + DRM_FORMAT_RGB888, + DRM_FORMAT_XRGB8888, + DRM_FORMAT_ARGB8888, +}; + +static const uint64_t loongson_format_modifiers[] = { + DRM_FORMAT_MOD_LINEAR, + DRM_FORMAT_MOD_INVALID +}; + +static int loongson_crtc_enable_vblank(struct drm_crtc *crtc) { + struct loongson_crtc *lcrtc = to_loongson_crtc(crtc); + struct loongson_drm_device *ldev = lcrtc->ldev; + + if(lcrtc->crtc_id == 0) { + ldev->int_reg |= (BIT(LS_INT_DVO0_FB_END) << 16); + } else { + ldev->int_reg |= (BIT(LS_INT_DVO1_FB_END) << 16); + } + + writel(ldev->int_reg, ldev->rmmio + LS_FB_INT_REG); + + return 0; +} + +static void loongson_crtc_disable_vblank(struct drm_crtc *crtc) { + struct loongson_crtc *lcrtc = to_loongson_crtc(crtc); + struct loongson_drm_device *ldev = lcrtc->ldev; + + if(lcrtc->crtc_id == 0) { + ldev->int_reg &= (~BIT(LS_INT_DVO0_VSYNC) << 16); + } else { + ldev->int_reg &= (~BIT(LS_INT_DVO1_VSYNC) << 16); + } + + writel(ldev->int_reg, ldev->rmmio + LS_FB_INT_REG); + +} + +static const struct drm_crtc_funcs loongson_crtc_funcs = { + .destroy = drm_crtc_cleanup, + .set_config = drm_atomic_helper_set_config, + .page_flip = drm_atomic_helper_page_flip, + .reset = drm_atomic_helper_crtc_reset, + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, + .enable_vblank = loongson_crtc_enable_vblank, + .disable_vblank = loongson_crtc_disable_vblank, +}; + +static enum drm_mode_status loongson_crtc_mode_valid(struct drm_crtc *crtc, + const struct drm_display_mode *mode) +{ + if(mode->hdisplay % 16) + return MODE_BAD; + + return MODE_OK; +} + +u32 ls_crtc_read(struct loongson_crtc *lcrtc, u32 offset) +{ + struct loongson_drm_device *ldev = lcrtc->ldev; +// pr_err("ls_read: %lx", ldev->rmmio + offset + (lcrtc->crtc_id * REG_OFF)); + return readl(ldev->rmmio + offset + (lcrtc->crtc_id * REG_OFF)); + return 0; +} + +void ls_crtc_write(struct loongson_crtc *lcrtc, u32 offset, u32 val) +{ + struct loongson_drm_device *ldev = lcrtc->ldev; +// pr_err("ls_write: %lx, %lx", ldev->rmmio + offset + (lcrtc->crtc_id * REG_OFF), val); + writel(val, ldev->rmmio + offset + (lcrtc->crtc_id * REG_OFF)); +} + +static void loongson_crtc_mode_set_nofb(struct drm_crtc *crtc) +{ + struct loongson_crtc *lcrtc = to_loongson_crtc(crtc); + struct drm_display_mode *mode = &crtc->state->adjusted_mode; + + + unsigned int hr, hss, hse, hfl; + unsigned int vr, vss, vse, vfl; + unsigned int width, height; + unsigned int crtc_id, pix_freq; + + hr = mode->hdisplay; + hss = mode->hsync_start; + hse = mode->hsync_end; + hfl = mode->htotal; + + vr = mode->vdisplay; + vss = mode->vsync_start; + vse = mode->vsync_end; + vfl = mode->vtotal; + + pix_freq = mode->clock; + + +// pr_info("fb width = %d, height = %d\n", width, height); + pr_info("crtc_id = %d, hr = %d, hss = %d, hse = %d, hfl = %d, vr = %d, vss = %d, vse = %d, vfl = %d, pix_freq = %d,\n", + lcrtc->crtc_id, hr, hss, hse, hfl, vr, vss, vse, vfl, pix_freq); + + spin_lock_irq(&loongson_reglock); + ls_crtc_write(lcrtc, LS_FB_DITCFG_DVO0_REG, 0); + ls_crtc_write(lcrtc, LS_FB_DITTAB_LO_DVO0_REG, 0); + ls_crtc_write(lcrtc, LS_FB_DITTAB_HI_DVO0_REG, 0); + ls_crtc_write(lcrtc, LS_FB_PANCFG_DVO0_REG, 0x80001311); + ls_crtc_write(lcrtc, LS_FB_PANTIM_DVO0_REG, 0); + + ls_crtc_write(lcrtc, LS_FB_HDISPLAY_DVO0_REG, (mode->crtc_htotal << 16) | mode->crtc_hdisplay); + ls_crtc_write(lcrtc, LS_FB_HSYNC_DVO0_REG, 0x40000000 | (mode->crtc_hsync_end << 16) | mode->crtc_hsync_start); + + ls_crtc_write(lcrtc, LS_FB_VDISPLAY_DVO0_REG, (mode->crtc_vtotal << 16) | mode->crtc_vdisplay); + ls_crtc_write(lcrtc, LS_FB_VSYNC_DVO0_REG, 0x40000000 | (mode->crtc_vsync_end << 16) | mode->crtc_vsync_start); + + ls_crtc_write(lcrtc, LS_FB_STRI_DVO0_REG, (crtc->primary->state->fb->pitches[0] + 255) & ~255); + + pr_info("stride: %x",(crtc->primary->state->fb->pitches[0] + 255) & ~255); + + + switch (crtc->primary->state->fb->format->format) { + case DRM_FORMAT_RGB565: + pr_info("16bit"); + lcrtc->cfg_reg |= 0x3; + break; + case DRM_FORMAT_RGB888: + default: + pr_info("24/32bit"); + lcrtc->cfg_reg |= 0x4; + break; + } + spin_unlock_irq(&loongson_reglock); + + ls_config_pll(lcrtc->crtc_id, mode->clock); +} + +static void loongson_crtc_atomic_enable(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) +{ + struct loongson_crtc *lcrtc = to_loongson_crtc(crtc); + + lcrtc->cfg_reg |= CFG_ENABLE; + + spin_lock_irq(&loongson_reglock); + ls_crtc_write(lcrtc, LS_FB_CFG_DVO0_REG, 0x0); + mdelay(100); + ls_crtc_write(lcrtc, LS_FB_CFG_DVO0_REG, lcrtc->cfg_reg); + mdelay(10); + spin_unlock_irq(&loongson_reglock); + + drm_crtc_vblank_on(crtc); +} + +static void loongson_crtc_atomic_disable(struct drm_crtc *crtc, + struct drm_crtc_state *old_state) +{ + struct loongson_crtc *lcrtc = to_loongson_crtc(crtc); + + lcrtc->cfg_reg &= ~CFG_ENABLE; + spin_lock_irq(&loongson_reglock); +// ls_crtc_write(lcrtc, LS_FB_CFG_DVO0_REG, lcrtc->cfg_reg); + ls_crtc_write(lcrtc, LS_FB_CFG_DVO0_REG, 0x0); + spin_unlock_irq(&loongson_reglock); + + spin_lock_irq(&crtc->dev->event_lock); + if (crtc->state->event) { + drm_crtc_send_vblank_event(crtc, crtc->state->event); + crtc->state->event = NULL; + } + spin_unlock_irq(&crtc->dev->event_lock); + + drm_crtc_vblank_off(crtc); +} + +static void loongson_crtc_atomic_flush(struct drm_crtc *crtc, + struct drm_crtc_state *old_crtc_state) +{ + struct loongson_crtc *lcrtc = to_loongson_crtc(crtc); + struct drm_pending_vblank_event *event = crtc->state->event; + + if (event) { + crtc->state->event = NULL; + + spin_lock_irq(&crtc->dev->event_lock); + if (drm_crtc_vblank_get(crtc) == 0) + drm_crtc_arm_vblank_event(crtc, event); + else + drm_crtc_send_vblank_event(crtc, event); + spin_unlock_irq(&crtc->dev->event_lock); + } +} + + +static const struct drm_crtc_helper_funcs loongson_crtc_helper_funcs = { + .mode_valid = loongson_crtc_mode_valid, + .mode_set_nofb = loongson_crtc_mode_set_nofb, + .atomic_enable = loongson_crtc_atomic_enable, + .atomic_disable = loongson_crtc_atomic_disable, + .atomic_flush = loongson_crtc_atomic_flush, +}; + +static void loongson_plane_atomic_update(struct drm_plane *plane, + struct drm_plane_state *old_state) +{ + struct loongson_crtc *lcrtc; + + if (!plane->state->crtc || !plane->state->fb) + return; + + lcrtc = to_loongson_crtc(plane->state->crtc); + spin_lock_irq(&loongson_reglock); + if(old_state->fb){ + if(old_state->fb->pitches[0] != plane->state->fb->pitches[0]) + ls_crtc_write(lcrtc, LS_FB_STRI_DVO0_REG, plane->state->fb->pitches[0]); + } else { +// ls_crtc_write(lcrtc, LS_FB_STRI_DVO0_REG, plane->state->fb->pitches[0]); + } + if(((ls_crtc_read(lcrtc, LS_FB_CFG_DVO0_REG) & CFG_FBNUM) >> CFG_FBNUM_BIT) == 1) { + ls_crtc_write(lcrtc, LS_FB_ADDR0_DVO0_REG, drm_fb_cma_get_gem_addr(plane->state->fb, plane->state, 0)); + } else { + ls_crtc_write(lcrtc, LS_FB_ADDR1_DVO0_REG, drm_fb_cma_get_gem_addr(plane->state->fb, plane->state, 0)); + } + ls_crtc_write(lcrtc, LS_FB_CFG_DVO0_REG, lcrtc->cfg_reg | CFG_FBSWITCH); + spin_unlock_irq(&loongson_reglock); +} + +static const struct drm_plane_helper_funcs loongson_plane_helper_funcs = { + .atomic_update = loongson_plane_atomic_update, +}; + +static void loongson_plane_destroy(struct drm_plane *plane) +{ + drm_plane_cleanup(plane); +} + + +static const struct drm_plane_funcs loongson_plane_funcs = { + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, + .destroy = loongson_plane_destroy, + .disable_plane = drm_atomic_helper_disable_plane, + .reset = drm_atomic_helper_plane_reset, + .update_plane = drm_atomic_helper_update_plane, +}; + +void loongson_crtc_init(struct loongson_drm_device *ldev) +{ + struct loongson_crtc *ls_crtc; + int i, ret; + + for(i=0;ivbios->crtc_num;i++){ + ldev->lcrtc[i].ldev = ldev; + ldev->lcrtc[i].crtc_id = i; + ldev->lcrtc[i].cfg_reg = CFG_RESET; + + ls_crtc_write(&ldev->lcrtc[i], LS_FB_CFG_DVO0_REG, CFG_RESET); + + pr_info("init crtc"); + + ldev->lcrtc[i].primary = devm_kzalloc(ldev->dev->dev, sizeof(*ldev->lcrtc[i].primary), GFP_KERNEL); + if (!ldev->lcrtc[i].primary) + return; + + ret = drm_universal_plane_init(ldev->dev, ldev->lcrtc[i].primary, BIT(i), &loongson_plane_funcs, + loongson_primary_formats, + ARRAY_SIZE(loongson_primary_formats), + loongson_format_modifiers, + DRM_PLANE_TYPE_PRIMARY, NULL); + if(ret) + return; + drm_plane_helper_add(ldev->lcrtc[i].primary, &loongson_plane_helper_funcs); + + ret = drm_crtc_init_with_planes(ldev->dev, &ldev->lcrtc[i].base,ldev->lcrtc[i].primary, NULL, + &loongson_crtc_funcs, NULL); + if (ret) { + loongson_plane_destroy(ldev->lcrtc[i].primary); + return; + } + drm_crtc_helper_add(&ldev->lcrtc[i].base, &loongson_crtc_helper_funcs); + } +} diff --git a/drivers/gpu/drm/loongson/loongson_drv.c b/drivers/gpu/drm/loongson/loongson_drv.c new file mode 100755 index 000000000..4524baa63 --- /dev/null +++ b/drivers/gpu/drm/loongson/loongson_drv.c @@ -0,0 +1,726 @@ +/* + * Copyright (c) 2018 Loongson Technology Co., Ltd. + * Authors: + * Chen Zhu + * Yaling Fang + * Dandan Zhang + * Huacai Chen + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +//#include +#include +#include +#include "loongson_drv.h" + +#define DEVICE_NAME "loongson-drm" +#define DRIVER_NAME "loongson-drm" +#define DRIVER_DESC "Loongson DRM Driver" +#define DRIVER_DATE "20190705" +#define DRIVER_MAJOR 1 +#define DRIVER_MINOR 0 +#define DRIVER_PATCHLEVEL 0 + +static bool poll_connector = false; +module_param_named(poll, poll_connector, bool, 0600); + +DEFINE_SPINLOCK(loongson_reglock); + +static void loongson_output_poll_changed(struct drm_device *dev) +{ + struct loongson_drm_device *ldev = dev->dev_private; +// loongson_fb_output_poll_changed(ldev); +} + +/** + * loongson_mode_funcs---basic driver provided mode setting functions + * + * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that + * involve drivers. + */ +static const struct drm_mode_config_funcs loongson_mode_funcs = { + .fb_create = drm_gem_fb_create, + .atomic_check = drm_atomic_helper_check, + .atomic_commit = drm_atomic_helper_commit, + .output_poll_changed = loongson_output_poll_changed +}; + +/** + * loongson_drm_device_init ----init drm device + * + * @dev pointer to drm_device structure + * @flags start up flag + * + * RETURN + * drm device init result + */ +static int loongson_drm_device_init(struct drm_device *dev, uint32_t flags) +{ + int ret; + struct loongson_drm_device *ldev = dev->dev_private; + + loongson_vbios_init(ldev); + ldev->num_crtc = ldev->vbios->crtc_num; + ldev->fb_vram_base = 0x0; + + if (ldev->dev->pdev) { + /*BAR 0 contains registers */ + ldev->rmmio_base = pci_resource_start(ldev->dev->pdev, 0); + ldev->rmmio_size = pci_resource_len(ldev->dev->pdev, 0); + + ldev->rmmio = pcim_iomap(dev->pdev, 0, 0); + if (ldev->rmmio == NULL) + return -ENOMEM; + } else { + struct resource *res; + + res = platform_get_resource(to_platform_device(dev->dev), IORESOURCE_MEM, 0); + + ldev->rmmio_base = res->start; + ldev->rmmio_size = resource_size(res); + + ldev->rmmio = ioremap(ldev->rmmio_base, ldev->rmmio_size); + if (ldev->rmmio == NULL) + return -ENOMEM; + } + + DRM_INFO("ldev->rmmio_base = 0x%llx, ldev->rmmio_size = 0x%llx\n", + ldev->rmmio_base, ldev->rmmio_size); + + if (!devm_request_mem_region(ldev->dev->dev, ldev->rmmio_base, ldev->rmmio_size, + "loongson_drmfb_mmio")) { + DRM_ERROR("Can't reserve mmio registers\n"); + return -ENOMEM; + } + + return 0; +} + +/** + * loongson_modeset_init --- init kernel mode setting + * + * @ldev: pointer to loongson_drm_device structure + * + * RETURN + * return init result + */ +int loongson_modeset_init(struct loongson_drm_device *ldev) +{ + struct drm_encoder *encoder; + struct drm_connector *connector; + int ret,i; + + + ldev->mode_info[0].mode_config_initialized = true; + ldev->mode_info[1].mode_config_initialized = true; + + ldev->dev->mode_config.max_width = LOONGSON_MAX_FB_WIDTH; + ldev->dev->mode_config.max_height = LOONGSON_MAX_FB_HEIGHT; + + ldev->dev->mode_config.cursor_width = 32; + ldev->dev->mode_config.cursor_height = 32; + + ldev->dev->mode_config.allow_fb_modifiers = true; + ldev->dev->mode_config.fb_base = ldev->mc.vram_base; + + loongson_crtc_init(ldev); + ldev->num_crtc = ldev->vbios->crtc_num; + + for (i=0; inum_crtc; i++) { + DRM_DEBUG("loongson drm encoder init\n"); + ldev->mode_info[i].crtc = &ldev->lcrtc[i]; + encoder = loongson_encoder_init(ldev, ldev->dev, i); + to_loongson_encoder(encoder)->lcrtc = &ldev->lcrtc[i]; + if (!encoder) { + DRM_ERROR("loongson_encoder_init failed\n"); + return -1; + } + + DRM_DEBUG("loongson drm i2c init\n"); + connector = loongson_vga_init(ldev->dev, i); + if (!connector) { + DRM_ERROR("loongson_vga_init failed\n"); + return -1; + } + + ldev->mode_info[i].connector = to_loongson_connector(connector); + drm_connector_attach_encoder(connector, encoder); + if (poll_connector) + connector->polled = DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT; + } + + return 0; +} + +/** + * loongson_modeset_fini --- deinit kernel mode setting + * + * @ldev: pointer to loongson_drm_device structure + * + * RETURN + */ +void loongson_modeset_fini(struct loongson_drm_device *ldev) +{ +} + +/** + * loongson_vga_load - setup chip and create an initial config + * @dev: DRM device + * @flags: startup flags + * + * The driver load routine has to do several things: + * - initialize the memory manager + * - allocate initial config memory + * - setup the DRM framebuffer with the allocated memory + */ +static int loongson_drm_load(struct drm_device *dev, unsigned long flags) +{ + int r, ret, irq; + struct loongson_drm_device *ldev; + + dma_set_mask_and_coherent(dev->dev, DMA_BIT_MASK(32)); + + ldev = devm_kzalloc(dev->dev, sizeof(struct loongson_drm_device), GFP_KERNEL); + if (ldev == NULL) + return -ENOMEM; + dev->dev_private = (void *)ldev; + ldev->dev = dev; + + ret = loongson_drm_device_init(dev, flags); + DRM_DEBUG("end loongson drm device init.\n"); + + drm_mode_config_init(dev); + dev->mode_config.funcs = (void *)&loongson_mode_funcs; + dev->mode_config.preferred_depth = 24; + dev->mode_config.prefer_shadow = 1; + + if (dev->pdev) { + irq = dev->pdev->irq; + pci_set_drvdata(dev->pdev, dev); + vga_set_default_device(dev->pdev); + } else { + irq = platform_get_irq(to_platform_device(dev->dev), 0); + platform_set_drvdata(to_platform_device(dev->dev), dev); + } + dev_set_drvdata(dev->dev, dev); + + r = drm_irq_install(dev, irq); + if (r) + dev_err(dev->dev, "Fatal error during irq install: %d\n", r); + + r = loongson_modeset_init(ldev); + if (r) + dev_err(dev->dev, "Fatal error during modeset init: %d\n", r); + + ldev->inited = true; + drm_mode_config_reset(dev); + + r = drm_vblank_init(dev, ldev->num_crtc); + if (r) + dev_err(dev->dev, "Fatal error during vblank init: %d\n", r); + + /* Make small buffers to store a hardware cursor (double buffered icon updates) */ + ldev->cursor = drm_gem_cma_create(dev, roundup(32*32*4, PAGE_SIZE)); + + drm_kms_helper_poll_init(dev); + + return 0; +} + +/** + * loongson_drm_unload--release drm resource + * + * @dev: pointer to drm_device + * + */ +static void loongson_drm_unload(struct drm_device *dev) +{ + struct loongson_drm_device *ldev = dev->dev_private; + + if (ldev == NULL) + return; + + loongson_modeset_fini(ldev); + drm_mode_config_cleanup(dev); + dev->dev_private = NULL; + dev_set_drvdata(dev->dev, NULL); + ldev->inited = false; + + return; +} + +/** + * loongson_drm_open -Driver callback when a new struct drm_file is opened. + * Useful for setting up driver-private data structures like buffer allocators, + * execution contexts or similar things. + * + * @dev DRM device + * @file DRM file private date + * + * RETURN + * 0 on success, a negative error code on failure, which will be promoted to + * userspace as the result of the open() system call. + */ +static int loongson_drm_open(struct drm_device *dev, struct drm_file *file) +{ + file->driver_priv = NULL; + + DRM_DEBUG("open: dev=%p, file=%p", dev, file); + + return 0; +} + +DEFINE_DRM_GEM_CMA_FOPS(fops); + +/** + * loongson_drm_driver - DRM device structure + * + * .load: driver callback to complete initialization steps after the driver is registered + * .unload:Reverse the effects of the driver load callback + * .open:Driver callback when a new struct drm_file is opened + * .fops:File operations for the DRM device node. + * .gem_free_object:deconstructor for drm_gem_objects + * .dumb_create:This creates a new dumb buffer in the driver’s backing storage manager + * (GEM, TTM or something else entirely) and returns the resulting buffer handle. + * This handle can then be wrapped up into a framebuffer modeset object + * .dumb_map_offset:Allocate an offset in the drm device node’s address space + * to be able to memory map a dumb buffer + * .dump_destory:This destroys the userspace handle for the given dumb backing storage buffer + */ +static struct drm_driver loongson_drm_driver = { + .driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_HAVE_IRQ | DRIVER_ATOMIC, + .open = loongson_drm_open, + .fops = &fops, + + .dumb_create = drm_gem_cma_dumb_create, + .gem_free_object_unlocked = drm_gem_cma_free_object, + .gem_vm_ops = &drm_gem_cma_vm_ops, + + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, + + .gem_prime_import = drm_gem_prime_import, + .gem_prime_export = drm_gem_prime_export, + + .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, + .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, + .gem_prime_vmap = drm_gem_cma_prime_vmap, + .gem_prime_vunmap = drm_gem_cma_prime_vunmap, + .gem_prime_mmap = drm_gem_cma_prime_mmap, + + .irq_handler = loongson_irq_handler, + .irq_preinstall = loongson_irq_preinstall, + .irq_postinstall = loongson_irq_postinstall, + .irq_uninstall = loongson_irq_uninstall, + .name = DRIVER_NAME, + .desc = DRIVER_DESC, + .date = DRIVER_DATE, + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, + .patchlevel = DRIVER_PATCHLEVEL, +}; + +/** + * loongson_drm_pci_devices -- pci device id info + * + * __u32 vendor, device Vendor and device ID or PCI_ANY_ID + * __u32 subvendor, subdevice Subsystem ID's or PCI_ANY_ID + * __u32 class, class_mask (class,subclass,prog-if) triplet + * kernel_ulong_t driver_data Data private to the driver + */ +static struct pci_device_id loongson_drm_pci_devices[] = { + {PCI_DEVICE(PCI_VENDOR_ID_LOONGSON, PCI_DEVICE_ID_LOONGSON_DC)}, + {0, 0, 0, 0, 0, 0, 0} +}; + +/** + * loongson_drm_pci_register -- add pci device + * + * @pdev PCI device + * @ent pci device id + */ +static int loongson_drm_pci_register(struct pci_dev *pdev, + const struct pci_device_id *ent) + +{ + int ret; + struct drm_device *dev; + + dev = drm_dev_alloc(&loongson_drm_driver, &pdev->dev); + if (IS_ERR(dev)) + return PTR_ERR(dev); + + dev->pdev = pdev; + + loongson_drm_load(dev, 0x0); + + ret = drm_dev_register(dev, 0); + if (ret) + goto err_free; + + drm_fbdev_generic_setup(dev, 32); + + return 0; + +err_free: + drm_dev_put(dev); + return ret; +} + +/** + * loongson_drm_pci_unregister -- release drm device + * + * @pdev PCI device + */ +static void loongson_drm_pci_unregister(struct pci_dev *pdev) +{ + struct drm_device *dev = pci_get_drvdata(pdev); + loongson_drm_unload(dev); + drm_dev_put(dev); +} + +static int loongson_drm_plat_register(struct platform_device *pdev) + +{ + int ret; + struct drm_device *dev; + + dev = drm_dev_alloc(&loongson_drm_driver, &pdev->dev); + if (IS_ERR(dev)) + return PTR_ERR(dev); + + loongson_drm_load(dev, 0x0); + + ret = drm_dev_register(dev, 0); + if (ret) + goto err_free; + + drm_fbdev_generic_setup(dev, 32); + + return 0; + +err_free: + drm_dev_put(dev); + return ret; +} + +static int loongson_drm_plat_unregister(struct platform_device *pdev) +{ + struct drm_device *dev = platform_get_drvdata(pdev); + loongson_drm_unload(dev); + drm_dev_put(dev); + + return 0; +} + +/* + * Suspend & resume. + */ +/* + * loongson_drm_suspend - initiate device suspend + * + * @pdev: drm dev pointer + * @state: suspend state + * + * Puts the hw in the suspend state (all asics). + * Returns 0 for success or an error on failure. + * Called at driver suspend. + */ +int loongson_drm_suspend(struct drm_device *dev, bool suspend, bool fbcon) +{ + int i, r; + struct drm_crtc *crtc; + struct drm_connector *connector; + struct loongson_drm_device *ldev; + + if (dev == NULL || dev->dev_private == NULL) { + return -ENODEV; + } + + ldev = dev->dev_private; + + drm_kms_helper_poll_disable(dev); + + drm_modeset_lock_all(dev); + /* turn off display hw */ + list_for_each_entry(connector, &dev->mode_config.connector_list, head) { + drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF); + } + drm_modeset_unlock_all(dev); + if (dev->pdev) { + pci_save_state(dev->pdev); + if (suspend) { + /* Shut down the device */ + pci_disable_device(dev->pdev); + pci_set_power_state(dev->pdev, PCI_D3hot); + } + } + + return 0; +} + +/* + * * loongson_drm_resume - initiate device suspend + * + * @pdev: drm dev pointer + * @state: suspend state + * + * Puts the hw in the suspend state (all asics). + * Returns 0 for success or an error on failure. + * Called at driver suspend. + */ + +int loongson_drm_resume(struct drm_device *dev, bool resume, bool fbcon) +{ + int r; + struct drm_crtc *crtc; + struct drm_connector *connector; + struct loongson_drm_device *ldev = dev->dev_private; + + if (fbcon) + console_lock(); + + if (resume && dev->pdev) { + pci_set_power_state(dev->pdev, PCI_D0); + pci_restore_state(dev->pdev); + if (pci_enable_device(dev->pdev)) { + if (fbcon) + console_unlock(); + return -1; + } + } + + /* blat the mode back in */ + if (fbcon) { + drm_helper_resume_force_mode(dev); + /* turn on display hw */ + drm_modeset_lock_all(dev); + list_for_each_entry(connector, &dev->mode_config.connector_list, head) { + drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON); + } + drm_modeset_unlock_all(dev); + } + + drm_kms_helper_poll_enable(dev); + + return 0; +} + +/** + * loongson_drm_pm_suspend + * + * @dev pointer to the device + * + * Executed before putting the system into a sleep state in which the + * contents of main memory are preserved. + */ +static int loongson_drm_pm_suspend(struct device *dev) +{ + struct drm_device *drm_dev = dev_get_drvdata(dev); + + DRM_DEBUG("loongson_drm_pm_suspend"); + return loongson_drm_suspend(drm_dev, true, true); +} + +/** + * loongson_drm_pm_resume + * + * @dev pointer to the device + * + * Executed after waking the system up from a sleep state in which the + * contents of main memory were preserved. + */ +static int loongson_drm_pm_resume(struct device *dev) +{ + struct drm_device *drm_dev = dev_get_drvdata(dev); + + DRM_DEBUG("loongson_drm_pm_resume"); + return loongson_drm_resume(drm_dev, true, true); +} + +/** + * loongson_drm_pm_freeze + * + * @dev pointer to device + * + * Hibernation-specific, executed before creating a hibernation image. + * Analogous to @suspend(), but it should not enable the device to signal + * wakeup events or change its power state. + */ +static int loongson_drm_pm_freeze(struct device *dev) +{ + struct drm_device *drm_dev = dev_get_drvdata(dev); + + DRM_DEBUG("loongson_drm_pm_freeze"); + return loongson_drm_suspend(drm_dev, false, true); +} + +/** + * loongson_drm_pm_draw + * + * @dev pointer to device + * + * Hibernation-specific, executed after creating a hibernation image OR + * if the creation of an image has failed. Also executed after a failing + * attempt to restore the contents of main memory from such an image. + * Undo the changes made by the preceding @freeze(), so the device can be + * operated in the same way as immediately before the call to @freeze(). + */ +static int loongson_drm_pm_thaw(struct device *dev) +{ + struct drm_device *drm_dev = dev_get_drvdata(dev); + + DRM_DEBUG("loongson_drm_pm_thaw"); + return loongson_drm_resume(drm_dev, false, true); +} + +/** + * loongson_drm_pm_restore + * + * @dev pointer to device + * + * Hibernation-specific, executed after restoring the contents of main + * memory from a hibernation image, analogous to @resume() + */ +static int loongson_drm_pm_restore(struct device *dev) +{ + struct drm_device *drm_dev = dev_get_drvdata(dev); + + DRM_DEBUG("loongson_drm_pm_restore"); + return loongson_drm_resume(drm_dev, true, true); +} + +/* + * * struct dev_pm_ops - device PM callbacks + * + *@suspend: Executed before putting the system into a sleep state in which the + * contents of main memory are preserved. + *@resume: Executed after waking the system up from a sleep state in which the + * contents of main memory were preserved. + *@freeze: Hibernation-specific, executed before creating a hibernation image. + * Analogous to @suspend(), but it should not enable the device to signal + * wakeup events or change its power state. The majority of subsystems + * (with the notable exception of the PCI bus type) expect the driver-level + * @freeze() to save the device settings in memory to be used by @restore() + * during the subsequent resume from hibernation. + *@thaw: Hibernation-specific, executed after creating a hibernation image OR + * if the creation of an image has failed. Also executed after a failing + * attempt to restore the contents of main memory from such an image. + * Undo the changes made by the preceding @freeze(), so the device can be + * operated in the same way as immediately before the call to @freeze(). + *@poweroff: Hibernation-specific, executed after saving a hibernation image. + * Analogous to @suspend(), but it need not save the device's settings in + * memory. + *@restore: Hibernation-specific, executed after restoring the contents of main + * memory from a hibernation image, analogous to @resume(). + */ +static const struct dev_pm_ops loongson_drm_pm_ops = { + .suspend = loongson_drm_pm_suspend, + .resume = loongson_drm_pm_resume, + .freeze = loongson_drm_pm_freeze, + .thaw = loongson_drm_pm_thaw, + .poweroff = loongson_drm_pm_freeze, + .restore = loongson_drm_pm_restore, +}; + + +/** + * loongson_drm_pci_driver -- pci driver structure + * + * .id_table : must be non-NULL for probe to be called + * .probe: New device inserted + * .remove: Device removed + * .resume: Device suspended + * .suspend: Device woken up + */ +static struct pci_driver loongson_drm_pci_driver = { + .name = DRIVER_NAME, + .id_table = loongson_drm_pci_devices, + .probe = loongson_drm_pci_register, + .remove = loongson_drm_pci_unregister, + .driver.pm = &loongson_drm_pm_ops, +}; + +#ifdef CONFIG_OF +static struct of_device_id loongson_drm_ids[] = { + { .compatible = "loongson,ls2h-drmfb", }, +}; +#endif + +static struct platform_driver loongson_drm_plat_driver = { + .probe = loongson_drm_plat_register, + .remove = loongson_drm_plat_unregister, + .driver = { + .name = DRIVER_NAME, + .pm = &loongson_drm_pm_ops, +#ifdef CONFIG_OF + .of_match_table = of_match_ptr(loongson_drm_ids), +#endif + }, +}; + +/** + * loongson_drm_pci_init() -- kernel module init function + */ +static int __init loongson_drm_init(void) +{ + int ret; + struct pci_dev *pdev = NULL; + + /* If external graphics card exist, use it as default */ + while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev))) { + if (pdev->vendor == PCI_VENDOR_ID_ATI) + return 0; + if (pdev->vendor == 0x1a03) /* ASpeed */ + return 0; + } + + ret = pci_register_driver(&loongson_drm_pci_driver); + if (ret < 0) + return ret; + + ret = platform_driver_register(&loongson_drm_plat_driver); + + return ret; +} + +/** + * loongson_drm_pci_exit() -- kernel module exit function + */ +static void __exit loongson_drm_exit(void) +{ + pci_unregister_driver(&loongson_drm_pci_driver); + platform_driver_unregister(&loongson_drm_plat_driver); +} + +module_init(loongson_drm_init); +module_exit(loongson_drm_exit); + +MODULE_AUTHOR("Chen Zhu "); +MODULE_AUTHOR("Huacai Chen "); +MODULE_DESCRIPTION("Loongson LS2H/LS7A DRM Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/loongson/loongson_drv.h b/drivers/gpu/drm/loongson/loongson_drv.h new file mode 100755 index 000000000..183256c86 --- /dev/null +++ b/drivers/gpu/drm/loongson/loongson_drv.h @@ -0,0 +1,280 @@ +#ifndef __LOONGSON_DRV_H__ +#define __LOONGSON_DRV_H__ + +#include +#include