coreboot-gerrit February 2016

coreboot-gerrit@coreboot.org

1 participants
1305 discussions

Patch set updated for coreboot: soc/apollolake/bootblock: Add transition to romstage
by Andrey Petrov 03 Feb '16

03 Feb '16

Andrey Petrov (andrey.petrov(a)intel.com) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/13322 -gerrit commit 3a4436c8f1d682e7b2e3c79852feb08052a0dc0c Author: Andrey Petrov <andrey.petrov(a)intel.com> Date: Tue Oct 27 12:43:44 2015 -0700 soc/apollolake/bootblock: Add transition to romstage This adds calling romstage. Since by default romstage is run from CAR, a workaround is added as well to keep CAR executable. Change-Id: Ied49a5695c6499ad0cfaf27e3ba6860a884a6684 Signed-off-by: Andrey Petrov <andrey.petrov(a)intel.com> --- src/soc/intel/apollolake/bootblock/bootblock_car.c | 28 +++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/src/soc/intel/apollolake/bootblock/bootblock_car.c b/src/soc/intel/apollolake/bootblock/bootblock_car.c index e9cbb09..251d7b5 100644 --- a/src/soc/intel/apollolake/bootblock/bootblock_car.c +++ b/src/soc/intel/apollolake/bootblock/bootblock_car.c @@ -11,9 +11,11 @@ */ #include <arch/io.h> +#include <cbfs.h> #include <console/console.h> #include <device/pci.h> #include <soc/bootblock.h> +#include <soc/cpu.h> #include <soc/uart.h> static void disable_watchdog(void) @@ -32,8 +34,18 @@ static void disable_watchdog(void) outl(reg, 0x400 + 0x68); } +static void call_romstage(void *entry) +{ + __asm__ volatile ( + "call *%0" + :: "r" (entry) + ); +} + void bootblock_car_main(void) { + void *romstage_entry; + /* Quick post code to show we made it to C code */ outb(0x30, 0x80); @@ -45,7 +57,17 @@ void bootblock_car_main(void) /* Wait until after we have console to disable this */ disable_watchdog(); - /* Don't return, so we see the above post code */ - while (1) - ; + romstage_entry = cbfs_boot_load_stage_by_name("fallback/romstage"); + if (!romstage_entry) { + outb(POST_DIE, 0x80); + die("romstage not found\n"); + } + + /* APLK workaround: do this magic to keep cache executable on update */ + bxt_remark_cache_exec(); + + /* Call the romstage entry point */ + call_romstage(romstage_entry); + + /* We should never reach this */ }

1 0

Patch set updated for coreboot: buildgcc: Update coreboot's IASL version to 20151218
by Stefan Reinauer 03 Feb '16

03 Feb '16

Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/12817 -gerrit commit 09fab496956be84b366117f117871d70cbca3613 Author: Martin Roth <gaumless(a)gmail.com> Date: Wed Dec 30 15:10:13 2015 -0700 buildgcc: Update coreboot's IASL version to 20151218 Update IASL from 20150619 to 20151218 See release notes at acpica.org Change-Id: Ic7e7b3956378ad611069e984d5a59c78e4cb08b1 Signed-off-by: Martin Roth <gaumless(a)gmail.com> --- util/crossgcc/buildgcc | 2 +- .../patches/acpica-unix-20150619_iasl.patch | 12 ---------- .../patches/acpica-unix-20151218_iasl.patch | 27 ++++++++++++++++++++++ .../crossgcc/sum/acpica-unix-20150619.tar.gz.cksum | 1 - .../crossgcc/sum/acpica-unix-20151218.tar.gz.cksum | 1 + 5 files changed, 29 insertions(+), 14 deletions(-) diff --git a/util/crossgcc/buildgcc b/util/crossgcc/buildgcc index 8f67949..246842e 100755 --- a/util/crossgcc/buildgcc +++ b/util/crossgcc/buildgcc @@ -39,7 +39,7 @@ GCC_VERSION=5.2.0 GCC_AUTOCONF_VERSION=2.69 BINUTILS_VERSION=2.25 GDB_VERSION=7.9.1 -IASL_VERSION=20150619 +IASL_VERSION=20151218 PYTHON_VERSION=3.4.3 EXPAT_VERSION=2.1.0 # CLANG version number diff --git a/util/crossgcc/patches/acpica-unix-20150619_iasl.patch b/util/crossgcc/patches/acpica-unix-20150619_iasl.patch deleted file mode 100644 index 6cb087c..0000000 --- a/util/crossgcc/patches/acpica-unix-20150619_iasl.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -urN acpica-unix-20150619/source/compiler/asloptions.c acpica-unix-20150619/source/compiler/asloptions.c ---- acpica-unix-20150619/source/compiler/asloptions.c 2015-06-19 08:56:19.000000000 -0600 -+++ acpica-unix-20150619/source/compiler/asloptions.c 2015-12-08 10:44:58.816669240 -0700 -@@ -717,6 +717,7 @@ - case '^': - - printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME)); -+ printf ("%s\n", COREBOOT_TOOLCHAIN_VERSION); - exit (0); - - case 'a': - diff --git a/util/crossgcc/patches/acpica-unix-20151218_iasl.patch b/util/crossgcc/patches/acpica-unix-20151218_iasl.patch new file mode 100644 index 0000000..e35a360 --- /dev/null +++ b/util/crossgcc/patches/acpica-unix-20151218_iasl.patch @@ -0,0 +1,27 @@ +Add coreboot toolchain version string +--- acpica-unix-20151218/source/compiler/asloptions.c ++++ acpica-unix-20151218/source/compiler/asloptions.c +@@ -169,6 +169,7 @@ + if (argc < 2) + { + printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME)); ++ printf ("%s\n", COREBOOT_TOOLCHAIN_VERSION); + Usage (); + exit (1); + } +@@ -199,6 +200,7 @@ + if (Gbl_DoSignon) + { + printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME)); ++ printf ("%s\n", COREBOOT_TOOLCHAIN_VERSION); + if (Gbl_IgnoreErrors) + { + printf ("Ignoring all errors, forcing AML file generation\n\n"); +@@ -743,6 +745,7 @@ + case '^': + + printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME)); ++ printf ("%s\n", COREBOOT_TOOLCHAIN_VERSION); + exit (0); + + case 'a': diff --git a/util/crossgcc/sum/acpica-unix-20150619.tar.gz.cksum b/util/crossgcc/sum/acpica-unix-20150619.tar.gz.cksum deleted file mode 100644 index 4047300..0000000 --- a/util/crossgcc/sum/acpica-unix-20150619.tar.gz.cksum +++ /dev/null @@ -1 +0,0 @@ -ccc86513f10c47762bf46bf4d348c8cbda4336f5 tarballs/acpica-unix-20150619.tar.gz diff --git a/util/crossgcc/sum/acpica-unix-20151218.tar.gz.cksum b/util/crossgcc/sum/acpica-unix-20151218.tar.gz.cksum new file mode 100644 index 0000000..fb9876b --- /dev/null +++ b/util/crossgcc/sum/acpica-unix-20151218.tar.gz.cksum @@ -0,0 +1 @@ +97e430aa6e936e77abeba936345588fff003e280 tarballs/acpica-unix-20151218.tar.gz

1 0

Patch set updated for coreboot: drivers/lenovo: Add hybrid graphics driver
by Martin Roth 03 Feb '16

03 Feb '16

Martin Roth (martinroth(a)google.com) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/12896 -gerrit commit 8365ecd554c3c6cf92b98d951a882bbaa9758f86 Author: Patrick Rudolph <siro(a)das-labor.org> Date: Sat Dec 26 08:35:08 2015 +0100 drivers/lenovo: Add hybrid graphics driver Add a universal hybrid graphics driver compatible with all supported lenovo devices. Hybrid graphics allows to connect the display panel to either of one GPUs. As there are only two GPUs one GPIO needs to be toggled. In case the discrete GPU is activated the panel is routed to it. On deactivation the panel is routed to the integrated GPU and the discrete HDMI audio device is disabled too. The northbridge code won't disable the PEG port if the HDMI audio device is still visible. Tested on Lenovo T530 using Nvidia NVS 5400m. Depends on commit: "southbridge/intel: move gpio.c" Change-Id: I9b80b31a7749bdf893ed3b772a6505c9f29a56d1 Signed-off-by: Patrick Rudolph <siro(a)das-labor.org> --- src/drivers/lenovo/Kconfig | 12 +++ src/drivers/lenovo/Makefile.inc | 1 + src/drivers/lenovo/hybrid_graphics.c | 140 +++++++++++++++++++++++++++++++++++ src/mainboard/lenovo/t400/Kconfig | 1 + src/mainboard/lenovo/t420s/Kconfig | 1 + src/mainboard/lenovo/t430s/Kconfig | 1 + src/mainboard/lenovo/t520/Kconfig | 1 + src/mainboard/lenovo/t530/Kconfig | 1 + 8 files changed, 158 insertions(+) diff --git a/src/drivers/lenovo/Kconfig b/src/drivers/lenovo/Kconfig index f20f3b2..651ec80 100644 --- a/src/drivers/lenovo/Kconfig +++ b/src/drivers/lenovo/Kconfig @@ -27,3 +27,15 @@ config DIGITIZER_ABSENT endchoice endif + +config DRIVERS_LENOVO_HYBRID_GRAPHICS + bool + default n + +if DRIVERS_LENOVO_HYBRID_GRAPHICS + +config HYBRID_GRAPHICS_GPIO_NUM + int + default 52 + +endif diff --git a/src/drivers/lenovo/Makefile.inc b/src/drivers/lenovo/Makefile.inc index c50db5b..66f8594 100644 --- a/src/drivers/lenovo/Makefile.inc +++ b/src/drivers/lenovo/Makefile.inc @@ -1 +1,2 @@ ramstage-$(CONFIG_DRIVERS_LENOVO_WACOM) += wacom.c +ramstage-$(CONFIG_DRIVERS_LENOVO_HYBRID_GRAPHICS) += hybrid_graphics.c diff --git a/src/drivers/lenovo/hybrid_graphics.c b/src/drivers/lenovo/hybrid_graphics.c new file mode 100644 index 0000000..ada09df --- /dev/null +++ b/src/drivers/lenovo/hybrid_graphics.c @@ -0,0 +1,140 @@ +/* + * This file is part of the coreboot project. + * + * Copyright (C) 2015 Patrick Rudolph + * + * 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; version 2 of the License. + * + * 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. + */ + +#include <types.h> +#include <string.h> +#include <device/device.h> +#include <device/pci_def.h> +#include <device/pci_ops.h> +#include <device/pci.h> +#include <console/console.h> +#include <southbridge/intel/common/gpio.h> + +#define VENDOR_ID_NVIDIA 0x10de +#define VENDOR_ID_AMD 0x1002 + +/* Hybrid graphics allows to connect LVDS interface to either iGPU + * or dGPU depending on GPIO level. + * On systems without dGPU this code is either not linked in or is never called + * and has no effect. + * + * Note: Once native gfx init is done for AMD or Nvida graphic + * cards merge this code. + */ + +static struct device *get_audio_dev(struct device *dev) +{ + /* returns the GPU HDMI audio device */ + if (dev->vendor == VENDOR_ID_NVIDIA) { + switch (dev->device) { + case 0x0def: + return dev_find_device(dev->vendor, 0x0bea, dev->bus->dev); + case 0x0dfc: + return dev_find_device(dev->vendor, 0x0bea, dev->bus->dev); + case 0x1056: + return dev_find_device(dev->vendor, 0x0e08, dev->bus->dev); + case 0x1057: + return dev_find_device(dev->vendor, 0x0bea, dev->bus->dev); + case 0x0a6c: + return dev_find_device(dev->vendor, 0x0be3, dev->bus->dev); + default: + break; + } + } else { + switch (dev->device) { + case 0x9591: + return dev_find_device(dev->vendor, 0xaa20, dev->bus->dev); + case 0x95c4: + return dev_find_device(dev->vendor, 0xaa28, dev->bus->dev); + default: + break; + } + } + return NULL; +} + +static void hybrid_graphics_enable_peg(struct device *dev) +{ + struct device *audio_dev; + + /* connect LVDS interface to dGPU */ + set_gpio(CONFIG_HYBRID_GRAPHICS_GPIO_NUM, GPIO_LEVEL_LOW); + printk(BIOS_DEBUG, "Switching panel to discrete GPU\n"); + dev->enabled = 1; + + audio_dev = get_audio_dev(dev); + if (audio_dev) + audio_dev->enabled = 1; +} + +static void hybrid_graphics_disable_peg(struct device *dev) +{ + struct device *audio_dev; + + /* connect LVDS interface to iGPU */ + set_gpio(CONFIG_HYBRID_GRAPHICS_GPIO_NUM, GPIO_LEVEL_HIGH); + printk(BIOS_DEBUG, "Switching panel to integrated GPU\n"); + printk(BIOS_DEBUG, "Disabling device 0x%04x:0x%04x on bus %s\n", + dev->vendor, dev->device, bus_path(dev->bus)); + dev->enabled = 0; + + audio_dev = get_audio_dev(dev); + if (audio_dev) { + printk(BIOS_DEBUG, "Disabling device 0x%04x:0x%04x on bus %s\n", + audio_dev->vendor, audio_dev->device, bus_path(audio_dev->bus)); + audio_dev->enabled = 0; + } +} + +static struct pci_operations pci_dev_ops_pci = { + .set_subsystem = pci_dev_set_subsystem, +}; + +struct device_operations hybrid_graphics_ops = { + .read_resources = pci_dev_read_resources, + .set_resources = pci_dev_set_resources, + .enable_resources = pci_dev_enable_resources, + .init = pci_dev_init, + .scan_bus = 0, + .enable = hybrid_graphics_enable_peg, + .disable = hybrid_graphics_disable_peg, + .ops_pci = &pci_dev_ops_pci, +}; + +static const unsigned short pci_device_ids_nvidia[] = { + 0x0def, /* NVidia NVS 5400m Lenovo T430/T530 */ + 0x0dfc, /* NVidia NVS 5200m Lenovo T430s */ + 0x1056, /* NVidia NVS 4200m Lenovo T420/T520 */ + 0x1057, /* NVidia NVS 4200m Lenovo T420/T520 */ + 0x0a6c, /* NVidia NVS 3100m Lenovo T410/T510 */ + 0 }; + +static const struct pci_driver hybrid_peg_nvidia __pci_driver = { + .ops = &hybrid_graphics_ops, + .vendor = VENDOR_ID_NVIDIA, + .devices = pci_device_ids_nvidia, +}; + +static const unsigned short pci_device_ids_amd[] = { + 0x9591, /* ATI Mobility Radeon HD 3650 Lenovo T500/W500 */ + 0x95c4, /* ATI Mobility Radeon HD 3470 Lenovo T400/R400 */ + 0 }; + +static const struct pci_driver hybrid_peg_amd __pci_driver = { + .ops = &hybrid_graphics_ops, + .vendor = VENDOR_ID_AMD, + .devices = pci_device_ids_amd, +}; + diff --git a/src/mainboard/lenovo/t400/Kconfig b/src/mainboard/lenovo/t400/Kconfig index 0eac311..59938bd 100644 --- a/src/mainboard/lenovo/t400/Kconfig +++ b/src/mainboard/lenovo/t400/Kconfig @@ -22,6 +22,7 @@ config BOARD_SPECIFIC_OPTIONS # dummy select MAINBOARD_HAS_NATIVE_VGA_INIT_TEXTMODECFG select INTEL_INT15 select SUPERIO_NSC_PC87382 + select DRIVERS_LENOVO_HYBRID_GRAPHICS config MAINBOARD_DIR string diff --git a/src/mainboard/lenovo/t420s/Kconfig b/src/mainboard/lenovo/t420s/Kconfig index 65d37a7..d511a2b 100644 --- a/src/mainboard/lenovo/t420s/Kconfig +++ b/src/mainboard/lenovo/t420s/Kconfig @@ -21,6 +21,7 @@ config BOARD_SPECIFIC_OPTIONS # dummy select MAINBOARD_HAS_NATIVE_VGA_INIT_TEXTMODECFG select SANDYBRIDGE_LVDS select MAINBOARD_HAS_LPC_TPM + select DRIVERS_LENOVO_HYBRID_GRAPHICS # Workaround for EC/KBC IRQ1. select SERIRQ_CONTINUOUS_MODE diff --git a/src/mainboard/lenovo/t430s/Kconfig b/src/mainboard/lenovo/t430s/Kconfig index 6e257dd..2ca71a4 100644 --- a/src/mainboard/lenovo/t430s/Kconfig +++ b/src/mainboard/lenovo/t430s/Kconfig @@ -22,6 +22,7 @@ config BOARD_SPECIFIC_OPTIONS # dummy select IVYBRIDGE_LVDS select ENABLE_VMX select MAINBOARD_HAS_LPC_TPM + select DRIVERS_LENOVO_HYBRID_GRAPHICS # Workaround for EC/KBC IRQ1. select SERIRQ_CONTINUOUS_MODE diff --git a/src/mainboard/lenovo/t520/Kconfig b/src/mainboard/lenovo/t520/Kconfig index df7c2db..4a7a6c2 100644 --- a/src/mainboard/lenovo/t520/Kconfig +++ b/src/mainboard/lenovo/t520/Kconfig @@ -21,6 +21,7 @@ config BOARD_SPECIFIC_OPTIONS # dummy select MAINBOARD_HAS_NATIVE_VGA_INIT_TEXTMODECFG select SANDYBRIDGE_LVDS select MAINBOARD_HAS_LPC_TPM + select DRIVERS_LENOVO_HYBRID_GRAPHICS # Workaround for EC/KBC IRQ1. select SERIRQ_CONTINUOUS_MODE diff --git a/src/mainboard/lenovo/t530/Kconfig b/src/mainboard/lenovo/t530/Kconfig index 7b4ca7a..d947466 100644 --- a/src/mainboard/lenovo/t530/Kconfig +++ b/src/mainboard/lenovo/t530/Kconfig @@ -23,6 +23,7 @@ config BOARD_SPECIFIC_OPTIONS # dummy select MAINBOARD_DO_NATIVE_VGA_INIT # default to native vga init select ENABLE_VMX select MAINBOARD_HAS_LPC_TPM + select DRIVERS_LENOVO_HYBRID_GRAPHICS # Workaround for EC/KBC IRQ1. select SERIRQ_CONTINUOUS_MODE

1 0

Patch merged into coreboot/master: vendorcode/amd/agesa/f1{4, 2, 0} Sync Include directory
by gerrit＠coreboot.org 03 Feb '16

03 Feb '16

the following patch was just integrated into master: commit e3f47eada383defcc31b41cc4931c3cf3234c37d Author: Edward O'Callaghan <eocallaghan(a)alterapraxis.com> Date: Tue Nov 18 18:27:29 2014 +1100 vendorcode/amd/agesa/f1{4,2,0} Sync Include directory Sync and merge useless differences. Change-Id: I4eea66c35af66d473dd56db9ccf105c878266f22 Signed-off-by: Edward O'Callaghan <eocallaghan(a)alterapraxis.com> Reviewed-on: https://review.coreboot.org/7513 Tested-by: build bot (Jenkins) Reviewed-by: Stefan Reinauer <stefan.reinauer(a)coreboot.org> See https://review.coreboot.org/7513 for details. -gerrit

1 0

Patch merged into coreboot/master: vendorcode/amd/agesa/f15?tn: Strip false/redudant AMD ver tag
by gerrit＠coreboot.org 03 Feb '16

03 Feb '16

the following patch was just integrated into master: commit c389635f6e5618b40279e823a46ae2ff50e620d1 Author: Edward O'Callaghan <eocallaghan(a)alterapraxis.com> Date: Wed Nov 19 10:53:09 2014 +1100 vendorcode/amd/agesa/f15?tn: Strip false/redudant AMD ver tag Strip out the AMD internal version tag, e.g. * @e \$Revision: 63425 $ @e \$Date: 2011-12-22 11:24:10 -0600 (Thu, 22 Dec 2011) $ which are false/inconsistent and serve no real meaning or purpose now. Change-Id: I4cca0899eba66a1c361ba784c5ac0222b0ee1aa6 Signed-off-by: Edward O'Callaghan <eocallaghan(a)alterapraxis.com> Reviewed-on: https://review.coreboot.org/7516 Tested-by: build bot (Jenkins) Reviewed-by: Stefan Reinauer <stefan.reinauer(a)coreboot.org> See https://review.coreboot.org/7516 for details. -gerrit

1 0

Patch merged into coreboot/master: util/kconfig:xconf(QT): Update QT version of xconf
by gerrit＠coreboot.org 03 Feb '16

03 Feb '16

the following patch was just integrated into master: commit 11a262c86c426f49b6e77a3ca02ce584e2014510 Author: zbao <fishbaozi(a)gmail.com> Date: Fri Jan 22 18:54:22 2016 +0800 util/kconfig:xconf(QT): Update QT version of xconf Update the qconf.cc and qconf.h to upstream code, which added support of QT5 and removed the support of QT3. All code is ported from kernel.org, with only one line added to qconf.cc. int kconfig_warnings = 0; Change-Id: Ice77cddcc00e43375039379978e55f42acf867f7 Signed-off-by: Zheng Bao <fishbaozi(a)gmail.com> Reviewed-on: https://review.coreboot.org/13130 Tested-by: build bot (Jenkins) Reviewed-by: Stefan Reinauer <stefan.reinauer(a)coreboot.org> See https://review.coreboot.org/13130 for details. -gerrit

1 0

Patch set updated for coreboot: google/oak: Initialize DRAM
by Stefan Reinauer 03 Feb '16

