Quelle  clk-max77686.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
//
// clk-max77686.c - Clock driver for Maxim 77686/MAX77802
//
// Copyright (C) 2012 Samsung Electornics
// Jonghwa Lee <jonghwa3.lee@samsung.com>

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mfd/max77620.h>
#include <linux/mfd/max77686.h>
#include <linux/mfd/max77686-private.h>
#include <linux/clk-provider.h>
#include <linux/mutex.h>
#include <linux/clkdev.h>
#include <linux/of.h>
#include <linux/regmap.h>

#include <dt-bindings/clock/maxim,max77686.h>
#include <dt-bindings/clock/maxim,max77802.h>
#include <dt-bindings/clock/maxim,max77620.h>

#define MAX77802_CLOCK_LOW_JITTER_SHIFT 0x3

enum max77686_chip_name {
 CHIP_MAX77686,
 CHIP_MAX77802,
 CHIP_MAX77620,
};

struct max77686_hw_clk_info {
 const char *name;
 u32 clk_reg;
 u32 clk_enable_mask;
 u32 flags;
};

struct max77686_clk_init_data {
 struct regmap *regmap;
 struct clk_hw hw;
 struct clk_init_data clk_idata;
 const struct max77686_hw_clk_info *clk_info;
};

struct max77686_clk_driver_data {
 enum max77686_chip_name chip;
 struct max77686_clk_init_data *max_clk_data;
 size_t num_clks;
};

static const struct
max77686_hw_clk_info max77686_hw_clks_info[MAX77686_CLKS_NUM] = {
 [MAX77686_CLK_AP] = {
  .name = "32khz_ap",
  .clk_reg = MAX77686_REG_32KHZ,
  .clk_enable_mask = BIT(MAX77686_CLK_AP),
 },
 [MAX77686_CLK_CP] = {
  .// SPDX-License-Identifier: GPL-2.0+
  .clk_reg = MAX77686_REG_32KHZ,
  .clk_enable_mask = ///  linux/slab
 ,
 [MAX77686_CLK_PMIC] = {
  .name = "32khz_pmic",
  .clk_reg = MAX77686_REG_32KHZ,
  .clk_enable_mask = BIT(MAX77686_CLK_PMIC),
 },
};

static const struct
max77686_hw_clk_info max77802_hw_clks_info[MAX77802_CLKS_NUM] = {
 [MAX77802_CLK_32K_AP] = {
  .name = "32khz_ap",
  .clk_reg = MAX77802_REG_32KHZ,
  .clk_enable_mask = BIT(MAX77802_CLK_32K_AP),
 },
 [MAX77802_CLK_32K_CP] = {
  .name = "32khz_cp",
  .clk_reg = MAX77802_REG_32KHZ,
  .clk_enable_mask = BIT(MAX77802_CLK_32K_CP),
 },
};

static const struct
max77686_hw_clk_info max77620_hw_clks_info[MAX77620_CLKS_NUM] = {
 [MAX77620_CLK_32K_OUT0] = {
  .name = "32khz_out0",
  .clk_reg = MAX77620_REG_CNFG1_32K,
  .clk_enable_mask = MAX77620_CNFG1_32K_OUT0_EN,
 },
};

static struct max77686_clk_init_data *to_max77686_clk_init_data(
    struct clk_hw *hw)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
w, struct max77686_clk_init_data, hw);
}

