sys/arm/allwinner/clkng/aw_clk.h

   1 /*-
   2  * Copyright (c) 2017 Emmanuel Vadot <manu@freebsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  21  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #ifndef __AW_CLK_H__
  30 #define __AW_CLK_H__
  31
  32 /*
  33   Allwinner clocks formula :
  34
  35 PLLs:
  36
  37 (24MHz*N*K)/(M*P)
  38 (24MHz*N)/(M*P)
  39 (24MHz*N*2)/M
  40 (24MHz*N)/M
  41 (24MHz*N*K)/M
  42 (24MHz*N*K/2)
  43 (24MHz*N)/M
  44 (24MHz*N*K/2)
  45 (24MHz*N)/M
  46
  47 Periph clocks:
  48
  49 Clock Source/Divider N/Divider M
  50 Clock Source/Divider N/Divider M/2
  51 Clock Source*N/(Divider M+1)/(Divider P+1)
  52
  53  */
  54
  55 struct aw_clk_init {
  56         const char      *name;
  57         const char      *parent_name;
  58         uint64_t        default_freq;
  59         bool            enable;
  60 };
  61
  62 #define AW_CLK_HAS_GATE         0x0001
  63 #define AW_CLK_HAS_LOCK         0x0002
  64 #define AW_CLK_HAS_MUX          0x0004
  65 #define AW_CLK_REPARENT         0x0008
  66 #define AW_CLK_SCALE_CHANGE     0x0010
  67 #define AW_CLK_HAS_UPDATE       0x0040
  68 #define AW_CLK_HAS_PREDIV       0x0080
  69 #define AW_CLK_SET_PARENT       0x0100
  70
  71 #define AW_CLK_FACTOR_POWER_OF_TWO      0x0001
  72 #define AW_CLK_FACTOR_ZERO_BASED        0x0002
  73 #define AW_CLK_FACTOR_HAS_COND          0x0004
  74 #define AW_CLK_FACTOR_FIXED             0x0008
  75 #define AW_CLK_FACTOR_ZERO_IS_ONE       0x0010
  76 #define AW_CLK_FACTOR_MIN_VALUE         0x0020
  77 #define AW_CLK_FACTOR_MAX_VALUE         0x0040
  78
  79 struct aw_clk_factor {
  80         uint32_t        shift;          /* Shift bits for the factor */
  81         uint32_t        mask;           /* Mask to get the factor, will be override by the clk methods */
  82         uint32_t        width;          /* Number of bits for the factor */
  83         uint32_t        value;          /* Fixed value, depends on AW_CLK_FACTOR_FIXED */
  84
  85         uint32_t        cond_shift;
  86         uint32_t        cond_mask;
  87         uint32_t        cond_width;
  88         uint32_t        cond_value;
  89
  90         uint32_t        min_value;
  91         uint32_t        max_value;
  92
  93         uint32_t        flags;          /* Flags */
  94 };
  95
  96 struct aw_clk_frac {
  97         uint64_t        freq0;
  98         uint64_t        freq1;
  99         uint32_t        mode_sel;
 100         uint32_t        freq_sel;
 101 };
 102
 103 static inline uint32_t
 104 aw_clk_get_factor(uint32_t val, struct aw_clk_factor *factor)
 105 {
 106         uint32_t factor_val;
 107         uint32_t cond;
 108
 109         if (factor->flags & AW_CLK_FACTOR_HAS_COND) {
 110                 cond = (val & factor->cond_mask) >> factor->cond_shift;
 111                 if (cond != factor->cond_value)
 112                         return (1);
 113         }
 114
 115         if (factor->flags & AW_CLK_FACTOR_FIXED)
 116                 return (factor->value);
 117
 118         factor_val = (val & factor->mask) >> factor->shift;
 119         if (factor_val == 0 && (factor->flags & AW_CLK_FACTOR_ZERO_IS_ONE))
 120                 factor_val = 1;
 121
 122         if (factor->flags & AW_CLK_FACTOR_POWER_OF_TWO)
 123                 factor_val = 1 << factor_val;
 124         else if (!(factor->flags & AW_CLK_FACTOR_ZERO_BASED))
 125                 factor_val += 1;
 126
 127         return (factor_val);
 128 }
 129
 130 static inline uint32_t
 131 aw_clk_factor_get_max(struct aw_clk_factor *factor)
 132 {
 133         uint32_t max;
 134
 135         if (factor->flags & AW_CLK_FACTOR_FIXED)
 136                 max = factor->value;
 137         else if (factor->flags & AW_CLK_FACTOR_POWER_OF_TWO)
 138                 max = 1 << ((1 << factor->width) - 1);
 139         else {
 140                 max = (1 << factor->width);
 141         }
 142
 143         return (max);
 144 }
 145
 146 static inline uint32_t
 147 aw_clk_factor_get_min(struct aw_clk_factor *factor)
 148 {
 149         uint32_t min;
 150
 151         if (factor->flags & AW_CLK_FACTOR_FIXED)
 152                 min = factor->value;
 153         else if (factor->flags & AW_CLK_FACTOR_ZERO_BASED)
 154                 min = 0;
 155         else if (factor->flags & AW_CLK_FACTOR_MIN_VALUE)
 156                 min = factor->min_value;
 157         else
 158                 min = 1;
 159
 160         return (min);
 161 }
 162
 163 static inline uint32_t
 164 aw_clk_factor_get_value(struct aw_clk_factor *factor, uint32_t raw)
 165 {
 166         uint32_t val;
 167
 168         if (factor->flags & AW_CLK_FACTOR_FIXED)
 169                 return (factor->value);
 170
 171         if (factor->flags & AW_CLK_FACTOR_ZERO_BASED)
 172                 val = raw;
 173         else if (factor->flags & AW_CLK_FACTOR_POWER_OF_TWO) {
 174                 for (val = 0; raw != 1; val++)
 175                         raw >>= 1;
 176         } else if (factor->flags & AW_CLK_FACTOR_MAX_VALUE)
 177                 val = factor->max_value;
 178         else
 179                 val = raw - 1;
 180
 181         return (val);
 182 }
 183
 184 #define CCU_RESET(idx, o, s)    \
 185         [idx] = {               \
 186                 .offset = o,    \
 187                 .shift = s,     \
 188         },
 189
 190 #define CCU_GATE(idx, clkname, pname, o, s)     \
 191         [idx] = {                               \
 192                 .name = clkname,                \
 193                 .parent_name = pname,           \
 194                 .offset = o,                    \
 195                 .shift = s,                     \
 196         },
 197
 198 #define NKMP_CLK(_clkname, _id, _name, _pnames,         \
 199   _offset,                                              \
 200   _n_shift, _n_width, _n_value, _n_flags,               \
 201   _k_shift, _k_width, _k_value, _k_flags,               \
 202   _m_shift, _m_width, _m_value, _m_flags,               \
 203   _p_shift, _p_width, _p_value, _p_flags,               \
 204   _gate,                                                \
 205   _lock, _lock_retries,                                 \
 206   _flags)                                               \
 207         static struct aw_clk_nkmp_def _clkname = {      \
 208                 .clkdef = {                             \
 209                         .id = _id,                      \
 210                         .name = _name,                  \
 211                         .parent_names = _pnames,        \
 212                         .parent_cnt = nitems(_pnames),  \
 213                 },                                      \
 214                 .offset = _offset,                      \
 215                 .n.shift = _n_shift,                    \
 216                 .n.width = _n_width,                    \
 217                 .n.value = _n_value,                    \
 218                 .n.flags = _n_flags,                    \
 219                 .k.shift = _k_shift,                    \
 220                 .k.width = _k_width,                    \
 221                 .k.value = _k_value,                    \
 222                 .k.flags = _k_flags,                    \
 223                 .m.shift = _m_shift,                    \
 224                 .m.width = _m_width,                    \
 225                 .m.value = _m_value,                    \
 226                 .m.flags = _m_flags,                    \
 227                 .p.shift = _p_shift,                    \
 228                 .p.width = _p_width,                    \
 229                 .p.value = _p_value,                    \
 230                 .p.flags = _p_flags,                    \
 231                 .gate_shift = _gate,                    \
 232                 .lock_shift = _lock,                    \
 233                 .lock_retries = _lock_retries,          \
 234                 .flags = _flags,                        \
 235         }
 236
 237 #define NKMP_CLK_WITH_MUX(_clkname,                     \
 238   _id, _name, _pnames,                                  \
 239   _offset,                                              \
 240   _n_shift, _n_width, _n_value, _n_flags,               \
 241   _k_shift, _k_width, _k_value, _k_flags,               \
 242   _m_shift, _m_width, _m_value, _m_flags,               \
 243   _p_shift, _p_width, _p_value, _p_flags,               \
 244   _mux_shift, _mux_width, _gate,                        \
 245   _lock, _lock_retries,                                 \
 246   _flags)                                               \
 247         static struct aw_clk_nkmp_def _clkname = {      \
 248                 .clkdef = {                             \
 249                         .id = _id,                      \
 250                         .name = _name,                  \
 251                         .parent_names = _pnames,        \
 252                         .parent_cnt = nitems(_pnames),  \
 253                 },                                      \
 254                 .offset = _offset,                      \
 255                 .n.shift = _n_shift,                    \
 256                 .n.width = _n_width,                    \
 257                 .n.value = _n_value,                    \
 258                 .n.flags = _n_flags,                    \
 259                 .k.shift = _k_shift,                    \
 260                 .k.width = _k_width,                    \
 261                 .k.value = _k_value,                    \
 262                 .k.flags = _k_flags,                    \
 263                 .m.shift = _m_shift,                    \
 264                 .m.width = _m_width,                    \
 265                 .m.value = _m_value,                    \
 266                 .m.flags = _m_flags,                    \
 267                 .p.shift = _p_shift,                    \
 268                 .p.width = _p_width,                    \
 269                 .p.value = _p_value,                    \
 270                 .p.flags = _p_flags,                    \
 271                 .mux_shift = _mux_shift,                \
 272                 .mux_width = _mux_width,                \
 273                 .gate_shift = _gate,                    \
 274                 .lock_shift = _lock,                    \
 275                 .lock_retries = _lock_retries,          \
 276                 .flags = _flags,                        \
 277         }
 278
 279 #define NKMP_CLK_WITH_UPDATE(_clkname,                  \
 280   _id, _name, _pnames,                                  \
 281   _offset,                                              \
 282   _n_shift, _n_width, _n_value, _n_flags,               \
 283   _k_shift, _k_width, _k_value, _k_flags,               \
 284   _m_shift, _m_width, _m_value, _m_flags,               \
 285   _p_shift, _p_width, _p_value, _p_flags,               \
 286   _gate,                                                \
 287   _lock, _lock_retries,                                 \
 288   _update,                                              \
 289   _flags)                                               \
 290         static struct aw_clk_nkmp_def _clkname = {      \
 291                 .clkdef = {                             \
 292                         .id = _id,                      \
 293                         .name = _name,                  \
 294                         .parent_names = _pnames,        \
 295                         .parent_cnt = nitems(_pnames),  \
 296                 },                                      \
 297                 .offset = _offset,                      \
 298                 .n.shift = _n_shift,                    \
 299                 .n.width = _n_width,                    \
 300                 .n.value = _n_value,                    \
 301                 .n.flags = _n_flags,                    \
 302                 .k.shift = _k_shift,                    \
 303                 .k.width = _k_width,                    \
 304                 .k.value = _k_value,                    \
 305                 .k.flags = _k_flags,                    \
 306                 .m.shift = _m_shift,                    \
 307                 .m.width = _m_width,                    \
 308                 .m.value = _m_value,                    \
 309                 .m.flags = _m_flags,                    \
 310                 .p.shift = _p_shift,                    \
 311                 .p.width = _p_width,                    \
 312                 .p.value = _p_value,                    \
 313                 .p.flags = _p_flags,                    \
 314                 .gate_shift = _gate,                    \
 315                 .lock_shift = _lock,                    \
 316                 .lock_retries = _lock_retries,          \
 317                 .update_shift = _update,                \
 318                 .flags = _flags | AW_CLK_HAS_UPDATE,    \
 319         }
 320
 321 #define FRAC_CLK(_clkname, _id, _name, _pnames, \
 322      _offset,                                           \
 323      _nshift, _nwidth, _nvalue, _nflags,                \
 324      _mshift, _mwidth, _mvalue, _mflags,                \
 325      _gate_shift, _lock_shift,_lock_retries,            \
 326     _flags, _freq0, _freq1, _mode_sel, _freq_sel,       \
 327     _min_freq, _max_freq)                               \
 328         static struct aw_clk_frac_def _clkname = {      \
 329                 .clkdef = {                             \
 330                         .id = _id,                      \
 331                         .name = _name,                  \
 332                         .parent_names = _pnames,        \
 333                         .parent_cnt = nitems(_pnames),  \
 334                         .flags = CLK_NODE_GLITCH_FREE,  \
 335                 },                                      \
 336                 .offset = _offset,                      \
 337                 .n.shift = _nshift,                     \
 338                 .n.width = _nwidth,                     \
 339                 .n.value = _nvalue,                     \
 340                 .n.flags = _nflags,                     \
 341                 .m.shift = _mshift,                     \
 342                 .m.width = _mwidth,                     \
 343                 .m.value = _mvalue,                     \
 344                 .m.flags = _mflags,                     \
 345                 .gate_shift = _gate_shift,              \
 346                 .lock_shift = _lock_shift,              \
 347                 .lock_retries = _lock_retries,          \
 348                 .flags = _flags,                        \
 349                 .frac.freq0 = _freq0,                   \
 350                 .frac.freq1 = _freq1,                   \
 351                 .frac.mode_sel = _mode_sel,             \
 352                 .frac.freq_sel = _freq_sel,             \
 353                 .min_freq = _min_freq,                  \
 354                 .max_freq = _max_freq,                  \
 355         }
 356
 357 #define M_CLK(_clkname, _id, _name, _pnames,            \
 358      _offset,                                           \
 359      _mshift, _mwidth, _mvalue, _mflags,                \
 360     _mux_shift, _mux_width,                             \
 361     _gate_shift,                                        \
 362     _flags)                                             \
 363         static struct aw_clk_m_def _clkname =   {       \
 364                 .clkdef = {                             \
 365                         .id = _id,                      \
 366                         .name = _name,                  \
 367                         .parent_names = _pnames,        \
 368                         .parent_cnt = nitems(_pnames),  \
 369                 },                                      \
 370                 .offset = _offset,                      \
 371                 .mux_shift = _mux_shift,                \
 372                 .m.shift = _mshift,                     \
 373                 .m.width = _mwidth,                     \
 374                 .m.value = _mvalue,                     \
 375                 .m.flags = _mflags,                     \
 376                 .mux_width = _mux_width,                \
 377                 .gate_shift = _gate_shift,              \
 378                 .flags = _flags,                        \
 379         }
 380
 381 #define NM_CLK(_clkname, _id, _name, _pnames,           \
 382      _offset,                                           \
 383      _nshift, _nwidth, _nvalue, _nflags,                \
 384      _mshift, _mwidth, _mvalue, _mflags,                \
 385     _mux_shift, _mux_width,                             \
 386     _gate_shift,                                        \
 387     _flags)                                             \
 388         static struct aw_clk_nm_def _clkname =  {       \
 389                 .clkdef = {                             \
 390                         .id = _id,                      \
 391                         .name = _name,                  \
 392                         .parent_names = _pnames,        \
 393                         .parent_cnt = nitems(_pnames),  \
 394                 },                                      \
 395                 .offset = _offset,                      \
 396                 .n.shift = _nshift,                     \
 397                 .n.width = _nwidth,                     \
 398                 .n.value = _nvalue,                     \
 399                 .n.flags = _nflags,                     \
 400                 .mux_shift = _mux_shift,                \
 401                 .m.shift = _mshift,                     \
 402                 .m.width = _mwidth,                     \
 403                 .m.value = _mvalue,                     \
 404                 .m.flags = _mflags,                     \
 405                 .mux_width = _mux_width,                \
 406                 .gate_shift = _gate_shift,              \
 407                 .flags = _flags,                        \
 408         }
 409
 410 #define NMM_CLK(_clkname, _id, _name, _pnames,          \
 411      _offset,                                           \
 412      _nshift, _nwidth, _nvalue, _nflags,                \
 413     _m0shift, _m0width, _m0value, _m0flags,             \
 414     _m1shift, _m1width, _m1value, _m1flags,             \
 415     _gate_shift,                                        \
 416     _lock, _lock_retries,                               \
 417     _flags)                                             \
 418         static struct aw_clk_nmm_def _clkname = {       \
 419                 .clkdef = {                             \
 420                         .id = _id,                      \
 421                         .name = _name,                  \
 422                         .parent_names = _pnames,        \
 423                         .parent_cnt = nitems(_pnames),  \
 424                 },                                      \
 425                 .offset = _offset,                      \
 426                 .n.shift = _nshift,                     \
 427                 .n.width = _nwidth,                     \
 428                 .n.value = _nvalue,                     \
 429                 .n.flags = _nflags,                     \
 430                 .m0.shift = _m0shift,                   \
 431                 .m0.width = _m0width,                   \
 432                 .m0.value = _m0value,                   \
 433                 .m0.flags = _m0flags,                   \
 434                 .m1.shift = _m1shift,                   \
 435                 .m1.width = _m1width,                   \
 436                 .m1.value = _m1value,                   \
 437                 .m1.flags = _m1flags,                   \
 438                 .gate_shift = _gate_shift,              \
 439                 .lock_shift = _lock,                    \
 440                 .lock_retries = _lock_retries,          \
 441                 .flags = _flags,                        \
 442         }
 443
 444 #define NP_CLK(_clkname, _id, _name, _pnames,           \
 445      _offset,                                           \
 446      _nshift, _nwidth, _nvalue, _nflags,                \
 447      _pshift, _pwidth, _pvalue, _pflags,                \
 448     _gate_shift,                                        \
 449     _lock, _lock_retries,                               \
 450     _flags)                                             \
 451         static struct aw_clk_np_def _clkname =  {       \
 452                 .clkdef = {                             \
 453                         .id = _id,                      \
 454                         .name = _name,                  \
 455                         .parent_names = _pnames,        \
 456                         .parent_cnt = nitems(_pnames),  \
 457                 },                                      \
 458                 .offset = _offset,                      \
 459                 .n.shift = _nshift,                     \
 460                 .n.width = _nwidth,                     \
 461                 .n.value = _nvalue,                     \
 462                 .n.flags = _nflags,                     \
 463                 .p.shift = _pshift,                     \
 464                 .p.width = _pwidth,                     \
 465                 .p.value = _pvalue,                     \
 466                 .p.flags = _pflags,                     \
 467                 .gate_shift = _gate_shift,              \
 468                 .lock_shift = _lock,                    \
 469                 .lock_retries = _lock_retries,          \
 470                 .flags = _flags,                        \
 471         }
 472
 473 #define PREDIV_CLK(_clkname, _id, _name, _pnames,       \
 474   _offset,      \
 475   _mux_shift, _mux_width,       \
 476   _div_shift, _div_width, _div_value, _div_flags,       \
 477   _prediv_shift, _prediv_width, _prediv_value, _prediv_flags,   \
 478   _prediv_cond_shift, _prediv_cond_width, _prediv_cond_value)   \
 479         static struct aw_clk_prediv_mux_def _clkname = {        \
 480                 .clkdef = {                                     \
 481                         .id = _id,                              \
 482                         .name = _name,                          \
 483                         .parent_names = _pnames,                \
 484                         .parent_cnt = nitems(_pnames),          \
 485                 },                                              \
 486                 .offset = _offset,                              \
 487                 .mux_shift = _mux_shift,                        \
 488                 .mux_width = _mux_width,                        \
 489                 .div.shift = _div_shift,                        \
 490                 .div.width = _div_width,                        \
 491                 .div.value = _div_value,                        \
 492                 .div.flags = _div_flags,                        \
 493                 .prediv.shift = _prediv_shift,                  \
 494                 .prediv.width = _prediv_width,                  \
 495                 .prediv.value = _prediv_value,                  \
 496                 .prediv.flags = _prediv_flags,                  \
 497                 .prediv.cond_shift = _prediv_cond_shift,        \
 498                 .prediv.cond_width = _prediv_cond_width,        \
 499                 .prediv.cond_value = _prediv_cond_value,        \
 500         }
 501
 502 #define PREDIV_CLK_WITH_MASK(_clkname, _id, _name, _pnames,     \
 503   _offset,                                                      \
 504   _mux_shift, _mux_width,                                       \
 505   _div_shift, _div_width, _div_value, _div_flags,               \
 506   _prediv_shift, _prediv_width, _prediv_value, _prediv_flags,   \
 507   _prediv_cond_mask, _prediv_cond_value)                        \
 508         static struct aw_clk_prediv_mux_def _clkname = {        \
 509                 .clkdef = {                                     \
 510                         .id = _id,                              \
 511                         .name = _name,                          \
 512                         .parent_names = _pnames,                \
 513                         .parent_cnt = nitems(_pnames),          \
 514                 },                                              \
 515                 .offset = _offset,                              \
 516                 .mux_shift = _mux_shift,                        \
 517                 .mux_width = _mux_width,                        \
 518                 .div.shift = _div_shift,                        \
 519                 .div.width = _div_width,                        \
 520                 .div.value = _div_value,                        \
 521                 .div.flags = _div_flags,                        \
 522                 .prediv.shift = _prediv_shift,                  \
 523                 .prediv.width = _prediv_width,                  \
 524                 .prediv.value = _prediv_value,                  \
 525                 .prediv.flags = _prediv_flags,                  \
 526                 .prediv.cond_shift = 0,                         \
 527                 .prediv.cond_width = 0,                         \
 528                 .prediv.cond_mask = _prediv_cond_mask,          \
 529                 .prediv.cond_value = _prediv_cond_value,        \
 530         }
 531
 532 #define MIPI_CLK(_clkname, _id, _name, _pnames,                 \
 533         _offset,                                                \
 534         _kshift, _kwidth, _kflags, _kmin,                       \
 535         _mshift, _mwidth,                               \
 536         _nshift, _nwidth,                               \
 537         _gate_shift, _lock_shift)                               \
 538         static struct aw_clk_mipi_def _clkname = {              \
 539                 .clkdef = {                                     \
 540                         .id = _id,                              \
 541                         .name = _name,                          \
 542                         .parent_names = _pnames,                \
 543                         .parent_cnt = nitems(_pnames)           \
 544                 },                                              \
 545                 .offset = _offset,                              \
 546                 .k.shift = _kshift,                             \
 547                 .k.width = _kwidth,                             \
 548                 .k.flags = _kflags,                             \
 549                 .k.min_value = _kmin,                           \
 550                 .m.shift = _mshift,                             \
 551                 .m.width = _mwidth,                             \
 552                 .n.shift = _nshift,                             \
 553                 .n.width = _nwidth,                             \
 554                 .gate_shift = _gate_shift,                      \
 555                 .lock_shift = _lock_shift,                      \
 556                 }
 557
 558 #define MUX_CLK(_clkname, _id, _name, _pnames,          \
 559   _offset,  _shift,  _width)                            \
 560         static struct clk_mux_def _clkname = {  \
 561                 .clkdef = {                             \
 562                         .id = _id,                      \
 563                         .name = _name,                  \
 564                         .parent_names = _pnames,        \
 565                         .parent_cnt = nitems(_pnames)   \
 566                 },                                      \
 567                 .offset = _offset,                      \
 568                 .shift = _shift,                        \
 569                 .width = _width,                        \
 570         }
 571
 572 #define DIV_CLK(_clkname, _id, _name, _pnames,          \
 573   _offset,                                              \
 574   _i_shift, _i_width,                                   \
 575   _div_flags, _div_table)                               \
 576         static struct clk_div_def _clkname = {          \
 577                 .clkdef = {                             \
 578                         .id = _id,                      \
 579                         .name = _name,                  \
 580                         .parent_names = _pnames,        \
 581                         .parent_cnt = nitems(_pnames)   \
 582                 },                                      \
 583                 .offset = _offset,                      \
 584                 .i_shift = _i_shift,                    \
 585                 .i_width = _i_width,                    \
 586                 .div_flags = _div_flags,                \
 587                 .div_table = _div_table,                \
 588         }
 589
 590 #define FIXED_CLK(_clkname, _id, _name, _pnames,        \
 591   _freq, _mult, _div, _flags)                           \
 592         static struct clk_fixed_def _clkname = {        \
 593                 .clkdef = {                             \
 594                         .id = _id,                      \
 595                         .name = _name,                  \
 596                         .parent_names = _pnames,        \
 597                         .parent_cnt = 1,                \
 598                 },                                      \
 599                 .freq = _freq,                          \
 600                 .mult = _mult,                          \
 601                 .div = _div,                            \
 602                 .fixed_flags = _flags,                  \
 603         }
 604
 605 #endif /* __AW_CLK_H__ */