03 Feb '16

Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/13106 -gerrit commit 7bb0859473d77399cc3b54e57d1437fa3eac9653 Author: Peter Kao <peter.kao(a)mediatek.com> Date: Fri Jul 31 17:11:14 2015 +0800 google/oak: Initialize DRAM BUG=none TEST=emerge-oak coreboot BRANCH=none Change-Id: I3ed8bad1bdc7d17e334e0136f92a51c8e7ba4e67 Signed-off-by: Patrick Georgi <pgeorgi(a)chromium.org> Original-Commit-Id: b614eeb1bba5660438c214e82225832809caca8e Original-Change-Id: I0f7b0a426dae1548b34114a024c92befdf6002f6 Original-Signed-off-by: Peter Kao <peter.kao(a)mediatek.com> Original-Reviewed-on: https://chromium-review.googlesource.com/292692 Original-Commit-Ready: Yidi Lin <yidi.lin(a)mediatek.com> Original-Tested-by: Yidi Lin <yidi.lin(a)mediatek.com> Original-Reviewed-by: Julius Werner <jwerner(a)chromium.org> --- src/mainboard/google/oak/Makefile.inc | 2 +- src/mainboard/google/oak/romstage.c | 8 ++ src/mainboard/google/oak/sdram_configs.c | 49 +++++++++ .../oak/sdram_inf/sdram-lpddr3-hynix-2GB.inc | 116 +++++++++++++++++++++ .../oak/sdram_inf/sdram-lpddr3-samsung-2GB.inc | 116 +++++++++++++++++++++ .../google/oak/sdram_inf/sdram-unused.inc | 3 + 6 files changed, 293 insertions(+), 1 deletion(-) diff --git a/src/mainboard/google/oak/Makefile.inc b/src/mainboard/google/oak/Makefile.inc index c7f0401..f0bbb7b 100644 --- a/src/mainboard/google/oak/Makefile.inc +++ b/src/mainboard/google/oak/Makefile.inc @@ -22,7 +22,7 @@ verstage-y += chromeos.c verstage-y += memlayout.ld romstage-y += chromeos.c -romstage-y += romstage.c +romstage-y += romstage.c sdram_configs.c romstage-y += memlayout.ld romstage-y += boardid.c diff --git a/src/mainboard/google/oak/romstage.c b/src/mainboard/google/oak/romstage.c index a60a50d..d72693f 100644 --- a/src/mainboard/google/oak/romstage.c +++ b/src/mainboard/google/oak/romstage.c @@ -19,6 +19,7 @@ #include <arch/mmu.h> #include <cbfs.h> +#include <cbmem.h> #include <console/console.h> #include <delay.h> #include <program_loading.h> @@ -26,6 +27,7 @@ #include <symbols.h> #include <timestamp.h> +#include <soc/emi.h> #include <soc/mmu_operations.h> #include <soc/rtc.h> @@ -39,7 +41,13 @@ void main(void) rtc_boot(); + /* init memory */ + mt_mem_init(get_sdram_config()); + mt8173_mmu_after_dram(); + /* should be called after memory init */ + cbmem_initialize_empty(); + run_ramstage(); } diff --git a/src/mainboard/google/oak/sdram_configs.c b/src/mainboard/google/oak/sdram_configs.c new file mode 100644 index 0000000..f2b5362 --- /dev/null +++ b/src/mainboard/google/oak/sdram_configs.c @@ -0,0 +1,49 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#include <boardid.h> +#include <console/console.h> +#include <soc/emi.h> +#include <stdlib.h> + +static const struct mt8173_sdram_params sdram_configs[] = { +#include "sdram_inf/sdram-lpddr3-hynix-2GB.inc" /* ram_code = 0000 */ +#include "sdram_inf/sdram-lpddr3-samsung-2GB.inc" /* ram_code = 0001 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 0010 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 0011 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 0100 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 0101 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 0110 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 0111 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1000 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1001 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1010 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1011 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1100 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1101 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1110 */ +#include "sdram_inf/sdram-unused.inc" /* ram_code = 1111 */ +}; + +const struct mt8173_sdram_params *get_sdram_config(void) +{ + u32 ramcode = ram_code(); + + if (ramcode >= ARRAY_SIZE(sdram_configs) + || sdram_configs[ramcode].type == TYPE_INVALID) + die("Invalid RAMCODE."); + + return &sdram_configs[ramcode]; +} diff --git a/src/mainboard/google/oak/sdram_inf/sdram-lpddr3-hynix-2GB.inc b/src/mainboard/google/oak/sdram_inf/sdram-lpddr3-hynix-2GB.inc new file mode 100644 index 0000000..4e728e3 --- /dev/null +++ b/src/mainboard/google/oak/sdram_inf/sdram-lpddr3-hynix-2GB.inc @@ -0,0 +1,116 @@ +{ /* 2GB (8Gb + 8Gb) for single rank dram setting */ + { + .impedance_drvp = 0x9, + .impedance_drvn = 0xa, + .datlat_ucfirst = 19, + + .ca_train = { + [CHANNEL_A] = { 7, 7, 5, 6, 2, 1, 0, 1, 0, 2}, + [CHANNEL_B] = { 1, 2, 2, 0, 2, 3, 3, 3, 3, 3} + }, + + .ca_train_center = { + [CHANNEL_A] = 2, + [CHANNEL_B] = 0 + }, + + .wr_level = { + [CHANNEL_A] = { 5, 6, 5, 6}, + [CHANNEL_B] = { 6, 6, 6, 4} + }, + + .gating_win = { + [CHANNEL_A] = { + { 28, 56}, + { 0, 0} + }, + [CHANNEL_B] = { + { 28, 56}, + { 0, 0} + } + }, + + .rx_dqs_dly = { + [CHANNEL_A] = 0x110e0b0b, + [CHANNEL_B] = 0x12100d0d + }, + + .rx_dq_dly = { + [CHANNEL_A] = { + 0x01040302, + 0x04010300, + 0x02040300, + 0x04030302, + 0x04070400, + 0x07070707, + 0x05070808, + 0x00010404 + }, + [CHANNEL_B] = { + 0x05060604, + 0x04010400, + 0x05070300, + 0x05030504, + 0x07090500, + 0x08090707, + 0x080a0a0a, + 0x02000604 + } + }, + }, + { + .actim = 0xaafd478c, + .actim1 = 0x91001f59, + .actim05t = 0x000025e1, + .conf1 = 0x00048403, + .conf2 = 0x030000a9, + .ddr2ctl = 0x000063b1, + .gddr3ctl1 = 0x11000000, + .misctl0 = 0x21000000, + .pd_ctrl = 0xd1976442, + .rkcfg = 0x002156c0, + .test2_3 = 0xbfc70401, + .test2_4 = 0x2801110d + }, + { + .cona = 0x20102017, + .conb = 0x17283544, + .conc = 0x0a1a0b1a, + .cond = 0x00000000, + .cone = 0xffff0848, + .conf = 0x08420000, + .cong = 0x2b2b2a38, + .conh = 0x00000000, + .conm_1 = 0x40000500, + .conm_2 = 0x400005ff, + .mdct_1 = 0x80030303, + .mdct_2 = 0x34220c3f, + .test0 = 0xcccccccc, + .test1 = 0xcccccccc, + .testb = 0x00060124, + .testc = 0x38470000, + .testd = 0x00000000, + .arba = 0x7f077a49, + .arbc = 0xa0a070dd, + .arbd = 0x07007046, + .arbe = 0x40407046, + .arbf = 0xa0a070c6, + .arbg = 0xffff7047, + .arbi = 0x20406188, + .arbj = 0x9719595e, + .arbk = 0x64f3fc79, + .slct_1 = 0x00010800, + .slct_2 = 0xff03ff00, + .bmen = 0x00ff0001 + }, + { + .mrs_1 = 0x00830001, + .mrs_2 = 0x001c0002, + .mrs_3 = 0x00010003, + .mrs_10 = 0x00ff000a, + .mrs_11 = 0x0000000b, + .mrs_63 = 0x0000003f + }, + .type = TYPE_LPDDR3, + .dram_freq = 896 * MHz, +}, diff --git a/src/mainboard/google/oak/sdram_inf/sdram-lpddr3-samsung-2GB.inc b/src/mainboard/google/oak/sdram_inf/sdram-lpddr3-samsung-2GB.inc new file mode 100644 index 0000000..4c58286 --- /dev/null +++ b/src/mainboard/google/oak/sdram_inf/sdram-lpddr3-samsung-2GB.inc @@ -0,0 +1,116 @@ +{ /* 2GB (8Gb + 8Gb) for dual rank dram setting */ + { + .impedance_drvp = 0x9, + .impedance_drvn = 0xa, + .datlat_ucfirst = 18, + + .ca_train = { + [CHANNEL_A] = { 6, 4, 3, 5, 4, 0, 0, 0, 0, 0}, + [CHANNEL_B] = { 1, 1, 1, 1, 0, 6, 5, 5, 5, 7} + }, + + .ca_train_center = { + [CHANNEL_A] = 3, + [CHANNEL_B] = 3 + }, + + .wr_level = { + [CHANNEL_A] = { 8, 10, 6, 8}, + [CHANNEL_B] = { 9, 9, 7, 6} + }, + + .gating_win = { + [CHANNEL_A] = { + { 27, 64}, + { 27, 72} + }, + [CHANNEL_B] = { + { 27, 72}, + { 27, 72} + } + }, + + .rx_dqs_dly = { + [CHANNEL_A] = 0x08080908, + [CHANNEL_B] = 0x0b0b060b + }, + + .rx_dq_dly = { + [CHANNEL_A] = { + 0x01010300, + 0x06030002, + 0x01010201, + 0x03020002, + 0x00010103, + 0x02010201, + 0x02040200, + 0x02020201 + }, + [CHANNEL_B] = { + 0x00020202, + 0x02020202, + 0x01020201, + 0x01010100, + 0x01010101, + 0x01000002, + 0x02000201, + 0x00010101, + } + }, + }, + { + .actim = 0xaafd478c, + .actim1 = 0x91001f59, + .actim05t = 0x000025e1, + .conf1 = 0x00048403, + .conf2 = 0x030000a9, + .ddr2ctl = 0x000063b1, + .gddr3ctl1 = 0x11000000, + .misctl0 = 0x21000000, + .pd_ctrl = 0xd1976442, + .rkcfg = 0x002156c1, + .test2_3 = 0xbfc70401, + .test2_4 = 0x2801110d + }, + { + .cona = 0x50535057, + .conb = 0x17283544, + .conc = 0x0a1a0b1a, + .cond = 0x00000000, + .cone = 0xffff0848, + .conf = 0x08420000, + .cong = 0x2b2b2a38, + .conh = 0x00000000, + .conm_1 = 0x40000500, + .conm_2 = 0x400005ff, + .mdct_1 = 0x80030303, + .mdct_2 = 0x34220c3f, + .test0 = 0xcccccccc, + .test1 = 0xcccccccc, + .testb = 0x00060124, + .testc = 0x38470000, + .testd = 0x00000000, + .arba = 0x7f077a49, + .arbc = 0xa0a070dd, + .arbd = 0x07007046, + .arbe = 0x40407046, + .arbf = 0xa0a070c6, + .arbg = 0xffff7047, + .arbi = 0x20406188, + .arbj = 0x9719595e, + .arbk = 0x64f3fc79, + .slct_1 = 0x00010800, + .slct_2 = 0xff03ff00, + .bmen = 0x00ff0001 + }, + { + .mrs_1 = 0x00830001, + .mrs_2 = 0x001c0002, + .mrs_3 = 0x00010003, + .mrs_10 = 0x00ff000a, + .mrs_11 = 0x0000000b, + .mrs_63 = 0x0000003f + }, + .type = TYPE_LPDDR3, + .dram_freq = 896 * MHz, +}, diff --git a/src/mainboard/google/oak/sdram_inf/sdram-unused.inc b/src/mainboard/google/oak/sdram_inf/sdram-unused.inc new file mode 100644 index 0000000..21b2859 --- /dev/null +++ b/src/mainboard/google/oak/sdram_inf/sdram-unused.inc @@ -0,0 +1,3 @@ +{ + .type = TYPE_INVALID, +},

1 0

Patch set updated for coreboot: mediatek/mt8173: Add EMI driver, DRAM initialization
by Stefan Reinauer 03 Feb '16

