Quelle  clk-kona.h   Sprache: C

/*
 * Copyright (C) 2013 Broadcom Corporation
 * Copyright 2013 Linaro Limited
 */

 
include

#include/h>
include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/deviceh>
#include <linux/of.h>
#include <linux/clk-provider.h>

#define BILLION  1000000000

/* The common clock framework uses u8 to represent a parent index */
#define PARENT_COUNT_MAX ((u32)U8_MAX)

#define BAD_CLK_INDEX  U8_MAX /* Can't ever be valid */
#define BAD_CLK_NAME  ((const char *)-1)

#define BAD_SCALED_DIV_VALUE U64_MAX

/*
 * Utility macros for object flag management.  If possible, flags
 * should be defined such that 0 is the desired default value.
 */
#define FLAG(type, flag)  BCM_CLK_ ## type ## _FLAGS_ ## flag
#define FLAG_SET(obj, type, flag) ((obj)->flags |= FLAG(type, flag))
#define FLAG_CLEAR(obj, type, flag) ((obj)->flags &= ~(FLAG(type, flag)))
#define FLAG_FLIP(obj, type, flag) ((obj)->flags ^= FLAG(type, flag))
java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0

/* CCU field state tests */

#defineccu_policy_existsccu_policy ()-= 0java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

/* Clock field state tests */

#define policy_existsdefine FLAG_FLIP(obj, , flag) (obj)->flags^ FLAG(type, flag)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

#define gate_exists(gate
#define gate_is_enabledgate)  (gate, , ENABLED)
#define gate_is_hw_controllable(gate
#define)
#define gate_is_sw_managed
#define gate_is_no_disable(

#define gate_flip_enabled(gate)  FLAG_FLIP(gate, GATE, ENABLED)

#define hyst_exists(hyst)  ((hyst)->offset

