2020-04-05 15:47:17 +02:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
|
|
/* This file is part of the coreboot project. */
|
2015-05-13 03:19:47 +02:00
|
|
|
|
2017-06-08 16:46:51 +02:00
|
|
|
#include <bootmode.h>
|
2017-07-01 19:25:46 +02:00
|
|
|
#include <cbmem.h>
|
2018-12-16 02:39:28 +01:00
|
|
|
#include <commonlib/helpers.h>
|
2015-05-13 03:19:47 +02:00
|
|
|
#include <console/console.h>
|
|
|
|
#include <device/pci.h>
|
2019-03-01 12:43:02 +01:00
|
|
|
#include <device/pci_ops.h>
|
2018-12-16 02:39:28 +01:00
|
|
|
#include <device/resource.h>
|
2020-03-27 20:13:07 +01:00
|
|
|
#include <drivers/intel/gma/i915.h>
|
2015-05-13 03:19:47 +02:00
|
|
|
#include <drivers/intel/gma/i915_reg.h>
|
2017-06-08 16:46:51 +02:00
|
|
|
#include <drivers/intel/gma/libgfxinit.h>
|
2017-11-28 11:56:08 +01:00
|
|
|
#include <intelblocks/graphics.h>
|
2017-09-26 19:34:35 +02:00
|
|
|
#include <drivers/intel/gma/opregion.h>
|
2017-07-01 19:25:46 +02:00
|
|
|
#include <soc/nvs.h>
|
2015-05-13 03:19:47 +02:00
|
|
|
#include <soc/ramstage.h>
|
2019-05-15 21:11:39 +02:00
|
|
|
#include <types.h>
|
2015-05-13 03:19:47 +02:00
|
|
|
|
2016-08-30 17:17:13 +02:00
|
|
|
uintptr_t fsp_soc_get_igd_bar(void)
|
|
|
|
{
|
2017-11-28 11:56:08 +01:00
|
|
|
return graphics_get_memory_base();
|
2015-05-13 03:19:47 +02:00
|
|
|
}
|
|
|
|
|
2018-12-16 02:39:28 +01:00
|
|
|
static void graphics_setup_panel(struct device *dev)
|
|
|
|
{
|
2019-07-13 21:16:25 +02:00
|
|
|
struct soc_intel_skylake_config *conf = config_of(dev);
|
2018-12-16 02:39:28 +01:00
|
|
|
struct resource *mmio_res;
|
|
|
|
uint8_t *base;
|
|
|
|
u32 reg32;
|
|
|
|
|
|
|
|
if (!conf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mmio_res = find_resource(dev, PCI_BASE_ADDRESS_0);
|
|
|
|
if (!mmio_res || !mmio_res->base)
|
|
|
|
return;
|
|
|
|
base = (void *)(uintptr_t)mmio_res->base;
|
|
|
|
|
|
|
|
reg32 = conf->gpu_pp_up_delay_ms * 10 << 16;
|
|
|
|
reg32 |= conf->gpu_pp_backlight_on_delay_ms * 10;
|
|
|
|
write32(base + PCH_PP_ON_DELAYS, reg32);
|
|
|
|
|
|
|
|
reg32 = conf->gpu_pp_down_delay_ms * 10 << 16;
|
|
|
|
reg32 |= conf->gpu_pp_backlight_off_delay_ms * 10;
|
|
|
|
write32(base + PCH_PP_OFF_DELAYS, reg32);
|
|
|
|
|
|
|
|
reg32 = read32(base + PCH_PP_DIVISOR);
|
|
|
|
reg32 &= ~0x1f;
|
|
|
|
reg32 |= (DIV_ROUND_UP(conf->gpu_pp_cycle_delay_ms, 100) + 1) & 0x1f;
|
|
|
|
write32(base + PCH_PP_DIVISOR, reg32);
|
|
|
|
|
|
|
|
/* So far all devices seem to use the PCH PWM function.
|
|
|
|
The CPU PWM registers are all zero after reset. */
|
|
|
|
if (conf->gpu_pch_backlight_pwm_hz) {
|
|
|
|
/* Reference clock is 24MHz. We can choose either a 16
|
|
|
|
or a 128 step increment. Use 16 if we would have less
|
|
|
|
than 100 steps otherwise. */
|
|
|
|
const unsigned int hz_limit = 24 * 1000 * 1000 / 128 / 100;
|
|
|
|
unsigned int pwm_increment, pwm_period;
|
|
|
|
u32 south_chicken1;
|
|
|
|
|
|
|
|
south_chicken1 = read32(base + SOUTH_CHICKEN1);
|
|
|
|
if (conf->gpu_pch_backlight_pwm_hz > hz_limit) {
|
|
|
|
pwm_increment = 16;
|
|
|
|
south_chicken1 &= ~1;
|
|
|
|
} else {
|
|
|
|
pwm_increment = 128;
|
|
|
|
south_chicken1 |= 1;
|
|
|
|
}
|
|
|
|
write32(base + SOUTH_CHICKEN1, south_chicken1);
|
|
|
|
|
|
|
|
pwm_period = 24 * 1000 * 1000 / pwm_increment
|
|
|
|
/ conf->gpu_pch_backlight_pwm_hz;
|
|
|
|
/* Start with a 50% duty cycle. */
|
|
|
|
write32(base + BLC_PWM_PCH_CTL2,
|
|
|
|
pwm_period << 16 | pwm_period / 2);
|
|
|
|
|
|
|
|
write32(base + BLC_PWM_PCH_CTL1,
|
|
|
|
!!conf->gpu_pch_backlight_polarity << 29 |
|
|
|
|
BLM_PCH_PWM_ENABLE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-28 11:56:08 +01:00
|
|
|
void graphics_soc_init(struct device *dev)
|
2015-05-13 03:19:47 +02:00
|
|
|
{
|
2016-02-11 02:10:05 +01:00
|
|
|
u32 ddi_buf_ctl;
|
|
|
|
|
2018-12-16 02:39:28 +01:00
|
|
|
graphics_setup_panel(dev);
|
|
|
|
|
2016-02-11 02:10:05 +01:00
|
|
|
/*
|
|
|
|
* Enable DDI-A (eDP) 4-lane operation if the link is not up yet.
|
|
|
|
* This will allow the kernel to use 4-lane eDP links properly
|
|
|
|
* if the VBIOS or GOP driver does not execute.
|
|
|
|
*/
|
2017-11-28 11:56:08 +01:00
|
|
|
ddi_buf_ctl = graphics_gtt_read(DDI_BUF_CTL_A);
|
2016-02-11 02:10:05 +01:00
|
|
|
if (!acpi_is_wakeup_s3() && !(ddi_buf_ctl & DDI_BUF_CTL_ENABLE)) {
|
|
|
|
ddi_buf_ctl |= DDI_A_4_LANES;
|
2017-11-28 11:56:08 +01:00
|
|
|
graphics_gtt_write(DDI_BUF_CTL_A, ddi_buf_ctl);
|
2016-02-11 02:10:05 +01:00
|
|
|
}
|
|
|
|
|
2018-04-01 01:54:44 +02:00
|
|
|
/* IGD needs to Bus Master */
|
|
|
|
u32 reg32 = pci_read_config32(dev, PCI_COMMAND);
|
|
|
|
reg32 |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO;
|
|
|
|
pci_write_config32(dev, PCI_COMMAND, reg32);
|
|
|
|
|
2017-11-28 11:56:08 +01:00
|
|
|
/*
|
|
|
|
* GFX PEIM module inside FSP binary is taking care of graphics
|
2017-06-08 16:46:51 +02:00
|
|
|
* initialization based on RUN_FSP_GOP Kconfig option and input
|
|
|
|
* VBT file.
|
2017-11-28 11:56:08 +01:00
|
|
|
*
|
2017-06-08 16:46:51 +02:00
|
|
|
* In case of non-FSP solution, SoC need to select another
|
|
|
|
* Kconfig to perform GFX initialization.
|
2017-11-28 11:56:08 +01:00
|
|
|
*/
|
2019-03-06 01:53:33 +01:00
|
|
|
if (CONFIG(RUN_FSP_GOP)) {
|
2018-04-01 01:54:44 +02:00
|
|
|
/* nothing to do */
|
2019-03-06 01:53:33 +01:00
|
|
|
} else if (CONFIG(MAINBOARD_USE_LIBGFXINIT)) {
|
2017-06-08 16:46:51 +02:00
|
|
|
if (!acpi_is_wakeup_s3() && display_init_required()) {
|
|
|
|
int lightup_ok;
|
|
|
|
gma_gfxinit(&lightup_ok);
|
|
|
|
gfx_set_init_done(lightup_ok);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Initialize PCI device, load/execute BIOS Option ROM */
|
|
|
|
pci_dev_init(dev);
|
|
|
|
}
|
2017-07-01 19:25:46 +02:00
|
|
|
|
|
|
|
intel_gma_restore_opregion();
|
|
|
|
}
|
|
|
|
|
|
|
|
uintptr_t gma_get_gnvs_aslb(const void *gnvs)
|
|
|
|
{
|
|
|
|
const global_nvs_t *gnvs_ptr = gnvs;
|
|
|
|
return (uintptr_t)(gnvs_ptr ? gnvs_ptr->aslb : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void gma_set_gnvs_aslb(void *gnvs, uintptr_t aslb)
|
|
|
|
{
|
|
|
|
global_nvs_t *gnvs_ptr = gnvs;
|
|
|
|
if (gnvs_ptr)
|
|
|
|
gnvs_ptr->aslb = aslb;
|
2015-05-13 03:19:47 +02:00
|
|
|
}
|
|
|
|
|
2015-10-02 02:21:33 +02:00
|
|
|
/* Initialize IGD OpRegion, called from ACPI code */
|
2017-11-28 11:56:08 +01:00
|
|
|
static void update_igd_opregion(igd_opregion_t *opregion)
|
2015-10-02 02:21:33 +02:00
|
|
|
{
|
2017-09-26 19:34:35 +02:00
|
|
|
/* FIXME: Add platform specific mailbox initialization */
|
2015-10-02 02:21:33 +02:00
|
|
|
}
|
|
|
|
|
2020-04-24 15:41:18 +02:00
|
|
|
uintptr_t graphics_soc_write_acpi_opregion(const struct device *device,
|
2017-11-28 11:56:08 +01:00
|
|
|
uintptr_t current, struct acpi_rsdp *rsdp)
|
2015-10-02 02:21:33 +02:00
|
|
|
{
|
|
|
|
igd_opregion_t *opregion;
|
2017-07-01 19:25:46 +02:00
|
|
|
global_nvs_t *gnvs = cbmem_find(CBMEM_ID_ACPI_GNVS);
|
2015-10-02 02:21:33 +02:00
|
|
|
|
|
|
|
/* If GOP is not used, exit here */
|
2019-03-06 01:53:33 +01:00
|
|
|
if (!CONFIG(INTEL_GMA_ADD_VBT))
|
2015-10-02 02:21:33 +02:00
|
|
|
return current;
|
|
|
|
|
|
|
|
/* If IGD is disabled, exit here */
|
|
|
|
if (pci_read_config16(device, PCI_VENDOR_ID) == 0xFFFF)
|
|
|
|
return current;
|
|
|
|
|
|
|
|
printk(BIOS_DEBUG, "ACPI: * IGD OpRegion\n");
|
|
|
|
opregion = (igd_opregion_t *)current;
|
2017-07-25 16:34:26 +02:00
|
|
|
|
2017-09-26 19:34:35 +02:00
|
|
|
if (intel_gma_init_igd_opregion(opregion) != CB_SUCCESS)
|
2017-07-25 16:34:26 +02:00
|
|
|
return current;
|
2017-07-01 19:25:46 +02:00
|
|
|
if (gnvs)
|
|
|
|
gnvs->aslb = (u32)(uintptr_t)opregion;
|
2016-08-23 11:01:23 +02:00
|
|
|
update_igd_opregion(opregion);
|
2015-10-02 02:21:33 +02:00
|
|
|
current += sizeof(igd_opregion_t);
|
2015-12-11 00:07:38 +01:00
|
|
|
current = acpi_align_current(current);
|
2015-10-02 02:21:33 +02:00
|
|
|
|
|
|
|
printk(BIOS_DEBUG, "current = %lx\n", current);
|
|
|
|
return current;
|
|
|
|
}
|
2020-03-27 20:13:07 +01:00
|
|
|
|
|
|
|
const struct i915_gpu_controller_info *
|
|
|
|
intel_igd_get_controller_info(struct device *device)
|
|
|
|
{
|
|
|
|
struct soc_intel_skylake_config *chip = device->chip_info;
|
|
|
|
return &chip->gfx;
|
|
|
|
}
|