03 Feb '16

Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/13105 -gerrit commit 4e13cd2241e3e00ab2e59068d292ca858b21814b Author: Peter Kao <peter.kao(a)mediatek.com> Date: Fri Jul 31 17:11:14 2015 +0800 mediatek/mt8173: Add EMI driver, DRAM initialization BUG=none TEST=emerge-oak coreboot BRANCH=none Change-Id: I6b05898de2d0022e0de7b18f1db3c3e9c06d8135 Signed-off-by: Patrick Georgi <pgeorgi(a)chromium.org> Original-Commit-Id: b614eeb1bba5660438c214e82225832809caca8e Original-Change-Id: I0f7b0a426dae1548b34114a024c92befdf6002f6 Original-Signed-off-by: Peter Kao <peter.kao(a)mediatek.com> Original-Reviewed-on: https://chromium-review.googlesource.com/292692 Original-Commit-Ready: Yidi Lin <yidi.lin(a)mediatek.com> Original-Tested-by: Yidi Lin <yidi.lin(a)mediatek.com> Original-Reviewed-by: Julius Werner <jwerner(a)chromium.org> --- src/soc/mediatek/mt8173/Kconfig | 4 + src/soc/mediatek/mt8173/Makefile.inc | 3 + src/soc/mediatek/mt8173/dramc_pi_basic_api.c | 879 +++++++++++++++ src/soc/mediatek/mt8173/dramc_pi_calibration_api.c | 1150 ++++++++++++++++++++ src/soc/mediatek/mt8173/emi.c | 142 +++ src/soc/mediatek/mt8173/include/soc/dramc_common.h | 42 + src/soc/mediatek/mt8173/include/soc/dramc_pi_api.h | 187 ++++ .../mediatek/mt8173/include/soc/dramc_register.h | 522 +++++++++ src/soc/mediatek/mt8173/include/soc/emi.h | 140 +++ src/soc/mediatek/mt8173/include/soc/pll.h | 5 + src/soc/mediatek/mt8173/memory.c | 357 ++++++ src/soc/mediatek/mt8173/pll.c | 26 + 12 files changed, 3457 insertions(+) diff --git a/src/soc/mediatek/mt8173/Kconfig b/src/soc/mediatek/mt8173/Kconfig index b44c360..ec192e5 100644 --- a/src/soc/mediatek/mt8173/Kconfig +++ b/src/soc/mediatek/mt8173/Kconfig @@ -18,6 +18,10 @@ config SOC_MEDIATEK_MT8173 if SOC_MEDIATEK_MT8173 +config MEMORY_TEST + bool + default n + config DEBUG_SOC_DRIVER bool "The top level switch for soc driver debug message" default n diff --git a/src/soc/mediatek/mt8173/Makefile.inc b/src/soc/mediatek/mt8173/Makefile.inc index fa344c0..7b6dc75 100644 --- a/src/soc/mediatek/mt8173/Makefile.inc +++ b/src/soc/mediatek/mt8173/Makefile.inc @@ -43,6 +43,7 @@ verstage-$(CONFIG_SPI_FLASH) += flash_controller.c ################################################################################ romstage-$(CONFIG_SPI_FLASH) += flash_controller.c +romstage-y += pll.c romstage-y += timer.c romstage-$(CONFIG_DRIVERS_UART) += uart.c @@ -50,6 +51,8 @@ romstage-y += cbmem.c romstage-y += spi.c romstage-y += gpio.c romstage-y += pmic_wrap.c mt6391.c +romstage-y += memory.c +romstage-y += emi.c dramc_pi_basic_api.c dramc_pi_calibration_api.c romstage-y += mmu_operations.c romstage-y += rtc.c diff --git a/src/soc/mediatek/mt8173/dramc_pi_basic_api.c b/src/soc/mediatek/mt8173/dramc_pi_basic_api.c new file mode 100644 index 0000000..ac28373 --- /dev/null +++ b/src/soc/mediatek/mt8173/dramc_pi_basic_api.c @@ -0,0 +1,879 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#include <arch/barrier.h> +#include <arch/io.h> +#include <assert.h> +#include <console/console.h> +#include <delay.h> +#include <soc/addressmap.h> +#include <soc/dramc_common.h> +#include <soc/dramc_register.h> +#include <soc/dramc_pi_api.h> +#include <soc/emi.h> +#include <soc/mt6391.h> +#include <soc/pll.h> +#include <soc/spm.h> +#include <string.h> +#include <types.h> + +struct mem_pll { + u8 delay; + u8 phase; + u8 done; +}; + +inline u8 is_dual_rank(u32 channel, + const struct mt8173_sdram_params *sdram_params) +{ + /* judge ranks from EMI_CONA[17] (cha) and EMI_CONA[16] (chb) */ + return (sdram_params->emi_set.cona & (1 << (17 - channel))) ? 1 : 0; +} + +static void mem_pll_pre_init(u32 channel) +{ + write32(&ch[channel].ddrphy_regs->lpddr2_3, 0x1 << 29 | 0x1 << 25 | + 0xf << 16 | 0xffff); + + write32(&ch[channel].ddrphy_regs->lpddr2_4, 0x1 << 29 | 0x1 << 25 | + 0xf << 16 | 0xffff); + + /* adjust DQS/DQM phase to get best margin */ + write32(&ch[channel].ddrphy_regs->selph12, 0x1 << 28 | 0xf << 20 | + 0x1 << 12 | 0xf << 4); + /* adjust DQ phase to get best margin */ + write32(&ch[channel].ddrphy_regs->selph13, 0xffffffff << 0); + write32(&ch[channel].ddrphy_regs->selph14, 0xffffffff << 0); + + /* fix OCV effect */ + write32(&ch[channel].ddrphy_regs->selph15, 0x1 << 4 | 0xf << 0); + + /* pll register control by CPU and select internal pipe path */ + write32(&ch[channel].ddrphy_regs->peri[2], 0x11 << 24 | 0x11 << 16 | + 0xff << 8 | 0x11 << 0); + write32(&ch[channel].ddrphy_regs->peri[3], 0x11 << 24 | 0x51 << 16 | + 0x11 << 8 | 0x11 << 0); + + /* enable clock sync and spm control clock */ + write32(&ch[channel].ddrphy_regs->mempll_divider, 0x9 << 24 | + 0x1 << 15 | + 0x2 << 4 | + 0x1 << 1 | + 0x1 << 0); + /* pll2 enable from CPU control */ + write32(&ch[channel].ddrphy_regs->mempll05_divider, 0x1 << 27); + + /* enable chip top memory clock */ + setbits_le32(&ch[channel].ddrphy_regs->mempll_divider, 0x1 << 4); + + /* disable C/A and DQ M_CK clock gating */ + clrbits_le32(&ch[channel].ddrphy_regs->ddrphy_cg_ctrl, 0x1 << 2 | + 0x1 << 1); + + /* enable spm control clock */ + clrbits_le32(&ch[channel].ddrphy_regs->mempll_divider, 0x1 << 15 | + 0x1 << 0); + /* enable dramc 2X mode */ + setbits_le32(&ch[channel].ao_regs->ddr2ctl, 1 << 0); + + /* select internal clock path */ + write32(&ch[channel].ddrphy_regs->peri[0], 0x21 << 24 | 0x27 << 16 | + 0x1b << 8 | 0x3 << 0); + + write32(&ch[channel].ddrphy_regs->peri[1], 0x50 << 24 | 0x96 << 16 | + 0x6 << 8 | 0x1e << 0); + + /* trigger to make memory clock correct phase */ + setbits_le32(&ch[channel].ddrphy_regs->mempll_divider, 0x1 << 24 | + 0x1 << 7); + + if(channel == CHANNEL_A) { + /* select memory clock sync for channel A (internal source) */ + clrbits_le32(&ch[channel].ddrphy_regs->mempll_divider, 0x1 << 3); + } +} + +static void mem_pll_init_set_params(u32 channel) +{ + u32 pattern1, pattern2, pattern3; + u32 mempll_ic_3_0, mempll_bp_3_0; + u32 mempll_fbdiv_6_0, mempll_m4pdiv_1_0; + u32 mempll_br_1_0, mempll_bc_1_0, mempll_ir_3_0; + + mempll_fbdiv_6_0 = 0x7 << 16; + mempll_br_1_0 = 0x1 << 10; + mempll_bc_1_0 = 0x0 << 8; + mempll_ir_3_0 = 0xc << 28; + mempll_ic_3_0 = 0x6 << 8; + mempll_bp_3_0 = 0x1 << 12; + mempll_m4pdiv_1_0 = 0x0 << 28; + + write32(&ch[channel].ddrphy_regs->mempll[14], 0x0); + + write32(&ch[channel].ddrphy_regs->mempll[3], 0x3 << 30 | + 0x1 << 28); + /* mempll 2 config */ + pattern1 = mempll_ir_3_0 | mempll_fbdiv_6_0 | mempll_ic_3_0; + pattern2 = mempll_m4pdiv_1_0; + pattern3 = mempll_bp_3_0 | mempll_br_1_0 | mempll_bc_1_0; + + /* mempll2_autok_en = 1, mempll2_autok_load = 1 */ + write32(&ch[channel].ddrphy_regs->mempll[5], 0x1 << 26 | 0x3 << 24 | + 0x1 << 23 | pattern1); + write32(&ch[channel].ddrphy_regs->mempll[6], 0x1 << 30 | 0x3 << 26 | + 0x3 << 14 | pattern2); + write32(&ch[channel].ddrphy_regs->mempll[7], 0x1 << 17 | 0x1 << 0 | + pattern3); + /* mempll 4 */ + write32(&ch[channel].ddrphy_regs->mempll[11], 0x1 << 26 | 0x3 << 24 | + 0x1 << 23 | pattern1); + write32(&ch[channel].ddrphy_regs->mempll[12], 0x1 << 30 | 0x3 << 26 | + 0x3 << 14 | pattern2); + write32(&ch[channel].ddrphy_regs->mempll[13], 0x1 << 0 | pattern3); + + /* mempll 3 - enable signal tie together */ + write32(&ch[channel].ddrphy_regs->mempll[8], 0x1 << 26 | 0x3 << 24 | + 0x1 << 23 | pattern1); + write32(&ch[channel].ddrphy_regs->mempll[9], 0x1 << 30 | 0x3 << 26 | + 0x3 << 14 | pattern2); + write32(&ch[channel].ddrphy_regs->mempll[10], 0x1 << 17 | 0x1 << 0 | + pattern3); +} + +static void mem_pll_init_phase_sync(u32 channel) +{ + write32(&ch[channel].ddrphy_regs->mempll_divider, BIT(27) | BIT(24) | + BIT(7) | BIT(5) | + BIT(4) | BIT(0)); + /* spm control clock enable */ + clrsetbits_le32(&ch[channel].ddrphy_regs->mempll_divider, BIT(0), + BIT(1)); + + clrsetbits_le32(&ch[channel].ddrphy_regs->mempll_divider, BIT(1), + BIT(0)); +} + +static void pll_phase_adjust(u32 channel, struct mem_pll *mempll, int reg_offs) +{ + switch (mempll->phase) { + + case MEMPLL_INIT: + /* initial phase: zero out RG_MEPLL(2,3,4)_(REF_DL,FB)_DL */ + clrbits_le32(&ch[channel].ddrphy_regs->mempll[reg_offs], + 0x1f << MEMPLL_REF_DL_SHIFT | + 0x1f << MEMPLL_FB_DL_SHIFT); + break; + + case MEMPLL_REF_LAG: + /* REF lag FBK, delay FBK */ + clrsetbits_le32(&ch[channel].ddrphy_regs->mempll[reg_offs], + 0x1f << MEMPLL_REF_DL_SHIFT | + 0x1f << MEMPLL_FB_DL_SHIFT, + mempll->delay << MEMPLL_FB_DL_SHIFT); + break; + + case MEMPLL_REF_LEAD: + /* REF lead FBK, delay REF */ + clrsetbits_le32(&ch[channel].ddrphy_regs->mempll[reg_offs], + 0x1f << MEMPLL_REF_DL_SHIFT | + 0x1f << MEMPLL_FB_DL_SHIFT, + mempll->delay << MEMPLL_REF_DL_SHIFT); + }; +} + +static void pll_phase_check(u32 channel, struct mem_pll *mempll, int idx) +{ + u32 value = read32(&ch[channel].ddrphy_regs->jmeter_pll_st[idx]); + u16 one_count = (u16)((value >> 16) & 0xffff); + u16 zero_count = (u16)(value & 0xffff); + + dramc_dbg_msg("PLL %d, phase %d, one_count %d, zero_count %d\n", + (idx + 2), mempll->phase, one_count, zero_count); + + switch (mempll->phase) { + + case MEMPLL_INIT: + if ((one_count - zero_count) > JMETER_COUNT_N) { + /* REF lag FBK */ + mempll->phase = MEMPLL_REF_LAG; + mempll->delay++; + } else if ((zero_count - one_count) > JMETER_COUNT_N) { + /* REF lead FBK */ + mempll->phase = MEMPLL_REF_LEAD; + mempll->delay++; + } else { + /* in-phase at initial */ + mempll->done = 1; + } + break; + + case MEMPLL_REF_LAG: + if (JMETER_COUNT_N >= (one_count - zero_count)) { + mempll->done = 1; + } else { + mempll->delay++; + } + break; + + case MEMPLL_REF_LEAD: + if (JMETER_COUNT_N >= (zero_count - one_count)) { + mempll->done = 1; + } else { + mempll->delay++; + } + } +} + +static void mem_pll_phase_cali(u32 channel) +{ + u32 i; + + struct mem_pll mempll[3] = + { + {0, 0, 0}, + {0, 0, 0}, + {0, 0, 0}, + }; + + dramc_dbg_msg("[PLL_Phase_Calib] ===== PLL Phase Calibration: "); + dramc_dbg_msg("CHANNEL %d (0: CHA, 1: CHB) =====\n", channel); + + /* 1. set jitter meter count number to 1024 for mempll 2 3 4 */ + for (i = 0; i < 3; i++) + clrsetbits_le32(&ch[channel].ddrphy_regs->jmeter[i], + JMETER_COUNTER_MASK, + JMETER_COUNT << JMETER_COUNTER_SHIFT); + + while (1) { + + for (i = 0; i < 3; i++) { + if (!mempll[i].done) { + pll_phase_adjust(channel, &mempll[i], (i + 2) * 3); + } + } + + udelay(20); /* delay 20us for external loop pll stable */ + + /* 2. enable mempll 2 3 4 jitter meter */ + for (i = 0; i < 3; i++) + setbits_le32(&ch[channel].ddrphy_regs->jmeter[i], + JMETER_EN_BIT); + + /* 3. wait for jitter meter complete */ + udelay(JMETER_WAIT_DONE_US); + + /* 4. check jitter meter counter value for mempll 2 3 4 */ + for (i = 0; i < 3; i++) { + if (!mempll[i].done) { + pll_phase_check(channel, &mempll[i], i); + } + } + + /* 5. disable mempll 2 3 4 jitter meter */ + for (i = 0; i < 3; i++) + clrbits_le32(&ch[channel].ddrphy_regs->jmeter[i], + JMETER_EN_BIT); + + /* 6. all done early break */ + if (mempll[0].done && mempll[1].done && mempll[2].done) + break; + + /* 7. delay line overflow break */ + for (i = 0; i < 3; i++) { + if(mempll[i].delay >= 32) { + die("MEMPLL calibration fail\n"); + } + } + } + + dramc_dbg_msg("pll done: "); + + dramc_dbg_msg("%d, %d, %d\n", + mempll[0].done, mempll[1].done, mempll[2].done); + dramc_dbg_msg("pll dl: %d, %d, %d\n", + mempll[0].delay, mempll[1].delay, mempll[2].delay); +} + +void mem_pll_init(const struct mt8173_sdram_params *sdram_params) +{ + u32 channel; + + /* udelay waits for PLL to stabilize in this function */ + printk(BIOS_DEBUG, "[PLL] mempll_init and cali\n"); + + /* mempll pre_init for two channels */ + for (channel = 0; channel < CHANNEL_NUM; channel++) + mem_pll_pre_init(channel); + + /* only set once in MPLL */ + mt_mem_pll_config_pre(sdram_params); + + for (channel = 0; channel < CHANNEL_NUM; channel++) + mem_pll_init_set_params(channel); + + udelay(1); /* wait after da_mpll_sdm_iso_en goes low */ + + /* only set once in MPLL */ + mt_mem_pll_config_post(); + + udelay(100); + + for (channel = 0; channel < CHANNEL_NUM; channel++) { + + /* mempll_bias_en */ + write32(&ch[channel].ddrphy_regs->mempll[3], 0xd << 28 | + 0x1 << 6); + udelay(2); + + /* mempll2_en -> mempll4_en -> mempll3_en */ + setbits_le32(&ch[channel].ddrphy_regs->mempll[5], 1 << 0); + setbits_le32(&ch[channel].ddrphy_regs->mempll[11], 1 << 0); + setbits_le32(&ch[channel].ddrphy_regs->mempll[8], 1 << 0); + + udelay(100); + + /* mempll_bias_lpf_en */ + setbits_le32(&ch[channel].ddrphy_regs->mempll[3], 1 << 7); + + udelay(30); + + /* select mempll4 band register */ + setbits_le32(&ch[channel].ddrphy_regs->mempll[4], 1 << 26); + clrbits_le32(&ch[channel].ddrphy_regs->mempll[4], 1 << 26); + + /* PLL ready */ + + /* disable mempll2_en -> mempll4_en -> mempll3_en */ + clrbits_le32(&ch[channel].ddrphy_regs->mempll[5], 1 << 0); + clrbits_le32(&ch[channel].ddrphy_regs->mempll[11], 1 << 0); + clrbits_le32(&ch[channel].ddrphy_regs->mempll[8], 1 << 0); + + /* disable autok mempll2_en -> mempll4_en -> mempll3_en */ + clrbits_le32(&ch[channel].ddrphy_regs->mempll[5], 1 << 23); + clrbits_le32(&ch[channel].ddrphy_regs->mempll[11], 1 << 23); + clrbits_le32(&ch[channel].ddrphy_regs->mempll[8], 1 << 23); + + udelay(1); + + /* mempll[2->4->3]_fb_mck_sel=1 (switch to outer loop) */ + setbits_le32(&ch[channel].ddrphy_regs->mempll[6], 1 << 25); + setbits_le32(&ch[channel].ddrphy_regs->mempll[12], 1 << 25); + setbits_le32(&ch[channel].ddrphy_regs->mempll[9], 1 << 25); + + udelay(1); + + /* enable mempll2_en -> mempll4_en -> mempll3_en */ + setbits_le32(&ch[channel].ddrphy_regs->mempll[5], 1 << 0); + setbits_le32(&ch[channel].ddrphy_regs->mempll[11], 1 << 0); + setbits_le32(&ch[channel].ddrphy_regs->mempll[8], 1 << 0); + } + + /* mempll new power-on */ + write32(&mt8173_spm->poweron_config_set, 0x1 << 0 | + SPM_PROJECT_CODE << 16); + /* request mempll reset/pdn mode */ + setbits_le32(&mt8173_spm->power_on_val0, 0x1 << 27); + + udelay(2); + + /* unrequest mempll reset/pdn mode and wait settle */ + clrbits_le32(&mt8173_spm->power_on_val0, 0x1 << 27); + + udelay(31); /* PLL ready */ + + for (channel = 0; channel < CHANNEL_NUM; channel++) + mem_pll_init_phase_sync(channel); + + udelay(1); + + /* mempll calibration for two channels */ + for (channel = 0; channel < CHANNEL_NUM; channel++) + mem_pll_phase_cali(channel); + + div2_phase_sync(); /* phase sync for channel B */ + + mt_mem_pll_mux(); +} + +void dramc_pre_init(u32 channel, const struct mt8173_sdram_params *sdram_params) +{ + /* txdly_cs, txdly_cs1 */ + write32(&ch[channel].ao_regs->selph1, 0x0); + /* txdly_dqsgate, txdly_dqsgate_p1 */ + write32(&ch[channel].ao_regs->selph2, 0x3 << 20 | 0x2 << 12); + /* txldy_ra* */ + write32(&ch[channel].ao_regs->selph3, 0x0); + /* txldy_ra* */ + write32(&ch[channel].ao_regs->selph4, 0x0); + + /* setting of write latency (WL=8) */ + write32(&ch[channel].ao_regs->selph7, 0x3333 << 16 | 0x3333); + write32(&ch[channel].ao_regs->selph8, 0x3333 << 16 | 0x3333); + write32(&ch[channel].ao_regs->selph9, 0x3333 << 16 | 0x3333); + write32(&ch[channel].ao_regs->selph10, 0x5555 << 16 | 0xffff); + write32(&ch[channel].ao_regs->selph11, 0x55 << 16 | 0xff); + + write32(&ch[channel].ao_regs->selph5, 0x1 << 26 | 0x2 << 22 | + 0x1 << 20 | 0x5 << 16 | + 0x5555); + + write32(&ch[channel].ao_regs->selph6_1, 0x4 << 8 | 0x3 << 4 | + 0x2 << 0); + + write32(&ch[channel].ao_regs->ac_time_05t, + sdram_params->ac_timing.actim05t); +} + +static void mrs_write(int channel, int rank, u32 mrs_value, unsigned int dly) +{ + write32(&ch[channel].ao_regs->mrs, rank << 28 | mrs_value); + + write32(&ch[channel].ao_regs->spcmd, 0x1); + udelay(dly); + write32(&ch[channel].ao_regs->spcmd, 0x0); +} + +static void dramc_set_mrs_value(int channel, int rank, + const struct mt8173_sdram_params *sdram_params) +{ + /* MR63 -> Reset, Wait >=10us if not check DAI */ + mrs_write(channel, rank, sdram_params->mrs_set.mrs_63, 10); + /* MR10 -> ZQ Init, tZQINIT>=1us */ + mrs_write(channel, rank, sdram_params->mrs_set.mrs_10, 1); + /* MR3 driving stregth set to max */ + mrs_write(channel, rank, sdram_params->mrs_set.mrs_3, 1); + /* MR1 */ + mrs_write(channel, rank, sdram_params->mrs_set.mrs_1, 1); + /* MR2 */ + mrs_write(channel, rank, sdram_params->mrs_set.mrs_2, 1); + /* MR11 ODT disable */ + mrs_write(channel, rank, sdram_params->mrs_set.mrs_11, 1); +} + +void dramc_init(u32 channel, const struct mt8173_sdram_params *sdram_params) +{ + u32 bit, dual_rank_set; + + const struct mt8173_calib_params *calib_params; + + dual_rank_set = is_dual_rank(channel, sdram_params); + calib_params = &sdram_params->calib_params; + + write32(&ch[channel].ddrphy_regs->peri[2], 0x1 << 12 | + 0x1 << 4); + + write32(&ch[channel].ddrphy_regs->peri[3], 0x0); + + write32(&ch[channel].ao_regs->test2_4, + sdram_params->ac_timing.test2_4); + + write32(&ch[channel].ao_regs->clk1delay, 0x1 << 23 | + 0x1 << 22 | + 0x1 << 21); + + /* rank config */ + assert((sdram_params->ac_timing.rkcfg & 0x1) == dual_rank_set); + write32(&ch[channel].ao_regs->rkcfg, + sdram_params->ac_timing.rkcfg); + + /* pimux */ + write32(&ch[channel].ao_regs->mckdly, 0x1 << 30 | + 0x1 << 20 | + 0x1 << 4); + + write32(&ch[channel].ddrphy_regs->mckdly, 0x1 << 8); + + write32(&ch[channel].ao_regs->padctl4, 0x1 << 0); + + /* tCKEH/tCKEL extend 1T */ + write32(&ch[channel].ao_regs->dummy, 0x1 << 31 | + 0x3 << 10 | + 0x1 << 4); + + /* driving control */ + write32(&ch[channel].ao_regs->iodrv6, DEFAULT_DRIVING | + DRIVING_DS2_0 << 20 | + DRIVING_DS2_0 << 4); + + write32(&ch[channel].ddrphy_regs->drvctl1, DEFAULT_DRIVING | + DRIVING_DS2_0 << 20); + + write32(&ch[channel].ao_regs->drvctl1, DEFAULT_DRIVING | + DRIVING_DS2_0 << 4); + + /* enable dqs signal output */ + write32(&ch[channel].ddrphy_regs->ioctl, 0x0); + + /* rank 0 dqs gating delay */ + write32(&ch[channel].ao_regs->dqsien[0], 0x40 << 24 | + 0x40 << 16 | + 0x40 << 8 | + 0x40 << 0); + + write32(&ch[channel].ao_regs->dqsctl1, 0x1 << 28 | + 0x5 << 24); + + write32(&ch[channel].ao_regs->dqsctl2, 0x5 << 0); + write32(&ch[channel].ao_regs->phyctl1, 0x1 << 25); + write32(&ch[channel].ao_regs->gddr3ctl1, 0x1 << 24); + write32(&ch[channel].ddrphy_regs->gddr3ctl1, 0x1 << 28); + write32(&ch[channel].ao_regs->arbctl0, 0x80 << 0); + + /* enable clock pad 0 */ + write32(&ch[channel].ao_regs->clkctl, 0x1 << 28); + + udelay(1); + + write32(&ch[channel].ao_regs->conf1, + sdram_params->ac_timing.conf1); + + write32(&ch[channel].ddrphy_regs->dqsgctl, 0x1 << 31 | + 0x1 << 30 | + 0x1 << 4 | + 0x1 << 0); + + write32(&ch[channel].ao_regs->dqscal0, 0x0); + write32(&ch[channel].ddrphy_regs->dqscal0, 0x0); + + write32(&ch[channel].ao_regs->actim0, + sdram_params->ac_timing.actim); + + write32(&ch[channel].ao_regs->misctl0, + sdram_params->ac_timing.misctl0); + write32(&ch[channel].ddrphy_regs->misctl0, + sdram_params->ac_timing.misctl0); + + write32(&ch[channel].ao_regs->perfctl0, 0x1 << 20); + + write32(&ch[channel].ao_regs->ddr2ctl, + sdram_params->ac_timing.ddr2ctl); + write32(&ch[channel].ddrphy_regs->ddr2ctl, + sdram_params->ac_timing.ddr2ctl); + + write32(&ch[channel].ao_regs->misc, 0xb << 8 | + 0x1 << 7 | + 0x1 << 6 | + 0x1 << 5); + + write32(&ch[channel].ao_regs->dllconf, 0xf << 28 | + 0x1 << 24); + + write32(&ch[channel].ao_regs->actim1, + sdram_params->ac_timing.actim1); + + write32(&ch[channel].ddrphy_regs->dqsisel, 0x0); + + /* disable ODT before ZQ calibration */ + write32(&ch[channel].ao_regs->wodt, 0x1 << 0); + + write32(&ch[channel].ao_regs->padctl4, 0x1 << 2 | + 0x1 << 0); + + udelay(200); /* tINIT3 > 200us */ + + write32(&ch[channel].ao_regs->gddr3ctl1, 0x1 << 24 | + 0x1 << 20); + + write32(&ch[channel].ddrphy_regs->gddr3ctl1, 0x1 << 28); + + /* set mode register value */ + dramc_set_mrs_value(channel, 0, sdram_params); + + if (dual_rank_set) + dramc_set_mrs_value(channel, 1, sdram_params); + + write32(&ch[channel].ao_regs->gddr3ctl1, + sdram_params->ac_timing.gddr3ctl1); + write32(&ch[channel].ddrphy_regs->gddr3ctl1, + sdram_params->ac_timing.gddr3ctl1); + + write32(&ch[channel].ao_regs->dramc_pd_ctrl, + sdram_params->ac_timing.pd_ctrl); + + write32(&ch[channel].ao_regs->padctl4, 0x1 << 0); + write32(&ch[channel].ao_regs->perfctl0, 0x1 << 20 | 0x1 << 0); + write32(&ch[channel].ao_regs->zqcs, 0xa << 8 | 0x56 << 0); + write32(&ch[channel].ddrphy_regs->padctl1, 0x0); + + write32(&ch[channel].ao_regs->test2_3, + sdram_params->ac_timing.test2_3); + + write32(&ch[channel].ao_regs->conf2, + sdram_params->ac_timing.conf2); + + write32(&ch[channel].ddrphy_regs->padctl2, 0x0); + + /* DISABLE_DRVREF */ + write32(&ch[channel].ao_regs->ocdk, 0x0); + write32(&ch[channel].ddrphy_regs->ocdk, 0x0); + + write32(&ch[channel].ao_regs->r1deldly, 0x12 << 24 | + 0x12 << 16 | + 0x12 << 8 | + 0x12 << 0); + + write32(&ch[channel].ao_regs->padctl7, 0x0); + + /* CLKTDN, DS0TDN, DS1TDN, DS2TDN, DS3TDN */ + setbits_le32(&ch[channel].ddrphy_regs->tdsel[2], 0x1 << 31 | + 0x1 << 29 | + 0x1 << 27 | + 0x1 << 25 | + 0x1 << 1); + /* DISABLE_PERBANK_REFRESH */ + clrbits_le32(&ch[channel].ao_regs->rkcfg, 0x1 << 7); + + /* clear R_DMREFTHD to reduce MR4 wait refresh queue time */ + clrbits_le32(&ch[channel].ao_regs->conf2, 0x7 << 24); + + /* duty default value */ + write32(&ch[channel].ddrphy_regs->phyclkduty, 0x1 << 28 | + 0x1 << 16); + + if (!dual_rank_set) { + /* single rank, CKE1 always off */ + setbits_le32(&ch[channel].ao_regs->gddr3ctl1, 0x1 << 21); + } + + /* default dqs rx perbit input delay */ + write32(&ch[channel].ao_regs->r0deldly, + calib_params->rx_dqs_dly[channel]); + + write32(&ch[channel].ao_regs->r1deldly, + calib_params->rx_dqs_dly[channel]); + + for (bit = 0; bit < DQS_BIT_NUMBER; bit++) + write32(&ch[channel].ao_regs->dqidly[bit], + calib_params->rx_dq_dly[channel][bit]); +} + +void div2_phase_sync(void) +{ + clrbits_le32(&ch[CHANNEL_B].ddrphy_regs->mempll_divider, + 1 << MEMCLKENB_SHIFT); + udelay(1); + + setbits_le32(&ch[CHANNEL_B].ddrphy_regs->mempll_divider, + 1 << MEMCLKENB_SHIFT); +} + +void dramc_phy_reset(u32 channel) +{ + /* reset phy */ + setbits_le32(&ch[channel].ddrphy_regs->phyctl1, + 1 << PHYCTL1_PHYRST_SHIFT); + + /* read data counter reset */ + setbits_le32(&ch[channel].ao_regs->gddr3ctl1, + 1 << GDDR3CTL1_RDATRST_SHIFT); + + udelay(1); /* delay 1ns */ + + clrbits_le32(&ch[channel].ao_regs->gddr3ctl1, + 1 << GDDR3CTL1_RDATRST_SHIFT); + + clrbits_le32(&ch[channel].ddrphy_regs->phyctl1, + 1 << PHYCTL1_PHYRST_SHIFT); +} + +void dramc_runtime_config(u32 channel, + const struct mt8173_sdram_params *sdram_params) +{ + /* enable hw gating */ + setbits_le32(&ch[channel].ao_regs->dqscal0, + 1 << DQSCAL0_STBCALEN_SHIFT); + + /* if frequency >1600, tCKE should >7 clk */ + setbits_le32(&ch[channel].ao_regs->dummy, 0x1 << 4); + + if(sdram_params->dram_freq * 2 < 1600 * MHz) + die("set tCKE error in runtime config"); + + /* DDRPHY C/A and DQ M_CK clock gating enable */ + setbits_le32(&ch[channel].ddrphy_regs->ddrphy_cg_ctrl, 0x1 << 2 | + 0x1 << 1); + + setbits_le32(&ch[channel].ao_regs->perfctl0, BIT(19) | BIT(14) | + BIT(11) | BIT(10) | + BIT(9) | BIT(8) | + BIT(4) | BIT(0)); + /* ZQCS_ENABLE */ + if (sdram_params->emi_set.cona & 0x1) { + /* dual channel, clear ZQCSCNT */ + clrbits_le32(&ch[channel].ao_regs->spcmd, 0xff << 16); + /* set ZQCSMASK for different channels */ + if (channel == CHANNEL_A) { + clrbits_le32(&ch[channel].ao_regs->perfctl0, 0x1 << 24); + } else { + setbits_le32(&ch[channel].ao_regs->perfctl0, 0x1 << 24); + } + /* enable ZQCSDUAL */ + setbits_le32(&ch[channel].ao_regs->perfctl0, 0x1 << 25); + } else { + /* single channel, set ZQCSCNT */ + setbits_le32(&ch[channel].ao_regs->spcmd, 0x8 << 16); + } +} + +void transfer_to_spm_control(void) +{ + u32 msk; + + msk = BIT(7) | BIT(11) | BIT(15); + clrbits_le32(&mt8173_apmixed->ap_pll_con3, msk); + + msk = BIT(0) | BIT(4) | BIT(8); + clrbits_le32(&ch[CHANNEL_A].ddrphy_regs->peri[3], msk); + + msk = BIT(0) | BIT(8); + clrbits_le32(&ch[CHANNEL_B].ddrphy_regs->peri[3], msk); + + msk = BIT(0) | BIT(9) | BIT(10) | BIT(11) | BIT(16) | BIT(24); + clrbits_le32(&ch[CHANNEL_A].ddrphy_regs->peri[2], msk); + clrbits_le32(&ch[CHANNEL_B].ddrphy_regs->peri[2], msk); +} + +void transfer_to_reg_control(void) +{ + u32 val; + + val = BIT(7) | BIT(11) | BIT(15); + setbits_le32(&mt8173_apmixed->ap_pll_con3, val); + + val = BIT(0) | BIT(4) | BIT(8); + setbits_le32(&ch[CHANNEL_A].ddrphy_regs->peri[3], val); + + val = BIT(0) | BIT(8); + write32(&ch[CHANNEL_B].ddrphy_regs->peri[3], val); + + val = BIT(0) | BIT(9) | BIT(10) | BIT(11) | BIT(16) | BIT(24); + setbits_le32(&ch[CHANNEL_A].ddrphy_regs->peri[2], val); + setbits_le32(&ch[CHANNEL_B].ddrphy_regs->peri[2], val); +} + +u32 dramc_engine2(u32 channel, enum dram_tw_op wr, u32 test2_1, u32 test2_2, + u8 testaudpat, u8 log2loopcount) +{ + u32 value; + + if (log2loopcount > 15) + die("Invalid loopcount of engine2!"); + + /* Disable Test Agent1, Test Agent2 write/read */ + clrbits_le32(&ch[channel].ao_regs->conf2, CONF2_TEST1_EN | + CONF2_TEST2R_EN | + CONF2_TEST2W_EN); + + /* 1. set pattern, base address, offset address */ + write32(&ch[channel].nao_regs->test2_1, test2_1); + write32(&ch[channel].nao_regs->test2_2, test2_2); + + /* 2. select test pattern */ + /* TESTXTALKPAT | TESTAUDPAT + * ISI 0 | 0 + * AUD 0 | 1 + * XTALK 1 | 0 + * UNKNOW 1 | 1 + */ + switch (testaudpat) { + case XTALK: + /* TESTAUDPAT = 0 */ + clrbits_le32(&ch[channel].ao_regs->test2_3, + TEST2_3_TESTAUDPAT_EN); + /* TESTXTALKPAT = 1, select xtalk pattern + * TESTAUDMODE = 0, read only + * TESTAUDBITINV = 0, no bit inversion + */ + clrsetbits_le32(&ch[channel].ao_regs->test2_4, + TEST2_4_TESTAUDBITINV_EN | + TEST2_4_TESTAUDMODE_EN, + TEST2_4_TESTXTALKPAT_EN); + break; + case AUDIO: + /* TESTAUDPAT = 1 */ + setbits_le32(&ch[channel].ao_regs->test2_3, + TEST2_3_TESTAUDPAT_EN); + /* TESTXTALKPAT = 0 + * TESTAUDINIT = 0x11 + * TESTAUDINC = 0x0d + * TESTAUDBITINV = 1 + * TESTAUDMODE = 1 + */ + clrsetbits_le32(&ch[channel].ao_regs->test2_4, + TEST2_4_TESTXTALKPAT_EN | + TEST2_4_TESTAUDINIT_MASK | + TEST2_4_TESTAUDINC_MASK, + TEST2_4_TESTAUDMODE_EN | + TEST2_4_TESTAUDBITINV_EN | + 0x11 << TEST2_4_TESTAUDINIT_SHIFT | + 0xd << TEST2_4_TESTAUDINC_SHIFT); + + break; + case ISI: + /* TESTAUDPAT = 0 */ + clrbits_le32(&ch[channel].ao_regs->test2_3, + TEST2_3_TESTAUDPAT_EN); + /* TESTXTALKPAT = 0 */ + clrbits_le32(&ch[channel].ao_regs->test2_4, + TEST2_4_TESTXTALKPAT_EN); + } + + /* 3. set loop number */ + clrsetbits_le32(&ch[channel].ao_regs->test2_3, TEST2_3_TESTCNT_MASK, + log2loopcount << TEST2_3_TESTCNT_SHIFT); + + /* 4. enable read/write test */ + if (wr == TE_OP_READ_CHECK) { + if ((testaudpat == 1) || (testaudpat == 2)) { + /* if audio pattern, enable read only */ + /* (disable write after read), */ + /* AUDMODE=0x48[15]=0 */ + clrbits_le32(&ch[channel].ao_regs->test2_4, + TEST2_4_TESTAUDMODE_EN); + } + + /* enable read, 0x008[30:30] */ + setbits_le32(&ch[channel].ao_regs->conf2, CONF2_TEST2R_EN); + } else if (wr == TE_OP_WRITE_READ_CHECK) { + /* enable write, 0x008[31:31] */ + setbits_le32(&ch[channel].ao_regs->conf2, CONF2_TEST2W_EN); + + /* check "read data compare ready" bit */ + do { + value = read32(&ch[channel].nao_regs->testrpt); + } while ((value & (1 << TESTRPT_DM_CMP_CPT_SHIFT)) == 0); + + /* Disable Test Agent2 write and enable Test Agent2 read */ + clrbits_le32(&ch[channel].ao_regs->conf2, CONF2_TEST2W_EN); + setbits_le32(&ch[channel].ao_regs->conf2, CONF2_TEST2R_EN); + } + + /* 5 check "read data compare ready" bit */ + do { + value = read32(&ch[channel].nao_regs->testrpt); + } while ((value & (1 << TESTRPT_DM_CMP_CPT_SHIFT)) == 0); + + /* delay 10ns after ready check from DE suggestion (1us here) */ + udelay(1); + + /* read CMP_ERR result */ + value = read32(&ch[channel].nao_regs->cmp_err); + + /* 6 disable read */ + clrbits_le32(&ch[channel].ao_regs->conf2, CONF2_TEST2R_EN); + + /* return CMP_ERR result, pass: 0, failure: otherwise */ + return value; +} diff --git a/src/soc/mediatek/mt8173/dramc_pi_calibration_api.c b/src/soc/mediatek/mt8173/dramc_pi_calibration_api.c new file mode 100644 index 0000000..1237b2e --- /dev/null +++ b/src/soc/mediatek/mt8173/dramc_pi_calibration_api.c @@ -0,0 +1,1150 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#include <delay.h> +#include <boardid.h> +#include <arch/io.h> +#include <stdlib.h> +#include <soc/addressmap.h> +#include <soc/dramc_common.h> +#include <soc/dramc_register.h> +#include <soc/dramc_pi_api.h> +#include <soc/emi.h> + +static u8 opt_gw_coarse_value[CHANNEL_NUM][DUAL_RANKS]; +static u8 opt_gw_fine_value[CHANNEL_NUM][DUAL_RANKS]; +static s8 wrlevel_dqs_dly[CHANNEL_NUM][DQS_NUMBER]; + +void sw_impedance_cal(u32 channel, + const struct mt8173_sdram_params *sdram_params) +{ + u32 mask, value; + + const struct mt8173_calib_params *params = &sdram_params->calib_params; + + dramc_dbg_msg("[Imp Calibration] DRVP:%d\n", params->impedance_drvp); + dramc_dbg_msg("[Imp Calibration] DRVN:%d\n", params->impedance_drvn); + + mask = 0xf << 28 | 0xf << 24 | 0xf << 12 | 0xf << 8; /* driving */ + + value = params->impedance_drvp << 28 | params->impedance_drvn << 24 | + params->impedance_drvp << 12 | params->impedance_drvn << 8; + + /* DQS and DQ */ + clrsetbits_le32(&ch[channel].ao_regs->iodrv6, mask, value); + /* CLK and CMD */ + clrsetbits_le32(&ch[channel].ao_regs->drvctl1, mask, value); + clrsetbits_le32(&ch[channel].ddrphy_regs->drvctl1, mask, value); + /* DQ_2 and CMD_2 */ + clrsetbits_le32(&ch[channel].ao_regs->iodrv4, mask, value); + /* disable impcal calibration */ + clrbits_le32(&ch[channel].ao_regs->impcal, 1 << IMP_CALI_ENP_SHIFT | + 1 << IMP_CALI_ENN_SHIFT | + 1 << IMP_CALI_EN_SHIFT | + 0xf << IMP_CALI_DRVP_SHIFT | + 0xf << IMP_CALI_DRVN_SHIFT); +} + +void ca_training(u32 channel, const struct mt8173_sdram_params *sdram_params) +{ + const struct mt8173_calib_params *params = &sdram_params->calib_params; + + u32 i, ca_shift_avg32 = 0; + s8 ca_max_center, ca_shift_avg8 = 0, order, ca_shift[CATRAINING_NUM]; + + s8 shift[CATRAINING_NUM] = { + CMDDLY0_RA2_SHIFT, CMDDLY1_RA7_SHIFT, CMDDLY3_BA0_SHIFT, + CMDDLY3_BA1_SHIFT, CMDDLY3_BA2_SHIFT, CMDDLY4_RAS_SHIFT, + CMDDLY4_CAS_SHIFT, CMDDLY5_RA13_SHIFT, CMDDLY5_WE_SHIFT + }; + + s8 ca_order[CHANNEL_NUM][CATRAINING_NUM] = { + { 7, 5, 6, 1, 3, 0, 9, 8, 2, 4}, + { 2, 0, 3, 7, 5, 9, 4, 1, 6, 8} + }; + + s8 cmd_order[CATRAINING_NUM] = { + 0, 1, 3, 3, 3, 4, 4, 5, 5 + }; + + for(i = 0; i < CATRAINING_NUM; i++) { + ca_shift[i] = params->ca_train[channel][i]; + ca_shift_avg8 += ca_shift[i]; + } + + /* CA pins align the center */ + ca_max_center = params->ca_train_center[channel]; + + /* set CA pins output delay */ + for (i = 0; i < (CATRAINING_NUM - 1); i++) { + order = ca_order[channel][i]; + clrsetbits_le32(&ch[channel].ddrphy_regs->cmddly[cmd_order[i]], + 0xf << shift[i], ca_shift[order] << shift[i]); + } + + order = ca_order[channel][9]; + clrsetbits_le32(&ch[channel].ddrphy_regs->dqscal0, + 0xf << DQSCAL0_RA14_SHIFT, + ca_shift[order] << DQSCAL0_RA14_SHIFT); + + /* CKE and CS delay */ + ca_shift_avg32 = (u32)(ca_shift_avg8 + (CATRAINING_NUM >> 1)); + ca_shift_avg32 /= (u32) CATRAINING_NUM; + + /* CKEDLY */ + clrsetbits_le32(&ch[channel].ddrphy_regs->cmddly[4], + 0x1f << CMDDLY4_CS_SHIFT | + 0x1f << CMDDLY4_CKE_SHIFT, + ca_shift_avg32 << CMDDLY4_CS_SHIFT | + ca_shift_avg32 << CMDDLY4_CKE_SHIFT); + + /* CKE1DLY */ + clrsetbits_le32(&ch[channel].ao_regs->dqscal1, + 0x1f << DQSCAL1_CKE1_SHIFT, + ca_shift_avg32 << DQSCAL1_CKE1_SHIFT); + + /* CS1DLY */ + clrsetbits_le32(&ch[channel].ddrphy_regs->padctl1, + 0xf << PADCTL1_CS1_SHIFT, + ca_shift_avg32 << PADCTL1_CS1_SHIFT); + + /* set max center into clk output delay */ + clrsetbits_le32(&ch[channel].ddrphy_regs->padctl1, + 0xf << PADCTL1_CLK_SHIFT, + ca_max_center << PADCTL1_CLK_SHIFT); + + dramc_dbg_msg("=========================================\n"); + dramc_dbg_msg(" [Channel %d] CA training\n", channel); + dramc_dbg_msg("=========================================\n"); + + for (i = 0; i < CATRAINING_NUM; i++) + dramc_dbg_msg("[CA] CA %d\tShift %d\n", i, ca_shift[i]); + + dramc_dbg_msg("[CA] Reg CMDDLY4 = %xh\n", + read32(&ch[channel].ddrphy_regs->cmddly[4])); + dramc_dbg_msg("[CA] Reg DQSCAL1 = %xh\n", + read32(&ch[channel].ao_regs->dqscal1)); + dramc_dbg_msg("[CA] Reg PADCTL1 = %xh\n", + read32(&ch[channel].ddrphy_regs->padctl1)); +} + +void write_leveling(u32 channel, const struct mt8173_sdram_params *sdram_params) +{ + u8 i, byte_i; + u32 value; + + for (i = 0; i < DQS_NUMBER; i++) + wrlevel_dqs_dly[channel][i] = + sdram_params->calib_params.wr_level[channel][i]; + /* DQS */ + value = 0; + for (i = 0; i < DQS_NUMBER; i++) { + value += ((u32)wrlevel_dqs_dly[channel][i]) << (4 * i); + } + write32(&ch[channel].ddrphy_regs->padctl3, value); + + /* DQM */ + clrsetbits_le32(&ch[channel].ddrphy_regs->padctl2, MASK_PADCTL2_32BIT, + (value << PADCTL2_SHIFT) & MASK_PADCTL2_32BIT); + + /* DQ */ + for (byte_i = 0; byte_i < DQS_NUMBER; byte_i++) { + value = 0; + for (i = 0; i < DQS_BIT_NUMBER; i++) { + s8 val = wrlevel_dqs_dly[channel][byte_i]; + value += (((u32)val) << (4 * i)); + } + write32(&ch[channel].ddrphy_regs->dqodly[byte_i], value); + } + + dramc_dbg_msg("========================================\n"); + dramc_dbg_msg("[Channel %d] dramc_write_leveling_swcal\n", channel); + dramc_dbg_msg("========================================\n"); + + dramc_dbg_msg("[WL] DQS: %#x", + read32(&ch[channel].ddrphy_regs->padctl3)); + dramc_dbg_msg("[WL] DQM: %#x\n", + read32(&ch[channel].ddrphy_regs->padctl2)); + + for (byte_i = 0; byte_i < DQS_NUMBER; byte_i++) + dramc_dbg_msg("[WL] DQ byte%d: %#x\n", byte_i, + read32(&ch[channel].ddrphy_regs->dqodly[byte_i])); +} + +static void set_gw_coarse_factor(u32 channel, u8 curr_val) +{ + u8 curr_val_p1, selph2_dqsgate, selph2_dqsgate_p1; + + u32 coarse_tune_start = curr_val >> 2; + + if (coarse_tune_start > 3) { + coarse_tune_start -= 3; + } else { + if (coarse_tune_start) { + coarse_tune_start = 1; + } + } + + if (coarse_tune_start > 15) { + coarse_tune_start = 15; + } + + curr_val_p1 = curr_val + 2; /* diff is 0.5T */ + + /* Rank 0 P0/P1 coarse tune settings */ + clrsetbits_le32(&ch[channel].ao_regs->dqsctl1, + 0xf << DQSCTL1_DQSINCTL_SHIFT, + coarse_tune_start << DQSCTL1_DQSINCTL_SHIFT & + 0xf << DQSCTL1_DQSINCTL_SHIFT); + + /* DQSINCTL does not have P1. */ + /* Need to use TXDLY_DQSGATE/TXDLY_DQSGATE_P1 to set */ + /* different 1 M_CK coarse tune values for P0 & P1. */ + selph2_dqsgate = (curr_val >> 2) - coarse_tune_start; + selph2_dqsgate_p1 = (curr_val_p1 >> 2) - coarse_tune_start; + + clrsetbits_le32(&ch[channel].ao_regs->selph2, + 0x7 << SELPH2_TXDLY_DQSGATE_SHIFT | + 0x7 << SELPH2_TXDLY_DQSGATE_P1_SHIFT, + selph2_dqsgate << SELPH2_TXDLY_DQSGATE_SHIFT | + selph2_dqsgate_p1 << SELPH2_TXDLY_DQSGATE_P1_SHIFT); + + /* dly_DQSGATE and dly_DQSGATE_P1 */ + clrsetbits_le32(&ch[channel].ao_regs->selph5, + 0x3 << SELPH5_DLY_DQSGATE_SHIFT | + 0x3 << SELPH5_DLY_DQSGATE_P1_SHIFT, + (curr_val & 0x3) << SELPH5_DLY_DQSGATE_SHIFT | + (curr_val_p1 & 0x3) << SELPH5_DLY_DQSGATE_P1_SHIFT); +} + +static void set_gw_fine_factor(u32 channel, u8 curr_val, u8 rank) +{ + u32 set = curr_val & (0x7f << DQSIEN_DQS0IEN_SHIFT); + + clrsetbits_le32(&ch[channel].ao_regs->dqsien[rank], + 0x7f << DQSIEN_DQS0IEN_SHIFT | + 0x7f << DQSIEN_DQS1IEN_SHIFT | + 0x7f << DQSIEN_DQS2IEN_SHIFT | + 0x7f << DQSIEN_DQS3IEN_SHIFT, + set << DQSIEN_DQS0IEN_SHIFT | + set << DQSIEN_DQS1IEN_SHIFT | + set << DQSIEN_DQS2IEN_SHIFT | + set << DQSIEN_DQS3IEN_SHIFT); +} + +static void set_gw_coarse_factor_rank1(u32 channel, u8 curr_val, u8 dqsinctl) +{ + u8 curr_val_p1, r1dqsgate, r1dqsgate_p1; + + curr_val_p1 = curr_val + 2; /* diff is 0.5T */ + + clrsetbits_le32(&ch[channel].ao_regs->dqsctl2, + 0xf << DQSCTL2_DQSINCTL_SHIFT, + dqsinctl << DQSCTL2_DQSINCTL_SHIFT); + + /* TXDLY_R1DQSGATE and TXDLY_R1DQSGATE_P1 */ + r1dqsgate = (curr_val >> 2) - dqsinctl; + r1dqsgate_p1 = (curr_val_p1 >> 2) - dqsinctl; + + clrsetbits_le32(&ch[channel].ao_regs->selph6_1, + 0x7 << SELPH6_1_TXDLY_R1DQSGATE_SHIFT | + 0x7 << SELPH6_1_TXDLY_R1DQSGATE_P1_SHIFT, + r1dqsgate << SELPH6_1_TXDLY_R1DQSGATE_SHIFT | + r1dqsgate_p1 << SELPH6_1_TXDLY_R1DQSGATE_P1_SHIFT); + + /* dly_R1DQSGATE and dly_R1DQSGATE_P1 */ + clrsetbits_le32(&ch[channel].ao_regs->selph6_1, + 0x3 << SELPH6_1_DLY_R1DQSGATE_SHIFT | + 0x3 << SELPH6_1_DLY_R1DQSGATE_P1_SHIFT, + (curr_val & 0x3) << SELPH6_1_DLY_R1DQSGATE_SHIFT | + (curr_val_p1 & 0x3) << SELPH6_1_DLY_R1DQSGATE_P1_SHIFT); +} + +static void dqs_gw_counter_reset(u32 channel) +{ + /* reset dqs counter (1 to 0) */ + setbits_le32(&ch[channel].ao_regs->spcmd, 1 << SPCMD_DQSGCNTRST_SHIFT); + clrbits_le32(&ch[channel].ao_regs->spcmd, 1 << SPCMD_DQSGCNTRST_SHIFT); + dramc_phy_reset(channel); +} + +static int dqs_gw_test(u32 channel) +{ + u32 coarse_result01, coarse_result23; + + /* read data counter reset in PHY layer */ + dqs_gw_counter_reset(channel); + + /* use audio pattern to run the test */ + dramc_engine2(channel, TE_OP_READ_CHECK, DQS_GW_PATTERN2, + DQS_GW_PATTERN1 | DQS_GW_TE_OFFSET, 1, 0); + + /* get coarse result of DQS0, 1, 2, 3 */ + coarse_result01 = read32(&ch[channel].nao_regs->dqsgnwcnt[0]); + coarse_result23 = read32(&ch[channel].nao_regs->dqsgnwcnt[1]); + + if (coarse_result01 == DQS_GW_GOLD_COUNTER_32BIT && + coarse_result23 == DQS_GW_GOLD_COUNTER_32BIT) + return 1; + + return 0; +} + +static u8 dqs_gw_fine_tune_calib(u32 channel, u8 fine_val) +{ + u8 i, opt_fine_val; + s8 gw_ret[3], delta[3] = {0, -16, 16}; + + for (i = 0; i < 3; i++) { + /* adjust gw fine tune */ + opt_fine_val = fine_val + delta[i]; + set_gw_fine_factor(channel, opt_fine_val, 0); + /* get gw test result */ + gw_ret[i] = dqs_gw_test(channel); + } + + /* start fine tune adjustment from default fine value */ + opt_fine_val = fine_val; + + if (gw_ret[0] && gw_ret[1] && gw_ret[2]) { + opt_fine_val += ((delta[0] + delta[1] + delta[2]) / 3); + } + else if (gw_ret[0] && gw_ret[1]) { + opt_fine_val += ((delta[0] + delta[1]) / 2); + } + else if (gw_ret[0] && gw_ret[2]) { + opt_fine_val += ((delta[0] + delta[2]) / 2); + } + else { /* abnormal test result, set to default fine tune value */ + printk(BIOS_ERR, "[GW] ERROR, No found fine tune!!!\n"); + } + + return opt_fine_val; +} + +static u8 dqs_gw_coarse_tune_calib(u32 channel, u8 coarse_val) +{ + u8 i, opt_coarse_val[3]; + s8 gw_ret[3], delta[3] = {0, 1, -1}; + + for (i = 0; i < 3; i++) { + /* adjust gw coarse tune value */ + opt_coarse_val[i] = coarse_val + delta[i]; + set_gw_coarse_factor(channel, opt_coarse_val[i]); + /* get gw test result */ + gw_ret[i] = dqs_gw_test(channel); + /* judge test result */ + if (gw_ret[i] != 0) + return opt_coarse_val[i]; + } + + /* abnormal test result, set to default coarse tune value */ + printk(BIOS_ERR, "[GW] ERROR, No found coarse tune!!!\n"); + + return coarse_val; +} + +void rx_dqs_gating_cal(u32 channel, u8 rank, + const struct mt8173_sdram_params *sdram_params) +{ + u8 gw_coarse_val, gw_fine_val; + + /* disable HW gating */ + clrbits_le32(&ch[channel].ao_regs->dqscal0, + 1 << DQSCAL0_STBCALEN_SHIFT); + /* enable DQS gating window counter */ + setbits_le32(&ch[channel].ao_regs->dqsctl1, + 1 << DQSCTL1_DQSIENMODE_SHIFT); + setbits_le32(&ch[channel].ao_regs->spcmd, + 1 << SPCMD_DQSGCNTEN_SHIFT); + /* dual-phase DQS clock gating control enabling */ + setbits_le32(&ch[channel].ddrphy_regs->dqsgctl, + 1 << DQSGCTL_DQSGDUALP_SHIFT); + + /* gating calibration value */ + gw_coarse_val = sdram_params->calib_params.gating_win[channel][rank][0]; + gw_fine_val = sdram_params->calib_params.gating_win[channel][rank][1]; + + dramc_dbg_msg("****************************************************\n"); + dramc_dbg_msg("Channel %d Rank %d DQS GW Calibration\n", channel, rank); + dramc_dbg_msg("Default (coarse, fine) tune value %d, %d.\n", + gw_coarse_val, gw_fine_val); + dramc_dbg_msg("****************************************************\n"); + + /* set default coarse and fine value */ + set_gw_coarse_factor(channel, gw_coarse_val); + set_gw_fine_factor(channel, gw_fine_val, 0); + + /* adjust gw coarse tune */ + opt_gw_coarse_value[channel][rank] = + dqs_gw_coarse_tune_calib(channel, gw_coarse_val); + + /* set adjusted gw coarse tune */ + set_gw_coarse_factor(channel, opt_gw_coarse_value[channel][rank]); + + /* adjust gw fine tune */ + opt_gw_fine_value[channel][rank] = + dqs_gw_fine_tune_calib(channel, gw_fine_val); + + /* set adjusted gw fine tune */ + set_gw_fine_factor(channel, opt_gw_fine_value[channel][rank], 0); + + /* read data counter reset in PHY layer */ + dqs_gw_counter_reset(channel); + + /* gating window training result */ + printk(BIOS_INFO, "[GW] [Channel %d] [Rank %d] adjusted (coarse, fine) tune value: %d, %d.\n", + channel, rank, opt_gw_coarse_value[channel][rank], + opt_gw_fine_value[channel][rank]); +} + +void dual_rank_rx_dqs_gating_cal(u32 channel, + const struct mt8173_sdram_params *sdram_params) +{ + u32 dqsinctl; + + /* rank 0 gw calibration */ + rx_dqs_gating_cal(channel, 0, sdram_params); + + /* get dqsinctl after rank 0 calibration */ + dqsinctl = read32(&ch[channel].ao_regs->dqsctl1); + dqsinctl = (dqsinctl >> DQSCTL1_DQSINCTL_SHIFT) & (0xf << 0); + + /* swap cs0 and cs1 */ + setbits_le32(&ch[channel].ao_regs->rkcfg, MASK_RKCFG_RKSWAP_EN); + + /* rank 1 gw calibration */ + rx_dqs_gating_cal(channel, 1, sdram_params); + + /* set rank 1 coarse tune and fine tune */ + set_gw_coarse_factor_rank1(channel, opt_gw_coarse_value[channel][1], + dqsinctl); + set_gw_fine_factor(channel, opt_gw_fine_value[channel][1], 1); + + /* swap cs back */ + clrbits_le32(&ch[channel].ao_regs->rkcfg, MASK_RKCFG_RKSWAP_EN); + + /* set rank 0 coarse tune and fine tune back */ + set_gw_coarse_factor(channel, opt_gw_coarse_value[channel][0]); + set_gw_fine_factor(channel, opt_gw_fine_value[channel][0], 0); +} + +void dramc_rankinctl_config(u32 channel, + const struct mt8173_sdram_params *sdram_params) +{ + u32 value; + + if (is_dual_rank(channel, sdram_params)) { + /* RANKINCTL_ROOT1 = DQSINCTL + reg_TX_DLY_DQSGATE */ + value = min(opt_gw_coarse_value[channel][0], + opt_gw_coarse_value[channel][1]) >> 2; + + clrsetbits_le32(&ch[channel].ao_regs->dummy, 0xf, value); + + /* RANKINCTL = RANKINCTL_ROOT1 */ + clrsetbits_le32(&ch[channel].ao_regs->dqscal1, + 0xf << 16, value << 16); + } + /* disable per-bank refresh when refresh rate >= 5 */ + setbits_le32(&ch[channel].ao_regs->rkcfg, + 1 << RKCFG_PBREF_DISBYRATE_SHIFT); +} + +u32 dram_k_perbit(u32 channel) +{ + u32 err_value = 0x0; + + /* use XTALK pattern to run the test */ + err_value = dramc_engine2(channel, TE_OP_WRITE_READ_CHECK, + DEFAULT_TEST2_1_CAL, DEFAULT_TEST2_2_CAL, + 2, 0); + return err_value; +} + +void dramk_check_dqs_win(struct dqs_perbit_dly *p, u8 dly_step, u8 last_step, + u32 fail_bit) +{ + s8 dqsdly_pass_win, best_pass_win; + + if (fail_bit == 0) { + if (p->first_dqsdly_pass == -1) { + /* first DQS pass delay tap */ + p->first_dqsdly_pass = dly_step; + } + if ((p->last_dqsdly_pass == -2) && (dly_step == last_step)) { + /* pass to the last tap */ + p->last_dqsdly_pass = dly_step; + dqsdly_pass_win = p->last_dqsdly_pass - + p->first_dqsdly_pass; + best_pass_win = p->best_last_dqsdly_pass - + p->best_first_dqsdly_pass; + if (dqsdly_pass_win > best_pass_win) { + p->best_last_dqsdly_pass = p->last_dqsdly_pass; + p->best_first_dqsdly_pass = p->first_dqsdly_pass; + } + /* clear to find the next pass range if it has */ + p->first_dqsdly_pass = -1; + p->last_dqsdly_pass = -2; + } + } else { + if ((p->first_dqsdly_pass != -1) && (p->last_dqsdly_pass == -2)) { + p->last_dqsdly_pass = dly_step - 1; + dqsdly_pass_win = p->last_dqsdly_pass - + p->first_dqsdly_pass; + best_pass_win = p->best_last_dqsdly_pass - + p->best_first_dqsdly_pass; + if (dqsdly_pass_win > best_pass_win) { + p->best_last_dqsdly_pass = p->last_dqsdly_pass; + p->best_first_dqsdly_pass = p->first_dqsdly_pass; + } + /* clear to find the next pass range if it has */ + p->first_dqsdly_pass = -1; + p->last_dqsdly_pass = -2; + } + } +} + +void dramk_check_dq_win(struct dqs_perbit_dly *p, u8 dly_step, u8 last_step, + u32 fail_bit) +{ + s8 dqdly_pass_win, best_pass_win; + + if (fail_bit == 0) { + if (p->first_dqdly_pass == -1) { + /* first DQ pass delay tap */ + p->first_dqdly_pass = dly_step; + } + + if ((p->last_dqdly_pass == -2) && (dly_step == last_step)) { + /* pass to the last tap */ + p->last_dqdly_pass = dly_step; + dqdly_pass_win = p->last_dqdly_pass - + p->first_dqdly_pass; + best_pass_win = p->best_last_dqdly_pass - + p->best_first_dqdly_pass; + if (dqdly_pass_win > best_pass_win) { + p->best_last_dqdly_pass = p->last_dqdly_pass; + p->best_first_dqdly_pass = p->first_dqdly_pass; + } + /* clear to find the next pass range if it has */ + p->first_dqdly_pass = -1; + p->last_dqdly_pass = -2; + } + } else { + if ((p->first_dqdly_pass != -1) && (p->last_dqdly_pass == -2)) { + p->last_dqdly_pass = dly_step - 1; + dqdly_pass_win = p->last_dqdly_pass - + p->first_dqdly_pass; + best_pass_win = p->best_last_dqdly_pass - + p->best_first_dqdly_pass; + if (dqdly_pass_win > best_pass_win) { + p->best_last_dqdly_pass = p->last_dqdly_pass; + p->best_first_dqdly_pass = p->first_dqdly_pass; + } + /* clear to find the next pass range if it has */ + p->first_dqdly_pass = -1; + p->last_dqdly_pass = -2; + } + } +} + +u8 dramk_calcu_best_dly(u8 bit, struct dqs_perbit_dly *p, u8 *p_max_byte) +{ + u8 fail = 0; + u8 hold, setup; + + /* hold time = DQS pass taps */ + hold = p->best_last_dqsdly_pass - p->best_first_dqsdly_pass + 1; + /* setup time = DQ pass taps */ + setup = p->best_last_dqdly_pass - p->best_first_dqdly_pass + 1; + + /* The relationship of setup and hold time of dqs and dq signals + * is represented with delay tap in the following format: + * + * setup time(dq delay) hold time(dqs delay) + * xxxxxxxxxxxxxoooooooo|ooooooooooooooooooooxxxxx + * 15 0 1 15 tap + */ + + if (hold > setup) { + /* like this: (setup time != 0) */ + /* xxxxxxxxxxxxxoooooooo|ooooooooooooooooooooxxxxx */ + /* like this: (setup time == 0) */ + /* xxxxxxxxxxxxxxxxxxxxx|xxxooooooooooxxxxxxxxxxxx */ + + p->best_dqdly = 0; + p->best_dqsdly = (setup != 0)? (hold - setup) / 2: + (hold - setup) / 2 + p->best_first_dqsdly_pass; + + if (p->best_dqsdly > *p_max_byte) { + *p_max_byte = p->best_dqsdly; + } + + } else if (hold < setup) { + /* like this: (hold time != 0 )*/ + /* xxxoooooooooooooooooo|ooooooooxxxxxxxxxxxxxxxxx */ + /* like this: (hold time == 0 ) */ + /* xxxoooooooooooooooxxx|xxxxxxxxxxxxxxxxxxxxxxxxx */ + + p->best_dqsdly = 0; + p->best_dqdly = (hold != 0)? (setup - hold) / 2: + (setup - hold) / 2 + p->best_first_dqdly_pass; + + } else { /* hold time == setup time */ + p->best_dqsdly = 0; + p->best_dqdly = 0; + + if (hold == 0) { + /* like this: (mean this bit is error) */ + /* xxxxxxxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxxxxxxxxxxx */ + printk(BIOS_ERR, "ERROR, error bit %d, " + "setup_time = hold_time = 0!!\n", bit); + fail = 1; + } + } + + dramc_dbg_msg("bit#%d : dq =%d dqs=%d win=%d (%d, %d)\n", + bit, setup, hold, setup + hold, + p->best_dqdly, p->best_dqsdly); + + return fail; +} + +void clk_duty_cal(u32 channel) +{ + u8 max_duty_sel, max_duty; + u32 max_win_size = 0; + + max_duty_sel = max_duty = 1; + + clrsetbits_le32(&ch[channel].ddrphy_regs->phyclkduty, + 0x3 << PHYCLKDUTY_CMDCLKP0DUTYN_SHIFT | + 1 << PHYCLKDUTY_CMDCLKP0DUTYP_SHIFT, + 1 << PHYCLKDUTY_CMDCLKP0DUTYSEL_SHIFT | + max_duty << PHYCLKDUTY_CMDCLKP0DUTYN_SHIFT); + + max_win_size = read32(&ch[channel].ddrphy_regs->phyclkduty); + + dramc_dbg_msg("[Channel %d CLK DUTY CALIB] ", channel); + dramc_dbg_msg("Final DUTY_SEL=%d, DUTY=%d, rx window size=%d\n", + max_duty_sel, max_duty, max_win_size); +} + +static void set_dle_factor(u32 channel, u8 curr_val) +{ + clrsetbits_le32(&ch[channel].ao_regs->ddr2ctl, + 0x7 << DDR2CTL_DATLAT_SHIFT, + (curr_val & 0x7) << DDR2CTL_DATLAT_SHIFT); + + clrsetbits_le32(&ch[channel].ao_regs->padctl4, + 0x1 << PADCTL4_DATLAT3_SHIFT, + ((curr_val >> 3) & 0x1) << PADCTL4_DATLAT3_SHIFT); + + clrsetbits_le32(&ch[channel].ao_regs->phyctl1, + 0x1 << PHYCTL1_DATLAT4_SHIFT, + ((curr_val >> 4) & 0x1) << PHYCTL1_DATLAT4_SHIFT); + + clrsetbits_le32(&ch[channel].ao_regs->misc, + 0x1f << MISC_DATLAT_DSEL_SHIFT, + (curr_val - 8) << MISC_DATLAT_DSEL_SHIFT); + + /* optimize bandwidth for HW run time test engine use */ + clrsetbits_le32(&ch[channel].ao_regs->misc, + 0x1f << MISC_LATNORMP_SHIFT, + (curr_val - 3) << MISC_LATNORMP_SHIFT); +} + +void dual_rank_rx_datlat_cal(u32 channel, + const struct mt8173_sdram_params *sdram_params) +{ + u8 r0_dle_setting, r1_dle_setting; + + /* rank 0 dle calibration */ + r0_dle_setting = rx_datlat_cal(channel, 0, sdram_params); + + /* swap cs0 and cs1 */ + setbits_le32(&ch[channel].ao_regs->rkcfg, MASK_RKCFG_RKSWAP_EN); + + /* set rank 1 coarse tune and fine tune back */ + set_gw_coarse_factor(channel, opt_gw_coarse_value[channel][1]); + set_gw_fine_factor(channel, opt_gw_fine_value[channel][1], 0); + + /* rank 1 dle calibration */ + r1_dle_setting = rx_datlat_cal(channel, 1, sdram_params); + + /* set rank 0 coarse tune and fine tune back */ + set_gw_coarse_factor(channel, opt_gw_coarse_value[channel][0]); + set_gw_fine_factor(channel, opt_gw_fine_value[channel][0], 0); + + /* swap cs back */ + clrbits_le32(&ch[channel].ao_regs->rkcfg, MASK_RKCFG_RKSWAP_EN); + + /* output dle setting of rank 0 and 1 */ + dramc_dbg_msg("[DLE] Rank 0 DLE calibrated setting = %xh.\n" + "[DLE] Rank 1 DLE calibrated setting = %xh.\n", + r0_dle_setting, r1_dle_setting); + + if (r1_dle_setting < r0_dle_setting) { + /* compare dle setting of two ranks */ + dramc_dbg_msg("[DLE] rank 0 > rank 1. set to rank 0.\n"); + /* case 1: set rank 0 dle setting */ + set_dle_factor(channel, r0_dle_setting); + } else { + /* compare dle setting of two ranks */ + dramc_dbg_msg("[DLE] rank 0 < rank 1. use rank 1.\n"); + /* case 2: set rank 1 dle setting */ + set_dle_factor(channel, r1_dle_setting); + } +} + +u8 rx_datlat_cal(u32 channel, u8 rank, + const struct mt8173_sdram_params *sdram_params) +{ + u8 i, best_step; + u32 err[DLE_TEST_NUM]; + + dramc_dbg_msg("=========================================\n"); + dramc_dbg_msg("[Channel %d] [Rank %d] DATLAT calibration\n", + channel, rank); + dramc_dbg_msg("=========================================\n"); + + clrbits_le32(&ch[channel].ao_regs->mckdly, + 0x11 << MCKDLY_DQIENQKEND_SHIFT | + 0x1 << MCKDLY_DQIENLAT_SHIFT); + + /* set dle calibration initial value */ + best_step = sdram_params->calib_params.datlat_ucfirst + 1; + + /* do dle calibration test */ + for (i = 0; i < DLE_TEST_NUM; i++) { + set_dle_factor(channel, best_step - i); + err[i] = dramc_engine2(channel, TE_OP_WRITE_READ_CHECK, + DEFAULT_TEST2_1_CAL, + DEFAULT_TEST2_2_CAL, 2, 0); + } + + if (err[0]) { + /* dle test error */ + printk(BIOS_ERR, "[DLE] calibration ERROR!\n"); + } else { + /* judge dle test result */ + for (i = 0; i < DLE_TEST_NUM; i++) { + if (!err[i] && (i + 1 == DLE_TEST_NUM || err[i + 1])) { + /* dle test ok */ + best_step -= (i - 1); + break; + } + } + } + + /* Default dle value is set when test error (error recovery). + * Others, adjusted dle calibration value is set normally. + */ + set_dle_factor(channel, best_step); + + dramc_dbg_msg("[DLE] adjusted value = %#x\n", best_step); + + return best_step; +} + +void tx_delay_for_wrleveling(u32 channel, + struct dqs_perbit_dly *dqdqs_perbit_dly, + u8 *max_dqsdly_byte, u8 *ave_dqdly_byte) +{ + s8 i, delta, index, max_taps; + + max_taps = MAX_DQDLY_TAPS - 1; + + for (i = 0; i < DATA_WIDTH_32BIT; i++) { + + index = i / DQS_BIT_NUMBER; + + if (i % DQS_BIT_NUMBER == 0) + dramc_dbg_msg("DQS%d: %d \n", index, + wrlevel_dqs_dly[channel][index]); + + if (max_dqsdly_byte[index] <= wrlevel_dqs_dly[channel][index]) { + /* set diff value (delta) */ + delta = wrlevel_dqs_dly[channel][index] - + max_dqsdly_byte[index]; + + dqdqs_perbit_dly[i].best_dqdly += delta; + + /* max limit to 15 */ + if (dqdqs_perbit_dly[i].best_dqdly > max_taps) + dqdqs_perbit_dly[i].best_dqdly = max_taps; + + if ((i + 1) % DQS_BIT_NUMBER == 0) { + /* DQS */ + max_dqsdly_byte[index] = + wrlevel_dqs_dly[channel][index]; + /* DQM */ + ave_dqdly_byte[index] += delta; + /* max limit to 15 */ + if (ave_dqdly_byte[index] > max_taps) + ave_dqdly_byte[index] = max_taps; + } + + } else if (i % DQS_BIT_NUMBER == 0) { + /* max_dqsdly_byte[j] > wrlevel_dqs_dly[channel][j] + * Originally, we should move clk and CA delay. + * Then, do GW calibration again. However, DQ/DQS + * skew should not be large in MT8173, so we sacrifice + * the Clk/DQS margin by keeping the clk out delay. + */ + printk(BIOS_ERR, "[Warning] DQSO %d in TX " + "per-bit = %d > DQSO %d in WL = %d ", + index, max_dqsdly_byte[index], index, + wrlevel_dqs_dly[channel][index]); + } + } +} + +static void set_rx_dly_factor(u32 channel, u32 curr_val, u8 type) +{ + u32 i, value = 0; + + for (i = 0; i < DQS_NUMBER; i++) + value += (curr_val << (8 * i)); + + switch (type) { + case RX_DQS: + write32(&ch[channel].ao_regs->r0deldly, value); + break; + case RX_DQ: + for (i = 0; i < DATA_WIDTH_32BIT; i += 4) + write32(&ch[channel].ao_regs->dqidly[i/4], value); + break; + } +} + +static void set_tx_dly_factor(u32 channel, u32 curr_val, u8 type) +{ + u32 i, bit_num, value = 0; + + bit_num = (type == TX_DQ)? DQS_BIT_NUMBER: DQS_NUMBER; + + for (i = 0; i < bit_num; i++) + value += (curr_val << (4 * i)); + + switch (type) { + + case TX_DQS: + write32(&ch[channel].ddrphy_regs->padctl3, value); + break; + case TX_DQM: + write32(&ch[channel].ddrphy_regs->padctl2, value); + break; + case TX_DQ: + for (i = 0; i < DQS_NUMBER; i++) + write32(&ch[channel].ddrphy_regs->dqodly[i], value); + break; + } +} + +static void set_dly_factor(u32 channel, u8 stage, u8 type, u8 dly) +{ + switch (stage | type << 1) { + /* set delay for DQ/DQM/DQS by setup/hold stage and window type */ + case STAGE_SETUP_TX_WIN: + /* set DQ/DQM delay for tx window */ + set_tx_dly_factor(channel, dly, TX_DQ); + set_tx_dly_factor(channel, dly, TX_DQM); + break; + case STAGE_SETUP_RX_WIN: + /* set DQ delay for rx window */ + set_rx_dly_factor(channel, dly, RX_DQ); + break; + case STAGE_HOLD_TX_WIN: + /* set DQS delay for tx window */ + set_tx_dly_factor(channel, dly, TX_DQS); + break; + case STAGE_HOLD_RX_WIN: + /* set DQS delay for rx window */ + set_rx_dly_factor(channel, dly, RX_DQS); + break; + } +} + +static void set_rx_best_dly_factor(u32 channel, + struct dqs_perbit_dly *dqdqs_perbit_dly, + u8 *max_dqsdly_byte) +{ + u32 i, value = 0; + + for (i = 0; i < DQS_NUMBER; i++) + value += (((u32)max_dqsdly_byte[i]) << (8 * i)); + + write32(&ch[channel].ao_regs->r0deldly, value); + write32(&ch[channel].ao_regs->r1deldly, value); + + dramc_dbg_msg("[RX] DQS Reg R0DELDLY=%xh\n", + read32(&ch[channel].ao_regs->r0deldly)); + dramc_dbg_msg("[RX] DQS Reg R1DELDLY=%xh\n", + read32(&ch[channel].ao_regs->r1deldly)); + + for (i = 0; i < DATA_WIDTH_32BIT; i += 4) { + /* every 4bit dq have the same delay register address */ + value = ((u32)dqdqs_perbit_dly[i].best_dqdly) + + (((u32)dqdqs_perbit_dly[i + 1].best_dqdly) << 8) + + (((u32)dqdqs_perbit_dly[i + 2].best_dqdly) << 16) + + (((u32)dqdqs_perbit_dly[i + 3].best_dqdly) << 24); + + write32(&ch[channel].ao_regs->dqidly[i / 4], value); + dramc_dbg_msg("[RX] DQ DQIDLY%d = %xh\n", (i + 4) / 4, value); + } +} + +static void set_tx_best_dly_factor(u32 channel, + struct dqs_perbit_dly *dqdqs_perbit_dly, + u8 *max_dqsdly_byte, u8 *ave_dqdly_byte) +{ + u32 bit, value, shift, dqs_index = 0; + + value = 0; + for (bit = 0; bit < DQS_NUMBER; bit++) { + value += (((u32)max_dqsdly_byte[bit]) << (4 * bit)); + } + + write32(&ch[channel].ddrphy_regs->padctl3, value); + dramc_dbg_msg("[TX] DQS PADCTL3 Reg = %#x\n", value); + + /* DQ delay */ + for (bit = 0; bit < DATA_WIDTH_32BIT; bit++) { + /* every 8 DQ reset */ + if (bit % DQS_BIT_NUMBER == 0) { + value = 0; + dqs_index = bit / DQS_BIT_NUMBER; + } + /* 4 bits field for each DQ */ + shift = 4 * (bit % DQS_BIT_NUMBER); + value += (((u32)(dqdqs_perbit_dly[bit].best_dqdly)) << shift); + /* each register is with 8 DQ */ + if ((bit + 1) % DQS_BIT_NUMBER == 0) { + write32(&ch[channel].ddrphy_regs->dqodly[dqs_index], value); + dramc_dbg_msg("[TX] DQ DQ0DLY%d = %xh\n", + dqs_index + 1, value); + } + } + + /* DQM delay */ + value = read32(&ch[channel].ddrphy_regs->padctl2); + value &= MASK_PADCTL2; + + for (bit = 0; bit < DQS_NUMBER; bit++) { + value += (((u32)ave_dqdly_byte[bit]) << (4 * bit)); + } + write32(&ch[channel].ddrphy_regs->padctl2, value); + dramc_dbg_msg("[TX] DQM PADCTL2 Reg = %#x\n", value); +} + +void perbit_window_cal(u32 channel, u8 type) +{ + u8 i, dly, bit, max_dqs_taps, fail = 0; + u8 max_dqsdly_byte[DQS_NUMBER], ave_dqdly_byte[DQS_NUMBER]; + u32 err_value, fail_bit, max_limit, index; + + struct dqs_perbit_dly dqdqs_perbit_dly[DQ_DATA_WIDTH]; + + dramc_dbg_msg("\n[Channel %d] %s DQ/DQS per bit :\n", + channel, (type == TX_WIN)? "TX": "RX"); + + if (type == TX_WIN) + dramc_phy_reset(channel); + + for (i = 0; i < DATA_WIDTH_32BIT; i++) { + dqdqs_perbit_dly[i].first_dqdly_pass = -1; + dqdqs_perbit_dly[i].last_dqdly_pass = -2; + dqdqs_perbit_dly[i].first_dqsdly_pass = -1; + dqdqs_perbit_dly[i].last_dqsdly_pass = -2; + dqdqs_perbit_dly[i].best_first_dqdly_pass = -1; + dqdqs_perbit_dly[i].best_last_dqdly_pass = -2; + dqdqs_perbit_dly[i].best_first_dqsdly_pass = -1; + dqdqs_perbit_dly[i].best_last_dqsdly_pass = -2; + } + + /* 1. delay DQ ,find the pass widnow (left boundary) + * 2. delay DQS find the pass window (right boundary) + * 3. find the best DQ / DQS to satify the middle value + * of the overall pass window per bit + * 4. set DQS delay to the max per byte, delay DQ to de-skew + */ + + /* 1. set DQS delay to 0 first */ + set_dly_factor(channel, STAGE_HOLD, type, FIRST_DQS_DELAY); + + dramc_dbg_msg("----------------------------------" + "--------------------\n"); + dramc_dbg_msg("Start DQ delay to find pass range," + "DQS delay fixed to %#x...\n", FIRST_DQS_DELAY); + dramc_dbg_msg("----------------------------------" + "-------------------\n"); + dramc_dbg_msg("x-axis is bit #; y-axis is DQ delay (%d~%d)\n", + FIRST_DQ_DELAY, MAX_DQDLY_TAPS - 1); + + /* delay DQ from 0 to 15 to get the setup time */ + for (dly = FIRST_DQ_DELAY; dly < MAX_DQDLY_TAPS; dly++) { + + set_dly_factor(channel, STAGE_SETUP, type, dly); + err_value = dram_k_perbit(channel); + + /* check fail bit, 0 ok, others fail */ + for (bit = 0; bit < DATA_WIDTH_32BIT; bit++) { + fail_bit = err_value & ((u32)1 << bit); + dramk_check_dq_win(&(dqdqs_perbit_dly[bit]), dly, + MAX_DQDLY_TAPS - 1, fail_bit); + if (fail_bit == 0) { + dramc_dbg_msg("o"); + } else { + dramc_dbg_msg("x"); + } + } + dramc_dbg_msg("\n"); + } + + /* 2. set DQ delay to 0 */ + set_dly_factor(channel, STAGE_SETUP, type, FIRST_DQ_DELAY); + + /* DQS delay taps: tx and rx are 16 and 64 taps */ + max_dqs_taps = (type == TX_WIN)? MAX_TX_DQSDLY_TAPS: MAX_RX_DQSDLY_TAPS; + + dramc_dbg_msg("-----------------------------------" + "-------------------\n"); + dramc_dbg_msg("Start DQS delay to find pass range," + "DQ delay fixed to %#x...\n", FIRST_DQ_DELAY); + dramc_dbg_msg("------------------------------------" + "------------------\n"); + dramc_dbg_msg("x-axis is bit #; y-axis is DQS delay (%d~%d)\n", + FIRST_DQS_DELAY + 1, max_dqs_taps - 1); + + /* delay DQS to get the hold time, dq_dly = dqs_dly = 0 is counted */ + /* when we delay dq, so we set first dqs delay to 1 */ + for (dly = (FIRST_DQS_DELAY + 1); dly < max_dqs_taps; dly++) { + + set_dly_factor(channel, STAGE_HOLD, type, dly); + err_value = dram_k_perbit(channel); + + /* check fail bit, 0 ok, others fail */ + for (bit = 0; bit < DATA_WIDTH_32BIT; bit++) { + fail_bit = err_value & ((u32)1 << bit); + dramk_check_dqs_win(&(dqdqs_perbit_dly[bit]), dly, + max_dqs_taps - 1, fail_bit); + if (fail_bit == 0) { + dramc_dbg_msg("o"); + } else { + dramc_dbg_msg("x"); + } + } + dramc_dbg_msg("\n"); + } + + /* 3 calculate dq and dqs time */ + dramc_dbg_msg("-------------------------------" + "-----------------------\n"); + dramc_dbg_msg("Start calculate dq time and dqs " + "time:\n"); + dramc_dbg_msg("Find max DQS delay per byte / " + "Adjust DQ delay to align DQS...\n"); + dramc_dbg_msg("--------------------------------" + "----------------------\n"); + + /* As per byte, check max DQS delay in 8-bit. + * Except for the bit of max DQS delay, delay + * DQ to fulfill setup time = hold time + */ + for (i = 0; i < DQS_NUMBER; i++) { + max_dqsdly_byte[i] = 0; + ave_dqdly_byte[i] = 0; + } + + for (i = 0; i < DATA_WIDTH_32BIT; i++) { + /* we delay DQ or DQS to let DQS sample the middle */ + /* of tx/rx pass window for all the 8 bits */ + index = i / DQS_BIT_NUMBER; + fail |= dramk_calcu_best_dly(i, &dqdqs_perbit_dly[i], + &max_dqsdly_byte[index]); + + if ((i + 1) % DQS_BIT_NUMBER == 0) + dramc_dbg_msg("----separate line----\n"); + } + + for (i = 0; i < DATA_WIDTH_32BIT; i++) { + /* dqs index for every 8-bit */ + index = i / DQS_BIT_NUMBER; + /* set DQS to max for 8-bit */ + if (dqdqs_perbit_dly[i].best_dqsdly < max_dqsdly_byte[index]) { + /* delay DQ to compensate extra DQS delay */ + dly = max_dqsdly_byte[index] - + dqdqs_perbit_dly[i].best_dqsdly; + dqdqs_perbit_dly[i].best_dqdly += dly; + /* max limit to 15 */ + max_limit = MAX_DQDLY_TAPS - 1; + if (dqdqs_perbit_dly[i].best_dqdly > max_limit) { + dqdqs_perbit_dly[i].best_dqdly = max_limit; + } + } + /* accumulation variable for TX DQM */ + ave_dqdly_byte[index] += dqdqs_perbit_dly[i].best_dqdly; + /* take the average of DQ for TX DQM */ + if ((i + 1) % DQS_BIT_NUMBER == 0) { + ave_dqdly_byte[index] /= DQS_BIT_NUMBER; + } + } + + if (fail == 1) /* error handling */ + die("fail on perbit_window_cal()\n"); + + dramc_dbg_msg("==================================================\n"); + dramc_dbg_msg(" dramc_perbit_window_swcal:\n"); + dramc_dbg_msg(" channel=%d(0:cha, 1:chb)\n", channel); + dramc_dbg_msg(" bus width=%d\n", DATA_WIDTH_32BIT); + dramc_dbg_msg("==================================================\n"); + dramc_dbg_msg("DQS Delay :\n DQS0 = %d DQS1 = %d DQS2 = %d DQS3 = %d\n", + max_dqsdly_byte[0], max_dqsdly_byte[1], + max_dqsdly_byte[2], max_dqsdly_byte[3]); + + if (type == TX_WIN) + dramc_dbg_msg("DQM Delay :\n" + "DQM0 = %d DQM1 = %d DQM2 = %d DQM3 = %d\n", + ave_dqdly_byte[0], ave_dqdly_byte[1], + ave_dqdly_byte[2], ave_dqdly_byte[3]); + + dramc_dbg_msg("DQ Delay :\n"); + for (i = 0; i < DATA_WIDTH_32BIT; i++) { + dramc_dbg_msg("DQ%d = %d ", i, dqdqs_perbit_dly[i].best_dqdly); + if ( ((i + 1) % 4) == 0) + dramc_dbg_msg("\n"); + } + + dramc_dbg_msg("____________________________________" + "____________________________________\n"); + + if (type == TX_WIN) { + /* Add CLK to DQS/DQ skew after write leveling */ + dramc_dbg_msg("Add CLK to DQS/DQ skew based on write leveling.\n"); + /* this subroutine add clk delay to DQS/DQ after WL */ + tx_delay_for_wrleveling(channel, dqdqs_perbit_dly, + max_dqsdly_byte, ave_dqdly_byte); + } + + if (type == TX_WIN) + set_tx_best_dly_factor(channel, dqdqs_perbit_dly, + max_dqsdly_byte, ave_dqdly_byte); + else + set_rx_best_dly_factor(channel, dqdqs_perbit_dly, + max_dqsdly_byte); + + dramc_phy_reset(channel); +} diff --git a/src/soc/mediatek/mt8173/emi.c b/src/soc/mediatek/mt8173/emi.c new file mode 100644 index 0000000..f6ef40f --- /dev/null +++ b/src/soc/mediatek/mt8173/emi.c @@ -0,0 +1,142 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#include <arch/io.h> +#include <assert.h> +#include <boardid.h> +#include <console/console.h> +#include <delay.h> +#include <string.h> +#include <soc/addressmap.h> +#include <soc/dramc_common.h> +#include <soc/dramc_register.h> +#include <soc/dramc_pi_api.h> +#include <soc/mt6391.h> +#include <soc/pll.h> + +struct emi_regs *emi_regs = (void *)EMI_BASE; + +static void dram_vcore_adjust(void) +{ + /* options: Vcore_HV_LPPDR3/Vcore_NV_LPPDR3/Vcore_LV_LPPDR3 */ + mt6391_write(PMIC_RG_VCORE_CON9, Vcore_NV_LPPDR3, 0x7F, 0); + mt6391_write(PMIC_RG_VCORE_CON10, Vcore_NV_LPPDR3, 0x7F, 0); +} + +static void dram_vmem_adjust(void) +{ + /* options: Vmem_HV_LPPDR3/Vmem_NV_LPPDR3/Vmem_LV_LPPDR3 */ + mt6391_write(PMIC_RG_VDRM_CON9, Vmem_NV_LPDDR3, 0x7F, 0); + mt6391_write(PMIC_RG_VDRM_CON10, Vmem_NV_LPDDR3, 0x7F, 0); +} + +static void emi_init(const struct mt8173_sdram_params *sdram_params) +{ + /* EMI setting initialization */ + write32(&emi_regs->emi_conf, sdram_params->emi_set.conf); + write32(&emi_regs->emi_conm, sdram_params->emi_set.conm_1); + write32(&emi_regs->emi_arbi, sdram_params->emi_set.arbi); + write32(&emi_regs->emi_arba, sdram_params->emi_set.arba); + write32(&emi_regs->emi_arbc, sdram_params->emi_set.arbc); + write32(&emi_regs->emi_arbd, sdram_params->emi_set.arbd); + write32(&emi_regs->emi_arbe, sdram_params->emi_set.arbe); + write32(&emi_regs->emi_arbf, sdram_params->emi_set.arbf); + write32(&emi_regs->emi_arbg, sdram_params->emi_set.arbg); + write32(&emi_regs->emi_arbj, sdram_params->emi_set.arbj); + write32(&emi_regs->emi_cona, sdram_params->emi_set.cona); + write32(&emi_regs->emi_testd, sdram_params->emi_set.testd); + write32(&emi_regs->emi_bmen, sdram_params->emi_set.bmen); + write32(&emi_regs->emi_conb, sdram_params->emi_set.conb); + write32(&emi_regs->emi_conc, sdram_params->emi_set.conc); + write32(&emi_regs->emi_cond, sdram_params->emi_set.cond); + write32(&emi_regs->emi_cone, sdram_params->emi_set.cone); + write32(&emi_regs->emi_cong, sdram_params->emi_set.cong); + write32(&emi_regs->emi_conh, sdram_params->emi_set.conh); + write32(&emi_regs->emi_slct, sdram_params->emi_set.slct_1); + write32(&emi_regs->emi_mdct, sdram_params->emi_set.mdct_1); + write32(&emi_regs->emi_arbk, sdram_params->emi_set.arbk); + write32(&emi_regs->emi_testc, sdram_params->emi_set.testc); + write32(&emi_regs->emi_mdct, sdram_params->emi_set.mdct_2); + write32(&emi_regs->emi_testb, sdram_params->emi_set.testb); + write32(&emi_regs->emi_slct, sdram_params->emi_set.slct_2); + write32(&emi_regs->emi_conm, sdram_params->emi_set.conm_2); + write32(&emi_regs->emi_test0, sdram_params->emi_set.test0); + write32(&emi_regs->emi_test1, sdram_params->emi_set.test1); +} + +static void do_calib(const struct mt8173_sdram_params *sdram_params) +{ + u32 channel; + + sw_impedance_cal(CHANNEL_A, sdram_params); + sw_impedance_cal(CHANNEL_B, sdram_params); + + /* SPM_CONTROL_AFTERK */ + transfer_to_reg_control(); + + /* do dram calibration for channel A and B */ + for(channel = 0; channel < CHANNEL_NUM; channel++) { + ca_training(channel, sdram_params); + write_leveling(channel, sdram_params); + + /* rx gating and datlat for single or dual rank */ + if (is_dual_rank(channel, sdram_params)) { + dual_rank_rx_dqs_gating_cal(channel, sdram_params); + dual_rank_rx_datlat_cal(channel, sdram_params); + } else { + rx_dqs_gating_cal(channel, 0, sdram_params); + rx_datlat_cal(channel, 0, sdram_params); + } + + clk_duty_cal(channel); + /* rx window perbit calibration */ + perbit_window_cal(channel, RX_WIN); + /* tx window perbit calibration */ + perbit_window_cal(channel, TX_WIN); + + dramc_rankinctl_config(channel, sdram_params); + dramc_runtime_config(channel, sdram_params); + } + + /* SPM_CONTROL_AFTERK */ + transfer_to_spm_control(); +} + +static void init_dram(const struct mt8173_sdram_params *sdram_params) +{ + emi_init(sdram_params); + + dramc_pre_init(CHANNEL_A, sdram_params); + dramc_pre_init(CHANNEL_B, sdram_params); + + div2_phase_sync(); + + dramc_init(CHANNEL_A, sdram_params); + dramc_init(CHANNEL_B, sdram_params); +} + +void mt_set_emi(const struct mt8173_sdram_params *sdram_params) +{ + /* voltage info */ + dram_vcore_adjust(); + dram_vmem_adjust(); + + if (sdram_params->type != TYPE_LPDDR3) { + die("The DRAM type is not supported"); + } + + init_dram(sdram_params); + do_calib(sdram_params); +} diff --git a/src/soc/mediatek/mt8173/include/soc/dramc_common.h b/src/soc/mediatek/mt8173/include/soc/dramc_common.h new file mode 100644 index 0000000..084e7de --- /dev/null +++ b/src/soc/mediatek/mt8173/include/soc/dramc_common.h @@ -0,0 +1,42 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef _DRAMC_COMMON_H_ +#define _DRAMC_COMMON_H_ + +enum { + CHANNEL_A = 0, + CHANNEL_B, + CHANNEL_NUM +}; + +enum { + GW_PARAM_COARSE = 0, + GW_PARAM_FINE, + GW_PARAM_NUM +}; + +enum { + DUAL_RANKS = 2, + CATRAINING_NUM = 10 +}; + +enum { + DQ_DATA_WIDTH = 32, + DQS_BIT_NUMBER = 8, + DQS_NUMBER = (DQ_DATA_WIDTH / DQS_BIT_NUMBER) +}; + +#endif /* _DRAMC_COMMON_H_ */ diff --git a/src/soc/mediatek/mt8173/include/soc/dramc_pi_api.h b/src/soc/mediatek/mt8173/include/soc/dramc_pi_api.h new file mode 100644 index 0000000..1411d39 --- /dev/null +++ b/src/soc/mediatek/mt8173/include/soc/dramc_pi_api.h @@ -0,0 +1,187 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef _DRAMC_PI_API_H +#define _DRAMC_PI_API_H + +#include <soc/emi.h> +#include <console/console.h> + +enum { + MAX_CLKO_DELAY = 15 +}; + +enum { + /* jitter meter for PLL phase calibration */ + JMETER_COUNT = 1024, + JMETER_COUNT_N = JMETER_COUNT/10, + /* 10us for more margin, Fin = 52 */ + JMETER_WAIT_DONE_US = (JMETER_COUNT/52 + 10) +}; + +enum { + DLE_TEST_NUM = 4 +}; + +enum { + /* window type: tx/rx */ + RX_WIN = 0, + TX_WIN = 1, + /* stage type: setup/hold time */ + STAGE_SETUP = 0, + STAGE_HOLD = 1, + /* combinational flags of stage and window type */ + STAGE_SETUP_RX_WIN = STAGE_SETUP | RX_WIN << 1, + STAGE_SETUP_TX_WIN = STAGE_SETUP | TX_WIN << 1, + STAGE_HOLD_RX_WIN = STAGE_HOLD | RX_WIN << 1, + STAGE_HOLD_TX_WIN = STAGE_HOLD | TX_WIN << 1 +}; + +enum { + RX_DQ = 0, + RX_DQS, + TX_DQ, + TX_DQS, + TX_DQM +}; + +enum { + AUDIO = 1, + XTALK, + ISI +}; + +enum { + MEMPLL_INIT = 0, + MEMPLL_REF_LAG, + MEMPLL_REF_LEAD +}; + +enum { + FIRST_DQ_DELAY = 0, /* first DQ delay taps */ + FIRST_DQS_DELAY = 0, /* first DQS delay taps */ + MAX_DQDLY_TAPS = 16, /* max DQ delay taps */ + MAX_TX_DQSDLY_TAPS = 16, /* max TX DQS delay taps */ + MAX_RX_DQSDLY_TAPS = 64 /* max RX DQS delay taps */ +}; + +enum { + DRAMK_READ = 0, + DRAMK_WRITE = 1 +}; + +enum { + ENABLE = 1, + DISABLE = 0 +}; + +enum { + DATA_WIDTH_16BIT = 16, + DATA_WIDTH_32BIT = 32 +}; + +enum dram_tw_op { + TE_OP_WRITE_READ_CHECK = 0, + TE_OP_READ_CHECK +}; + +enum { + DQS_GW_TE_OFFSET = 0x10, + DQS_GW_GOLD_COUNTER_32BIT = 0x20202020, + DQS_GW_PATTERN1 = 0xaa000000, + DQS_GW_PATTERN2 = 0x55000000 +}; + +enum { + /* pattern0 and base address for test engine when we do calibration */ + DEFAULT_TEST2_1_CAL = 0x55000000, + /* for testing, to separate TA4-3 address for running simultaneously */ + /* pattern1 and offset address for test engine when we do calibraion */ + DEFAULT_TEST2_2_CAL = 0xaa000400, + /* pattern0 and base addr. for test engine when doing dqs GW */ + DEFAULT_TEST2_1_DQSIEN = 0x55000000, + /* pattern1 and offset addr. for test engine when doing dqs GW */ + DEFAULT_TEST2_2_DQSIEN = 0xaa000010, + /* gold pattern */ + DEFAULT_GOLD_DQSIEN = 0x20202020 +}; + +enum { + TEST_ISI_PATTERN = 0, + TEST_AUDIO_PATTERN, + TEST_TA1_SIMPLE, + TEST_TESTPAT4, + TEST_TESTPAT4_3, + TEST_XTALK_PATTERN, + TEST_MIX_PATTERN +}; + +struct dqs_perbit_dly { + s8 first_dqdly_pass; + s8 last_dqdly_pass; + s8 first_dqsdly_pass; + s8 last_dqsdly_pass; + s8 best_first_dqdly_pass; + s8 best_last_dqdly_pass; + s8 best_first_dqsdly_pass; + s8 best_last_dqsdly_pass; + u8 best_dqdly; + u8 best_dqsdly; +}; + +void transfer_to_spm_control(void); +void transfer_to_reg_control(void); +void dramc_phy_reset(u32 channel); +void clk_duty_cal(u32 channel); +void div2_phase_sync(void); +void dramc_runtime_config(u32 channel, const struct mt8173_sdram_params *sdram_params); +void dramc_rankinctl_config(u32 channel, const struct mt8173_sdram_params *sdram_params); + +/* dramc init prototypes */ +void mem_pll_init(const struct mt8173_sdram_params *sdram_params); +void dramc_init(u32 channel, const struct mt8173_sdram_params *sdram_params); +void dramc_pre_init(u32 channel, const struct mt8173_sdram_params *sdram_params); + +/* mandatory calibration function prototypes */ +void tx_window_perbit_cal(u32 channel); +void rx_window_perbit_cal(u32 channel); +void perbit_window_cal(u32 channel, u8 type); +void sw_impedance_cal(u32 channel, const struct mt8173_sdram_params *sdram_params); +void ca_training(u32 channel, const struct mt8173_sdram_params *sdram_params); +void rx_dqs_gating_cal(u32 channel, u8 rank, const struct mt8173_sdram_params *sdram_params); +void dual_rank_rx_datlat_cal(u32 channel, const struct mt8173_sdram_params *sdram_params); +void dual_rank_rx_dqs_gating_cal(u32 channel, const struct mt8173_sdram_params *sdram_params); +void write_leveling(u32 channel, const struct mt8173_sdram_params *sdram_params); + +u8 dramk_calcu_best_dly(u8 bit, struct dqs_perbit_dly *p, u8 *p_max_byte); +u8 is_dual_rank(u32 channel, const struct mt8173_sdram_params *sdram_params); +u8 rx_datlat_cal(u32 channel, u8 rank, const struct mt8173_sdram_params *sdram_params); +u32 dram_k_perbit(u32 channel); +u32 dramc_engine2(u32 channel, enum dram_tw_op wr, u32 test2_1, u32 test2_2, + u8 testaudpat, u8 log2loopcount); + +void dramk_check_dqs_win(struct dqs_perbit_dly *p, u8 dly_step, u8 last_step, u32 fail_bit); +void dramk_check_dq_win(struct dqs_perbit_dly *p, u8 dly_step, u8 last_step, u32 fail_bit); + +void tx_delay_for_wrleveling(u32 channel, struct dqs_perbit_dly *dqdqs_perbit_dly, + u8 *ave_dqdly_byte, u8 *max_dqsdly_byte); + +#if CONFIG_DEBUG_DRAM +#define dramc_dbg_msg(_x_...) printk(BIOS_DEBUG, _x_) +#else +#define dramc_dbg_msg(_x_...) +#endif + +#endif /* _PI_API_H */ diff --git a/src/soc/mediatek/mt8173/include/soc/dramc_register.h b/src/soc/mediatek/mt8173/include/soc/dramc_register.h new file mode 100755 index 0000000..ce65173 --- /dev/null +++ b/src/soc/mediatek/mt8173/include/soc/dramc_register.h @@ -0,0 +1,522 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef _DRAMC_REGISTER_H_ +#define _DRAMC_REGISTER_H_ + +#include <stddef.h> +#include <types.h> + +#define DRIVING_DS2_0 7 /* DS[2:0] 7->6 */ +#define DEFAULT_DRIVING 0x99009900 + +enum { + /* CONF2 = 0x008 */ + CONF2_TEST1_EN = BIT(29), + CONF2_TEST2R_EN = BIT(30), + CONF2_TEST2W_EN = BIT(31), + /* PADCTL1 = 0x00c */ + PADCTL1_CLK_SHIFT = 24, + PADCTL1_CS1_SHIFT = 28, + /* PADCTL2 = 0x010 */ + MASK_PADCTL2_16BIT = 0x000000ff, + MASK_PADCTL2_32BIT = 0x0000ffff, + MASK_PADCTL2 = 0xffff0000, + PADCTL2_SHIFT = 0, + /* TEST2_3 = 0x044 */ + TEST2_3_TESTCNT_SHIFT = 0, + TEST2_3_TESTCNT_MASK = (0xful << TEST2_3_TESTCNT_SHIFT), + TEST2_3_TESTAUDPAT_EN = BIT(7), + TEST2_3_ADVREFEN_EN = BIT(30), + /* TEST2_4 = 0x048 */ + TEST2_4_TESTAUDINC_SHIFT = 0, + TEST2_4_TESTAUDINC_MASK = (0x1ful << TEST2_4_TESTAUDINC_SHIFT), + TEST2_4_TESTAUDINIT_SHIFT = 8, + TEST2_4_TESTAUDINIT_MASK = (0x1ful << TEST2_4_TESTAUDINIT_SHIFT), + TEST2_4_TESTAUDBITINV_EN = BIT(14), + TEST2_4_TESTAUDMODE_EN = BIT(15), + TEST2_4_TESTXTALKPAT_EN = BIT(16), + /* DDR2CTL = 0x07c */ + DDR2CTL_WOEN_SHIFT = 3, + DDR2CTL_DATLAT_SHIFT = 4, + /* MISC = 0x80 */ + MISC_LATNORMP_SHIFT = 0, + MISC_DATLAT_DSEL_SHIFT = 8, + /* MRS = 0x088 */ + MASK_MR2_OP = 0x00800000, + /* R0 R1 DQSIEN = 0x094 */ + DQSIEN_DQS0IEN_SHIFT = 0, + DQSIEN_DQS1IEN_SHIFT = 8, + DQSIEN_DQS2IEN_SHIFT = 16, + DQSIEN_DQS3IEN_SHIFT = 24, + /* MCKDLY = 0x0d8 */ + MCKDLY_DQIENLAT_SHIFT = 4, + MCKDLY_DQIENQKEND_SHIFT = 10, + MCKDLY_FIXDQIEN_SHIFT = 12, + MCKDLY_FIXODT_SHIFT = 23, + /* DQSCTL1 = 0x0e0 */ + DQSCTL1_DQSINCTL_SHIFT = 24, + DQSCTL1_DQSIENMODE_SHIFT = 28, + /* PADCTL4 = 0x0e4 */ + PADCTL4_CKEFIXON_SHIFT = 2, + PADCTL4_DATLAT3_SHIFT = 4, + /* PHYCTL1 = 0x0f0 */ + PHYCTL1_DATLAT4_SHIFT = 25, + PHYCTL1_PHYRST_SHIFT = 28, + /* GDDR3CTL1 = 0x0f4 */ + GDDR3CTL1_BKSWAP_SHIFT = 20, + GDDR3CTL1_RDATRST_SHIFT = 25, + GDDR3CTL1_DQMSWAP_SHIFT = 31, + /* RKCFG = 0x110 */ + MASK_RKCFG_RKSWAP_EN = 0x08, + RKCFG_PBREF_DISBYRATE_SHIFT = 6, + RKCFG_WDATKEY64_SHIFT = 29, + /* DQSCTL2 = 0x118 */ + DQSCTL2_DQSINCTL_SHIFT = 0, + /* DQSGCTL = 0x124 */ + DQSGCTL_DQSGDUALP_SHIFT = 30, + /* PHYCLKDUTY = 0x148 */ + PHYCLKDUTY_CMDCLKP0DUTYN_SHIFT = 16, + PHYCLKDUTY_CMDCLKP0DUTYP_SHIFT = 18, + PHYCLKDUTY_CMDCLKP0DUTYSEL_SHIFT = 28, + /* CMDDLY0 = 0x1a8 */ + CMDDLY0_RA0_SHIFT = 0, + CMDDLY0_RA1_SHIFT = 8, + CMDDLY0_RA2_SHIFT = 16, + CMDDLY0_RA3_SHIFT = 24, + /* CMDDLY1 = 0x1ac */ + CMDDLY1_RA7_SHIFT = 24, + /* CMDDLY3 = 0x1b4 */ + CMDDLY3_BA0_SHIFT = 8, + CMDDLY3_BA1_SHIFT = 16, + CMDDLY3_BA2_SHIFT = 24, + /* CMDDLY4 = 0x1b8 */ + CMDDLY4_CS_SHIFT = 0, + CMDDLY4_CKE_SHIFT = 8, + CMDDLY4_RAS_SHIFT = 16, + CMDDLY4_CAS_SHIFT = 24, + /* CMDDLY5 = 0x1bc */ + CMDDLY5_WE_SHIFT = 8, + CMDDLY5_RA13_SHIFT = 16, + /* DQSCAL0 = 0x1c0 */ + DQSCAL0_RA14_SHIFT = 24, + DQSCAL0_STBCALEN_SHIFT = 31, + /* DQSCAL1 = 0x1c4 */ + DQSCAL1_CKE1_SHIFT = 24, + /* IMPCAL = 0x1c8 */ + IMP_CALI_EN_SHIFT = 0, + IMP_CALI_HW_SHIFT = 1, + IMP_CALI_ENN_SHIFT = 4, + IMP_CALI_ENP_SHIFT = 5, + IMP_CALI_PDN_SHIFT = 6, + IMP_CALI_PDP_SHIFT = 7, + IMP_CALI_DRVP_SHIFT = 8, + IMP_CALI_DRVN_SHIFT = 12, + /* JMETER for PLL2, PLL3, PLL4 */ + JMETER_EN_BIT= BIT(0), + JMETER_COUNTER_SHIFT = 16, + JMETER_COUNTER_MASK = (0xffff << JMETER_COUNTER_SHIFT), + /* SPCMD = 0x1e4 */ + SPCMD_MRWEN_SHIFT = 0, + SPCMD_DQSGCNTEN_SHIFT = 8, + SPCMD_DQSGCNTRST_SHIFT = 9, + /* JMETER for PLL2/3/4 ST */ + JMETER_PLL_ZERO_SHIFT = 0, + JMETER_PLL_ONE_SHIFT = 16, + /* TESTRPT = 0x3fc */ + TESTRPT_DM_CMP_CPT_SHIFT = 10, + TESTRPT_DM_CMP_ERR_SHIFT = 14, + /* SELPH2 = 0x404 */ + SELPH2_TXDLY_DQSGATE_SHIFT = 12, + SELPH2_TXDLY_DQSGATE_P1_SHIFT = 20, + /* SELPH5 = 0x410 */ + SELPH5_DLY_DQSGATE_SHIFT = 22, + SELPH5_DLY_DQSGATE_P1_SHIFT = 24, + /* SELPH6_1 = 0x418 */ + SELPH6_1_DLY_R1DQSGATE_SHIFT = 0, + SELPH6_1_DLY_R1DQSGATE_P1_SHIFT = 2, + SELPH6_1_TXDLY_R1DQSGATE_SHIFT = 4, + SELPH6_1_TXDLY_R1DQSGATE_P1_SHIFT = 8, + /* MEMPLL_S14 = 0x638 */ + MASK_MEMPLL_DL = 0xc0ffffff, + MEMPLL_FB_DL_SHIFT = 0, + MEMPLL_REF_DL_SHIFT = 8, + MEMPLL_DL_SHIFT = 24, + MEMPLL_MODE_SHIFT = 29, + /* MEMPLL_DIVIDER = 0x640 */ + MEMCLKENB_SHIFT = 5 +}; + +struct dramc_ao_regs { + uint32_t actim0; /* 0x0 */ + uint32_t conf1; /* 0x4 */ + uint32_t conf2; /* 0x8 */ + uint32_t rsvd_ao1[3]; /* 0xc */ + uint32_t r0deldly; /* 0x18 */ + uint32_t r1deldly; /* 0x1c */ + uint32_t r0difdly; /* 0x20 */ + uint32_t r1difdly; /* 0x24 */ + uint32_t dllconf; /* 0x28 */ + uint32_t rsvd_ao2[6]; /* 0x2c */ + uint32_t test2_3; /* 0x44 */ + uint32_t test2_4; /* 0x48 */ + uint32_t catraining; /* 0x4c */ + uint32_t catraining2; /* 0x50 */ + uint32_t wodt; /* 0x54 */ + uint32_t rsvd_ao3[9]; /* 0x58 */ + uint32_t ddr2ctl; /* 0x7c */ + uint32_t misc; /* 0x80 */ + uint32_t zqcs; /* 0x84 */ + uint32_t mrs; /* 0x88 */ + uint32_t clk1delay; /* 0x8c */ + uint32_t rsvd_ao4[1]; /* 0x90 */ + uint32_t dqsien[2]; /* 0x94 */ + uint32_t rsvd_ao5[2]; /* 0x9c */ + uint32_t iodrv1; /* 0xa4 */ + uint32_t iodrv2; /* 0xa8 */ + uint32_t iodrv3; /* 0xac */ + uint32_t iodrv4; /* 0xb0 */ + uint32_t iodrv5; /* 0xb4 */ + uint32_t iodrv6; /* 0xb8 */ + uint32_t drvctl1; /* 0xbc */ + uint32_t dllsel; /* 0xc0 */ + uint32_t rsvd_ao7[5]; /* 0xc4 */ + uint32_t mckdly; /* 0xd8 */ + uint32_t rsvd_ao8[1]; /* 0xdc */ + uint32_t dqsctl1; /* 0xe0 */ + uint32_t padctl4; /* 0xe4 */ + uint32_t rsvd_ao9[2]; /* 0xe8 */ + uint32_t phyctl1; /* 0xf0 */ + uint32_t gddr3ctl1; /* 0xf4 */ + uint32_t padctl7; /* 0xf8 */ + uint32_t misctl0; /* 0xfc */ + uint32_t ocdk; /* 0x100 */ + uint32_t rsvd_ao10[3]; /* 0x104 */ + uint32_t rkcfg; /* 0x110 */ + uint32_t ckphdet; /* 0x114 */ + uint32_t dqsctl2; /* 0x118 */ + uint32_t rsvd_ao11[5]; /* 0x11c */ + uint32_t clkctl; /* 0x130 */ + uint32_t rsvd_ao12[1]; /* 0x134 */ + uint32_t dummy; /* 0x138 */ + uint32_t write_leveling; /* 0x13c */ + uint32_t rsvd_ao13[10]; /* 0x140 */ + uint32_t arbctl0; /* 0x168 */ + uint32_t rsvd_ao14[21]; /* 0x16c */ + uint32_t dqscal0; /* 0x1c0 */ + uint32_t dqscal1; /* 0x1c4 */ + uint32_t impcal; /* 0x1c8 */ + uint32_t rsvd_ao15[4]; /* 0x1cc */ + uint32_t dramc_pd_ctrl; /* 0x1dc */ + uint32_t lpddr2_3; /* 0x1e0 */ + uint32_t spcmd; /* 0x1e4 */ + uint32_t actim1; /* 0x1e8 */ + uint32_t perfctl0; /* 0x1ec */ + uint32_t ac_derating; /* 0x1f0 */ + uint32_t rrrate_ctl; /* 0x1f4 */ + uint32_t ac_time_05t; /* 0x1f8 */ + uint32_t mrr_ctl; /* 0x1fc */ + uint32_t rsvd_ao16[4]; /* 0x200 */ + uint32_t dqidly[9]; /* 0x210 */ + uint32_t rsvd_ao17[115]; /* 0x234 */ + uint32_t selph1; /* 0x400 */ + uint32_t selph2; /* 0x404 */ + uint32_t selph3; /* 0x408 */ + uint32_t selph4; /* 0x40c */ + uint32_t selph5; /* 0x410 */ + uint32_t selph6; /* 0x414 */ + uint32_t selph6_1; /* 0x418 */ + uint32_t selph7; /* 0x41c */ + uint32_t selph8; /* 0x420 */ + uint32_t selph9; /* 0x424 */ + uint32_t selph10; /* 0x428 */ + uint32_t selph11; /* 0x42c */ +}; + +check_member(dramc_ao_regs, selph11, 0x42c); + +struct dramc_nao_regs { + uint32_t rsvd_nao1[11]; /* 0x0 */ + uint32_t test_mode; /* 0x2c */ + uint32_t rsvd_nao2[3]; /* 0x30 */ + uint32_t test2_1; /* 0x3c */ + uint32_t test2_2; /* 0x40 */ + uint32_t rsvd_nao3[48]; /* 0x44 */ + uint32_t lbwdat0; /* 0x104 */ + uint32_t lbwdat1; /* 0x108 */ + uint32_t lbwdat2; /* 0x10c */ + uint32_t rsvd_nao4[1]; /* 0x110 */ + uint32_t ckphdet; /* 0x114 */ + uint32_t rsvd_nao5[48]; /* 0x118 */ + uint32_t dmmonitor; /* 0x1d8 */ + uint32_t rsvd_nao6[41]; /* 0x1dc */ + uint32_t r2r_page_hit_counter; /* 0x280 */ + uint32_t r2r_page_miss_counter; /* 0x284 */ + uint32_t r2r_interbank_counter; /* 0x288 */ + uint32_t r2w_page_hit_counter; /* 0x28c */ + uint32_t r2w_page_miss_counter; /* 0x290 */ + uint32_t r2w_interbank_counter; /* 0x294 */ + uint32_t w2r_page_hit_counter; /* 0x298 */ + uint32_t w2r_page_miss_counter; /* 0x29c */ + uint32_t w2r_page_interbank_counter; /* 0x2a0 */ + uint32_t w2w_page_hit_counter; /* 0x2a4 */ + uint32_t w2w_page_miss_counter; /* 0x2a8 */ + uint32_t w2w_page_interbank_counter; /* 0x2ac */ + uint32_t dramc_idle_counter; /* 0x2b0 */ + uint32_t freerun_26m_counter; /* 0x2b4 */ + uint32_t refresh_pop_counter; /* 0x2b8 */ + uint32_t jmeter_st; /* 0x2bc */ + uint32_t dq_cal_max[8]; /* 0x2c0 */ + uint32_t dqs_cal_min[8]; /* 0x2e0 */ + uint32_t dqs_cal_max[8]; /* 0x300 */ + uint32_t rsvd_nao7[4]; /* 0x320 */ + uint32_t read_bytes_counter; /* 0x330 */ + uint32_t write_bytes_counter; /* 0x334 */ + uint32_t rsvd_nao8[6]; /* 0x338 */ + uint32_t dqical[4]; /* 0x350 */ + uint32_t rsvd_nao9[4]; /* 0x360 */ + uint32_t cmp_err; /* 0x370 */ + uint32_t r0dqsiendly; /* 0x374 */ + uint32_t r1dqsiendly; /* 0x378 */ + uint32_t rsvd_nao10[9]; /* 0x37c */ + uint32_t dqsdly0; /* 0x3a0 */ + uint32_t rsvd_nao11[4]; /* 0x3a4 */ + uint32_t mrrdata; /* 0x3b4 */ + uint32_t spcmdresp; /* 0x3b8 */ + uint32_t iorgcnt; /* 0x3bc */ + uint32_t dqsgnwcnt[6]; /* 0x3c0 */ + uint32_t rsvd_nao12[4]; /* 0x3d8 */ + uint32_t ckphcnt; /* 0x3e8 */ + uint32_t rsvd_nao13[4]; /* 0x3ec */ + uint32_t testrpt; /* 0x3fc */ +}; + +check_member(dramc_nao_regs, testrpt, 0x3fc); + +struct dramc_ddrphy_regs { + uint32_t rsvd_phy1[3]; /* 0x0 */ + uint32_t padctl1; /* 0xc */ + uint32_t padctl2; /* 0x10 */ + uint32_t padctl3; /* 0x14 */ + uint32_t rsvd_phy2[25]; /* 0x18 */ + uint32_t ddr2ctl; /* 0x7c */ + uint32_t rsvd_phy3[3]; /* 0x80 */ + uint32_t clk1delay; /* 0x8c */ + uint32_t ioctl; /* 0x90 */ + uint32_t rsvd_phy4[7]; /* 0x94 */ + uint32_t iodrv4; /* 0xb0 */ + uint32_t iodrv5; /* 0xb4 */ + uint32_t iodrv6; /* 0xb8 */ + uint32_t drvctl1; /* 0xbc */ + uint32_t dllsel; /* 0xc0 */ + uint32_t rsvd_phy5[2]; /* 0xc4 */ + uint32_t tdsel[3]; /* 0xcc */ + uint32_t mckdly; /* 0xd8 */ + uint32_t dqsctl0; /* 0xdc */ + uint32_t dqsctl1; /* 0xe0 */ + uint32_t dqsctl4; /* 0xe4 */ + uint32_t dqsctl5; /* 0xe8 */ + uint32_t dqsctl6; /* 0xec */ + uint32_t phyctl1; /* 0xf0 */ + uint32_t gddr3ctl1; /* 0xf4 */ + uint32_t rsvd_phy6[1]; /* 0xf8 */ + uint32_t misctl0; /* 0xfc */ + uint32_t ocdk; /* 0x100 */ + uint32_t rsvd_phy7[8]; /* 0x104 */ + uint32_t dqsgctl; /* 0x124 */ + uint32_t rsvd_phy8[6]; /* 0x128 */ + uint32_t ddrphydqsgctl; /* 0x140 */ + uint32_t dqsgct2; /* 0x144 */ + uint32_t phyclkduty; /* 0x148 */ + uint32_t rsvd_phy9[3]; /* 0x14c */ + uint32_t dqsisel; /* 0x158 */ + uint32_t dqmdqs_sel; /* 0x15c */ + uint32_t rsvd_phy10[10]; /* 0x160 */ + uint32_t jmeterpop1; /* 0x188 */ + uint32_t jmeterpop2; /* 0x18c */ + uint32_t jmeterpop3; /* 0x190 */ + uint32_t jmeterpop4; /* 0x194 */ + uint32_t rsvd_phy11[4]; /* 0x198 */ + uint32_t cmddly[6]; /* 0x1a8 */ + uint32_t dqscal0; /* 0x1c0 */ + uint32_t rsvd_phy12[2]; /* 0x1c4 */ + uint32_t jmeter[3]; /* 0x1cc */ + uint32_t rsvd_phy13[2]; /* 0x1d8 */ + uint32_t lpddr2_3; /* 0x1e0 */ + uint32_t spcmd; /* 0x1e4 */ + uint32_t rsvd_phy14[6]; /* 0x1e8 */ + uint32_t dqodly[4]; /* 0x200 */ + uint32_t rsvd_phy15[11]; /* 0x210 */ + uint32_t lpddr2_4; /* 0x23c */ + uint32_t rsvd_phy16[56]; /* 0x240 */ + uint32_t jmeter_pll_st[3]; /* 0x320 */ + uint32_t jmeter_done_st; /* 0x32c */ + uint32_t rsvd_phy17[2]; /* 0x330 */ + uint32_t jmeter_pll1_st; /* 0x338 */ + uint32_t jmeter_pop_pll2_st; /* 0x33c */ + uint32_t jmeter_pop_pll3_st; /* 0x340 */ + uint32_t jmeter_pop_pll4_st; /* 0x344 */ + uint32_t jmeter_pop_pll1_st; /* 0x348 */ + uint32_t rsvd_phy18[13]; /* 0x34c */ + uint32_t dq_o1; /* 0x380 */ + uint32_t rsvd_phy19[2]; /* 0x384 */ + uint32_t stben[4]; /* 0x38c */ + uint32_t rsvd_phy20[16]; /* 0x39c */ + uint32_t dllcnt0; /* 0x3dc */ + uint32_t pllautok; /* 0x3e0 */ + uint32_t poppllautok; /* 0x3e4 */ + uint32_t rsvd_phy21[18]; /* 0x3e8 */ + uint32_t selph12; /* 0x430 */ + uint32_t selph13; /* 0x434 */ + uint32_t selph14; /* 0x438 */ + uint32_t selph15; /* 0x43c */ + uint32_t selph16; /* 0x440 */ + uint32_t selph17; /* 0x444 */ + uint32_t selph18; /* 0x448 */ + uint32_t selph19; /* 0x44c */ + uint32_t selph20; /* 0x450 */ + uint32_t rsvd_phy22[91]; /* 0x454 */ + uint32_t peri[4]; /* 0x5c0 */ + uint32_t rsvd_phy23[12]; /* 0x5d0 */ + uint32_t mempll[15]; /* 0x600 */ + uint32_t ddrphy_cg_ctrl; /* 0x63c */ + uint32_t mempll_divider; /* 0x640 */ + uint32_t vrefctl0; /* 0x644 */ + uint32_t rsvd_phy24[18]; /* 0x648 */ + uint32_t mempll05_divider; /* 0x690 */ +}; + +check_member(dramc_ddrphy_regs, mempll05_divider, 0x690); + +struct emi_regs { + uint32_t emi_cona; /* 0x0 */ + uint32_t rsvd_emi1; /* 0x4 */ + uint32_t emi_conb; /* 0x08 */ + uint32_t rsvd_emi2; /* 0x0c */ + uint32_t emi_conc; /* 0x10 */ + uint32_t rsvd_emi3; /* 0x14 */ + uint32_t emi_cond; /* 0x18 */ + uint32_t rsvd_emi4; /* 0x1c */ + uint32_t emi_cone; /* 0x20 */ + uint32_t rsvd_emi5; /* 0x24 */ + uint32_t emi_conf; /* 0x28 */ + uint32_t rsvd_emi6; /* 0x2c */ + uint32_t emi_cong; /* 0x30 */ + uint32_t rsvd_emi7; /* 0x34 */ + uint32_t emi_conh; /* 0x38 */ + uint32_t rsvd_emi8[9]; /* 0x3c */ + uint32_t emi_conm; /* 0x60 */ + uint32_t rsvd_emi9[5]; /* 0x64 */ + uint32_t emi_mdct; /* 0x78 */ + uint32_t rsvd_emi10[21]; /* 0x7c */ + uint32_t emi_test0; /* 0xd0 */ + uint32_t rsvd_emi11; /* 0xd4 */ + uint32_t emi_test1; /* 0xd8 */ + uint32_t rsvd_emi12; /* 0xdc */ + uint32_t emi_testa; /* 0xe0 */ + uint32_t rsvd_emi13; /* 0xe4 */ + uint32_t emi_testb; /* 0xe8 */ + uint32_t rsvd_emi14; /* 0xec */ + uint32_t emi_testc; /* 0xf0 */ + uint32_t rsvd_emi15; /* 0xf4 */ + uint32_t emi_testd; /* 0xf8 */ + uint32_t rsvd_emi16; /* 0xfc */ + uint32_t emi_arba; /* 0x100 */ + uint32_t rsvd_emi17[3]; /* 0x104 */ + uint32_t emi_arbc; /* 0x110 */ + uint32_t rsvd_emi18; /* 0x114 */ + uint32_t emi_arbd; /* 0x118 */ + uint32_t rsvd_emi19; /* 0x11c */ + uint32_t emi_arbe; /* 0x120 */ + uint32_t rsvd_emi20; /* 0x124 */ + uint32_t emi_arbf; /* 0x128 */ + uint32_t rsvd_emi21; /* 0x12c */ + uint32_t emi_arbg; /* 0x130 */ + uint32_t rsvd_emi22; /* 0x134 */ + uint32_t emi_arbh; /* 0x138 */ + uint32_t rsvd_emi23; /* 0x13c */ + uint32_t emi_arbi; /* 0x140 */ + uint32_t emi_arbi_2nd; /* 0x144 */ + uint32_t emi_arbj; /* 0x148 */ + uint32_t emi_arbj_2nd; /* 0x14c */ + uint32_t emi_arbk; /* 0x150 */ + uint32_t emi_arbk_2nd; /* 0x154 */ + uint32_t emi_slct; /* 0x158 */ + uint32_t rsvd_emi24; /* 0x15C */ + uint32_t emi_mpua; /* 0x160 */ + uint32_t rsvd_emi25; /* 0x164 */ + uint32_t emi_mpub; /* 0x168 */ + uint32_t rsvd_emi26; /* 0x16c */ + uint32_t emi_mpuc; /* 0x170 */ + uint32_t rsvd_emi27; /* 0x174 */ + uint32_t emi_mpud; /* 0x178 */ + uint32_t rsvd_emi28; /* 0x17C */ + uint32_t emi_mpue; /* 0x180 */ + uint32_t rsvd_emi29; /* 0x184 */ + uint32_t emi_mpuf; /* 0x188 */ + uint32_t rsvd_emi30; /* 0x18C */ + uint32_t emi_mpug; /* 0x190 */ + uint32_t rsvd_emi31; /* 0x194 */ + uint32_t emi_mpuh; /* 0x198 */ + uint32_t rsvd_emi32; /* 0x19C */ + uint32_t emi_mpui; /* 0x1A0 */ + uint32_t rsvd_emi33; /* 0x1A4 */ + uint32_t emi_mpuj; /* 0x1A8 */ + uint32_t rsvd_emi34; /* 0x1AC */ + uint32_t emi_mpuk; /* 0x1B0 */ + uint32_t rsvd_emi35; /* 0x1B4 */ + uint32_t emi_mpul; /* 0x1B8 */ + uint32_t rsvd_emi36; /* 0x1BC */ + uint32_t emi_mpum; /* 0x1C0 */ + uint32_t rsvd_emi37; /* 0x1C4 */ + uint32_t emi_mpun; /* 0x1C8 */ + uint32_t rsvd_emi38; /* 0x1CC */ + uint32_t emi_mpuo; /* 0x1D0 */ + uint32_t rsvd_emi39; /* 0x1D4 */ + uint32_t emi_mpup; /* 0x1D8 */ + uint32_t rsvd_emi40; /* 0x1DC */ + uint32_t emi_mpuq; /* 0x1E0 */ + uint32_t rsvd_emi41; /* 0x1E4 */ + uint32_t emi_mpur; /* 0x1E8 */ + uint32_t rsvd_emi42; /* 0x1EC */ + uint32_t emi_mpus; /* 0x1F0 */ + uint32_t rsvd_emi43; /* 0x1F4 */ + uint32_t emi_mput; /* 0x1F8 */ + uint32_t rsvd_emi44; /* 0x1FC */ + uint32_t emi_mpuu; /* 0x200 */ + uint32_t rsvd_emi45[7]; /* 0x204 */ + uint32_t emi_mpuy; /* 0x220 */ + uint32_t rsvd_emi46[119]; /* 0x224 */ + uint32_t emi_bmen; /* 0x400 */ +}; + +check_member(emi_regs, emi_bmen, 0x400); + +extern struct dramc_ao_regs *ao_regs; +extern struct dramc_nao_regs *nao_regs; +extern struct dramc_ddrphy_regs *ddrphy_regs; + +struct dramc_channel { + struct dramc_ao_regs *ao_regs; + struct dramc_nao_regs *nao_regs; + struct dramc_ddrphy_regs *ddrphy_regs; +}; + +static struct dramc_channel const ch[2] = { + {(void *)CHA_DRAMCAO_BASE, (void *)CHA_DRAMCNAO_BASE, (void *)CHA_DDRPHY_BASE}, + {(void *)CHB_DRAMCAO_BASE, (void *)CHB_DRAMCNAO_BASE, (void *)CHB_DDRPHY_BASE} +}; + +#endif /* _DRAMC_REGISTER_H_ */ diff --git a/src/soc/mediatek/mt8173/include/soc/emi.h b/src/soc/mediatek/mt8173/include/soc/emi.h new file mode 100644 index 0000000..d3a2aee --- /dev/null +++ b/src/soc/mediatek/mt8173/include/soc/emi.h @@ -0,0 +1,140 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef SOC_MEDIATEK_MT8173_EMI_H +#define SOC_MEDIATEK_MT8173_EMI_H + +#include <soc/dramc_common.h> +#include <stdint.h> + +/* DDR type */ +enum ram_type { + TYPE_INVALID, + TYPE_DDR1, + TYPE_LPDDR2, + TYPE_LPDDR3, + TYPE_PCDDR3 +}; + +enum { + /* + * Vmem voltage adjustment: + * 1) HV: high voltage + * 2) NV: normal voltage + * 3) LV: low voltage + */ + Vmem_HV_LPDDR3 = 0x50, /* 1.300V */ + Vmem_NV_LPDDR3 = 0x44, /* 1.225V */ + Vmem_LV_LPDDR3 = 0x36 /* 1.138V */ +}; + +enum { + /* + * Vcore voltage adjustment: + * 1) HHV: extra high voltage + * 2) HV: high voltage + * 3) NV: normal voltage + * 4) LV: low voltage + * 5) LLV: extra low voltage + */ + Vcore_HHV_LPPDR3 = 0x60, /* 1.300V */ + Vcore_HV_LPPDR3 = 0x48, /* 1.150V */ + Vcore_NV_LPPDR3 = 0x44, /* 1.125V */ + Vcore_LV_LPPDR3 = 0x34, /* 1.025V */ + Vcore_LLV_LPPDR3 = 0x25 /* 0.931V */ +}; + +struct mt8173_calib_params { + u8 impedance_drvp; + u8 impedance_drvn; + u8 datlat_ucfirst; + s8 ca_train[CHANNEL_NUM][CATRAINING_NUM]; + s8 ca_train_center[CHANNEL_NUM]; + s8 wr_level[CHANNEL_NUM][DQS_NUMBER]; + u8 gating_win[CHANNEL_NUM][DUAL_RANKS][GW_PARAM_NUM]; + u32 rx_dqs_dly[CHANNEL_NUM]; + u32 rx_dq_dly[CHANNEL_NUM][DQS_BIT_NUMBER]; +}; + +struct mt8173_timing_params { + u32 actim; + u32 actim1; + u32 actim05t; + u32 conf1; + u32 conf2; + u32 ddr2ctl; + u32 gddr3ctl1; + u32 misctl0; + u32 pd_ctrl; + u32 rkcfg; + u32 test2_4; + u32 test2_3; +}; + +struct mt8173_emi_params { + u32 cona; + u32 conb; + u32 conc; + u32 cond; + u32 cone; + u32 conf; + u32 cong; + u32 conh; + u32 conm_1; + u32 conm_2; + u32 mdct_1; + u32 mdct_2; + u32 test0; + u32 test1; + u32 testb; + u32 testc; + u32 testd; + u32 arba; + u32 arbc; + u32 arbd; + u32 arbe; + u32 arbf; + u32 arbg; + u32 arbi; + u32 arbj; + u32 arbk; + u32 slct_1; + u32 slct_2; + u32 bmen; +}; + +struct mt8173_mrs_params { + u32 mrs_1; + u32 mrs_2; + u32 mrs_3; + u32 mrs_10; + u32 mrs_11; + u32 mrs_63; +}; + +struct mt8173_sdram_params { + struct mt8173_calib_params calib_params; + struct mt8173_timing_params ac_timing; + struct mt8173_emi_params emi_set; + struct mt8173_mrs_params mrs_set; + enum ram_type type; + unsigned int dram_freq; +}; + +void mt_set_emi(const struct mt8173_sdram_params *sdram_params); +void mt_mem_init(const struct mt8173_sdram_params *sdram_params); +const struct mt8173_sdram_params *get_sdram_config(void); + +#endif diff --git a/src/soc/mediatek/mt8173/include/soc/pll.h b/src/soc/mediatek/mt8173/include/soc/pll.h index 1eab709..6d38bb3 100644 --- a/src/soc/mediatek/mt8173/include/soc/pll.h +++ b/src/soc/mediatek/mt8173/include/soc/pll.h @@ -16,6 +16,7 @@ #ifndef SOC_MEDIATEK_MT8173_PLL_H #define SOC_MEDIATEK_MT8173_PLL_H +#include <soc/emi.h> #include <soc/addressmap.h> struct mt8173_topckgen_regs { @@ -285,5 +286,9 @@ void mt_pll_post_init(void); void mt_pll_init(void); void mt_pll_set_aud_div(u32 rate); void mt_pll_enable_ssusb_clk(void); +void mt_mem_pll_set_clk_cfg(void); +void mt_mem_pll_config_pre(const struct mt8173_sdram_params *sdram_params); +void mt_mem_pll_config_post(void); +void mt_mem_pll_mux(void); #endif /* SOC_MEDIATEK_MT8173_PLL_H */ diff --git a/src/soc/mediatek/mt8173/memory.c b/src/soc/mediatek/mt8173/memory.c new file mode 100644 index 0000000..3db9df8 --- /dev/null +++ b/src/soc/mediatek/mt8173/memory.c @@ -0,0 +1,357 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#include <arch/io.h> +#include <assert.h> +#include <console/console.h> +#include <soc/addressmap.h> +#include <soc/dramc_register.h> +#include <soc/dramc_pi_api.h> +#include <soc/emi.h> +#include <soc/pll.h> + +enum { + /* test patterns */ + PATTERN0 = 0x00000000, + PATTERN1 = 0x5A5A5A5A, + PATTERN2 = 0xA5A5A5A5, + PATTERN3 = 0xA5A5A500, + PATTERN4 = 0xA500A500, + PATTERN5 = 0xA5000000, + PATTERN6 = 0xFFFF0000, + PATTERN7 = 0x0000FFFF, + PATTERN8 = 0x00000012, + PATTERN9 = 0x00000034, + PATTERNA = 0x00000056, + PATTERNB = 0x00000078, + PATTERNC = 0x00001234, + PATTERND = 0x00005678, + PATTERNE = 0x12345678, + PATTERNF = 0xFFFFFFFF +}; + +static int complex_mem_test(unsigned int start, unsigned int len) +{ + unsigned char *mem8_base = (unsigned char *)(uintptr_t)start; + unsigned short *mem16_base = (unsigned short *)(uintptr_t)start; + unsigned int *mem32_base = (unsigned int *)(uintptr_t)start; + unsigned int *mem_base = (unsigned int *)(uintptr_t)start; + unsigned char pattern8; + unsigned short pattern16; + unsigned int i, j, size, pattern32; + unsigned int value; + + size = len >> 2; + + /* verify the tied bits (tied high) */ + for (i = 0; i < size; i++) { + mem32_base[i] = PATTERN0; + } + + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN0) { + return -1; + } else { + mem32_base[i] = PATTERNF; + } + } + + /* verify the tied bits (tied low) */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERNF) { + return -2; + } else + mem32_base[i] = PATTERN0; + } + + /* verify pattern 1 (0x00~0xff) */ + pattern8 = PATTERN0; + for (i = 0; i < len; i++) + mem8_base[i] = pattern8++; + pattern8 = PATTERN0; + for (i = 0; i < len; i++) { + if (mem8_base[i] != pattern8++) { + return -3; + } + } + + /* verify pattern 2 (0x00~0xff) */ + pattern8 = PATTERN0; + for (i = j = 0; i < len; i += 2, j++) { + if (mem8_base[i] == pattern8) + mem16_base[j] = pattern8; + if (mem16_base[j] != pattern8) { + return -4; + } + pattern8 += 2; + } + + /* verify pattern 3 (0x00~0xffff) */ + pattern16 = PATTERN0; + for (i = 0; i < (len >> 1); i++) + mem16_base[i] = pattern16++; + pattern16 = PATTERN0; + for (i = 0; i < (len >> 1); i++) { + if (mem16_base[i] != pattern16++) { + return -5; + } + } + + /* verify pattern 4 (0x00~0xffffffff) */ + pattern32 = PATTERN0; + for (i = 0; i < (len >> 2); i++) + mem32_base[i] = pattern32++; + pattern32 = PATTERN0; + for (i = 0; i < (len >> 2); i++) { + if (mem32_base[i] != pattern32++) { + return -6; + } + } + + /* pattern 5: filling memory range with 0x12345678 */ + for (i = 0; i < size; i++) + mem32_base[i] = PATTERNE; + + /* read check then fill memory with a5a5a5a5 pattern */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERNE) { + return -7; + } else { + mem32_base[i] = PATTERN2; + } + } + + /* read check then fill memory with 00 byte pattern at offset 0h */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN2) { + return -8; + } else { + mem8_base[i * 4] = PATTERN0; + } + } + + /* read check then fill memory with 00 byte pattern at offset 2h */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN3) { + return -9; + } else { + mem8_base[i * 4 + 2] = PATTERN0; + } + } + + /* read check then fill memory with 00 byte pattern at offset 1h */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN4) { + return -10; + } else { + mem8_base[i * 4 + 1] = PATTERN0; + } + } + + /* read check then fill memory with 00 byte pattern at offset 3h */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN5) { + return -11; + } else { + mem8_base[i * 4 + 3] = PATTERN0; + } + } + + /* read check then fill memory with ffff word pattern at offset 1h */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN0) { + return -12; + } else { + mem16_base[i * 2 + 1] = PATTERN7; + } + } + + /* read check then fill memory with ffff word pattern at offset 0h */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERN6) { + return -13; + } else { + mem16_base[i * 2] = PATTERN7; + } + } + + /* read check */ + for (i = 0; i < size; i++) { + if (mem32_base[i] != PATTERNF) { + return -14; + } + } + + /* stage 1 => write 0 */ + for (i = 0; i < size; i++) { + mem_base[i] = PATTERN1; + } + + /* stage 2 => read 0, write 0xf */ + for (i = 0; i < size; i++) { + value = mem_base[i]; + + if (value != PATTERN1) { + return -15; + } + mem_base[i] = PATTERN2; + } + + /* stage 3 => read 0xf, write 0 */ + for (i = 0; i < size; i++) { + value = mem_base[i]; + if (value != PATTERN2) { + return -16; + } + mem_base[i] = PATTERN1; + } + + /* stage 4 => read 0, write 0xf */ + for (i = 0; i < size; i++) { + value = mem_base[i]; + if (value != PATTERN1) { + return -17; + } + mem_base[i] = PATTERN2; + } + + /* stage 5 => read 0xf, write 0 */ + for (i = 0; i < size; i++) { + value = mem_base[i]; + if (value != PATTERN2) { + return -18; + } + mem_base[i] = PATTERN1; + } + + /* stage 6 => read 0 */ + for (i = 0; i < size; i++) { + value = mem_base[i]; + if (value != PATTERN1) { + return -19; + } + } + + /* 1/2/4-byte combination test */ + i = (unsigned int)(uintptr_t)mem_base; + + while (i < (unsigned int)(uintptr_t)mem_base + (size << 2)) { + *((unsigned char *)(uintptr_t)i) = PATTERNB; + i += 1; + *((unsigned char *)(uintptr_t)i) = PATTERNA; + i += 1; + *((unsigned short *)(uintptr_t)i) = PATTERNC; + i += 2; + *((unsigned int *)(uintptr_t)i) = PATTERNE; + i += 4; + *((unsigned short *)(uintptr_t)i) = PATTERND; + i += 2; + *((unsigned char *)(uintptr_t)i) = PATTERN9; + i += 1; + *((unsigned char *)(uintptr_t)i) = PATTERN8; + i += 1; + *((unsigned int *)(uintptr_t)i) = PATTERNE; + i += 4; + *((unsigned char *)(uintptr_t)i) = PATTERNB; + i += 1; + *((unsigned char *)(uintptr_t)i) = PATTERNA; + i += 1; + *((unsigned short *)(uintptr_t)i) = PATTERNC; + i += 2; + *((unsigned int *)(uintptr_t)i) = PATTERNE; + i += 4; + *((unsigned short *)(uintptr_t)i) = PATTERND; + i += 2; + *((unsigned char *)(uintptr_t)i) = PATTERN9; + i += 1; + *((unsigned char *)(uintptr_t)i) = PATTERN8; + i += 1; + *((unsigned int *)(uintptr_t)i) = PATTERNE; + i += 4; + } + + for (i = 0; i < size; i++) { + value = mem_base[i]; + if (value != PATTERNE) { + return -20; + } + } + + /* verify pattern 1 (0x00~0xff) */ + pattern8 = PATTERN0; + mem8_base[0] = pattern8; + for (i = 0; i < size * 4; i++) { + unsigned char waddr8, raddr8; + + waddr8 = i + 1; + raddr8 = i; + if (i < size * 4 - 1) + mem8_base[waddr8] = pattern8 + 1; + if (mem8_base[raddr8] != pattern8) { + return -21; + } + pattern8++; + } + + /* verify pattern 2 (0x00~0xffff) */ + pattern16 = PATTERN0; + mem16_base[0] = pattern16; + for (i = 0; i < size * 2; i++) { + if (i < size * 2 - 1) + mem16_base[i + 1] = pattern16 + 1; + if (mem16_base[i] != pattern16) { + return -22; + } + pattern16++; + } + + /* verify pattern 3 (0x00~0xffffffff) */ + pattern32 = PATTERN0; + mem32_base[0] = pattern32; + for (i = 0; i < size; i++) { + if (i < size - 1) + mem32_base[i + 1] = pattern32 + 1; + if (mem32_base[i] != pattern32) { + return -23; + } + pattern32++; + } + + return 0; +} + +void mt_mem_init(const struct mt8173_sdram_params *sdram_params) +{ + int i = 0; + + /* init mempll */ + mem_pll_init(sdram_params); + + /* memory calibration */ + mt_set_emi(sdram_params); + + if (IS_ENABLED(CONFIG_MEMORY_TEST)) { + /* do memory test: + * set memory scan range 0x2000 + * larger test length, longer system boot up time + */ + i = complex_mem_test(DDR_BASE, 0x2000); + + printk(BIOS_DEBUG, "[MEM] complex R/W mem test %s : %d\n", + (i == 0) ? "pass" : "fail", i); + + ASSERT(i == 0); + } +} diff --git a/src/soc/mediatek/mt8173/pll.c b/src/soc/mediatek/mt8173/pll.c index 3faf785..d54538d 100644 --- a/src/soc/mediatek/mt8173/pll.c +++ b/src/soc/mediatek/mt8173/pll.c @@ -505,3 +505,29 @@ void mt_pll_set_aud_div(u32 rate) 7 << 28); } } + +void mt_mem_pll_config_pre(const struct mt8173_sdram_params *sdram_params) +{ + u32 mpll_sdm_pcw_20_0 = 0xF13B1; + + /* disable MPLL for adjusting memory clk frequency */ + clrbits_le32(&mt8173_apmixed->mpll_con0, BIT(0)); + /* MPLL configuration: mode selection */ + setbits_le32(&mt8173_apmixed->mpll_con0, BIT(16)); + clrbits_le32(&mt8173_apmixed->mpll_con0, 0x7 << 4); + clrbits_le32(&mt8173_apmixed->pll_test_con0, 1 << 31); + /* set RG_MPLL_SDM_PCW for feedback divide ratio */ + clrsetbits_le32(&mt8173_apmixed->mpll_con1, 0x1fffff, mpll_sdm_pcw_20_0); +} + +void mt_mem_pll_config_post(void) +{ + /* power up sequence starts: enable MPLL */ + setbits_le32(&mt8173_apmixed->mpll_con0, BIT(0)); +} + +void mt_mem_pll_mux(void) +{ + /* CLK_CFG_0 */ + mux_set_sel(&muxes[TOP_MEM_SEL], 1); /* 1: dmpll_ck */ +}

