target/linux/brcm63xx/files/arch/mips/bcm63xx/clk.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/mutex.h>
  11 #include <linux/err.h>
  12 #include <linux/clk.h>
  13 #include <bcm63xx_cpu.h>
  14 #include <bcm63xx_io.h>
  15 #include <bcm63xx_regs.h>
  16 #include <bcm63xx_clk.h>
  17
  18 DEFINE_MUTEX(clocks_mutex);
  19
  20
  21 static void clk_enable_unlocked(struct clk *clk)
  22 {
  23         if (clk->set && (clk->usage++) == 0)
  24                 clk->set(clk, 1);
  25 }
  26
  27 static void clk_disable_unlocked(struct clk *clk)
  28 {
  29         if (clk->set && (--clk->usage) == 0)
  30                 clk->set(clk, 0);
  31 }
  32
  33 static void bcm_hwclock_set(u32 mask, int enable)
  34 {
  35         u32 reg;
  36
  37         reg = bcm_perf_readl(PERF_CKCTL_REG);
  38         if (enable)
  39                 reg |= mask;
  40         else
  41                 reg &= ~mask;
  42         bcm_perf_writel(reg, PERF_CKCTL_REG);
  43 }
  44
  45 /*
  46  * Ethernet MAC "misc" clock: dma clocks and main clock on 6348
  47  */
  48 static void enet_misc_set(struct clk *clk, int enable)
  49 {
  50         u32 mask;
  51
  52         if (BCMCPU_IS_6348())
  53                 mask = CKCTL_6348_ENET_EN;
  54         else
  55                 /* BCMCPU_IS_6358 */
  56                 mask = CKCTL_6358_EMUSB_EN;
  57         bcm_hwclock_set(mask, enable);
  58 }
  59
  60 static struct clk clk_enet_misc = {
  61         .set    = enet_misc_set,
  62 };
  63
  64 /*
  65  * Ethernet MAC clocks: only revelant on 6358, silently enable misc
  66  * clocks
  67  */
  68 static void enetx_set(struct clk *clk, int enable)
  69 {
  70         if (enable)
  71                 clk_enable_unlocked(&clk_enet_misc);
  72         else
  73                 clk_disable_unlocked(&clk_enet_misc);
  74
  75         if (BCMCPU_IS_6358()) {
  76                 u32 mask;
  77
  78                 if (clk->id == 0)
  79                         mask = CKCTL_6358_ENET0_EN;
  80                 else
  81                         mask = CKCTL_6358_ENET1_EN;
  82                 bcm_hwclock_set(mask, enable);
  83         }
  84 }
  85
  86 static struct clk clk_enet0 = {
  87         .id     = 0,
  88         .set    = enetx_set,
  89 };
  90
  91 static struct clk clk_enet1 = {
  92         .id     = 1,
  93         .set    = enetx_set,
  94 };
  95
  96 /*
  97  * Ethernet PHY clock
  98  */
  99 static void ephy_set(struct clk *clk, int enable)
 100 {
 101         if (!BCMCPU_IS_6358())
 102                 return;
 103         bcm_hwclock_set(CKCTL_6358_EPHY_EN, enable);
 104 }
 105
 106
 107 static struct clk clk_ephy = {
 108         .set    = ephy_set,
 109 };
 110
 111 /*
 112  * PCM clock
 113  */
 114 static void pcm_set(struct clk *clk, int enable)
 115 {
 116         if (!BCMCPU_IS_6358())
 117                 return;
 118         bcm_hwclock_set(CKCTL_6358_PCM_EN, enable);
 119 }
 120
 121 static struct clk clk_pcm = {
 122         .set    = pcm_set,
 123 };
 124
 125 /*
 126  * USB host clock
 127  */
 128 static void usbh_set(struct clk *clk, int enable)
 129 {
 130         if (!BCMCPU_IS_6348())
 131                 return;
 132         bcm_hwclock_set(CKCTL_6348_USBH_EN, enable);
 133 }
 134
 135 static struct clk clk_usbh = {
 136         .set    = usbh_set,
 137 };
 138
 139 /*
 140  * USB slave clock
 141  */
 142 static void usbs_set(struct clk *clk, int enable)
 143 {
 144         u32 mask;
 145
 146         switch(bcm63xx_get_cpu_id()) {
 147         case BCM6338_CPU_ID: mask = CKCTL_6338_USBS_EN; break;
 148         case BCM6348_CPU_ID: mask = CKCTL_6348_USBS_EN; break;
 149         default:
 150                 return;
 151         }
 152         bcm_hwclock_set(mask, enable);
 153 }
 154
 155 static struct clk clk_usbs = {
 156         .set    = usbs_set,
 157 };
 158
 159 /*
 160  * SPI clock
 161  */
 162 static void spi_set(struct clk *clk, int enable)
 163 {
 164         u32 mask;
 165
 166         if (BCMCPU_IS_6348())
 167                 mask = CKCTL_6348_SPI_EN;
 168         else
 169                 /* BCMCPU_IS_6358 */
 170                 mask = CKCTL_6358_SPI_EN;
 171         bcm_hwclock_set(mask, enable);
 172 }
 173
 174 static struct clk clk_spi = {
 175         .set    = spi_set,
 176 };
 177
 178 /*
 179  * Internal peripheral clock
 180  */
 181 static struct clk clk_periph = {
 182         .rate   = (50 * 1000 * 1000),
 183 };
 184
 185
 186 /*
 187  * Linux clock API implementation
 188  */
 189 int clk_enable(struct clk *clk)
 190 {
 191         mutex_lock(&clocks_mutex);
 192         clk_enable_unlocked(clk);
 193         mutex_unlock(&clocks_mutex);
 194         return 0;
 195 }
 196
 197 EXPORT_SYMBOL(clk_enable);
 198
 199 void clk_disable(struct clk *clk)
 200 {
 201         mutex_lock(&clocks_mutex);
 202         clk_disable_unlocked(clk);
 203         mutex_unlock(&clocks_mutex);
 204 }
 205
 206 EXPORT_SYMBOL(clk_disable);
 207
 208 unsigned long clk_get_rate(struct clk *clk)
 209 {
 210         return clk->rate;
 211 }
 212
 213 EXPORT_SYMBOL(clk_get_rate);
 214
 215 struct clk *clk_get(struct device *dev, const char *id)
 216 {
 217         if (!strcmp(id, "enet0"))
 218                 return &clk_enet0;
 219         if (!strcmp(id, "enet1"))
 220                 return &clk_enet1;
 221         if (!strcmp(id, "ephy"))
 222                 return &clk_ephy;
 223         if (!strcmp(id, "usbh"))
 224                 return &clk_usbh;
 225         if (!strcmp(id, "usbs"))
 226                 return &clk_usbs;
 227         if (!strcmp(id, "spi"))
 228                 return &clk_spi;
 229         if (!strcmp(id, "periph"))
 230                 return &clk_periph;
 231         if (BCMCPU_IS_6358() && !strcmp(id, "pcm"))
 232                 return &clk_pcm;
 233         return ERR_PTR(-ENOENT);
 234 }
 235
 236 EXPORT_SYMBOL(clk_get);
 237
 238 void clk_put(struct clk *clk)
 239 {
 240 }
 241
 242 EXPORT_SYMBOL(clk_put);