arch/x86/cpu/ivybridge/bd82x6x.c

   1 /*
   2  * Copyright (C) 2014 Google, Inc
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <errno.h>
   9 #include <fdtdec.h>
  10 #include <malloc.h>
  11 #include <pch.h>
  12 #include <asm/lapic.h>
  13 #include <asm/pci.h>
  14 #include <asm/arch/bd82x6x.h>
  15 #include <asm/arch/model_206ax.h>
  16 #include <asm/arch/pch.h>
  17 #include <asm/arch/sandybridge.h>
  18
  19 #define BIOS_CTRL       0xdc
  20
  21 void bd82x6x_pci_init(pci_dev_t dev)
  22 {
  23         u16 reg16;
  24         u8 reg8;
  25
  26         debug("bd82x6x PCI init.\n");
  27         /* Enable Bus Master */
  28         reg16 = x86_pci_read_config16(dev, PCI_COMMAND);
  29         reg16 |= PCI_COMMAND_MASTER;
  30         x86_pci_write_config16(dev, PCI_COMMAND, reg16);
  31
  32         /* This device has no interrupt */
  33         x86_pci_write_config8(dev, INTR, 0xff);
  34
  35         /* disable parity error response and SERR */
  36         reg16 = x86_pci_read_config16(dev, BCTRL);
  37         reg16 &= ~(1 << 0);
  38         reg16 &= ~(1 << 1);
  39         x86_pci_write_config16(dev, BCTRL, reg16);
  40
  41         /* Master Latency Count must be set to 0x04! */
  42         reg8 = x86_pci_read_config8(dev, SMLT);
  43         reg8 &= 0x07;
  44         reg8 |= (0x04 << 3);
  45         x86_pci_write_config8(dev, SMLT, reg8);
  46
  47         /* Will this improve throughput of bus masters? */
  48         x86_pci_write_config8(dev, PCI_MIN_GNT, 0x06);
  49
  50         /* Clear errors in status registers */
  51         reg16 = x86_pci_read_config16(dev, PSTS);
  52         /* reg16 |= 0xf900; */
  53         x86_pci_write_config16(dev, PSTS, reg16);
  54
  55         reg16 = x86_pci_read_config16(dev, SECSTS);
  56         /* reg16 |= 0xf900; */
  57         x86_pci_write_config16(dev, SECSTS, reg16);
  58 }
  59
  60 static int bd82x6x_probe(struct udevice *dev)
  61 {
  62         const void *blob = gd->fdt_blob;
  63         struct pci_controller *hose;
  64         struct x86_cpu_priv *cpu;
  65         int sata_node, gma_node;
  66         int ret;
  67
  68         if (!(gd->flags & GD_FLG_RELOC))
  69                 return 0;
  70
  71         hose = pci_bus_to_hose(0);
  72         lpc_enable(PCH_LPC_DEV);
  73         lpc_init_extra(hose, PCH_LPC_DEV);
  74         sata_node = fdtdec_next_compatible(blob, 0,
  75                                            COMPAT_INTEL_PANTHERPOINT_AHCI);
  76         if (sata_node < 0) {
  77                 debug("%s: Cannot find SATA node\n", __func__);
  78                 return -EINVAL;
  79         }
  80         bd82x6x_sata_init(PCH_SATA_DEV, blob, sata_node);
  81         bd82x6x_usb_ehci_init(PCH_EHCI1_DEV);
  82         bd82x6x_usb_ehci_init(PCH_EHCI2_DEV);
  83
  84         cpu = calloc(1, sizeof(*cpu));
  85         if (!cpu)
  86                 return -ENOMEM;
  87         model_206ax_init(cpu);
  88
  89         gma_node = fdtdec_next_compatible(blob, 0, COMPAT_INTEL_GMA);
  90         if (gma_node < 0) {
  91                 debug("%s: Cannot find GMA node\n", __func__);
  92                 return -EINVAL;
  93         }
  94         ret = dm_pci_bus_find_bdf(PCH_VIDEO_DEV, &dev);
  95         if (ret)
  96                 return ret;
  97         ret = gma_func0_init(dev, blob, gma_node);
  98         if (ret)
  99                 return ret;
 100
 101         return 0;
 102 }
 103
 104 /* TODO(sjg@chromium.org): Move this to the PCH init() method */
 105 int bd82x6x_init_extra(void)
 106 {
 107         const void *blob = gd->fdt_blob;
 108         int sata_node;
 109
 110         sata_node = fdtdec_next_compatible(blob, 0,
 111                                            COMPAT_INTEL_PANTHERPOINT_AHCI);
 112         if (sata_node < 0) {
 113                 debug("%s: Cannot find SATA node\n", __func__);
 114                 return -EINVAL;
 115         }
 116
 117         bd82x6x_pci_init(PCH_DEV);
 118         bd82x6x_sata_enable(PCH_SATA_DEV, blob, sata_node);
 119         northbridge_enable(PCH_DEV);
 120         northbridge_init(PCH_DEV);
 121
 122         return 0;
 123 }
 124
 125 static int bd82x6x_pch_get_sbase(struct udevice *dev, ulong *sbasep)
 126 {
 127         u32 rcba;
 128
 129         dm_pci_read_config32(dev, PCH_RCBA, &rcba);
 130         /* Bits 31-14 are the base address, 13-1 are reserved, 0 is enable */
 131         rcba = rcba & 0xffffc000;
 132         *sbasep = rcba + 0x3800;
 133
 134         return 0;
 135 }
 136
 137 static enum pch_version bd82x6x_pch_get_version(struct udevice *dev)
 138 {
 139         return PCHV_9;
 140 }
 141
 142 static int bd82x6x_set_spi_protect(struct udevice *dev, bool protect)
 143 {
 144         uint8_t bios_cntl;
 145
 146         /* Adjust the BIOS write protect and SMM BIOS Write Protect Disable */
 147         dm_pci_read_config8(dev, BIOS_CTRL, &bios_cntl);
 148         if (protect) {
 149                 bios_cntl &= ~BIOS_CTRL_BIOSWE;
 150                 bios_cntl |= BIT(5);
 151         } else {
 152                 bios_cntl |= BIOS_CTRL_BIOSWE;
 153                 bios_cntl &= ~BIT(5);
 154         }
 155         dm_pci_write_config8(dev, BIOS_CTRL, bios_cntl);
 156
 157         return 0;
 158 }
 159
 160 static const struct pch_ops bd82x6x_pch_ops = {
 161         .get_sbase      = bd82x6x_pch_get_sbase,
 162         .get_version    = bd82x6x_pch_get_version,
 163         .set_spi_protect = bd82x6x_set_spi_protect,
 164 };
 165
 166 static const struct udevice_id bd82x6x_ids[] = {
 167         { .compatible = "intel,bd82x6x" },
 168         { }
 169 };
 170
 171 U_BOOT_DRIVER(bd82x6x_drv) = {
 172         .name           = "bd82x6x",
 173         .id             = UCLASS_PCH,
 174         .of_match       = bd82x6x_ids,
 175         .probe          = bd82x6x_probe,
 176         .ops            = &bd82x6x_pch_ops,
 177 };