1 0

Patch set updated for coreboot: mediatek/mt8173: enable RTC in ramstage
by Stefan Reinauer 03 Feb '16

03 Feb '16

Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/13103 -gerrit commit a572a73dea66509d3eac5c081d20d6658055dd4b Author: CC Ma <cc.ma(a)mediatek.com> Date: Tue Sep 15 17:33:38 2015 +0800 mediatek/mt8173: enable RTC in ramstage BRANCH=none BUG=none TEST=boot to shell on Rev3 Change-Id: I77c5a8aa31ab10d82115a60bdfee1da35707619f Signed-off-by: Patrick Georgi <pgeorgi(a)chromium.org> Original-Commit-Id: 7d511df7f527ae96c2da01804c62fe98a13fed56 Original-Change-Id: I68ab8be50f210fa17bd731b400a087b150566e3b Original-Signed-off-by: CC Ma <cc.ma(a)mediatek.com> Original-Reviewed-on: https://chromium-review.googlesource.com/303207 Original-Commit-Ready: Yidi Lin <yidi.lin(a)mediatek.com> Original-Tested-by: Yidi Lin <yidi.lin(a)mediatek.com> Original-Reviewed-by: Julius Werner <jwerner(a)chromium.org> --- src/soc/mediatek/mt8173/Kconfig | 1 + src/soc/mediatek/mt8173/Makefile.inc | 1 + 2 files changed, 2 insertions(+) diff --git a/src/soc/mediatek/mt8173/Kconfig b/src/soc/mediatek/mt8173/Kconfig index d8f1116..b44c360 100644 --- a/src/soc/mediatek/mt8173/Kconfig +++ b/src/soc/mediatek/mt8173/Kconfig @@ -14,6 +14,7 @@ config SOC_MEDIATEK_MT8173 select HAS_PRECBMEM_TIMESTAMP_REGION select GENERIC_GPIO_LIB select HAVE_HARD_RESET + select RTC if SOC_MEDIATEK_MT8173 diff --git a/src/soc/mediatek/mt8173/Makefile.inc b/src/soc/mediatek/mt8173/Makefile.inc index 97053a5..fa344c0 100644 --- a/src/soc/mediatek/mt8173/Makefile.inc +++ b/src/soc/mediatek/mt8173/Makefile.inc @@ -65,6 +65,7 @@ ramstage-y += pmic_wrap.c mt6391.c ramstage-y += gpio.c ramstage-y += wdt.c ramstage-y += pll.c +ramstage-y += rtc.c ramstage-y += usb.c

