drivers/clk/versatile/clk-icst.c

   1 /*
   2  * Driver for the ICST307 VCO clock found in the ARM Reference designs.
   3  * We wrap the custom interface from <asm/hardware/icst.h> into the generic
   4  * clock framework.
   5  *
   6  * Copyright (C) 2012-2015 Linus Walleij
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * TODO: when all ARM reference designs are migrated to generic clocks, the
  13  * ICST clock code from the ARM tree should probably be merged into this
  14  * file.
  15  */
  16 #include <linux/kernel.h>
  17 #include <linux/slab.h>
  18 #include <linux/export.h>
  19 #include <linux/err.h>
  20 #include <linux/clk-provider.h>
  21 #include <linux/io.h>
  22 #include <linux/regmap.h>
  23 #include <linux/mfd/syscon.h>
  24
  25 #include "icst.h"
  26 #include "clk-icst.h"
  27
  28 /* Magic unlocking token used on all Versatile boards */
  29 #define VERSATILE_LOCK_VAL      0xA05F
  30
  31 #define VERSATILE_AUX_OSC_BITS 0x7FFFF
  32 #define INTEGRATOR_AP_CM_BITS 0xFF
  33 #define INTEGRATOR_AP_SYS_BITS 0xFF
  34 #define INTEGRATOR_CP_CM_CORE_BITS 0x7FF
  35 #define INTEGRATOR_CP_CM_MEM_BITS 0x7FF000
  36
  37 #define INTEGRATOR_AP_PCI_25_33_MHZ BIT(8)
  38
  39 /**
  40  * enum icst_control_type - the type of ICST control register
  41  */
  42 enum icst_control_type {
  43         ICST_VERSATILE, /* The standard type, all control bits available */
  44         ICST_INTEGRATOR_AP_CM, /* Only 8 bits of VDW available */
  45         ICST_INTEGRATOR_AP_SYS, /* Only 8 bits of VDW available */
  46         ICST_INTEGRATOR_AP_PCI, /* Odd bit pattern storage */
  47         ICST_INTEGRATOR_CP_CM_CORE, /* Only 8 bits of VDW and 3 bits of OD */
  48         ICST_INTEGRATOR_CP_CM_MEM, /* Only 8 bits of VDW and 3 bits of OD */
  49 };
  50
  51 /**
  52  * struct clk_icst - ICST VCO clock wrapper
  53  * @hw: corresponding clock hardware entry
  54  * @vcoreg: VCO register address
  55  * @lockreg: VCO lock register address
  56  * @params: parameters for this ICST instance
  57  * @rate: current rate
  58  * @ctype: the type of control register for the ICST
  59  */
  60 struct clk_icst {
  61         struct clk_hw hw;
  62         struct regmap *map;
  63         u32 vcoreg_off;
  64         u32 lockreg_off;
  65         struct icst_params *params;
  66         unsigned long rate;
  67         enum icst_control_type ctype;
  68 };
  69
  70 #define to_icst(_hw) container_of(_hw, struct clk_icst, hw)
  71
  72 /**
  73  * vco_get() - get ICST VCO settings from a certain ICST
  74  * @icst: the ICST clock to get
  75  * @vco: the VCO struct to return the value in
  76  */
  77 static int vco_get(struct clk_icst *icst, struct icst_vco *vco)
  78 {
  79         u32 val;
  80         int ret;
  81
  82         ret = regmap_read(icst->map, icst->vcoreg_off, &val);
  83         if (ret)
  84                 return ret;
  85
  86         /*
  87          * The Integrator/AP core clock can only access the low eight
  88          * bits of the v PLL divider. Bit 8 is tied low and always zero,
  89          * r is hardwired to 22 and output divider s is hardwired to 1
  90          * (divide by 2) according to the document
  91          * "Integrator CM926EJ-S, CM946E-S, CM966E-S, CM1026EJ-S and
  92          * CM1136JF-S User Guide" ARM DUI 0138E, page 3-13 thru 3-14.
  93          */
  94         if (icst->ctype == ICST_INTEGRATOR_AP_CM) {
  95                 vco->v = val & INTEGRATOR_AP_CM_BITS;
  96                 vco->r = 22;
  97                 vco->s = 1;
  98                 return 0;
  99         }
 100
 101         /*
 102          * The Integrator/AP system clock on the base board can only
 103          * access the low eight bits of the v PLL divider. Bit 8 is tied low
 104          * and always zero, r is hardwired to 46, and the output divider is
 105          * hardwired to 3 (divide by 4) according to the document
 106          * "Integrator AP ASIC Development Motherboard" ARM DUI 0098B,
 107          * page 3-16.
 108          */
 109         if (icst->ctype == ICST_INTEGRATOR_AP_SYS) {
 110                 vco->v = val & INTEGRATOR_AP_SYS_BITS;
 111                 vco->r = 46;
 112                 vco->s = 3;
 113                 return 0;
 114         }
 115
 116         /*
 117          * The Integrator/AP PCI clock is using an odd pattern to create
 118          * the child clock, basically a single bit called DIVX/Y is used
 119          * to select between two different hardwired values: setting the
 120          * bit to 0 yields v = 17, r = 22 and OD = 1, whereas setting the
 121          * bit to 1 yields v = 14, r = 14 and OD = 1 giving the frequencies
 122          * 33 or 25 MHz respectively.
 123          */
 124         if (icst->ctype == ICST_INTEGRATOR_AP_PCI) {
 125                 bool divxy = !!(val & INTEGRATOR_AP_PCI_25_33_MHZ);
 126
 127                 vco->v = divxy ? 17 : 14;
 128                 vco->r = divxy ? 22 : 14;
 129                 vco->s = 1;
 130                 return 0;
 131         }
 132
 133         /*
 134          * The Integrator/CP core clock can access the low eight bits
 135          * of the v PLL divider. Bit 8 is tied low and always zero,
 136          * r is hardwired to 22 and the output divider s is accessible
 137          * in bits 8 thru 10 according to the document
 138          * "Integrator/CM940T, CM920T, CM740T, and CM720T User Guide"
 139          * ARM DUI 0157A, page 3-20 thru 3-23 and 4-10.
 140          */
 141         if (icst->ctype == ICST_INTEGRATOR_CP_CM_CORE) {
 142                 vco->v = val & 0xFF;
 143                 vco->r = 22;
 144                 vco->s = (val >> 8) & 7;
 145                 return 0;
 146         }
 147
 148         if (icst->ctype == ICST_INTEGRATOR_CP_CM_MEM) {
 149                 vco->v = (val >> 12) & 0xFF;
 150                 vco->r = 22;
 151                 vco->s = (val >> 20) & 7;
 152                 return 0;
 153         }
 154
 155         vco->v = val & 0x1ff;
 156         vco->r = (val >> 9) & 0x7f;
 157         vco->s = (val >> 16) & 03;
 158         return 0;
 159 }
 160
 161 /**
 162  * vco_set() - commit changes to an ICST VCO
 163  * @icst: the ICST clock to set
 164  * @vco: the VCO struct to set the changes from
 165  */
 166 static int vco_set(struct clk_icst *icst, struct icst_vco vco)
 167 {
 168         u32 mask;
 169         u32 val;
 170         int ret;
 171
 172         /* Mask the bits used by the VCO */
 173         switch (icst->ctype) {
 174         case ICST_INTEGRATOR_AP_CM:
 175                 mask = INTEGRATOR_AP_CM_BITS;
 176                 val = vco.v & 0xFF;
 177                 if (vco.v & 0x100)
 178                         pr_err("ICST error: tried to set bit 8 of VDW\n");
 179                 if (vco.s != 1)
 180                         pr_err("ICST error: tried to use VOD != 1\n");
 181                 if (vco.r != 22)
 182                         pr_err("ICST error: tried to use RDW != 22\n");
 183                 break;
 184         case ICST_INTEGRATOR_AP_SYS:
 185                 mask = INTEGRATOR_AP_SYS_BITS;
 186                 val = vco.v & 0xFF;
 187                 if (vco.v & 0x100)
 188                         pr_err("ICST error: tried to set bit 8 of VDW\n");
 189                 if (vco.s != 3)
 190                         pr_err("ICST error: tried to use VOD != 1\n");
 191                 if (vco.r != 46)
 192                         pr_err("ICST error: tried to use RDW != 22\n");
 193                 break;
 194         case ICST_INTEGRATOR_CP_CM_CORE:
 195                 mask = INTEGRATOR_CP_CM_CORE_BITS; /* Uses 12 bits */
 196                 val = (vco.v & 0xFF) | vco.s << 8;
 197                 if (vco.v & 0x100)
 198                         pr_err("ICST error: tried to set bit 8 of VDW\n");
 199                 if (vco.r != 22)
 200                         pr_err("ICST error: tried to use RDW != 22\n");
 201                 break;
 202         case ICST_INTEGRATOR_CP_CM_MEM:
 203                 mask = INTEGRATOR_CP_CM_MEM_BITS; /* Uses 12 bits */
 204                 val = ((vco.v & 0xFF) << 12) | (vco.s << 20);
 205                 if (vco.v & 0x100)
 206                         pr_err("ICST error: tried to set bit 8 of VDW\n");
 207                 if (vco.r != 22)
 208                         pr_err("ICST error: tried to use RDW != 22\n");
 209                 break;
 210         default:
 211                 /* Regular auxilary oscillator */
 212                 mask = VERSATILE_AUX_OSC_BITS;
 213                 val = vco.v | (vco.r << 9) | (vco.s << 16);
 214                 break;
 215         }
 216
 217         pr_debug("ICST: new val = 0x%08x\n", val);
 218
 219         /* This magic unlocks the VCO so it can be controlled */
 220         ret = regmap_write(icst->map, icst->lockreg_off, VERSATILE_LOCK_VAL);
 221         if (ret)
 222                 return ret;
 223         ret = regmap_update_bits(icst->map, icst->vcoreg_off, mask, val);
 224         if (ret)
 225                 return ret;
 226         /* This locks the VCO again */
 227         ret = regmap_write(icst->map, icst->lockreg_off, 0);
 228         if (ret)
 229                 return ret;
 230         return 0;
 231 }
 232
 233 static unsigned long icst_recalc_rate(struct clk_hw *hw,
 234                                       unsigned long parent_rate)
 235 {
 236         struct clk_icst *icst = to_icst(hw);
 237         struct icst_vco vco;
 238         int ret;
 239
 240         if (parent_rate)
 241                 icst->params->ref = parent_rate;
 242         ret = vco_get(icst, &vco);
 243         if (ret) {
 244                 pr_err("ICST: could not get VCO setting\n");
 245                 return 0;
 246         }
 247         icst->rate = icst_hz(icst->params, vco);
 248         return icst->rate;
 249 }
 250
 251 static long icst_round_rate(struct clk_hw *hw, unsigned long rate,
 252                             unsigned long *prate)
 253 {
 254         struct clk_icst *icst = to_icst(hw);
 255         struct icst_vco vco;
 256
 257         if (icst->ctype == ICST_INTEGRATOR_AP_CM ||
 258             icst->ctype == ICST_INTEGRATOR_CP_CM_CORE) {
 259                 if (rate <= 12000000)
 260                         return 12000000;
 261                 if (rate >= 160000000)
 262                         return 160000000;
 263                 /* Slam to closest megahertz */
 264                 return DIV_ROUND_CLOSEST(rate, 1000000) * 1000000;
 265         }
 266
 267         if (icst->ctype == ICST_INTEGRATOR_CP_CM_MEM) {
 268                 if (rate <= 6000000)
 269                         return 6000000;
 270                 if (rate >= 66000000)
 271                         return 66000000;
 272                 /* Slam to closest 0.5 megahertz */
 273                 return DIV_ROUND_CLOSEST(rate, 500000) * 500000;
 274         }
 275
 276         if (icst->ctype == ICST_INTEGRATOR_AP_SYS) {
 277                 /* Divides between 3 and 50 MHz in steps of 0.25 MHz */
 278                 if (rate <= 3000000)
 279                         return 3000000;
 280                 if (rate >= 50000000)
 281                         return 5000000;
 282                 /* Slam to closest 0.25 MHz */
 283                 return DIV_ROUND_CLOSEST(rate, 250000) * 250000;
 284         }
 285
 286         if (icst->ctype == ICST_INTEGRATOR_AP_PCI) {
 287                 /*
 288                  * If we're below or less than halfway from 25 to 33 MHz
 289                  * select 25 MHz
 290                  */
 291                 if (rate <= 25000000 || rate < 29000000)
 292                         return 25000000;
 293                 /* Else just return the default frequency */
 294                 return 33000000;
 295         }
 296
 297         vco = icst_hz_to_vco(icst->params, rate);
 298         return icst_hz(icst->params, vco);
 299 }
 300
 301 static int icst_set_rate(struct clk_hw *hw, unsigned long rate,
 302                          unsigned long parent_rate)
 303 {
 304         struct clk_icst *icst = to_icst(hw);
 305         struct icst_vco vco;
 306
 307         if (icst->ctype == ICST_INTEGRATOR_AP_PCI) {
 308                 /* This clock is especially primitive */
 309                 unsigned int val;
 310                 int ret;
 311
 312                 if (rate == 25000000) {
 313                         val = 0;
 314                 } else if (rate == 33000000) {
 315                         val = INTEGRATOR_AP_PCI_25_33_MHZ;
 316                 } else {
 317                         pr_err("ICST: cannot set PCI frequency %lu\n",
 318                                rate);
 319                         return -EINVAL;
 320                 }
 321                 ret = regmap_write(icst->map, icst->lockreg_off,
 322                                    VERSATILE_LOCK_VAL);
 323                 if (ret)
 324                         return ret;
 325                 ret = regmap_update_bits(icst->map, icst->vcoreg_off,
 326                                          INTEGRATOR_AP_PCI_25_33_MHZ,
 327                                          val);
 328                 if (ret)
 329                         return ret;
 330                 /* This locks the VCO again */
 331                 ret = regmap_write(icst->map, icst->lockreg_off, 0);
 332                 if (ret)
 333                         return ret;
 334                 return 0;
 335         }
 336
 337         if (parent_rate)
 338                 icst->params->ref = parent_rate;
 339         vco = icst_hz_to_vco(icst->params, rate);
 340         icst->rate = icst_hz(icst->params, vco);
 341         return vco_set(icst, vco);
 342 }
 343
 344 static const struct clk_ops icst_ops = {
 345         .recalc_rate = icst_recalc_rate,
 346         .round_rate = icst_round_rate,
 347         .set_rate = icst_set_rate,
 348 };
 349
 350 static struct clk *icst_clk_setup(struct device *dev,
 351                                   const struct clk_icst_desc *desc,
 352                                   const char *name,
 353                                   const char *parent_name,
 354                                   struct regmap *map,
 355                                   enum icst_control_type ctype)
 356 {
 357         struct clk *clk;
 358         struct clk_icst *icst;
 359         struct clk_init_data init;
 360         struct icst_params *pclone;
 361
 362         icst = kzalloc(sizeof(struct clk_icst), GFP_KERNEL);
 363         if (!icst) {
 364                 pr_err("could not allocate ICST clock!\n");
 365                 return ERR_PTR(-ENOMEM);
 366         }
 367
 368         pclone = kmemdup(desc->params, sizeof(*pclone), GFP_KERNEL);
 369         if (!pclone) {
 370                 kfree(icst);
 371                 pr_err("could not clone ICST params\n");
 372                 return ERR_PTR(-ENOMEM);
 373         }
 374
 375         init.name = name;
 376         init.ops = &icst_ops;
 377         init.flags = 0;
 378         init.parent_names = (parent_name ? &parent_name : NULL);
 379         init.num_parents = (parent_name ? 1 : 0);
 380         icst->map = map;
 381         icst->hw.init = &init;
 382         icst->params = pclone;
 383         icst->vcoreg_off = desc->vco_offset;
 384         icst->lockreg_off = desc->lock_offset;
 385         icst->ctype = ctype;
 386
 387         clk = clk_register(dev, &icst->hw);
 388         if (IS_ERR(clk)) {
 389                 kfree(pclone);
 390                 kfree(icst);
 391         }
 392
 393         return clk;
 394 }
 395
 396 struct clk *icst_clk_register(struct device *dev,
 397                         const struct clk_icst_desc *desc,
 398                         const char *name,
 399                         const char *parent_name,
 400                         void __iomem *base)
 401 {
 402         struct regmap_config icst_regmap_conf = {
 403                 .reg_bits = 32,
 404                 .val_bits = 32,
 405                 .reg_stride = 4,
 406         };
 407         struct regmap *map;
 408
 409         map = regmap_init_mmio(dev, base, &icst_regmap_conf);
 410         if (IS_ERR(map)) {
 411                 pr_err("could not initialize ICST regmap\n");
 412                 return ERR_CAST(map);
 413         }
 414         return icst_clk_setup(dev, desc, name, parent_name, map,
 415                               ICST_VERSATILE);
 416 }
 417 EXPORT_SYMBOL_GPL(icst_clk_register);
 418
 419 #ifdef CONFIG_OF
 420 /*
 421  * In a device tree, an memory-mapped ICST clock appear as a child
 422  * of a syscon node. Assume this and probe it only as a child of a
 423  * syscon.
 424  */
 425
 426 static const struct icst_params icst525_params = {
 427         .vco_max        = ICST525_VCO_MAX_5V,
 428         .vco_min        = ICST525_VCO_MIN,
 429         .vd_min         = 8,
 430         .vd_max         = 263,
 431         .rd_min         = 3,
 432         .rd_max         = 65,
 433         .s2div          = icst525_s2div,
 434         .idx2s          = icst525_idx2s,
 435 };
 436
 437 static const struct icst_params icst307_params = {
 438         .vco_max        = ICST307_VCO_MAX,
 439         .vco_min        = ICST307_VCO_MIN,
 440         .vd_min         = 4 + 8,
 441         .vd_max         = 511 + 8,
 442         .rd_min         = 1 + 2,
 443         .rd_max         = 127 + 2,
 444         .s2div          = icst307_s2div,
 445         .idx2s          = icst307_idx2s,
 446 };
 447
 448 /**
 449  * The core modules on the Integrator/AP and Integrator/CP have
 450  * especially crippled ICST525 control.
 451  */
 452 static const struct icst_params icst525_apcp_cm_params = {
 453         .vco_max        = ICST525_VCO_MAX_5V,
 454         .vco_min        = ICST525_VCO_MIN,
 455         /* Minimum 12 MHz, VDW = 4 */
 456         .vd_min         = 12,
 457         /*
 458          * Maximum 160 MHz, VDW = 152 for all core modules, but
 459          * CM926EJ-S, CM1026EJ-S and CM1136JF-S can actually
 460          * go to 200 MHz (max VDW = 192).
 461          */
 462         .vd_max         = 192,
 463         /* r is hardcoded to 22 and this is the actual divisor, +2 */
 464         .rd_min         = 24,
 465         .rd_max         = 24,
 466         .s2div          = icst525_s2div,
 467         .idx2s          = icst525_idx2s,
 468 };
 469
 470 static const struct icst_params icst525_ap_sys_params = {
 471         .vco_max        = ICST525_VCO_MAX_5V,
 472         .vco_min        = ICST525_VCO_MIN,
 473         /* Minimum 3 MHz, VDW = 4 */
 474         .vd_min         = 3,
 475         /* Maximum 50 MHz, VDW = 192 */
 476         .vd_max         = 50,
 477         /* r is hardcoded to 46 and this is the actual divisor, +2 */
 478         .rd_min         = 48,
 479         .rd_max         = 48,
 480         .s2div          = icst525_s2div,
 481         .idx2s          = icst525_idx2s,
 482 };
 483
 484 static const struct icst_params icst525_ap_pci_params = {
 485         .vco_max        = ICST525_VCO_MAX_5V,
 486         .vco_min        = ICST525_VCO_MIN,
 487         /* Minimum 25 MHz */
 488         .vd_min         = 25,
 489         /* Maximum 33 MHz */
 490         .vd_max         = 33,
 491         /* r is hardcoded to 14 or 22 and this is the actual divisors +2 */
 492         .rd_min         = 16,
 493         .rd_max         = 24,
 494         .s2div          = icst525_s2div,
 495         .idx2s          = icst525_idx2s,
 496 };
 497
 498 static void __init of_syscon_icst_setup(struct device_node *np)
 499 {
 500         struct device_node *parent;
 501         struct regmap *map;
 502         struct clk_icst_desc icst_desc;
 503         const char *name = np->name;
 504         const char *parent_name;
 505         struct clk *regclk;
 506         enum icst_control_type ctype;
 507
 508         /* We do not release this reference, we are using it perpetually */
 509         parent = of_get_parent(np);
 510         if (!parent) {
 511                 pr_err("no parent node for syscon ICST clock\n");
 512                 return;
 513         }
 514         map = syscon_node_to_regmap(parent);
 515         if (IS_ERR(map)) {
 516                 pr_err("no regmap for syscon ICST clock parent\n");
 517                 return;
 518         }
 519
 520         if (of_property_read_u32(np, "vco-offset", &icst_desc.vco_offset)) {
 521                 pr_err("no VCO register offset for ICST clock\n");
 522                 return;
 523         }
 524         if (of_property_read_u32(np, "lock-offset", &icst_desc.lock_offset)) {
 525                 pr_err("no lock register offset for ICST clock\n");
 526                 return;
 527         }
 528
 529         if (of_device_is_compatible(np, "arm,syscon-icst525")) {
 530                 icst_desc.params = &icst525_params;
 531                 ctype = ICST_VERSATILE;
 532         } else if (of_device_is_compatible(np, "arm,syscon-icst307")) {
 533                 icst_desc.params = &icst307_params;
 534                 ctype = ICST_VERSATILE;
 535         } else if (of_device_is_compatible(np, "arm,syscon-icst525-integratorap-cm")) {
 536                 icst_desc.params = &icst525_apcp_cm_params;
 537                 ctype = ICST_INTEGRATOR_AP_CM;
 538         } else if (of_device_is_compatible(np, "arm,syscon-icst525-integratorap-sys")) {
 539                 icst_desc.params = &icst525_ap_sys_params;
 540                 ctype = ICST_INTEGRATOR_AP_SYS;
 541         } else if (of_device_is_compatible(np, "arm,syscon-icst525-integratorap-pci")) {
 542                 icst_desc.params = &icst525_ap_pci_params;
 543                 ctype = ICST_INTEGRATOR_AP_PCI;
 544         } else if (of_device_is_compatible(np, "arm,syscon-icst525-integratorcp-cm-core")) {
 545                 icst_desc.params = &icst525_apcp_cm_params;
 546                 ctype = ICST_INTEGRATOR_CP_CM_CORE;
 547         } else if (of_device_is_compatible(np, "arm,syscon-icst525-integratorcp-cm-mem")) {
 548                 icst_desc.params = &icst525_apcp_cm_params;
 549                 ctype = ICST_INTEGRATOR_CP_CM_MEM;
 550         } else {
 551                 pr_err("unknown ICST clock %s\n", name);
 552                 return;
 553         }
 554
 555         /* Parent clock name is not the same as node parent */
 556         parent_name = of_clk_get_parent_name(np, 0);
 557
 558         regclk = icst_clk_setup(NULL, &icst_desc, name, parent_name, map, ctype);
 559         if (IS_ERR(regclk)) {
 560                 pr_err("error setting up syscon ICST clock %s\n", name);
 561                 return;
 562         }
 563         of_clk_add_provider(np, of_clk_src_simple_get, regclk);
 564         pr_debug("registered syscon ICST clock %s\n", name);
 565 }
 566
 567 CLK_OF_DECLARE(arm_syscon_icst525_clk,
 568                "arm,syscon-icst525", of_syscon_icst_setup);
 569 CLK_OF_DECLARE(arm_syscon_icst307_clk,
 570                "arm,syscon-icst307", of_syscon_icst_setup);
 571 CLK_OF_DECLARE(arm_syscon_integratorap_cm_clk,
 572                "arm,syscon-icst525-integratorap-cm", of_syscon_icst_setup);
 573 CLK_OF_DECLARE(arm_syscon_integratorap_sys_clk,
 574                "arm,syscon-icst525-integratorap-sys", of_syscon_icst_setup);
 575 CLK_OF_DECLARE(arm_syscon_integratorap_pci_clk,
 576                "arm,syscon-icst525-integratorap-pci", of_syscon_icst_setup);
 577 CLK_OF_DECLARE(arm_syscon_integratorcp_cm_core_clk,
 578                "arm,syscon-icst525-integratorcp-cm-core", of_syscon_icst_setup);
 579 CLK_OF_DECLARE(arm_syscon_integratorcp_cm_mem_clk,
 580                "arm,syscon-icst525-integratorcp-cm-mem", of_syscon_icst_setup);
 581 #endif