drivers/clk/at91/clk-usb.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (C) 2013 Boris BREZILLON <b.brezillon@overkiz.com>
   4  */
   5
   6 #include <linux/clk-provider.h>
   7 #include <linux/clkdev.h>
   8 #include <linux/clk/at91_pmc.h>
   9 #include <linux/of.h>
  10 #include <linux/mfd/syscon.h>
  11 #include <linux/regmap.h>
  12
  13 #include "pmc.h"
  14
  15 #define SAM9X5_USB_DIV_SHIFT    8
  16 #define SAM9X5_USB_MAX_DIV      0xf
  17
  18 #define RM9200_USB_DIV_SHIFT    28
  19 #define RM9200_USB_DIV_TAB_SIZE 4
  20
  21 #define SAM9X5_USBS_MASK        GENMASK(0, 0)
  22 #define SAM9X60_USBS_MASK       GENMASK(1, 0)
  23
  24 struct at91sam9x5_clk_usb {
  25         struct clk_hw hw;
  26         struct regmap *regmap;
  27         struct at91_clk_pms pms;
  28         u32 usbs_mask;
  29         u8 num_parents;
  30 };
  31
  32 #define to_at91sam9x5_clk_usb(hw) \
  33         container_of(hw, struct at91sam9x5_clk_usb, hw)
  34
  35 struct at91rm9200_clk_usb {
  36         struct clk_hw hw;
  37         struct regmap *regmap;
  38         u32 divisors[4];
  39 };
  40
  41 #define to_at91rm9200_clk_usb(hw) \
  42         container_of(hw, struct at91rm9200_clk_usb, hw)
  43
  44 static unsigned long at91sam9x5_clk_usb_recalc_rate(struct clk_hw *hw,
  45                                                     unsigned long parent_rate)
  46 {
  47         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
  48         unsigned int usbr;
  49         u8 usbdiv;
  50
  51         regmap_read(usb->regmap, AT91_PMC_USB, &usbr);
  52         usbdiv = (usbr & AT91_PMC_OHCIUSBDIV) >> SAM9X5_USB_DIV_SHIFT;
  53
  54         return DIV_ROUND_CLOSEST(parent_rate, (usbdiv + 1));
  55 }
  56
  57 static int at91sam9x5_clk_usb_determine_rate(struct clk_hw *hw,
  58                                              struct clk_rate_request *req)
  59 {
  60         struct clk_hw *parent;
  61         long best_rate = -EINVAL;
  62         unsigned long tmp_rate;
  63         int best_diff = -1;
  64         int tmp_diff;
  65         int i;
  66
  67         for (i = 0; i < clk_hw_get_num_parents(hw); i++) {
  68                 int div;
  69
  70                 parent = clk_hw_get_parent_by_index(hw, i);
  71                 if (!parent)
  72                         continue;
  73
  74                 for (div = 1; div < SAM9X5_USB_MAX_DIV + 2; div++) {
  75                         unsigned long tmp_parent_rate;
  76
  77                         tmp_parent_rate = req->rate * div;
  78                         tmp_parent_rate = clk_hw_round_rate(parent,
  79                                                            tmp_parent_rate);
  80                         if (!tmp_parent_rate)
  81                                 continue;
  82
  83                         tmp_rate = DIV_ROUND_CLOSEST(tmp_parent_rate, div);
  84                         if (tmp_rate < req->rate)
  85                                 tmp_diff = req->rate - tmp_rate;
  86                         else
  87                                 tmp_diff = tmp_rate - req->rate;
  88
  89                         if (best_diff < 0 || best_diff > tmp_diff) {
  90                                 best_rate = tmp_rate;
  91                                 best_diff = tmp_diff;
  92                                 req->best_parent_rate = tmp_parent_rate;
  93                                 req->best_parent_hw = parent;
  94                         }
  95
  96                         if (!best_diff || tmp_rate < req->rate)
  97                                 break;
  98                 }
  99
 100                 if (!best_diff)
 101                         break;
 102         }
 103
 104         if (best_rate < 0)
 105                 return best_rate;
 106
 107         req->rate = best_rate;
 108         return 0;
 109 }
 110
 111 static int at91sam9x5_clk_usb_set_parent(struct clk_hw *hw, u8 index)
 112 {
 113         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 114
 115         if (index >= usb->num_parents)
 116                 return -EINVAL;
 117
 118         regmap_update_bits(usb->regmap, AT91_PMC_USB, usb->usbs_mask, index);
 119
 120         return 0;
 121 }
 122
 123 static u8 at91sam9x5_clk_usb_get_parent(struct clk_hw *hw)
 124 {
 125         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 126         unsigned int usbr;
 127
 128         regmap_read(usb->regmap, AT91_PMC_USB, &usbr);
 129
 130         return usbr & usb->usbs_mask;
 131 }
 132
 133 static int at91sam9x5_clk_usb_set_rate(struct clk_hw *hw, unsigned long rate,
 134                                        unsigned long parent_rate)
 135 {
 136         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 137         unsigned long div;
 138
 139         if (!rate)
 140                 return -EINVAL;
 141
 142         div = DIV_ROUND_CLOSEST(parent_rate, rate);
 143         if (div > SAM9X5_USB_MAX_DIV + 1 || !div)
 144                 return -EINVAL;
 145
 146         regmap_update_bits(usb->regmap, AT91_PMC_USB, AT91_PMC_OHCIUSBDIV,
 147                            (div - 1) << SAM9X5_USB_DIV_SHIFT);
 148
 149         return 0;
 150 }
 151
 152 static int at91sam9x5_usb_save_context(struct clk_hw *hw)
 153 {
 154         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 155         struct clk_hw *parent_hw = clk_hw_get_parent(hw);
 156
 157         usb->pms.parent = at91sam9x5_clk_usb_get_parent(hw);
 158         usb->pms.parent_rate = clk_hw_get_rate(parent_hw);
 159         usb->pms.rate = at91sam9x5_clk_usb_recalc_rate(hw, usb->pms.parent_rate);
 160
 161         return 0;
 162 }
 163
 164 static void at91sam9x5_usb_restore_context(struct clk_hw *hw)
 165 {
 166         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 167         int ret;
 168
 169         ret = at91sam9x5_clk_usb_set_parent(hw, usb->pms.parent);
 170         if (ret)
 171                 return;
 172
 173         at91sam9x5_clk_usb_set_rate(hw, usb->pms.rate, usb->pms.parent_rate);
 174 }
 175
 176 static const struct clk_ops at91sam9x5_usb_ops = {
 177         .recalc_rate = at91sam9x5_clk_usb_recalc_rate,
 178         .determine_rate = at91sam9x5_clk_usb_determine_rate,
 179         .get_parent = at91sam9x5_clk_usb_get_parent,
 180         .set_parent = at91sam9x5_clk_usb_set_parent,
 181         .set_rate = at91sam9x5_clk_usb_set_rate,
 182         .save_context = at91sam9x5_usb_save_context,
 183         .restore_context = at91sam9x5_usb_restore_context,
 184 };
 185
 186 static int at91sam9n12_clk_usb_enable(struct clk_hw *hw)
 187 {
 188         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 189
 190         regmap_update_bits(usb->regmap, AT91_PMC_USB, AT91_PMC_USBS,
 191                            AT91_PMC_USBS);
 192
 193         return 0;
 194 }
 195
 196 static void at91sam9n12_clk_usb_disable(struct clk_hw *hw)
 197 {
 198         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 199
 200         regmap_update_bits(usb->regmap, AT91_PMC_USB, AT91_PMC_USBS, 0);
 201 }
 202
 203 static int at91sam9n12_clk_usb_is_enabled(struct clk_hw *hw)
 204 {
 205         struct at91sam9x5_clk_usb *usb = to_at91sam9x5_clk_usb(hw);
 206         unsigned int usbr;
 207
 208         regmap_read(usb->regmap, AT91_PMC_USB, &usbr);
 209
 210         return usbr & AT91_PMC_USBS;
 211 }
 212
 213 static const struct clk_ops at91sam9n12_usb_ops = {
 214         .enable = at91sam9n12_clk_usb_enable,
 215         .disable = at91sam9n12_clk_usb_disable,
 216         .is_enabled = at91sam9n12_clk_usb_is_enabled,
 217         .recalc_rate = at91sam9x5_clk_usb_recalc_rate,
 218         .determine_rate = at91sam9x5_clk_usb_determine_rate,
 219         .set_rate = at91sam9x5_clk_usb_set_rate,
 220 };
 221
 222 static struct clk_hw * __init
 223 _at91sam9x5_clk_register_usb(struct regmap *regmap, const char *name,
 224                              const char **parent_names, u8 num_parents,
 225                              u32 usbs_mask)
 226 {
 227         struct at91sam9x5_clk_usb *usb;
 228         struct clk_hw *hw;
 229         struct clk_init_data init;
 230         int ret;
 231
 232         usb = kzalloc(sizeof(*usb), GFP_KERNEL);
 233         if (!usb)
 234                 return ERR_PTR(-ENOMEM);
 235
 236         init.name = name;
 237         init.ops = &at91sam9x5_usb_ops;
 238         init.parent_names = parent_names;
 239         init.num_parents = num_parents;
 240         init.flags = CLK_SET_RATE_GATE | CLK_SET_PARENT_GATE |
 241                      CLK_SET_RATE_PARENT;
 242
 243         usb->hw.init = &init;
 244         usb->regmap = regmap;
 245         usb->usbs_mask = usbs_mask;
 246         usb->num_parents = num_parents;
 247
 248         hw = &usb->hw;
 249         ret = clk_hw_register(NULL, &usb->hw);
 250         if (ret) {
 251                 kfree(usb);
 252                 hw = ERR_PTR(ret);
 253         }
 254
 255         return hw;
 256 }
 257
 258 struct clk_hw * __init
 259 at91sam9x5_clk_register_usb(struct regmap *regmap, const char *name,
 260                             const char **parent_names, u8 num_parents)
 261 {
 262         return _at91sam9x5_clk_register_usb(regmap, name, parent_names,
 263                                             num_parents, SAM9X5_USBS_MASK);
 264 }
 265
 266 struct clk_hw * __init
 267 sam9x60_clk_register_usb(struct regmap *regmap, const char *name,
 268                          const char **parent_names, u8 num_parents)
 269 {
 270         return _at91sam9x5_clk_register_usb(regmap, name, parent_names,
 271                                             num_parents, SAM9X60_USBS_MASK);
 272 }
 273
 274 struct clk_hw * __init
 275 at91sam9n12_clk_register_usb(struct regmap *regmap, const char *name,
 276                              const char *parent_name)
 277 {
 278         struct at91sam9x5_clk_usb *usb;
 279         struct clk_hw *hw;
 280         struct clk_init_data init;
 281         int ret;
 282
 283         usb = kzalloc(sizeof(*usb), GFP_KERNEL);
 284         if (!usb)
 285                 return ERR_PTR(-ENOMEM);
 286
 287         init.name = name;
 288         init.ops = &at91sam9n12_usb_ops;
 289         init.parent_names = &parent_name;
 290         init.num_parents = 1;
 291         init.flags = CLK_SET_RATE_GATE | CLK_SET_RATE_PARENT;
 292
 293         usb->hw.init = &init;
 294         usb->regmap = regmap;
 295
 296         hw = &usb->hw;
 297         ret = clk_hw_register(NULL, &usb->hw);
 298         if (ret) {
 299                 kfree(usb);
 300                 hw = ERR_PTR(ret);
 301         }
 302
 303         return hw;
 304 }
 305
 306 static unsigned long at91rm9200_clk_usb_recalc_rate(struct clk_hw *hw,
 307                                                     unsigned long parent_rate)
 308 {
 309         struct at91rm9200_clk_usb *usb = to_at91rm9200_clk_usb(hw);
 310         unsigned int pllbr;
 311         u8 usbdiv;
 312
 313         regmap_read(usb->regmap, AT91_CKGR_PLLBR, &pllbr);
 314
 315         usbdiv = (pllbr & AT91_PMC_USBDIV) >> RM9200_USB_DIV_SHIFT;
 316         if (usb->divisors[usbdiv])
 317                 return parent_rate / usb->divisors[usbdiv];
 318
 319         return 0;
 320 }
 321
 322 static long at91rm9200_clk_usb_round_rate(struct clk_hw *hw, unsigned long rate,
 323                                           unsigned long *parent_rate)
 324 {
 325         struct at91rm9200_clk_usb *usb = to_at91rm9200_clk_usb(hw);
 326         struct clk_hw *parent = clk_hw_get_parent(hw);
 327         unsigned long bestrate = 0;
 328         int bestdiff = -1;
 329         unsigned long tmprate;
 330         int tmpdiff;
 331         int i = 0;
 332
 333         for (i = 0; i < RM9200_USB_DIV_TAB_SIZE; i++) {
 334                 unsigned long tmp_parent_rate;
 335
 336                 if (!usb->divisors[i])
 337                         continue;
 338
 339                 tmp_parent_rate = rate * usb->divisors[i];
 340                 tmp_parent_rate = clk_hw_round_rate(parent, tmp_parent_rate);
 341                 tmprate = DIV_ROUND_CLOSEST(tmp_parent_rate, usb->divisors[i]);
 342                 if (tmprate < rate)
 343                         tmpdiff = rate - tmprate;
 344                 else
 345                         tmpdiff = tmprate - rate;
 346
 347                 if (bestdiff < 0 || bestdiff > tmpdiff) {
 348                         bestrate = tmprate;
 349                         bestdiff = tmpdiff;
 350                         *parent_rate = tmp_parent_rate;
 351                 }
 352
 353                 if (!bestdiff)
 354                         break;
 355         }
 356
 357         return bestrate;
 358 }
 359
 360 static int at91rm9200_clk_usb_set_rate(struct clk_hw *hw, unsigned long rate,
 361                                        unsigned long parent_rate)
 362 {
 363         int i;
 364         struct at91rm9200_clk_usb *usb = to_at91rm9200_clk_usb(hw);
 365         unsigned long div;
 366
 367         if (!rate)
 368                 return -EINVAL;
 369
 370         div = DIV_ROUND_CLOSEST(parent_rate, rate);
 371
 372         for (i = 0; i < RM9200_USB_DIV_TAB_SIZE; i++) {
 373                 if (usb->divisors[i] == div) {
 374                         regmap_update_bits(usb->regmap, AT91_CKGR_PLLBR,
 375                                            AT91_PMC_USBDIV,
 376                                            i << RM9200_USB_DIV_SHIFT);
 377
 378                         return 0;
 379                 }
 380         }
 381
 382         return -EINVAL;
 383 }
 384
 385 static const struct clk_ops at91rm9200_usb_ops = {
 386         .recalc_rate = at91rm9200_clk_usb_recalc_rate,
 387         .round_rate = at91rm9200_clk_usb_round_rate,
 388         .set_rate = at91rm9200_clk_usb_set_rate,
 389 };
 390
 391 struct clk_hw * __init
 392 at91rm9200_clk_register_usb(struct regmap *regmap, const char *name,
 393                             const char *parent_name, const u32 *divisors)
 394 {
 395         struct at91rm9200_clk_usb *usb;
 396         struct clk_hw *hw;
 397         struct clk_init_data init;
 398         int ret;
 399
 400         usb = kzalloc(sizeof(*usb), GFP_KERNEL);
 401         if (!usb)
 402                 return ERR_PTR(-ENOMEM);
 403
 404         init.name = name;
 405         init.ops = &at91rm9200_usb_ops;
 406         init.parent_names = &parent_name;
 407         init.num_parents = 1;
 408         init.flags = CLK_SET_RATE_PARENT;
 409
 410         usb->hw.init = &init;
 411         usb->regmap = regmap;
 412         memcpy(usb->divisors, divisors, sizeof(usb->divisors));
 413
 414         hw = &usb->hw;
 415         ret = clk_hw_register(NULL, &usb->hw);
 416         if (ret) {
 417                 kfree(usb);
 418                 hw = ERR_PTR(ret);
 419         }
 420
 421         return hw;
 422 }