arch/arm/mach-tegra/tegra2_emc.c

   1 /*
   2  * Copyright (C) 2011 Google, Inc.
   3  *
   4  * Author:
   5  *      Colin Cross <ccross@android.com>
   6  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/device.h>
  20 #include <linux/clk.h>
  21 #include <linux/err.h>
  22 #include <linux/io.h>
  23 #include <linux/module.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/platform_data/tegra_emc.h>
  26
  27 #include <mach/iomap.h>
  28
  29 #include "tegra2_emc.h"
  30
  31 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
  32 static bool emc_enable = true;
  33 #else
  34 static bool emc_enable;
  35 #endif
  36 module_param(emc_enable, bool, 0644);
  37
  38 static struct platform_device *emc_pdev;
  39 static void __iomem *emc_regbase;
  40
  41 static inline void emc_writel(u32 val, unsigned long addr)
  42 {
  43         writel(val, emc_regbase + addr);
  44 }
  45
  46 static inline u32 emc_readl(unsigned long addr)
  47 {
  48         return readl(emc_regbase + addr);
  49 }
  50
  51 static const unsigned long emc_reg_addr[TEGRA_EMC_NUM_REGS] = {
  52         0x2c,   /* RC */
  53         0x30,   /* RFC */
  54         0x34,   /* RAS */
  55         0x38,   /* RP */
  56         0x3c,   /* R2W */
  57         0x40,   /* W2R */
  58         0x44,   /* R2P */
  59         0x48,   /* W2P */
  60         0x4c,   /* RD_RCD */
  61         0x50,   /* WR_RCD */
  62         0x54,   /* RRD */
  63         0x58,   /* REXT */
  64         0x5c,   /* WDV */
  65         0x60,   /* QUSE */
  66         0x64,   /* QRST */
  67         0x68,   /* QSAFE */
  68         0x6c,   /* RDV */
  69         0x70,   /* REFRESH */
  70         0x74,   /* BURST_REFRESH_NUM */
  71         0x78,   /* PDEX2WR */
  72         0x7c,   /* PDEX2RD */
  73         0x80,   /* PCHG2PDEN */
  74         0x84,   /* ACT2PDEN */
  75         0x88,   /* AR2PDEN */
  76         0x8c,   /* RW2PDEN */
  77         0x90,   /* TXSR */
  78         0x94,   /* TCKE */
  79         0x98,   /* TFAW */
  80         0x9c,   /* TRPAB */
  81         0xa0,   /* TCLKSTABLE */
  82         0xa4,   /* TCLKSTOP */
  83         0xa8,   /* TREFBW */
  84         0xac,   /* QUSE_EXTRA */
  85         0x114,  /* FBIO_CFG6 */
  86         0xb0,   /* ODT_WRITE */
  87         0xb4,   /* ODT_READ */
  88         0x104,  /* FBIO_CFG5 */
  89         0x2bc,  /* CFG_DIG_DLL */
  90         0x2c0,  /* DLL_XFORM_DQS */
  91         0x2c4,  /* DLL_XFORM_QUSE */
  92         0x2e0,  /* ZCAL_REF_CNT */
  93         0x2e4,  /* ZCAL_WAIT_CNT */
  94         0x2a8,  /* AUTO_CAL_INTERVAL */
  95         0x2d0,  /* CFG_CLKTRIM_0 */
  96         0x2d4,  /* CFG_CLKTRIM_1 */
  97         0x2d8,  /* CFG_CLKTRIM_2 */
  98 };
  99
 100 /* Select the closest EMC rate that is higher than the requested rate */
 101 long tegra_emc_round_rate(unsigned long rate)
 102 {
 103         struct tegra_emc_pdata *pdata;
 104         int i;
 105         int best = -1;
 106         unsigned long distance = ULONG_MAX;
 107
 108         if (!emc_pdev)
 109                 return -EINVAL;
 110
 111         pdata = emc_pdev->dev.platform_data;
 112
 113         pr_debug("%s: %lu\n", __func__, rate);
 114
 115         /*
 116          * The EMC clock rate is twice the bus rate, and the bus rate is
 117          * measured in kHz
 118          */
 119         rate = rate / 2 / 1000;
 120
 121         for (i = 0; i < pdata->num_tables; i++) {
 122                 if (pdata->tables[i].rate >= rate &&
 123                     (pdata->tables[i].rate - rate) < distance) {
 124                         distance = pdata->tables[i].rate - rate;
 125                         best = i;
 126                 }
 127         }
 128
 129         if (best < 0)
 130                 return -EINVAL;
 131
 132         pr_debug("%s: using %lu\n", __func__, pdata->tables[best].rate);
 133
 134         return pdata->tables[best].rate * 2 * 1000;
 135 }
 136
 137 /*
 138  * The EMC registers have shadow registers.  When the EMC clock is updated
 139  * in the clock controller, the shadow registers are copied to the active
 140  * registers, allowing glitchless memory bus frequency changes.
 141  * This function updates the shadow registers for a new clock frequency,
 142  * and relies on the clock lock on the emc clock to avoid races between
 143  * multiple frequency changes
 144  */
 145 int tegra_emc_set_rate(unsigned long rate)
 146 {
 147         struct tegra_emc_pdata *pdata;
 148         int i;
 149         int j;
 150
 151         if (!emc_pdev)
 152                 return -EINVAL;
 153
 154         pdata = emc_pdev->dev.platform_data;
 155
 156         /*
 157          * The EMC clock rate is twice the bus rate, and the bus rate is
 158          * measured in kHz
 159          */
 160         rate = rate / 2 / 1000;
 161
 162         for (i = 0; i < pdata->num_tables; i++)
 163                 if (pdata->tables[i].rate == rate)
 164                         break;
 165
 166         if (i >= pdata->num_tables)
 167                 return -EINVAL;
 168
 169         pr_debug("%s: setting to %lu\n", __func__, rate);
 170
 171         for (j = 0; j < TEGRA_EMC_NUM_REGS; j++)
 172                 emc_writel(pdata->tables[i].regs[j], emc_reg_addr[j]);
 173
 174         emc_readl(pdata->tables[i].regs[TEGRA_EMC_NUM_REGS - 1]);
 175
 176         return 0;
 177 }
 178
 179 static int __devinit tegra_emc_probe(struct platform_device *pdev)
 180 {
 181         struct tegra_emc_pdata *pdata;
 182         struct resource *res;
 183
 184         if (!emc_enable) {
 185                 dev_err(&pdev->dev, "disabled per module parameter\n");
 186                 return -ENODEV;
 187         }
 188
 189         pdata = pdev->dev.platform_data;
 190
 191         if (!pdata) {
 192                 dev_err(&pdev->dev, "missing platform data\n");
 193                 return -ENXIO;
 194         }
 195
 196         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 197         if (!res) {
 198                 dev_err(&pdev->dev, "missing register base\n");
 199                 return -ENOMEM;
 200         }
 201
 202         emc_regbase = devm_request_and_ioremap(&pdev->dev, res);
 203         if (!emc_regbase) {
 204                 dev_err(&pdev->dev, "failed to remap registers\n");
 205                 return -ENOMEM;
 206         }
 207         emc_pdev = pdev;
 208
 209         return 0;
 210 }
 211
 212 static struct platform_driver tegra_emc_driver = {
 213         .driver         = {
 214                 .name   = "tegra-emc",
 215                 .owner  = THIS_MODULE,
 216         },
 217         .probe          = tegra_emc_probe,
 218 };
 219
 220 static int __init tegra_emc_init(void)
 221 {
 222         return platform_driver_register(&tegra_emc_driver);
 223 }
 224 device_initcall(tegra_emc_init);