tegra: Add EMC support for optimal memory timings
authorJimmy Zhang <jimmzhang@nvidia.com>
Mon, 2 Apr 2012 13:18:52 +0000 (13:18 +0000)
committerAlbert ARIBAUD <albert.u.boot@aribaud.net>
Tue, 15 May 2012 06:31:38 +0000 (08:31 +0200)
Add support for setting up the memory controller parameters. Boards
can set up an appropriate table in the device tree.

Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Tom Warren <twarren@nvidia.com>
arch/arm/cpu/armv7/tegra2/Makefile
arch/arm/cpu/armv7/tegra2/emc.c [new file with mode: 0644]
arch/arm/include/asm/arch-tegra2/emc.h [new file with mode: 0644]
include/fdtdec.h
lib/fdtdec.c

index e9ac6c9..dcd6329 100644 (file)
@@ -34,6 +34,7 @@ LIB   =  $(obj)lib$(SOC).o
 
 SOBJS  := lowlevel_init.o
 COBJS-y        := ap20.o board.o clock.o funcmux.o pinmux.o sys_info.o timer.o
+COBJS-$(CONFIG_TEGRA_CLOCK_SCALING) += emc.o
 COBJS-$(CONFIG_USB_EHCI_TEGRA) += usb.o
 
 COBJS  := $(COBJS-y)
