arch/mips/ar7/clock.c

   1 /*
   2  * Copyright (C) 2007 Felix Fietkau <nbd@openwrt.org>
   3  * Copyright (C) 2007 Eugene Konev <ejka@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/init.h>
  22 #include <linux/types.h>
  23 #include <linux/module.h>
  24 #include <linux/delay.h>
  25 #include <linux/gcd.h>
  26 #include <linux/io.h>
  27
  28 #include <asm/addrspace.h>
  29 #include <asm/mach-ar7/ar7.h>
  30
  31 #define BOOT_PLL_SOURCE_MASK    0x3
  32 #define CPU_PLL_SOURCE_SHIFT    16
  33 #define BUS_PLL_SOURCE_SHIFT    14
  34 #define USB_PLL_SOURCE_SHIFT    18
  35 #define DSP_PLL_SOURCE_SHIFT    22
  36 #define BOOT_PLL_SOURCE_AFE     0
  37 #define BOOT_PLL_SOURCE_BUS     0
  38 #define BOOT_PLL_SOURCE_REF     1
  39 #define BOOT_PLL_SOURCE_XTAL    2
  40 #define BOOT_PLL_SOURCE_CPU     3
  41 #define BOOT_PLL_BYPASS         0x00000020
  42 #define BOOT_PLL_ASYNC_MODE     0x02000000
  43 #define BOOT_PLL_2TO1_MODE      0x00008000
  44
  45 #define TNETD7200_CLOCK_ID_CPU  0
  46 #define TNETD7200_CLOCK_ID_DSP  1
  47 #define TNETD7200_CLOCK_ID_USB  2
  48
  49 #define TNETD7200_DEF_CPU_CLK   211000000
  50 #define TNETD7200_DEF_DSP_CLK   125000000
  51 #define TNETD7200_DEF_USB_CLK   48000000
  52
  53 struct tnetd7300_clock {
  54         u32 ctrl;
  55 #define PREDIV_MASK     0x001f0000
  56 #define PREDIV_SHIFT    16
  57 #define POSTDIV_MASK    0x0000001f
  58         u32 unused1[3];
  59         u32 pll;
  60 #define MUL_MASK        0x0000f000
  61 #define MUL_SHIFT       12
  62 #define PLL_MODE_MASK   0x00000001
  63 #define PLL_NDIV        0x00000800
  64 #define PLL_DIV         0x00000002
  65 #define PLL_STATUS      0x00000001
  66         u32 unused2[3];
  67 };
  68
  69 struct tnetd7300_clocks {
  70         struct tnetd7300_clock bus;
  71         struct tnetd7300_clock cpu;
  72         struct tnetd7300_clock usb;
  73         struct tnetd7300_clock dsp;
  74 };
  75
  76 struct tnetd7200_clock {
  77         u32 ctrl;
  78         u32 unused1[3];
  79 #define DIVISOR_ENABLE_MASK 0x00008000
  80         u32 mul;
  81         u32 prediv;
  82         u32 postdiv;
  83         u32 postdiv2;
  84         u32 unused2[6];
  85         u32 cmd;
  86         u32 status;
  87         u32 cmden;
  88         u32 padding[15];
  89 };
  90
  91 struct tnetd7200_clocks {
  92         struct tnetd7200_clock cpu;
  93         struct tnetd7200_clock dsp;
  94         struct tnetd7200_clock usb;
  95 };
  96
  97 int ar7_cpu_clock = 150000000;
  98 EXPORT_SYMBOL(ar7_cpu_clock);
  99 int ar7_bus_clock = 125000000;
 100 EXPORT_SYMBOL(ar7_bus_clock);
 101 int ar7_dsp_clock;
 102 EXPORT_SYMBOL(ar7_dsp_clock);
 103
 104 static void approximate(int base, int target, int *prediv,
 105                         int *postdiv, int *mul)
 106 {
 107         int i, j, k, freq, res = target;
 108         for (i = 1; i <= 16; i++)
 109                 for (j = 1; j <= 32; j++)
 110                         for (k = 1; k <= 32; k++) {
 111                                 freq = abs(base / j * i / k - target);
 112                                 if (freq < res) {
 113                                         res = freq;
 114                                         *mul = i;
 115                                         *prediv = j;
 116                                         *postdiv = k;
 117                                 }
 118                         }
 119 }
 120
 121 static void calculate(int base, int target, int *prediv, int *postdiv,
 122         int *mul)
 123 {
 124         int tmp_gcd, tmp_base, tmp_freq;
 125
 126         for (*prediv = 1; *prediv <= 32; (*prediv)++) {
 127                 tmp_base = base / *prediv;
 128                 tmp_gcd = gcd(target, tmp_base);
 129                 *mul = target / tmp_gcd;
 130                 *postdiv = tmp_base / tmp_gcd;
 131                 if ((*mul < 1) || (*mul >= 16))
 132                         continue;
 133                 if ((*postdiv > 0) & (*postdiv <= 32))
 134                         break;
 135         }
 136
 137         if (base / *prediv * *mul / *postdiv != target) {
 138                 approximate(base, target, prediv, postdiv, mul);
 139                 tmp_freq = base / *prediv * *mul / *postdiv;
 140                 printk(KERN_WARNING
 141                        "Adjusted requested frequency %d to %d\n",
 142                        target, tmp_freq);
 143         }
 144
 145         printk(KERN_DEBUG "Clocks: prediv: %d, postdiv: %d, mul: %d\n",
 146                *prediv, *postdiv, *mul);
 147 }
 148
 149 static int tnetd7300_dsp_clock(void)
 150 {
 151         u32 didr1, didr2;
 152         u8 rev = ar7_chip_rev();
 153         didr1 = readl((void *)KSEG1ADDR(AR7_REGS_GPIO + 0x18));
 154         didr2 = readl((void *)KSEG1ADDR(AR7_REGS_GPIO + 0x1c));
 155         if (didr2 & (1 << 23))
 156                 return 0;
 157         if ((rev >= 0x23) && (rev != 0x57))
 158                 return 250000000;
 159         if ((((didr2 & 0x1fff) << 10) | ((didr1 & 0xffc00000) >> 22))
 160             > 4208000)
 161                 return 250000000;
 162         return 0;
 163 }
 164
 165 static int tnetd7300_get_clock(u32 shift, struct tnetd7300_clock *clock,
 166         u32 *bootcr, u32 bus_clock)
 167 {
 168         int product;
 169         int base_clock = AR7_REF_CLOCK;
 170         u32 ctrl = readl(&clock->ctrl);
 171         u32 pll = readl(&clock->pll);
 172         int prediv = ((ctrl & PREDIV_MASK) >> PREDIV_SHIFT) + 1;
 173         int postdiv = (ctrl & POSTDIV_MASK) + 1;
 174         int divisor = prediv * postdiv;
 175         int mul = ((pll & MUL_MASK) >> MUL_SHIFT) + 1;
 176
 177         switch ((*bootcr & (BOOT_PLL_SOURCE_MASK << shift)) >> shift) {
 178         case BOOT_PLL_SOURCE_BUS:
 179                 base_clock = bus_clock;
 180                 break;
 181         case BOOT_PLL_SOURCE_REF:
 182                 base_clock = AR7_REF_CLOCK;
 183                 break;
 184         case BOOT_PLL_SOURCE_XTAL:
 185                 base_clock = AR7_XTAL_CLOCK;
 186                 break;
 187         case BOOT_PLL_SOURCE_CPU:
 188                 base_clock = ar7_cpu_clock;
 189                 break;
 190         }
 191
 192         if (*bootcr & BOOT_PLL_BYPASS)
 193                 return base_clock / divisor;
 194
 195         if ((pll & PLL_MODE_MASK) == 0)
 196                 return (base_clock >> (mul / 16 + 1)) / divisor;
 197
 198         if ((pll & (PLL_NDIV | PLL_DIV)) == (PLL_NDIV | PLL_DIV)) {
 199                 product = (mul & 1) ?
 200                         (base_clock * mul) >> 1 :
 201                         (base_clock * (mul - 1)) >> 2;
 202                 return product / divisor;
 203         }
 204
 205         if (mul == 16)
 206                 return base_clock / divisor;
 207
 208         return base_clock * mul / divisor;
 209 }
 210
 211 static void tnetd7300_set_clock(u32 shift, struct tnetd7300_clock *clock,
 212         u32 *bootcr, u32 frequency)
 213 {
 214         int prediv, postdiv, mul;
 215         int base_clock = ar7_bus_clock;
 216
 217         switch ((*bootcr & (BOOT_PLL_SOURCE_MASK << shift)) >> shift) {
 218         case BOOT_PLL_SOURCE_BUS:
 219                 base_clock = ar7_bus_clock;
 220                 break;
 221         case BOOT_PLL_SOURCE_REF:
 222                 base_clock = AR7_REF_CLOCK;
 223                 break;
 224         case BOOT_PLL_SOURCE_XTAL:
 225                 base_clock = AR7_XTAL_CLOCK;
 226                 break;
 227         case BOOT_PLL_SOURCE_CPU:
 228                 base_clock = ar7_cpu_clock;
 229                 break;
 230         }
 231
 232         calculate(base_clock, frequency, &prediv, &postdiv, &mul);
 233
 234         writel(((prediv - 1) << PREDIV_SHIFT) | (postdiv - 1), &clock->ctrl);
 235         msleep(1);
 236         writel(4, &clock->pll);
 237         while (readl(&clock->pll) & PLL_STATUS)
 238                 ;
 239         writel(((mul - 1) << MUL_SHIFT) | (0xff << 3) | 0x0e, &clock->pll);
 240         msleep(75);
 241 }
 242
 243 static void __init tnetd7300_init_clocks(void)
 244 {
 245         u32 *bootcr = (u32 *)ioremap_nocache(AR7_REGS_DCL, 4);
 246         struct tnetd7300_clocks *clocks =
 247                                         ioremap_nocache(UR8_REGS_CLOCKS,
 248                                         sizeof(struct tnetd7300_clocks));
 249
 250         ar7_bus_clock = tnetd7300_get_clock(BUS_PLL_SOURCE_SHIFT,
 251                 &clocks->bus, bootcr, AR7_AFE_CLOCK);
 252
 253         if (*bootcr & BOOT_PLL_ASYNC_MODE)
 254                 ar7_cpu_clock = tnetd7300_get_clock(CPU_PLL_SOURCE_SHIFT,
 255                         &clocks->cpu, bootcr, AR7_AFE_CLOCK);
 256         else
 257                 ar7_cpu_clock = ar7_bus_clock;
 258
 259         if (ar7_dsp_clock == 250000000)
 260                 tnetd7300_set_clock(DSP_PLL_SOURCE_SHIFT, &clocks->dsp,
 261                         bootcr, ar7_dsp_clock);
 262
 263         iounmap(clocks);
 264         iounmap(bootcr);
 265 }
 266
 267 static int tnetd7200_get_clock(int base, struct tnetd7200_clock *clock,
 268         u32 *bootcr, u32 bus_clock)
 269 {
 270         int divisor = ((readl(&clock->prediv) & 0x1f) + 1) *
 271                 ((readl(&clock->postdiv) & 0x1f) + 1);
 272
 273         if (*bootcr & BOOT_PLL_BYPASS)
 274                 return base / divisor;
 275
 276         return base * ((readl(&clock->mul) & 0xf) + 1) / divisor;
 277 }
 278
 279
 280 static void tnetd7200_set_clock(int base, struct tnetd7200_clock *clock,
 281         int prediv, int postdiv, int postdiv2, int mul, u32 frequency)
 282 {
 283         printk(KERN_INFO
 284                 "Clocks: base = %d, frequency = %u, prediv = %d, "
 285                 "postdiv = %d, postdiv2 = %d, mul = %d\n",
 286                 base, frequency, prediv, postdiv, postdiv2, mul);
 287
 288         writel(0, &clock->ctrl);
 289         writel(DIVISOR_ENABLE_MASK | ((prediv - 1) & 0x1F), &clock->prediv);
 290         writel((mul - 1) & 0xF, &clock->mul);
 291
 292         while (readl(&clock->status) & 0x1)
 293                 ; /* nop */
 294
 295         writel(DIVISOR_ENABLE_MASK | ((postdiv - 1) & 0x1F), &clock->postdiv);
 296
 297         writel(readl(&clock->cmden) | 1, &clock->cmden);
 298         writel(readl(&clock->cmd) | 1, &clock->cmd);
 299
 300         while (readl(&clock->status) & 0x1)
 301                 ; /* nop */
 302
 303         writel(DIVISOR_ENABLE_MASK | ((postdiv2 - 1) & 0x1F), &clock->postdiv2);
 304
 305         writel(readl(&clock->cmden) | 1, &clock->cmden);
 306         writel(readl(&clock->cmd) | 1, &clock->cmd);
 307
 308         while (readl(&clock->status) & 0x1)
 309                 ; /* nop */
 310
 311         writel(readl(&clock->ctrl) | 1, &clock->ctrl);
 312 }
 313
 314 static int tnetd7200_get_clock_base(int clock_id, u32 *bootcr)
 315 {
 316         if (*bootcr & BOOT_PLL_ASYNC_MODE)
 317                 /* Async */
 318                 switch (clock_id) {
 319                 case TNETD7200_CLOCK_ID_DSP:
 320                         return AR7_REF_CLOCK;
 321                 default:
 322                         return AR7_AFE_CLOCK;
 323                 }
 324         else
 325                 /* Sync */
 326                 if (*bootcr & BOOT_PLL_2TO1_MODE)
 327                         /* 2:1 */
 328                         switch (clock_id) {
 329                         case TNETD7200_CLOCK_ID_DSP:
 330                                 return AR7_REF_CLOCK;
 331                         default:
 332                                 return AR7_AFE_CLOCK;
 333                         }
 334                 else
 335                         /* 1:1 */
 336                         return AR7_REF_CLOCK;
 337 }
 338
 339
 340 static void __init tnetd7200_init_clocks(void)
 341 {
 342         u32 *bootcr = (u32 *)ioremap_nocache(AR7_REGS_DCL, 4);
 343         struct tnetd7200_clocks *clocks =
 344                                         ioremap_nocache(AR7_REGS_CLOCKS,
 345                                         sizeof(struct tnetd7200_clocks));
 346         int cpu_base, cpu_mul, cpu_prediv, cpu_postdiv;
 347         int dsp_base, dsp_mul, dsp_prediv, dsp_postdiv;
 348         int usb_base, usb_mul, usb_prediv, usb_postdiv;
 349
 350         cpu_base = tnetd7200_get_clock_base(TNETD7200_CLOCK_ID_CPU, bootcr);
 351         dsp_base = tnetd7200_get_clock_base(TNETD7200_CLOCK_ID_DSP, bootcr);
 352
 353         if (*bootcr & BOOT_PLL_ASYNC_MODE) {
 354                 printk(KERN_INFO "Clocks: Async mode\n");
 355
 356                 printk(KERN_INFO "Clocks: Setting DSP clock\n");
 357                 calculate(dsp_base, TNETD7200_DEF_DSP_CLK,
 358                         &dsp_prediv, &dsp_postdiv, &dsp_mul);
 359                 ar7_bus_clock =
 360                         ((dsp_base / dsp_prediv) * dsp_mul) / dsp_postdiv;
 361                 tnetd7200_set_clock(dsp_base, &clocks->dsp,
 362                         dsp_prediv, dsp_postdiv * 2, dsp_postdiv, dsp_mul * 2,
 363                         ar7_bus_clock);
 364
 365                 printk(KERN_INFO "Clocks: Setting CPU clock\n");
 366                 calculate(cpu_base, TNETD7200_DEF_CPU_CLK, &cpu_prediv,
 367                         &cpu_postdiv, &cpu_mul);
 368                 ar7_cpu_clock =
 369                         ((cpu_base / cpu_prediv) * cpu_mul) / cpu_postdiv;
 370                 tnetd7200_set_clock(cpu_base, &clocks->cpu,
 371                         cpu_prediv, cpu_postdiv, -1, cpu_mul,
 372                         ar7_cpu_clock);
 373
 374         } else
 375                 if (*bootcr & BOOT_PLL_2TO1_MODE) {
 376                         printk(KERN_INFO "Clocks: Sync 2:1 mode\n");
 377
 378                         printk(KERN_INFO "Clocks: Setting CPU clock\n");
 379                         calculate(cpu_base, TNETD7200_DEF_CPU_CLK, &cpu_prediv,
 380                                 &cpu_postdiv, &cpu_mul);
 381                         ar7_cpu_clock = ((cpu_base / cpu_prediv) * cpu_mul)
 382                                                                 / cpu_postdiv;
 383                         tnetd7200_set_clock(cpu_base, &clocks->cpu,
 384                                 cpu_prediv, cpu_postdiv, -1, cpu_mul,
 385                                 ar7_cpu_clock);
 386
 387                         printk(KERN_INFO "Clocks: Setting DSP clock\n");
 388                         calculate(dsp_base, TNETD7200_DEF_DSP_CLK, &dsp_prediv,
 389                                 &dsp_postdiv, &dsp_mul);
 390                         ar7_bus_clock = ar7_cpu_clock / 2;
 391                         tnetd7200_set_clock(dsp_base, &clocks->dsp,
 392                                 dsp_prediv, dsp_postdiv * 2, dsp_postdiv,
 393                                 dsp_mul * 2, ar7_bus_clock);
 394                 } else {
 395                         printk(KERN_INFO "Clocks: Sync 1:1 mode\n");
 396
 397                         printk(KERN_INFO "Clocks: Setting DSP clock\n");
 398                         calculate(dsp_base, TNETD7200_DEF_DSP_CLK, &dsp_prediv,
 399                                 &dsp_postdiv, &dsp_mul);
 400                         ar7_bus_clock = ((dsp_base / dsp_prediv) * dsp_mul)
 401                                                                 / dsp_postdiv;
 402                         tnetd7200_set_clock(dsp_base, &clocks->dsp,
 403                                 dsp_prediv, dsp_postdiv * 2, dsp_postdiv,
 404                                 dsp_mul * 2, ar7_bus_clock);
 405
 406                         ar7_cpu_clock = ar7_bus_clock;
 407                 }
 408
 409         printk(KERN_INFO "Clocks: Setting USB clock\n");
 410         usb_base = ar7_bus_clock;
 411         calculate(usb_base, TNETD7200_DEF_USB_CLK, &usb_prediv,
 412                 &usb_postdiv, &usb_mul);
 413         tnetd7200_set_clock(usb_base, &clocks->usb,
 414                 usb_prediv, usb_postdiv, -1, usb_mul,
 415                 TNETD7200_DEF_USB_CLK);
 416
 417         ar7_dsp_clock = ar7_cpu_clock;
 418
 419         iounmap(clocks);
 420         iounmap(bootcr);
 421 }
 422
 423 int __init ar7_init_clocks(void)
 424 {
 425         switch (ar7_chip_id()) {
 426         case AR7_CHIP_7100:
 427         case AR7_CHIP_7200:
 428                 tnetd7200_init_clocks();
 429                 break;
 430         case AR7_CHIP_7300:
 431                 ar7_dsp_clock = tnetd7300_dsp_clock();
 432                 tnetd7300_init_clocks();
 433                 break;
 434         default:
 435                 break;
 436         }
 437
 438         return 0;
 439 }
 440 arch_initcall(ar7_init_clocks);