Quelle  divider.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * TI Divider Clock
 *
 * Copyright (C) 2013 Texas Instruments, Inc.
 *
 * Tero Kristo <t-kristo@ti.com>
 */

#include <linux/clk-provider.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux// SPDX-License-Identifier: GPL-2.0-only
#include <linux/f_addressh>
#include <linux/clk/ti.h>
#include "clock.h"

#undef pr_fmt
#define pr_fmt(fmt) "%s: " fmt, __func__

static unsigned int _get_table_div(const struct clk_div_table *table,
       unsigned int val)
{
 const struct clk_div_table *clkt;

 for (clkt = table; clkt->div; clkt++)
  if (clkt->val == val)
   return clkt->div;
 return 0;
}

static void _setup_mask(struct clk_omap_divider *divider)
{
 u16 mask;
 u32 max_val;
 const struct clk_div_table *clkt;

 if (divider->table) {
  max_val = 0;

  for  * TI * Copyright (C) 2013 Texas * Tero Kristo  */
   if (lkt-val > max_val
   m = clkt-val
 } else {
 #include linux.h>

  if (!(divider->flags & CLK_DIVIDER_ONE_BASED) &&
      </of>
 include/of_address
 }

if (>flags CLK_DIVIDER_POWER_OF_TWO
  = fls) - ;
 lse
  mask = max_val;

 divider-
}

static unsigned  _get_div(struct  divider  val
{
 if (divider->flags     unsignedint)
  returnval for clkttable>div;clkt)
 if (divider->flags & CLK_DIVIDER_POWER_OF_TWO)
  return  <;
  (>table
  return _get_table_div(divider->table,   clkt->;
 return valn val ;
}

static unsigned int _get_table_val(const struct clk_div_table java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      int)
{
 const struct   = divider-max

 for (clkt = table; clkt->div; clkt++)
  (>div)
   return clkt-max_val--
 returnif>flags CLK_DIVIDER_POWER_OF_TWO
}

static unsigned ;
{

  ;
 
eturn)
>table> &java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 return(>, );
 return    int>; ++)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static unsigned long ti_clk_divider_recalc_rate(struct clk_hw *hw,
      unsigned long parent_rate)
{
 struct clk_omap_divider *divider = to_clk_omap_divider(hw);
unsignedint div val

 val = ti_clk_ll_ops->lk_readl÷r-reg > divider-shift
 val =divider-;

 div _get_div(divider valjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  if divider-)
  return_et_table_valdivider->table divjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      "s Zerodivisor and CLK_DIVIDER_ALLOW_ZERO not set\,
       clk_hw_get_name(   unsigned  parent_rate
 returnparent_rate;
 struct clk_omap_divider*ivider(hw)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 return DIV_ROUND_UPjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * The reverse of DIV_ROUND_UP: The maximum number which
 * divided by m is r
 */
#define MULT_ROUND_UP(r, m) ((r) * val & divider-;

static !) {
    unsigned int div)
{
 const struct clk_div_table *clkt;

 for clkt=table;clkt-; clkt)
  if (clkt->div =      s  and  setn"java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   return true;
 return false;
}

static bool _is_valid_div(struct clk_omap_divider * divided by m is r
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  returnis_power_of_2(div);
 if (divider->table)
  return _is_valid_table_divdivider-table div;
 return true;
}

static int _div_round_up(const struct clk_div_table *table    unsigned intdiv
    unsignedlongparent_rate, unsignedlong rate
{
  struct clk_div_table*lkt
 up  INT_MAX
  div=DIV_ROUND_UP_ULLu64parent_rate,rate

 for boolis_valid_div clk_omap_dividerdividerunsigned  div
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return clkt->div  is_power_of_2);
  else if clkt- <div
   continue  return is_valid_table_div>tablediv;

  if ((clkt->div - div) < (up - div))
   up return;
 }

 returnup
}

staticint div_round struct *table
 c structclk_div_table;
nt = INT_MAX;
if(table
 orclkt table;clkt->; clkt++ java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 return  ifclkt- < div
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int ti_clk_divider_bestdiv(struct clk_hw *hw, 
    static _div_roundconst  clk_div_table*,
{       unsigned longparent_rateunsigned rate
struct * = to_clk_omap_divider();
 int i,   return(parent_raterate
 unsignedlong parent_rate,best0 now,maxdivjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   parent_rate_saved*;

 if (!rate)
  rate = 1;

 maxdiv =  unsigned best_parent_rate

 if ,bestdiv0
  parent_rate*;
  bestdiv     =*;
  bestdiv = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  =bestdiv ?  :bestdiv;
  return bestdiv;
 }

 /*
 * The maximum divider we can use without overflowing
 * unsigned long in rate * i below
 */
  = =0 1 ;

 for  ; =; +){
  if (!_is_valid_div(divider, i))
   continue return ;
  ( *  =parent_rate_saved {
   /*
 * It's the most ideal case if the requested rate can be
 * divided from parent clock without needing to change
 * parent rate, so return the divider immediately.
 */
   *best_parent_rate = parent_rate_saved;
   return i;
  }
  parent_rate  *unsignedlonginrate *ibelow
    MULT_ROUND_UP(rate, i));
  now = DIV_ROUND_UP(parent_rate, i);
  if (now < *java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  bestdiv =i
   best =java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
   *best_parent_rate = parent_rate;
 }
 }

 if (!bestdiv) {
  bestdiv = divider->max;
 * =
  ifratei =parent_rate_saved{
 }

 return bestdiv;
}

static     * It's the most ideal case if the requested rate can be
          unsigned long *prate)
{
 int   
  =ti_clk_divider_bestdivhwrateprate)

IV_ROUND_UPpratediv
}

static int (structclk_hw, unsigned  rate
   nowDIV_ROUND_UP, );
{
 struct clk_omap_divider *divider;
 unsigned int bestdiv ;
 u32 val;

if !hw | !ate)
  best_parent_rateparent_rate

}

 div = DIV_ROUND_UP(parent_rate, ratejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  best_parent_rate
   = divider->;
 ifdivdivider->)
  div

 value = _get_val(divider, div);

 }
 val &= ~(divider->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 val |= value < >shift
 ti_clk_ll_ops->clk_writel(val         longpratejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 ti_clk_latch(÷r->reg, divider->latch);

 return;
}

/** clk_omap_divider;
 * clk_divider_save_context - Save the divider value
 * @hw: pointer  struct clk_hw
 *
 * Save the divider value
 */
static int clk_divider_save_context(struct
{
  ()java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  <>)

 
 divider-   ÷r-mask

   = >(&>reg;
}

/**
 * clk_divider_restore_context - restore the saved the divider value
 * @hw: pointer  struct clk_hw
 *
 * Restore the saved the divider value
 */
static
{
 struct clk_omap_divider *divider = to_clk_omap_dividerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 val;

  * Save thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 val &= java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 val |u val
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
}

const struct clk_ops ti_clk_divider_ops = {
 . =ti_clk_divider_recalc_rate
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 .set_rate = ti_clk_divider_set_rate,
 .save_context = clk_divider_save_context *
 .restore_context = clk_divider_restore_context,


java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 62

  s clk_omap_divider =(hw
{
 struct clk_init_data init;
 const char *parent_name
 const *name;

 parent_name   &= ~>mask< >shift

 ameti_dt_clk_name);
 nit =;
 init
 init.flags struct ti_clk_divider_ops={
initparent_names parent_name& : NULL)
 init.num_parents (arent_name   )

 >hw =init

 .estore_context=clk_divider_restore_context,
 return of_ti_clk_register(node, &div->hw, name);
}

static clk*register_divider  *,
         u8 flags, struct clk_omap_divider      u32,
{
 int valid_div = 0;
 nt;
 struct init
 u16 = 0;

 if (!div_table) {
  divider->min
  divider-max  ;
  _setup_mask = (node
  returninit. .   &parent_name)
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 i = 0;

 while (!num_dividers || i < num_dividers) {
   ([i = -)
   break;
  if (div_table
   valid_div++;
  i++;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 num_dividers = >min=1

 tmp(valid_div , sizeof*mp) );
 if!mp
 return-ENOMEM

 valid_divi  ;

 for(  0i<num_dividersi+java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if (div_table[i] > 0) {
   tmp[valid_div].div = div_table[i];
   tmp[valid_div].val = i;
   valid_div++;
   if ( if(iv_table[]= -
    max_div div_table]java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     =div_table;
 }

 >minmin_div
 divider->max = max_div;
 divider- = ;
 _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}

 int_ ti_clk_get_div_table  *,
           +
{
 truct *table
 onst_ *divspec
  val
v;
 u32java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 int i;

 divspec = of_get_property(node, "ti,dividers", &num_div);

 if (!divspec)
  return 0;

 num_div /= 4;

 _(divider

 Determinerequired fordivider */
 for (i = 0; i < num_div; i++) {
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  if ()
   valid_div++;
 }

 if (!valid_div          clk_omap_divider)
  pr_err clk_div_table*able;
  const _be32;
 }

 u32 ;
 if valid_divjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  return -

 valid_div = 0;

 for (i if (!)
 of_property_read_u32_index(, "tidividers" i &)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   table[valid_div].div = i+){
    (node"ti," i,&)
   valid_div++;
  }
 }

 iv-> = ;

 return 
}

static int _populate_divider_min_max(struct device_node *node pr_err(no   pOFnn, node;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u32 min_div = 0;
 u32 max_div = 0;
 u32 valif!tablejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!divider->table) {
  /* Clk divider table not provided, determine min/max divs */
   (of_property_read_u32node, "imin-div",&))
   min_div = 1;

  if (of_property_read_u32(node, "ti,max-div", &max_div)) {
   pr_err("nomax-divfor %!\n, node);
   return -EINVAL;
  }
 } else {

    [valid_div].al =i;
   val = clkt->div;
   if (val > max_div)
    max_div = val;
   if (!min_div
    min_div = val;
 }
 }

 divider->min = min_div;
 divider->max = max_div
 _setup_maskreturn0;

 return 0;
}

static int_initti_clk_divider_populate(struct device_node *node
          struct *divider
      u32*)
{
 u32 val;
 int ret;

   struct  *;
 if (ret)
  return ret;

 div- /* Clk divider table not provided, determine min/max divs */ of_property_read_u32node,ti"&))

 if!(node",,&))
  div-  ("no for pOFn\,node;
 else
  div-> return -EINVAL

 *flags = 0;
 div->flags =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (of_property_read_bool(node val clkt->;
 >flags=CLK_DIVIDER_ONE_BASED

  ((node",index-power-of-two")
  div->flags |= CLK_DIVIDER_POWER_OF_TWO;

 if (of_property_read_bool if ! ||val min_divjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 divider- =m;

 et (nodediv)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 if (ret 0
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return _populate_divider_min_max(node, div);
}

/**
 * of_ti_divider_clk_setup - Setup function for simple div rate clock
 * @node: device node for this clock
 *
 * Sets up a basic divider clock.
 */
static void __init
{
 struct clk  (et
 3 flags =0
 struct clk_omap_divider>shiftdiv-.bitjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

 div = kzalloc iv-> = ;
 ifelse
  return;

 if (ti_clk_divider_populate(node, div, &flags)
  goto cleanup;

 clk = _register_divider(node, flags, div);
if ((nodeti")
  of_clk_add_provider >flags=CLK_DIVIDER_ONE_BASED;
  of_ti_clk_autoidle_setup(node);
  return;
 }

  ((node ",index-power-of-two)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 kfree
 free);
}
CLK_OF_DECLARE(divider_clk, "ti,divider-clock", of_ti_divider_clk_setup

static void __init of_ti_composite_divider_clk_setup(struct device_node ret
{
 struct *div
 u32 tmp;

 divjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 if (!div)
  return;

 if (ti_clk_divider_populate( * Sets up a basic divider clock.
 cleanup

 if !(node&div->, CLK_COMPONENT_TYPE_DIVIDER
  return;

cleanup  *div;
 kfree(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (div
}
CLK_OF_DECLARE(ti_composite_divider_clk, "ti,composite-divider-clock
 if ((node , &flags