diff --git a/arch/arm/cpu/armv7/tegra2/emc.c b/arch/arm/cpu/armv7/tegra2/emc.c
new file mode 100644 (file)
index 0000000..c0e5c56
--- /dev/null
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2011 The Chromium OS Authors.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <common.h>
+#include <fdtdec.h>
+#include <asm/io.h>
+#include <asm/arch/ap20.h>
+#include <asm/arch/apb_misc.h>
+#include <asm/arch/clock.h>
+#include <asm/arch/emc.h>
+#include <asm/arch/tegra2.h>
+
+/*
+ * The EMC registers have shadow registers.  When the EMC clock is updated
+ * in the clock controller, the shadow registers are copied to the active
+ * registers, allowing glitchless memory bus frequency changes.
+ * This function updates the shadow registers for a new clock frequency,
+ * and relies on the clock lock on the emc clock to avoid races between
+ * multiple frequency changes
+ */
+
+/*
+ * This table defines the ordering of the registers provided to
+ * tegra_set_mmc()
+ * TODO: Convert to fdt version once available
+ */
+static const unsigned long emc_reg_addr[TEGRA_EMC_NUM_REGS] = {
+       0x2c,   /* RC */
+       0x30,   /* RFC */
+       0x34,   /* RAS */
+       0x38,   /* RP */
+       0x3c,   /* R2W */
+       0x40,   /* W2R */
+       0x44,   /* R2P */
+       0x48,   /* W2P */
+       0x4c,   /* RD_RCD */
+       0x50,   /* WR_RCD */
+       0x54,   /* RRD */
+       0x58,   /* REXT */
+       0x5c,   /* WDV */
+       0x60,   /* QUSE */
+       0x64,   /* QRST */
+       0x68,   /* QSAFE */
+       0x6c,   /* RDV */
+       0x70,   /* REFRESH */
+       0x74,   /* BURST_REFRESH_NUM */
+       0x78,   /* PDEX2WR */
+       0x7c,   /* PDEX2RD */
+       0x80,   /* PCHG2PDEN */
+       0x84,   /* ACT2PDEN */
+       0x88,   /* AR2PDEN */
+       0x8c,   /* RW2PDEN */
+       0x90,   /* TXSR */
+       0x94,   /* TCKE */
+       0x98,   /* TFAW */
+       0x9c,   /* TRPAB */
+       0xa0,   /* TCLKSTABLE */
+       0xa4,   /* TCLKSTOP */
+       0xa8,   /* TREFBW */
+       0xac,   /* QUSE_EXTRA */
+       0x114,  /* FBIO_CFG6 */
+       0xb0,   /* ODT_WRITE */
+       0xb4,   /* ODT_READ */
+       0x104,  /* FBIO_CFG5 */
+       0x2bc,  /* CFG_DIG_DLL */
+       0x2c0,  /* DLL_XFORM_DQS */
+       0x2c4,  /* DLL_XFORM_QUSE */
+       0x2e0,  /* ZCAL_REF_CNT */
+       0x2e4,  /* ZCAL_WAIT_CNT */
+       0x2a8,  /* AUTO_CAL_INTERVAL */
+       0x2d0,  /* CFG_CLKTRIM_0 */
+       0x2d4,  /* CFG_CLKTRIM_1 */
+       0x2d8,  /* CFG_CLKTRIM_2 */
+};
+
+struct emc_ctlr *emc_get_controller(const void *blob)
+{
+       fdt_addr_t addr;
+       int node;
+
+       node = fdtdec_next_compatible(blob, 0, COMPAT_NVIDIA_TEGRA20_EMC);
+       if (node > 0) {
+               addr = fdtdec_get_addr(blob, node, "reg");
+               if (addr != FDT_ADDR_T_NONE)
+                       return (struct emc_ctlr *)addr;
+       }
+       return NULL;
+}
+
+/* Error codes we use */
+enum {
+       ERR_NO_EMC_NODE = -10,
+       ERR_NO_EMC_REG,
+       ERR_NO_FREQ,
+       ERR_FREQ_NOT_FOUND,
+       ERR_BAD_REGS,
+       ERR_NO_RAM_CODE,
+       ERR_RAM_CODE_NOT_FOUND,
+};
+
+/**
+ * Find EMC tables for the given ram code.
+ *
+ * The tegra EMC binding has two options, one using the ram code and one not.
+ * We detect which is in use by looking for the nvidia,use-ram-code property.
+ * If this is not present, then the EMC tables are directly below 'node',
+ * otherwise we select the correct emc-tables subnode based on the 'ram_code'
+ * value.
+ *
+ * @param blob         Device tree blob
+ * @param node         EMC node (nvidia,tegra20-emc compatible string)
+ * @param ram_code     RAM code to select (0-3, or -1 if unknown)
+ * @return 0 if ok, otherwise a -ve ERR_ code (see enum above)
+ */
+static int find_emc_tables(const void *blob, int node, int ram_code)
+{
+       int need_ram_code;
+       int depth;
+       int offset;
+
+       /* If we are using RAM codes, scan through the tables for our code */
+       need_ram_code = fdtdec_get_bool(blob, node, "nvidia,use-ram-code");
+       if (!need_ram_code)
+               return node;
+       if (ram_code == -1) {
+               debug("%s: RAM code required but not supplied\n", __func__);
+               return ERR_NO_RAM_CODE;
+       }
+
+       offset = node;
+       depth = 0;
+       do {
+               /*
+                * Sadly there is no compatible string so we cannot use
+                * fdtdec_next_compatible_subnode().
+                */
+               offset = fdt_next_node(blob, offset, &depth);
+               if (depth <= 0)
+                       break;
+
+               /* Make sure this is a direct subnode */
+               if (depth != 1)
+                       continue;
+               if (strcmp("emc-tables", fdt_get_name(blob, offset, NULL)))
+                       continue;
+
+               if (fdtdec_get_int(blob, offset, "nvidia,ram-code", -1)
+                               == ram_code)
+                       return offset;
+       } while (1);
+
+       debug("%s: Could not find tables for RAM code %d\n", __func__,
+             ram_code);
+       return ERR_RAM_CODE_NOT_FOUND;
+}
+
+/**
+ * Decode the EMC node of the device tree, returning a pointer to the emc
+ * controller and the table to be used for the given rate.
+ *
+ * @param blob Device tree blob
+ * @param rate Clock speed of memory controller in Hz (=2x memory bus rate)
+ * @param emcp Returns address of EMC controller registers
+ * @param tablep Returns pointer to table to program into EMC. There are
+ *             TEGRA_EMC_NUM_REGS entries, destined for offsets as per the
+ *             emc_reg_addr array.
+ * @return 0 if ok, otherwise a -ve error code which will allow someone to
+ * figure out roughly what went wrong by looking at this code.
+ */
+static int decode_emc(const void *blob, unsigned rate, struct emc_ctlr **emcp,
+                     const u32 **tablep)
+{
+       struct apb_misc_pp_ctlr *pp =
+               (struct apb_misc_pp_ctlr *)NV_PA_APB_MISC_BASE;
+       int ram_code;
+       int depth;
+       int node;
+
+       ram_code = (readl(&pp->strapping_opt_a) & RAM_CODE_MASK)
+                       >> RAM_CODE_SHIFT;
+       /*
+        * The EMC clock rate is twice the bus rate, and the bus rate is
+        * measured in kHz
+        */
+       rate = rate / 2 / 1000;
+
+       node = fdtdec_next_compatible(blob, 0, COMPAT_NVIDIA_TEGRA20_EMC);
+       if (node < 0) {
+               debug("%s: No EMC node found in FDT\n", __func__);
+               return ERR_NO_EMC_NODE;
+       }
+       *emcp = (struct emc_ctlr *)fdtdec_get_addr(blob, node, "reg");
+       if (*emcp == (struct emc_ctlr *)FDT_ADDR_T_NONE) {
+               debug("%s: No EMC node reg property\n", __func__);
+               return ERR_NO_EMC_REG;
+       }
+
+       /* Work out the parent node which contains our EMC tables */
+       node = find_emc_tables(blob, node, ram_code & 3);
+       if (node < 0)
+               return node;
+
+       depth = 0;
+       for (;;) {
+               int node_rate;
+
+               node = fdtdec_next_compatible_subnode(blob, node,
+                               COMPAT_NVIDIA_TEGRA20_EMC_TABLE, &depth);
+               if (node < 0)
+                       break;
+               node_rate = fdtdec_get_int(blob, node, "clock-frequency", -1);
+               if (node_rate == -1) {
+                       debug("%s: Missing clock-frequency\n", __func__);
+                       return ERR_NO_FREQ; /* we expect this property */
+               }
+
+               if (node_rate == rate)
+                       break;
+       }
+       if (node < 0) {
+               debug("%s: No node found for clock frequency %d\n", __func__,
+                     rate);
+               return ERR_FREQ_NOT_FOUND;
+       }
+
+       *tablep = fdtdec_locate_array(blob, node, "nvidia,emc-registers",
+                                     TEGRA_EMC_NUM_REGS);
+       if (!*tablep) {
+               debug("%s: node '%s' array missing / wrong size\n", __func__,
+                     fdt_get_name(blob, node, NULL));
+               return ERR_BAD_REGS;
+       }
+
+       /* All seems well */
+       return 0;
+}
+
+int tegra_set_emc(const void *blob, unsigned rate)
+{
+       struct emc_ctlr *emc;
+       const u32 *table;
+       int err, i;
+
+       err = decode_emc(blob, rate, &emc, &table);
+       if (err) {
+               debug("Warning: no valid EMC (%d), memory timings unset\n",
+                      err);
+               return err;
+       }
+
+       debug("%s: Table found, setting EMC values as follows:\n", __func__);
+       for (i = 0; i < TEGRA_EMC_NUM_REGS; i++) {
+               u32 value = fdt32_to_cpu(table[i]);
+               u32 addr = (uintptr_t)emc + emc_reg_addr[i];
+
+               debug("   %#x: %#x\n", addr, value);
+               writel(value, addr);
+       }
+
+       /* trigger emc with new settings */
+       clock_adjust_periph_pll_div(PERIPH_ID_EMC, CLOCK_ID_MEMORY,
+                               clock_get_rate(CLOCK_ID_MEMORY), NULL);
+       debug("EMC clock set to %lu\n",
+             clock_get_periph_rate(PERIPH_ID_EMC, CLOCK_ID_MEMORY));
+
+       return 0;
+}
diff --git a/arch/arm/include/asm/arch-tegra2/emc.h b/arch/arm/include/asm/arch-tegra2/emc.h
new file mode 100644 (file)
index 0000000..deb3d36
--- /dev/null
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2011 The Chromium OS Authors.
+ * (C) Copyright 2010,2011 NVIDIA Corporation <www.nvidia.com>
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef _ARCH_EMC_H_
+#define _ARCH_EMC_H_
+
+#include <asm/types.h>
+
+#define TEGRA_EMC_NUM_REGS     46
+
+/* EMC Registers */
+struct emc_ctlr {
+       u32 cfg;                /* 0x00: EMC_CFG */
+       u32 reserved0[3];       /* 0x04 ~ 0x0C */
+       u32 adr_cfg;            /* 0x10: EMC_ADR_CFG */
+       u32 adr_cfg1;           /* 0x14: EMC_ADR_CFG_1 */
+       u32 reserved1[2];       /* 0x18 ~ 0x18 */
+       u32 refresh_ctrl;       /* 0x20: EMC_REFCTRL */
+       u32 pin;                /* 0x24: EMC_PIN */
+       u32 timing_ctrl;        /* 0x28: EMC_TIMING_CONTROL */
+       u32 rc;                 /* 0x2C: EMC_RC */
+       u32 rfc;                /* 0x30: EMC_RFC */
+       u32 ras;                /* 0x34: EMC_RAS */
+       u32 rp;                 /* 0x38: EMC_RP */
+       u32 r2w;                /* 0x3C: EMC_R2W */
+       u32 w2r;                /* 0x40: EMC_W2R */
+       u32 r2p;                /* 0x44: EMC_R2P */
+       u32 w2p;                /* 0x48: EMC_W2P */
+       u32 rd_rcd;             /* 0x4C: EMC_RD_RCD */
+       u32 wd_rcd;             /* 0x50: EMC_WD_RCD */
+       u32 rrd;                /* 0x54: EMC_RRD */
+       u32 rext;               /* 0x58: EMC_REXT */
+       u32 wdv;                /* 0x5C: EMC_WDV */
+       u32 quse;               /* 0x60: EMC_QUSE */
+       u32 qrst;               /* 0x64: EMC_QRST */
+       u32 qsafe;              /* 0x68: EMC_QSAFE */
+       u32 rdv;                /* 0x6C: EMC_RDV */
+       u32 refresh;            /* 0x70: EMC_REFRESH */
+       u32 burst_refresh_num;  /* 0x74: EMC_BURST_REFRESH_NUM */
+       u32 pdex2wr;            /* 0x78: EMC_PDEX2WR */
+       u32 pdex2rd;            /* 0x7c: EMC_PDEX2RD */
+       u32 pchg2pden;          /* 0x80: EMC_PCHG2PDEN */
+       u32 act2pden;           /* 0x84: EMC_ACT2PDEN */
+       u32 ar2pden;            /* 0x88: EMC_AR2PDEN */
+       u32 rw2pden;            /* 0x8C: EMC_RW2PDEN */
+       u32 txsr;               /* 0x90: EMC_TXSR */
+       u32 tcke;               /* 0x94: EMC_TCKE */
+       u32 tfaw;               /* 0x98: EMC_TFAW */
+       u32 trpab;              /* 0x9C: EMC_TRPAB */
+       u32 tclkstable;         /* 0xA0: EMC_TCLKSTABLE */
+       u32 tclkstop;           /* 0xA4: EMC_TCLKSTOP */
+       u32 trefbw;             /* 0xA8: EMC_TREFBW */
+       u32 quse_extra;         /* 0xAC: EMC_QUSE_EXTRA */
+       u32 odt_write;          /* 0xB0: EMC_ODT_WRITE */
+       u32 odt_read;           /* 0xB4: EMC_ODT_READ */
+       u32 reserved2[5];       /* 0xB8 ~ 0xC8 */
+       u32 mrs;                /* 0xCC: EMC_MRS */
+       u32 emrs;               /* 0xD0: EMC_EMRS */
+       u32 ref;                /* 0xD4: EMC_REF */
+       u32 pre;                /* 0xD8: EMC_PRE */
+       u32 nop;                /* 0xDC: EMC_NOP */
+       u32 self_ref;           /* 0xE0: EMC_SELF_REF */
+       u32 dpd;                /* 0xE4: EMC_DPD */
+       u32 mrw;                /* 0xE8: EMC_MRW */
+       u32 mrr;                /* 0xEC: EMC_MRR */
+       u32 reserved3;          /* 0xF0: */
+       u32 fbio_cfg1;          /* 0xF4: EMC_FBIO_CFG1 */
+       u32 fbio_dqsib_dly;     /* 0xF8: EMC_FBIO_DQSIB_DLY */
+       u32 fbio_dqsib_dly_msb; /* 0xFC: EMC_FBIO_DQSIB_DLY_MSG */
+       u32 fbio_spare;         /* 0x100: SBIO_SPARE */
+                               /* There are more registers ... */
+};
+
+/**
+ * Set up the EMC for the given rate. The timing parameters are retrieved
+ * from the device tree "nvidia,tegra20-emc" node and its
+ * "nvidia,tegra20-emc-table" sub-nodes.
+ *
+ * @param blob Device tree blob
+ * @param rate Clock speed of memory controller in Hz (=2x memory bus rate)
+ * @return 0 if ok, else -ve error code (look in emc.c to decode it)
+ */
+int tegra_set_emc(const void *blob, unsigned rate);
+
+/**
+ * Get a pointer to the EMC controller from the device tree.
+ *
+ * @param blob Device tree blob
+ * @return pointer to EMC controller
+ */
+struct emc_ctlr *emc_get_controller(const void *blob);
+
+#endif
index 0351a25..49251d5 100644 (file)
@@ -60,6 +60,8 @@ enum fdt_compat_id {
        COMPAT_NVIDIA_TEGRA20_USB,      /* Tegra2 USB port */
        COMPAT_NVIDIA_TEGRA20_I2C,      /* Tegra2 i2c */
        COMPAT_NVIDIA_TEGRA20_DVC,      /* Tegra2 dvc (really just i2c) */
+       COMPAT_NVIDIA_TEGRA20_EMC,      /* Tegra2 memory controller */
+       COMPAT_NVIDIA_TEGRA20_EMC_TABLE, /* Tegra2 memory timing table */
 
        COMPAT_COUNT,
 };
index 76d3808..42c3e89 100644 (file)
@@ -40,6 +40,8 @@ static const char * const compat_names[COMPAT_COUNT] = {
        COMPAT(NVIDIA_TEGRA20_USB, "nvidia,tegra20-ehci"),
        COMPAT(NVIDIA_TEGRA20_I2C, "nvidia,tegra20-i2c"),
        COMPAT(NVIDIA_TEGRA20_DVC, "nvidia,tegra20-i2c-dvc"),
+       COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"),
+       COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"),
 };
 
 const char *fdtdec_get_compatible(enum fdt_compat_id id)