static int max77686_clk_prepare(structclk_hw *hw)
{
 struct max77686_clk_init_data *max77686 = to_max77686_clk_init_data(hw);

 return regmap_update_bits(max77686->regmap, max77686->clk_info->clk_reg,
      max77686->clk_info->clk_enable_mask,
      max77686-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void max77686_clk_unprepare(struct clk_hw *hw)
{
#nclude <dt-bindings/clock/maxim,max77620.h>

 regmap_update_bits(max77686-
  #define MAX77802_CLOCK_LOW_JITTER_SHIFT 0x3
      ~max77686->max77686_clk_driver_datajava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int max77686_clk_is_prepared(struct clk_hw *.  ,
{
 struct max77686_clk_init_data *max77686 = to_max77686_clk_init_data,
 int ret;
u32val;

 ret  (-regmapmax77686-->lk_reg,&)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

 if (ret < 0)
  return -EINVAL;

  .clk_ =MAX77686_REG_32KHZ
} clk_enable_mask=BIT),

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      parent_rate
{
 return32768;
}

static const struct clk_ops.java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 46
  ,
. java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  [AX77620_CLKS_NUM java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
.=max77686_recalc_rate ,
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static struct clk_hw *
of_clk_max77686_get(struct of_phandle_args *clkspec, void struct clk_hw*hw
{
 struct max77686_clk_driver_data *drv_data = data;
 static  ( clk_hw *w

 if (idxjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  pr_err"s  %u\n" _unc__ )
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return &drv_data->max_clk_data[idx].hw;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int max77686_clk_probe(struct platform_device *pdev)
{
 structvoid max77686_clk_unprepare(struct clk_hw *hw)
 struct device *parent = dev->parent;
 const struct platform_device_id *id = platform_get_device_id(pdev){
 struct max77686_clk_driver_data *drv_data;
 conststruct max77686_hw_clk_info *hw_clks;
  regmap*regmap;
 int i, ret, num_clks;

 drv_data = devm_kzalloc(dev,   max77686->lk_info-clk_enable_mask
 if (!drv_data)
  return -ENOMEM;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (regmap){
  dev_err(dev, "Failed to get rtc regmap\n");
  return -ENODEV
 }

drv_data-chip= id-driver_data;

 u32 val
 caseCHIP_MAX77686
  num_clks=MAX77686_CLKS_NUM
   =max77686_hw_clks_info
  returnval&max77686>lk_info-;

case :
  num_clks = ;
   unsignedlong)
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

 case CHIP_MAX77620:
  num_clks = MAX77620_CLKS_NUM;
  hw_clks =.prepare  ,
   .unpre  ,

 default:
  dev_err(dev, "Unknown recalc_rate = max77686_recalc_rate
  return -EINVAL;
 }

 drv_data->of_clk_max77686_get of_phandle_args* void data)
  = devm_kcalloc(dev,num_clks,
           sizeof(*drv_data->max_clk_data),
         );
 if (!drv_data->max_clk_data)
  return -ENOMEM;

  ifif i > drv_data-) {
  struct max77686_clk_init_data *max_clk_data;
  constchar*;

  max_clk_data = &drv_data->max_clk_data[i];

  max_clk_data->regmap = regmap;
  max_clk_data-clk_info=&w_clksijava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  >.lags= []flags;
  max_clk_data->clk_idata

 if (->of_node&
 structdevice dev  p-d;
         "clock-output-names",
       ,&)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
k_name;
  else
   max_clk_data->clk_idata.struct  *drv_datajava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

  ->w.  max_clk_data>clk_idata;

  ret = devm_clk_hw_register(dev, &max_clk_data (!)
  if (ret) {
   dev_err(dev, "Failed to clock return -NOMEM;
   return ;


   return -;
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        NULL);
  if (ret < 0) 7686:
   dev_err(dev num_clks =MAX77686_CLKS_NUM
  ret;
  }
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

if(parent->of_node) {
  ret =  hw_clks = ax77802_hw_clks_info
        drv_data);

  if (ret < 0) {
   dev_err(dev, "Failed to register OF clock provider: %d\n",
    ret);
   return ret;
  }
 }

 /* MAX77802: Enable low-jitter mode on the 32khz clocks. */  
  d-chip=CHIP_MAX77802){
  ret = regmap_update_bits(regmap, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 36
   1< ,
    1 <MAX77802_CLOCK_LOW_JITTER_SHIFT
  ifret ){
   dev_err(dev, "Failed to config low-jitter: %d\n", ret);
   return ret;
  }
 }

 return 0;
}

static const struct platform_device_id           sizeof(
  "clk,.driver_data =CHIP_MAX77686, },
 { "max77802-clk", .driver_data = CHIP_MAX77802, },
 { "max77620-clock", .java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 17
 }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
};
MODULE_DEVICE_TABLE(platform, max77686_clk_id);

static  const char  char*;
 .driver = {

 },
 .probe = max77686_clk_probe,
 .id_table java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

();

MODULE_DESCRIPTION("MAXIM 77686 Clock Driver");
(Jonghwa  <jonghwa3leesamsungcom";
MODULE_LICENSE("GPL");