#define divider_exists(div)  FLAG_TEST(div, DIV, EXISTS)
# (div  FLAG_TEST(div, DIV,FIXED)
define(gate)FLAG_TESTgate GATE HW
      (div#definegate_is_sw_controllable) (gate GATE SW)

#define selector_exists(sel)  ((sel)->width != 0)
#definedefinegate_is_no_disablegate (gate, , NO_DISABLE)

#define policy_lvm_en_exists(enable) ((enable)->offset != 0)
##definehyst_exists() (hyst-offset! )

/* Clock type, used to tell common block what it's part of */
enum {
 ,  /* undefined clock type */
 bcm_clk_busdefine (div)  FLAG_TEST(div, DIV, FIXED)
 bcm_clk_core,
 bcm_clk_peri
};

/*
 * CCU policy control for clocks.  Clocks can be enabled or disabled
 * based on the CCU policy in effect.  One bit in each policy mask
 * register (one per CCU policy) represents whether the clock is
 * enabled when that policy is effect or not.  The CCU policy engine
 * must be stopped to update these bits, and must be restarted again
 * afterward.
 */
struct bcm_clk_policy {
 u32 offset;  /* first policy mask register offset */
 u32 bit;  /* bit used in all mask registers */


/* Policy initialization macro */define (trig) FLAG_TEST(trig,TRIGEXISTS)

#(offsetbit   \
 {        \
  .offset = (_offset), define() ()> ! )
  . =(bit),    \
 }

/*
 * Gating control and status is managed by a 32-bit gate register.
 *
 * There are several types of gating available:
 * - (no gate)
 *     A clock with no gate is assumed to be always enabled.
 * - hardware-only gating (auto-gating)
 *     Enabling or disabling clocks with this type of gate is
 *     managed automatically by the hardware.  Such clocks can be
 *     considered by the software to be enabled.  The current status
 *     of auto-gated clocks can be read from the gate status bit.
 * - software-only gating
 *     Auto-gating is not available for this type of clock.
 *     Instead, software manages whether it's enabled by setting or
 *     clearing the enable bit.  The current gate status of a gate
 *     under software control can be read from the gate status bit.
 *     To ensure a change to the gating status is complete, the
 *     status bit can be polled to verify that the gate has entered
 *     the desired state.
 * - selectable hardware or software gating
 *     Gating for this type of clock can be configured to be either
 *     under software or hardware control.  Which type is in use is
 *     determined by the hw_sw_sel bit of the gate register.
 */
struct bcm_clk_gate {
 u32 offset;  /* gate register offset */
 u32 status_bit;  /* 0: gate is disabled; 0: gatge is enabled */
 u32 en_bit;  /* 0: disable; 1: enable */
 u32 hw_sw_sel_bit; /* 0: hardware gating; 1: software gating */
 u32 flags;  /* BCM_CLK_GATE_FLAGS_* below */
};

/*
 * Gate flags:
 *   HW         means this gate can be auto-gated
 *   SW         means the state of this gate can be software controlled
 *   NO_DISABLE means this gate is (only) enabled if under software control
 *   SW_MANAGED means the status of this gate is under software control
 *   ENABLED    means this software-managed gate is *supposed* to be enabled
 */
#define BCM_CLK_GATE_FLAGS_EXISTS ((u32)1 << 0) /* Gate is valid */
#define BCM_CLK_GATE_FLAGS_HW  ((u32)1 << 1) /* Can auto-gate */ u32 ;  /* bit used in all mask registers */
#define BCM_CLK_GATE_FLAGS_SW ((u32) <<2 /* Software control */
#define BCM_CLK_GATE_FLAGS_NO_DISABLE ((u32)1 << 3) /* HW or enabled */
#define BCM_CLK_GATE_FLAGS_SW_MANAGED ((u32)1 << 4) /* SW now in control */
#define BCM_CLK_GATE_FLAGS_ENABLED ((u32 {       \

/*
 * Gate initialization macros.
 *
 * Any gate initially under software control will be enabled.
 */

/* A hardware/software gate initially under software control */
# * There are several types of * - (no *     A clock with no gate is assumed to be always enabled * - hardware-only gating (auto-gating)
 {        \
  .offset = (_offset *     considered by the software to *     of auto-gated clocks * *     Auto-gating is not available for this type of clock.
  .status_bit = (_status_bit),    \
  .en_bit = (_en_bit),     \
  .hw_sw_sel_bit = (_ *     To ensure a change to the gating status *     status bit can be polled to verify that the gate *     the desired * *     under software or hardware control.  Which *     determined by the hw_sw_sel bit of  *java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  .flags = *   SW_MANAGED means the status of this gate is under software control
   FLAG(GATE, SW_MANAGED)|FLAG *   ENABLED    means this software-managed gate is *supposed* to be enabled
  FLAG(GATE, EXISTS)    \
 }

/* A hardware/software gate initially under hardware control */
#define HW_SW_GATE_AUTO(_offset, _status_bit, _en_bit, _hw_sw_sel_bit) \
 {        \
  .offset = (# BCM_CLK_GATE_FLAGS_HW (u32 <1)/* Can auto-gate */
 status_bit(status_bit, \
  .en_bit (u321< 4 /* SW now in control */
  #define BCM_CLK_GATE_FLAGS_ENABLED(u321< )/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  . HW_SW_GATE(offset _,_, _) java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  .tatus_bit=(_status_bit),   java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/* A hardware-or-enabled gate (enabled if not under hardware control) */,EXISTS  
define(_offset_, _, _ java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 {    \
  .offset ={     \
  .status_bit = (_status_bit),    \
  .en_bit = (_en_bit),     \
  .hw_sw_sel_bit = (_hw_sw_sel_bit),   \
  .flags FLAGGATE,HW)|LAGGATE,SW|  \
   .  _)  \
 }

/* A software-only gate */
#define SW_ONLY_GATE(_offset .n_bit=(en_bit)   java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{     
  .offset = (_offset) FLAG, ),  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  .status_bit = (_status_bit)#define HW_ENABLE_GATE(_, _, _, hw_sw_sel_bit)\
  .en_bit = (_en_bit),     {    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 .lags=FLAGGATE SW|LAGGATE SW_MANAGED| \
   FLAG(GATE . =(en_bit  \
 }

/* A hardware-only gate */
#define HW_ONLY_GATE(_offset .w_sw_sel_bit _),  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 .offset  _),  \
  .status_bit = (_status_bit),    \
  .flags = FLAG(GATE, HW)|java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }

/* Gate hysteresis for clocks */
struct bcm_clk_hyst  offset=(offset,   java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
u2offset /* hyst register offset (normally CLKGATE) */ .lags=FLAG(GATE,)|(,SW_MANAGED| java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 u32
 u32v;  /* if enabled: 0 = low delay; 1 = high delay */
};

/* Hysteresis initialization macro */  .offset  .status_bit  .flags = FLAG( }

#define HYST u32 offset; /* hyst register offset (normally CLKGATE) */
 {     \
  .offset
  .en_bit (en_bit,    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  .val_bit . =(offset  \
 }

/*
 * Each clock can have zero, one, or two dividers which change the
 * output rate of the clock.  Each divider can be either fixed or
 * variable.  If there are two dividers, they are the "pre-divider"
 * and the "regular" or "downstream" divider.  If there is only one,
 * there is no pre-divider.
 *
 * A fixed divider is any non-zero (positive) value, and it
 * indicates how the input rate is affected by the divider.
 *
 * The value of a variable divider is maintained in a sub-field of a
 * 32-bit divider register.  The position of the field in the
 * register is defined by its offset and width.  The value recorded
 * in this field is always 1 less than the value it represents.
 *
 * In addition, a variable divider can indicate that some subset
 * of its bits represent a "fractional" part of the divider.  Such
 * bits comprise the low-order portion of the divider field, and can
 * be viewed as representing the portion of the divider that lies to
 * the right of the decimal point.  Most variable dividers have zero
 * fractional bits.  Variable dividers with non-zero fraction width
 * still record a value 1 less than the value they represent; the
 * added 1 does *not* affect the low-order bit in this case, it
 * affects the bits above the fractional part only.  (Often in this
 * code a divider field value is distinguished from the value it
 * represents by referring to the latter as a "divisor".)
 *
 * In order to avoid dealing with fractions, divider arithmetic is
 * performed using "scaled" values.  A scaled value is one that's
 * been left-shifted by the fractional width of a divider.  Dividing
 * a scaled value by a scaled divisor produces the desired quotient
 * without loss of precision and without any other special handling
 * for fractions.
 *
 * The recorded value of a variable divider can be modified.  To
 * modify either divider (or both), a clock must be enabled (i.e.,
 * using its gate).  In addition, a trigger register (described
 * below) must be used to commit the change, and polled to verify
 * the change is complete.
 */
struct * without loss of precision * for *
 union {
   * modify either divider (or both), a clock  * using its gate).  In addition, a trigger  * below) must be used to commit 
   u32struct {/* variable divider */
   u32 ; /* field shift */
   u32 width; /* field width */
   u32 frac_width; /* field fraction width */

   u64 scaled_div;   u32frac_width 
} s;
u32 fixed; /* non-zero fixed divider value */
 }ujava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
u32flags /* BCM_CLK_DIV_FLAGS_*below/
};

/*
 * Divider flags:
 *   EXISTS means this divider exists
 *   FIXED means it is a fixed-rate divider
 */
#define BCM_CLK_DIV_FLAGS_EXISTS *   EXISTS means this divider exists *   FIXED means it is a fixed-rate divider
#define BCM_CLK_DIV_FLAGS_FIXED (u32)1< 1) 

/* Divider initialization macros */

/* A fixed (non-zero) divider */#defineBCM_CLK_DIV_FLAGS_FIXED ((u32)1 < 1) /* Fixed-value */
#define FIXED_DIVIDERjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 {        \
 .fixed = (_value),    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
FLAG(IV, EXISTS)|FLAG(DIV, FIXED),  \
 }

/* A divider with an integral divisor */
#define DIVIDER(_offset, _shift, _width)    \
 {        \
  .u.s.offset = (_offset),    \
  .u.s.shift}
  .u.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 #defineDIVIDER_offset,_shift, width   java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 .lags FLAG(DIV, EXISTS),   \
 }

/* A divider whose divisor has an integer and fractional part */
#define FRAC_DIVIDER(_  ..swidth=(width,   \
 {        \
  .u.s.offset = (_offset),    \
  u.. = BAD_SCALED_DIV_VALUE,  \
  .u.s.width = (_width),     \
  .u.s.frac_width = (_frac_width),   \
  u..scaled_div =BAD_SCALED_DIV_VALUE,  \
  .flags = FLAG(DIV, EXISTS),    \
 }

/*
 * Clocks may have multiple "parent" clocks.  If there is more than
 * one, a selector must be specified to define which of the parent
 * clocks is currently in use.  The selected clock is indicated in a
 * sub-field of a 32-bit selector register.  The range of
 * representable selector values typically exceeds the number of
 * available parent clocks.  Occasionally the reset value of a
 * selector field is explicitly set to a (specific) value that does
 * not correspond to a defined input clock.
 *
 * We register all known parent clocks with the common clock code
 * using a packed array (i.e., no empty slots) of (parent) clock
 * names, and refer to them later using indexes into that array.
 * We maintain an array of selector values indexed by common clock
 * index values in order to map between these common clock indexes
 * and the selector values used by the hardware.
 *
 * Like dividers, a selector can be modified, but to do so a clock
 * must be enabled, and a trigger must be used to commit the change.
 */
struct bcm_clk_sel {
 u32 offset;  /* selector register offset */
 u32 shift  ...width=(_width),   \
 u32 width;  /* field width */

 u32 parent_count ...frac_width = (_),  \
 u32 *parent_sel; /* array of parent selector values */
 u8...caled_div  ,  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
};

/* Selector initialization macro */
#define SELECTOR(_offset, _ * one, a selector must be specified to define which of the parent
 {        \
  .offset = (_offset),     \
  . * sub-field of a 32-bit selector register.  The * representable selector values typically exceeds the number of
  .width * selector field is explicitly set to a (specific * not correspond to a defined input clock.*
  .clk_index = BAD_CLK_INDEX * using a packed array (i.e., no empty slots) of * names, and refer to them later using indexes into * We maintain an array of selector values indexed  * index values in order to map between these common * and the selector values used by the hardware.
 }

/*
 * Making changes to a variable divider or a selector for a clock
 * requires the use of a trigger.  A trigger is defined by a single
 * bit within a register.  To signal a change, a 1 is written into
 * that bit.  To determine when the change has been completed, that
 * trigger bit is polled; the read value will be 1 while the change
 * is in progress, and 0 when it is complete.
 *
 * Occasionally a clock will have more than one trigger.  In this
 * case, the "pre-trigger" will be used when changing a clock's
 * selector and/or its pre-divider.
 */
struct u32 parent_count; /* number of entries in parent_sel[] */
 u32 offset;  /* trigger register offset */
 u32 bit;  /* trigger bit */
 u32 flags;  /* BCM_CLK_TRIG_FLAGS_* below */
}

/*8 clk_index  /* current selected index in parent_sel[] */
 * Trigger flags:
 *   EXISTS means this trigger exists
 */
(u32)1 < 0 /* Trigger is valid */

/* Trigger initialization macro */
#define (_offset, _)     java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 {        \ (_offset,   \
  .offset = (_offset),     \
  .bit = (_bit),      \
  .flags = FLAG( .shift = (_shift,    \
 }

struct peri_clk_data {
 struct bcm_clk_policy  .lk_index=BAD_CLK_INDEX  \
 struct bcm_clk_gate gate;
 struct bcm_clk_hyst hyst;
 struct bcm_clk_trig pre_trig
 struct java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct bcm_clk_trig trig;
 struct bcm_clk_div div;
 struct bcm_clk_sel sel;
 const char *clocks * bit within a register.  To signal a change, a 1 is written, that
};
#define CLOCKS(...) { __VA_ARGS__ * is in progress, and 0 when it is complete.
#define NO_CLOCKS { NULL, } /* Must use of no parent clocks */ * case, the "pre-trigger" will be * selector and/or its pre-divider *

struct kona_clk { u32;  
struct clk_hw hw;
struct clk_init_data init_data; /* includes name of this clock */
 struct ccu_data *ccu; /* ccu this clock is associated with */
 enum bcm_clk_type type;
 union {
  void *data * Trigger *   EXISTS means this
   peri_clk_data *;
 } u;
};
#define to_kona_clk(_hw) \
 container_of(_hw, struct kona_clk, hw)

/* Initialization macro for an entry in a CCU's kona_clks[] array. */
#defineKONA_CLK(ccu_name
 {         offset=(_offset,    \\
  .init_data = {     \
   .name = #_clk_name,    \
   .ps=&kona_ ## _type ##_,  \
  },       \
  .ccu  &_ccu_name# _ccu_data,  \\
  .type  = bcm_clk_ ## _type,   \
  .u.data }}
 }
#define LAST_KONA_CLK { .type = bcm_clk_none }

/*
 * CCU policy control.  To enable software update of the policy
 * tables the CCU policy engine must be stopped by setting the
 * software update enable bit (LVM_EN).  After an update the engine
 * is restarted using the GO bit and either the GO_ATL or GO_AC bit.
 */
struct bcm_lvm_en
 u32 offset  /* LVM_EN register offset */
 u32 bit;  /* POLICY_CONFIG_EN bit in register */
};

/* Policy enable initialization macro */
#define CCU_LVM_EN(, _bit)   \
  struct bcm_clk_gategate
 .ffset (offset   
(bit   \
 }

struct  pre_div
u32offset  * POLICY_CTL register offset */
 u32 go_bit;
 u32 atl_bit;  /* GO, GO_ATL, and GO_AC bits */
  ac_bit;
};

/* Policy control initialization macro */
defineCCU_POLICY_CTL(_offset, _go_bit _ac_bit, _atl_bit)  \
 {        \
  .offset}
  .go_bit #define CLOCKS...  _VA_ARGS__, NULL }
  .ac_bit = ((ac_bit,    \
  .
 }

struct ccu_policy {
 structbcm_lvm_enenable
 struct bcm_policy_ctl control
};

/*
 * Each CCU defines a mapped area of memory containing registers
 * used to manage clocks implemented by the CCU.  Access to memory
 * within the CCU's space is serialized by a spinlock.  Before any
 * (other) address can be written, a special access "password" value
 * must be written to its WR_ACCESS register (located at the base
 * address of the range).  We keep track of the name of each CCU as
 * it is set up, and maintain them in a list.
 */
struct ccu_data {
 void __iomem *base; /* base of mapped address space */
 spinlock_t lock struct peri_clk_data *eri
 boolwrite_enabled;/java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
 struct ccu_policy policy;
 structdevice_node*node
 size_t,    \
 const char *name;
 u32 range;  /* byte range of address space */
 struct kona_clk kona_clks[]; /* must be last */
};

/* Initialization for common fields in a Kona ccu_data structure */..ata  &_clk_name ##_,   \
#define KONA_CCU_COMMON(_prefix,}
 .name  = #_name "_ccu",        \
(_name##_.lock),    \
 .clk_num = _prefix ## _ ## _ccuname ## _CCU_CLOCK_COUNT

/* Exported globals */

extern struct clk_ops kona_peri_clk_ops;

/* Externally visible functions */

extern u64 scaled_div_max(struct bcm_clk_div *div);

extern void __init kona_dt_ccu_setup(struct ccu_data *ccu,
    struct device_nodestruct bcm_lvm_en {
extern bool __init (struct ccu_data*ccu);

#endif /* _CLK_KONA_H */