mainboard.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0-only */
 
#include <acpi/acpi.h>
#include <baseboard/cbi_ssfc.h>
#include <baseboard/variants.h>
#include <boardid.h>
#include <bootstate.h>
#include <console/console.h>
#include <device/device.h>
#include <device/pci_def.h>
#include <device/pci_ops.h>
#include <drivers/i2c/generic/chip.h>
#include <ec/google/chromeec/ec.h>
#include <ec/ec.h>
#include <intelblocks/xhci.h>
#include <nhlt.h>
#include <smbios.h>
#include <soc/cpu.h>
#include <soc/gpio.h>
#include <soc/nhlt.h>
#include <soc/pci_devs.h>
#include <stdint.h>
#include <variant/ec.h>
#include <variant/gpio.h>
 
extern struct chip_operations drivers_i2c_generic_ops;
extern struct chip_operations drivers_i2c_cs42l42_ops;
extern struct chip_operations drivers_i2c_da7219_ops;
 
static bool is_cnvi_held_in_reset(void)
{
        struct device *dev = pcidev_path_on_root(PCH_DEVFN_CNVI);
        uint32_t reg = pci_read_config32(dev, PCI_VENDOR_ID);
 
        /*
         * If vendor/device ID for CNVi reads as 0xffffffff, then it is safe to
         * assume that it is being held in reset.
         */
        if (reg == 0xffffffff)
                return true;
 
        return false;
}
 
static void disable_wifi_wake(void)
{
        static const struct pad_config wifi_wake_gpio[] = {
                PAD_NC(GPIO_119, UP_20K),
        };
 
        gpio_configure_pads(wifi_wake_gpio, ARRAY_SIZE(wifi_wake_gpio));
}
 
/*
 * GPIO_137 for two audio codecs right now has the different configuration so
 * if SSFC indicates that codec is different than default one then GPIO_137
 * needs to be overridden for the corresponding second source.
 */
static void gpio_modification_by_ssfc(struct pad_config *table, size_t num)
{
        /* For RT5682, GPIO 137 should be set as EDGE_BOTH. */
        const struct pad_config rt5682_gpio_137 = PAD_CFG_GPI_APIC_IOS(GPIO_137,
                        NONE, DEEP, EDGE_BOTH, INVERT, HIZCRx1, DISPUPD);
        enum ssfc_audio_codec codec = ssfc_get_audio_codec();
 
        if (table == NULL || num == 0)
                return;
 
        /*
         * Currently we only have the case of RT5682 as the second source. And
         * in case of Ampton which used RT5682 as the default source, it didn't
         * provide override_table right now so it will be returned earlier since
         * table above is NULL.
         */
        if ((codec != SSFC_AUDIO_CODEC_RT5682) &&
                (codec != SSFC_AUDIO_CODEC_RT5682_VS))
                return;
 
        while (num--) {
                if (table->pad == GPIO_137) {
                        *table = rt5682_gpio_137;
                        printk(BIOS_INFO,
                                "Configure GPIO 137 based on SSFC.\n");
                        return;
                }
 
                table++;
        }
}
 
static void mainboard_init(void *chip_info)
{
        int boardid;
        const struct pad_config *base_pads;
        const struct pad_config *override_pads;
        size_t base_num, override_num;
 
        boardid = board_id();
        printk(BIOS_INFO, "Board ID: %d\n", boardid);
 
        base_pads = variant_base_gpio_table(&base_num);
        override_pads = variant_override_gpio_table(&override_num);
        gpio_modification_by_ssfc((struct pad_config *)override_pads,
                        override_num);
 
        gpio_configure_pads_with_override(base_pads, base_num,
                        override_pads, override_num);
 
        if (!is_cnvi_held_in_reset())
                disable_wifi_wake();
 
        mainboard_ec_init();
}
 
static unsigned long mainboard_write_acpi_tables(
        const struct device *device, unsigned long current, acpi_rsdp_t *rsdp)
{
        uintptr_t start_addr;
        uintptr_t end_addr;
        struct nhlt *nhlt;
 
        start_addr = current;
 
        nhlt = nhlt_init();
 
        if (nhlt == NULL)
                return start_addr;
 
        variant_nhlt_init(nhlt);
 
        end_addr = nhlt_soc_serialize(nhlt, start_addr);
 
        if (end_addr != start_addr)
                acpi_add_table(rsdp, (void *)start_addr);
 
        return end_addr;
}
 