1 0

Patch set updated for coreboot: mt8173: add SPI NOR support
by Stefan Reinauer 03 Feb '16

03 Feb '16

Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at https://review.coreboot.org/13102 -gerrit commit 64c880102172a5cd186a2ed93b78fa65c8703470 Author: mtk05962 <bayi.cheng(a)mediatek.com> Date: Fri Oct 16 13:42:49 2015 +0800 mt8173: add SPI NOR support BRANCH=none BUG=none TEST=boot oak to kernel on rev1 Change-Id: I0773c81398df445aec16bcfcd0c5a8fe5a588b5c Signed-off-by: Patrick Georgi <pgeorgi(a)chromium.org> Original-Commit-Id: ae15c42c2f7d9c2a716e5b6098d85e17279f5eae Original-Change-Id: I65abf810d35ae5e7156cf6f5730117e690183d18 Original-Signed-off-by: mtk05962 <bayi.cheng(a)mediatek.com> Original-Reviewed-on: https://chromium-review.googlesource.com/292693 Original-Commit-Ready: Yidi Lin <yidi.lin(a)mediatek.com> Original-Tested-by: Yidi Lin <yidi.lin(a)mediatek.com> Original-Reviewed-by: Julius Werner <jwerner(a)chromium.org> --- src/mainboard/google/oak/Kconfig | 8 +- src/mainboard/google/oak/bootblock.c | 31 ++++ src/soc/mediatek/mt8173/Makefile.inc | 8 +- src/soc/mediatek/mt8173/cbfs.c | 21 --- src/soc/mediatek/mt8173/flash_controller.c | 184 +++++++++++++++++++++ .../mediatek/mt8173/include/soc/flash_controller.h | 80 +++++++++ src/soc/mediatek/mt8173/spi.c | 8 + 7 files changed, 314 insertions(+), 26 deletions(-) diff --git a/src/mainboard/google/oak/Kconfig b/src/mainboard/google/oak/Kconfig index 33f10be..4a8f411 100644 --- a/src/mainboard/google/oak/Kconfig +++ b/src/mainboard/google/oak/Kconfig @@ -27,9 +27,11 @@ config BOARD_SPECIFIC_OPTIONS select MAINBOARD_HAS_CHROMEOS config CHROMEOS - select CHROMEOS_VBNV_EC + select CHROMEOS_VBNV_FLASH select EC_SOFTWARE_SYNC select VIRTUAL_DEV_SWITCH + select SPI_FLASH + select COMMON_CBFS_SPI_WRAPPER config MAINBOARD_DIR string @@ -55,4 +57,8 @@ config DRIVER_TPM_I2C_ADDR hex default 0x20 +config BOOT_MEDIA_SPI_BUS + int + default 9 + endif # BOARD_GOOGLE_OAK diff --git a/src/mainboard/google/oak/bootblock.c b/src/mainboard/google/oak/bootblock.c index 3d78551..efb489f 100644 --- a/src/mainboard/google/oak/bootblock.c +++ b/src/mainboard/google/oak/bootblock.c @@ -33,6 +33,34 @@ static void i2c_set_gpio_pinmux(void) gpio_set_mode(PAD_SCL4, PAD_SCL4_FUNC_SCL4); } +static void nor_set_gpio_pinmux(void) +{ + /* Set driving strength of EINT4~EINT9 to 8mA + * 0: 2mA + * 1: 4mA + * 2: 8mA + * 3: 16mA + */ + /* EINT4: 0x10005B20[14:13] */ + clrsetbits_le16(&mt8173_gpio->drv_mode[2].val, 0xf << 12, 2 << 13); + /* EINT5~EINT9: 0x10005B30[2:1] */ + clrsetbits_le16(&mt8173_gpio->drv_mode[3].val, 0xf << 0, 2 << 1), + + gpio_set_pull(PAD_EINT4, GPIO_PULL_ENABLE, GPIO_PULL_UP); + gpio_set_pull(PAD_EINT5, GPIO_PULL_ENABLE, GPIO_PULL_UP); + gpio_set_pull(PAD_EINT6, GPIO_PULL_ENABLE, GPIO_PULL_UP); + gpio_set_pull(PAD_EINT7, GPIO_PULL_ENABLE, GPIO_PULL_UP); + gpio_set_pull(PAD_EINT8, GPIO_PULL_ENABLE, GPIO_PULL_UP); + gpio_set_pull(PAD_EINT9, GPIO_PULL_ENABLE, GPIO_PULL_UP); + + gpio_set_mode(PAD_EINT4, PAD_EINT4_FUNC_SFWP_B); + gpio_set_mode(PAD_EINT5, PAD_EINT5_FUNC_SFOUT); + gpio_set_mode(PAD_EINT6, PAD_EINT6_FUNC_SFCS0); + gpio_set_mode(PAD_EINT7, PAD_EINT7_FUNC_SFHOLD); + gpio_set_mode(PAD_EINT8, PAD_EINT8_FUNC_SFIN); + gpio_set_mode(PAD_EINT9, PAD_EINT9_FUNC_SFCK); +} + void bootblock_mainboard_early_init(void) { /* Clear UART0 power down signal */ @@ -47,6 +75,9 @@ void bootblock_mainboard_init(void) /* set i2c related gpio */ i2c_set_gpio_pinmux(); + /* set nor related GPIO */ + nor_set_gpio_pinmux(); + mtk_spi_init(CONFIG_EC_GOOGLE_CHROMEEC_SPI_BUS, SPI_PAD1_MASK, 6*MHz); setup_chromeos_gpios(); diff --git a/src/soc/mediatek/mt8173/Makefile.inc b/src/soc/mediatek/mt8173/Makefile.inc index cbc9855..97053a5 100644 --- a/src/soc/mediatek/mt8173/Makefile.inc +++ b/src/soc/mediatek/mt8173/Makefile.inc @@ -16,7 +16,7 @@ ifeq ($(CONFIG_SOC_MEDIATEK_MT8173),y) bootblock-y += bootblock.c -bootblock-y += cbfs.c +bootblock-$(CONFIG_SPI_FLASH) += flash_controller.c bootblock-y += pll.c bootblock-y += spi.c bootblock-y += timer.c @@ -38,11 +38,11 @@ verstage-$(CONFIG_DRIVERS_UART) += uart.c verstage-y += timer.c verstage-y += wdt.c -verstage-y += cbfs.c +verstage-$(CONFIG_SPI_FLASH) += flash_controller.c ################################################################################ -romstage-y += cbfs.c +romstage-$(CONFIG_SPI_FLASH) += flash_controller.c romstage-y += timer.c romstage-$(CONFIG_DRIVERS_UART) += uart.c @@ -57,7 +57,7 @@ romstage-y += rtc.c ramstage-y += cbmem.c ramstage-y += spi.c -ramstage-y += cbfs.c +ramstage-$(CONFIG_SPI_FLASH) += flash_controller.c ramstage-y += soc.c mtcmos.c ramstage-y += timer.c ramstage-$(CONFIG_DRIVERS_UART) += uart.c diff --git a/src/soc/mediatek/mt8173/cbfs.c b/src/soc/mediatek/mt8173/cbfs.c deleted file mode 100644 index 25348fc..0000000 --- a/src/soc/mediatek/mt8173/cbfs.c +++ /dev/null @@ -1,21 +0,0 @@ -/* - * This file is part of the coreboot project. - * - * Copyright 2015 MediaTek Inc. - * - * 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; version 2 of the License. - * - * 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. - */ - -#include <boot_device.h> - -const struct region_device *boot_device_ro(void) -{ - return NULL; -} diff --git a/src/soc/mediatek/mt8173/flash_controller.c b/src/soc/mediatek/mt8173/flash_controller.c new file mode 100644 index 0000000..3cd81a2 --- /dev/null +++ b/src/soc/mediatek/mt8173/flash_controller.c @@ -0,0 +1,184 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +/* NOR Flash is clocked with 26MHz, from CLK26M -> TOP_SPINFI_IFR */ + +#include <arch/io.h> +#include <assert.h> +#include <console/console.h> +#include <spi_flash.h> +#include <spi-generic.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> +#include <timer.h> +#include <soc/flash_controller.h> + +#define get_nth_byte(d, n) ((d >> (8 * n)) & 0xff) + +static int polling_cmd(u32 val) +{ + struct stopwatch sw; + + stopwatch_init_usecs_expire(&sw, SFLASH_POLLINGREG_US); + + while ((read32(&mt8173_nor->cmd) & val) != 0) { + if (stopwatch_expired(&sw)) + return -1; + } + + return 0; +} + +static int mt8173_nor_execute_cmd(u8 cmdval) +{ + u8 val = cmdval & ~(SFLASH_AUTOINC); + + write8(&mt8173_nor->cmd, cmdval); + return polling_cmd(val); +} + +static int sflashhw_read_flash_status(u8 *value) +{ + if (mt8173_nor_execute_cmd(SFLASH_READSTATUS)) + return -1; + + *value = read8(&mt8173_nor->rdsr); + return 0; +} + +static int wait_for_write_done(void) +{ + struct stopwatch sw; + u8 reg; + + stopwatch_init_usecs_expire(&sw, SFLASH_POLLINGREG_US); + + while (sflashhw_read_flash_status(&reg) == 0) { + if (!(reg & SFLASH_WRITE_IN_PROGRESS)) + return 0; + if (stopwatch_expired(&sw)) + return -1; + } + + return -1; +} + +/* set serial flash program address */ +static void set_sfpaddr(u32 addr) +{ + write8(&mt8173_nor->radr[2], get_nth_byte(addr, 2)); + write8(&mt8173_nor->radr[1], get_nth_byte(addr, 1)); + write8(&mt8173_nor->radr[0], get_nth_byte(addr, 0)); +} + +static int sector_erase(int offset) +{ + if (wait_for_write_done()) + return -1; + + write8(&mt8173_nor->prgdata[5], SFLASH_OP_WREN); + write8(&mt8173_nor->cnt, 8); + mt8173_nor_execute_cmd(SFLASH_PRG_CMD); + + write8(&mt8173_nor->prgdata[5], SECTOR_ERASE_CMD); + write8(&mt8173_nor->prgdata[4], get_nth_byte(offset, 2)); + write8(&mt8173_nor->prgdata[3], get_nth_byte(offset, 1)); + write8(&mt8173_nor->prgdata[2], get_nth_byte(offset, 0)); + write8(&mt8173_nor->cnt, 32); + mt8173_nor_execute_cmd(SFLASH_PRG_CMD); + + if (wait_for_write_done()) + return -1; + + return 0; +} + +unsigned int spi_crop_chunk(unsigned int cmd_len, unsigned int buf_len) +{ + return min(65535, buf_len); +} + +static int nor_read(struct spi_flash *flash, u32 addr, size_t len, void *buf) +{ + u8 *buffer = (u8 *)buf; + + set_sfpaddr(addr); + while (len) { + if (mt8173_nor_execute_cmd(SFLASH_RD_TRIGGER | SFLASH_AUTOINC)) + return -1; + + *buffer++ = read8(&mt8173_nor->rdata); + len--; + } + return 0; +} + +static int nor_write(struct spi_flash *flash, u32 addr, size_t len, + const void *buf) +{ + const u8 *buffer = (const u8 *)buf; + + set_sfpaddr(addr); + while (len) { + write8(&mt8173_nor->wdata, *buffer); + if (mt8173_nor_execute_cmd(SFLASH_WR_TRIGGER | SFLASH_AUTOINC)) + return -1; + + if (wait_for_write_done()) + return -1; + buffer++; + len--; + } + return 0; +} + +static int nor_erase(struct spi_flash *flash, u32 offset, size_t len) +{ + int sector_start = offset; + int sector_num = (u32)len / flash->sector_size; + + while (sector_num) { + if (!sector_erase(sector_start)) { + sector_start += flash->sector_size; + sector_num--; + } else { + printk(BIOS_WARNING, "Erase failed at 0x%x!\n", + sector_start); + return -1; + } + } + return 0; +} + +struct spi_flash *mt8173_nor_flash_probe(struct spi_slave *spi) +{ + static struct spi_flash flash = {0}; + + if (flash.spi) + return &flash; + + write32(&mt8173_nor->wrprot, SFLASH_COMMAND_ENABLE); + flash.spi = spi; + flash.name = "mt8173 flash controller"; + flash.write = nor_write; + flash.erase = nor_erase; + flash.read = nor_read; + flash.status = 0; + flash.sector_size = 0x1000; + flash.erase_cmd = SECTOR_ERASE_CMD; + flash.size = CONFIG_ROM_SIZE; + return &flash; +} diff --git a/src/soc/mediatek/mt8173/include/soc/flash_controller.h b/src/soc/mediatek/mt8173/include/soc/flash_controller.h new file mode 100644 index 0000000..2527d6b --- /dev/null +++ b/src/soc/mediatek/mt8173/include/soc/flash_controller.h @@ -0,0 +1,80 @@ +/* + * This file is part of the coreboot project. + * + * Copyright 2015 MediaTek Inc. + * + * 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; version 2 of the License. + * + * 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. + */ + +#ifndef __SOC_MEDIATEK_MT8173_FLASH_CONTROLLER_H__ +#define __SOC_MEDIATEK_MT8173_FLASH_CONTROLLER_H__ + +#include <cbfs.h> +#include <spi-generic.h> +#include <stdint.h> +#include <soc/addressmap.h> + +enum { + SFLASH_POLLINGREG_US = 500000, + SFLASH_WRBUF_SIZE = 128, + SFLASHNAME_LENGTH = 16, + SFLASH_WRITE_IN_PROGRESS = 1, + SFLASH_COMMAND_ENABLE = 0x30, + + /* NOR flash controller commands */ + SFLASH_RD_TRIGGER = 1 << 0, + SFLASH_READSTATUS = 1 << 1, + SFLASH_PRG_CMD = 1 << 2, + SFLASH_WR_TRIGGER = 1 << 4, + SFLASH_WRITESTATUS = 1 << 5, + SFLASH_AUTOINC = 1 << 7, + /* NOR flash commands */ + SFLASH_OP_WREN = 0x6, + SECTOR_ERASE_CMD = 0x20, + SFLASH_UNPROTECTED = 0x0 +}; + +/* register Offset */ +struct mt8173_nor_regs { + u32 cmd; + u32 cnt; + u32 rdsr; + u32 rdata; + u32 radr[3]; + u32 wdata; + u32 prgdata[6]; + u32 shreg[10]; + u32 cfg[2]; + u32 shreg10; + u32 status[5]; + u32 timing; + u32 flash_cfg; + u32 reserved2[3]; + u32 sf_time; + u32 reserved3; + u32 diff_addr; + u32 del_sel[2]; + u32 intrstus; + u32 intren; + u32 pp_ctl; + u32 cfg3; + u32 chksum_ctl; + u32 chksum; + u32 aaicmd; + u32 wrprot; + u32 radr3; + u32 read_dual; + u32 delsel[3]; +}; +check_member(mt8173_nor_regs, delsel[2], 0xD8); +static struct mt8173_nor_regs * const mt8173_nor = (void *)SFLASH_REG_BASE; + +struct spi_flash *mt8173_nor_flash_probe(struct spi_slave *spi); +#endif /* __SOC_MEDIATEK_MT8173_FLASH_CONTROLLER_H__ */ diff --git a/src/soc/mediatek/mt8173/spi.c b/src/soc/mediatek/mt8173/spi.c index c3c71c3..dc674f3 100644 --- a/src/soc/mediatek/mt8173/spi.c +++ b/src/soc/mediatek/mt8173/spi.c @@ -23,6 +23,7 @@ #include <string.h> #include <timer.h> #include <soc/addressmap.h> +#include <soc/flash_controller.h> #include <soc/gpio.h> #include <soc/pinmux.h> #include <soc/pll.h> @@ -161,6 +162,7 @@ static void mtk_spi_dump_data(const char *name, const uint8_t *data, struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs) { struct mtk_spi_bus *eslave; + static struct spi_slave slave; switch (bus) { case CONFIG_EC_GOOGLE_CHROMEEC_SPI_BUS: @@ -168,6 +170,12 @@ struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs) assert(read32(&eslave->regs->spi_cfg0_reg) != 0); spi_sw_reset(eslave->regs); return &eslave->slave; + case CONFIG_BOOT_MEDIA_SPI_BUS: + slave.bus = bus; + slave.cs = cs; + slave.force_programmer_specific = 1; + slave.programmer_specific_probe = &mt8173_nor_flash_probe; + return &slave; default: die ("wrong bus number.\n"); };

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

coreboot-gerrit February 2016