static void mainboard_enable(struct device *dev)
{
        dev->ops->write_acpi_tables = mainboard_write_acpi_tables;
}
 
struct chip_operations mainboard_ops = {
        .init = mainboard_init,
        .enable_dev = mainboard_enable,
};
 
void __weak variant_update_devtree(struct device *dev)
{
        /* Place holder for common updates. */
}
 
/*
 * Check if CNVi PCI device is released from reset. If yes, then the system is
 * booting with CNVi module. In this case, the PCIe device for WiFi needs to
 * be disabled. If CNVi device is held in reset, then disable it.
 */
static void wifi_device_update(void)
{
        struct device *dev;
        unsigned int devfn;
 
        if (is_cnvi_held_in_reset())
                devfn = PCH_DEVFN_CNVI;
        else
                devfn = PCH_DEVFN_PCIE1;
 
        dev = pcidev_path_on_root(devfn);
        if (dev)
                dev->enabled = 0;
}
 
/*
 * Base on SSFC value in the CBI from EC to enable one of audio codec sources in
 * the device tree.
 */
static void audio_codec_device_update(void)
{
        struct device *audio_dev = NULL;
        struct bus *audio_i2c_bus =
                pcidev_path_on_root(PCH_DEVFN_I2C5)->link_list;
        enum ssfc_audio_codec codec = ssfc_get_audio_codec();
 
        while ((audio_dev = dev_bus_each_child(audio_i2c_bus, audio_dev))) {
                if (audio_dev->chip_info == NULL)
                        continue;
 
                if ((audio_dev->chip_ops == &drivers_i2c_da7219_ops) &&
                        (codec == SSFC_AUDIO_CODEC_DA7219)) {
                        printk(BIOS_INFO, "enable DA7219.\n");
                        continue;
                }
 
                if (audio_dev->chip_ops == &drivers_i2c_generic_ops) {
                        struct drivers_i2c_generic_config *cfg =
                                audio_dev->chip_info;
 
                        if ((cfg != NULL && !strcmp(cfg->hid, "10EC5682")) &&
                                (codec == SSFC_AUDIO_CODEC_RT5682)) {
                                printk(BIOS_INFO, "enable RT5682 VD.\n");
                                continue;
                        }
 
                        if ((cfg != NULL && !strcmp(cfg->hid, "10EC5682")) &&
                                (codec == SSFC_AUDIO_CODEC_RT5682_VS)) {
                                cfg->hid = "RTL5682";
                                printk(BIOS_INFO, "enable RT5682 VS.\n");
                                continue;
                        }
 
                        if ((cfg != NULL && !strcmp(cfg->hid, "RTL5682")) &&
                                (codec == SSFC_AUDIO_CODEC_RT5682_VS)) {
                                printk(BIOS_INFO, "enable RT5682 VS.\n");
                                continue;
                        }
                }
 
                if ((audio_dev->chip_ops == &drivers_i2c_cs42l42_ops) &&
                        (codec == SSFC_AUDIO_CODEC_CS42L42)) {
                        printk(BIOS_INFO, "enable CS42L42.\n");
                        continue;
                }
 
                printk(BIOS_INFO, "%s has been disabled\n", audio_dev->chip_ops->name);
                audio_dev->enabled = 0;
        }
}
 
void mainboard_devtree_update(struct device *dev)
{
        /* Apply common devtree updates. */
        wifi_device_update();
        audio_codec_device_update();
 
        /* Defer to variant for board-specific updates. */
        variant_update_devtree(dev);
}
 
bool __weak variant_ext_usb_status(unsigned int port_type, unsigned int port_id)
{
        /* All externally visible USB ports are present */
        return true;
}
 
static void disable_unused_devices(void *unused)
{
        usb_xhci_disable_unused(variant_ext_usb_status);
}
 
BOOT_STATE_INIT_ENTRY(BS_DEV_INIT, BS_ON_EXIT, disable_unused_devices, NULL);