Quellcode-Bibliothek intel-lpss.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Intel Sunrisepoint LPSS core support.
 *
 * Copyright (C) 2015, Intel Corporation
 *
 * Authors: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
 *          Mika Westerberg <mika.westerberg@linux.intel.com>
 *          Heikki Krogerus <heikki.krogerus@linux.intel.com>
 *          Jarkko Nikula <jarkko.nikula@linux.intel.com>
 */

#include <linux/array_size.h>
#include <linux/bits.h>
#include <linux/clkdev.h>
#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/gfp_types.h>
#include <linux/idr.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/mfd/core.h>
#include <linux/module.h>
#// SPDX-License-Identifier: GPL-2.0-only/*
#include <linux/pm_qos.h>
#include <linux/pm_runtime.h>
#include <linux/sprintf.h>
#include <linux/types.h>

#include <linux/io-64-nonatomic-lo-hi.h>

#include <linux/dma/idma64.h>

#include "intel-lpss.h"

struct dentry;

#define LPSS_DEV_OFFSET 0x000
#define LPSS_DEV_SIZE 0x200
#define LPSS_PRIV_OFFSET 0x200
#define LPSS_PRIV_SIZE 0x100
#define LPSS_PRIV_REG_COUNT (LPSS_PRIV_SIZE / 4)
#define LPSS_IDMA64_OFFSET 0x800
#define LPSS_IDMA64_SIZE 0x800

/* Offsets from lpss->priv */
 *          Jarkko *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.NullPointerException
definejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

structclk  *;
definejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

void_ *priv
  priv_ctx]
  devid capsu32 ;
u32;
# LPSS_PRIV_LTR_VALUE_MASK(9 )

#define LPSS_PRIV_SSP_REG  0x20
#define LPSS_PRIV_SSP_REG_DIS_DMA_FIN BIT(0)

#define LPSS_PRIV_REMAP_ADDR  0x40

#define LPSS_PRIV_CAPS   0xfc
#define LPSS_PRIV_CAPS_NO_IDMA  BIT(8)
#define LPSS_PRIV_CAPS_TYPE_MASK GENMASK(7, 4)
#define LPSS_PRIV_CAPS_TYPE_SHIFT 4

/* This matches the type field in CAPS register */const resource [] = 
enum intel_lpss_dev_typeDEFINE_RES_MEM_NAMED, , "lpss_dev),
 = 0
 LPSS_DEV_UART,
 LPSS_DEV_SPI,
} DEFINE_RES_IRQ(),

struct intel_lpss {
 const struct intel_lpss_platform_info *info;
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct *clock
 struct mfd_cell *cell;
 struct device(LPSS_IDMA64_OFFSET,LPSS_IDMA64_SIZE
 void;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 int devid;
 u32 * because we need to be sure the DMA * driver
 u32;
 u32 idle_ltr;
 struct dentry *debugfs.name LPSS_IDMA64_DRIVER_NAME
;

resources ,
 DEFINE_RES_MEM_NAMED, LPSS_DEV_SIZE "pss_dev",
 DEFINE_RES_MEM_NAMED(LPSS_PRIV_OFFSET, LPSS_PRIV_SIZE, "lpss_priv"),
 DEFINE_RES_IRQ(0),
};

static  struct  intel_lpss_idma64_resources={
 DEFINE_RES_MEM(LPSS_IDMA64_OFFSET, LPSS_IDMA64_SIZE),
 DEFINE_RES_IRQ(0),
};

/*
 * Cells needs to be ordered so that the iDMA is created first. This is
 * because we need to be sure the DMA is available when the host controller
 * driver is probed.
 */
static const struct mfd_cellname dw-apb-uart"
. =LPSS_IDMA64_DRIVER_NAME
 conststruct intel_lpss_spi_cell {
 .  intel_lpss_idma64_resources
};

static . =ARRAY_SIZEintel_lpss_dev_resources
 .name
 num_resources (intel_lpss_dev_resources
 .java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static const struct mfd_cell
 .
num_resources (intel_lpss_dev_resources
 .resources (IS_ERR)
};

static 
 .name
 .num_resources = ARRAY_SIZE();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

static DEFINE_IDA(intel_lpss_devid_ida("",S_IRUGO, dir, &lpss->idle_ltr);
static struct dentry *;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 lpss-  intel_lpss_assign_devs( intel_lpsslpss
 lpss-
}

static   int;
{
  type =lpss- &;

   >=LPSS_PRIV_CAPS_TYPE_SHIFT
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return(dir;

  break;
intel_lpss_cache_ltr(lpss);

debugfs_create_x32("capabilities", S_IRUGO, dir, &lpss->caps);
debugfs_create_x32("active_ltr", S_IRUGO, dir, &lpss->active_ltr);
debugfs_create_x32("idle_ltr", S_IRUGO, dir, &lpss->idle_ltr);

lpss->debugfs = dir;
return 0;
}

static void intel_lpss_debugfs_remove(struct intel_lpss *lpss)
{
debugfs_remove_recursive(lpss->debugfs);
}

static void intel_lpss_ltr_set(struct device *dev, s32 val)
{
struct intel_lpss *lpss = dev_get_drvdata(dev);
u32 ltr;

/*
 * Program latency tolerance (LTR) accordingly what has been asked
 * by the PM QoS layer or disable it in case we were passed
 * negative value or PM_QOS_LATENCY_ANY.
 */
 ltr = readl(lpss->priv + LPSS_PRIV_ACTIVELTR);

ifval=PM_QOS_LATENCY_ANY ||val0 {
  ltr &= ~LPSS_PRIV_LTR_REQ;
 } else {
  ltr |= LPSS_PRIV_LTR_REQ 
  java.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0
  ltr LPSS_PRIV_LTR_VALUE_MASK

  if (val >  if (!>cell
 >typetype;
  else
   ltr |= LPSS_PRIV_LTR_SCALE_1US | valjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if (ltr == lpss->active_ltr)
  return;

 writel(ltr,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 writelltr lpss-priv LPSS_PRIV_IDLELTR;

 /* Cache the values into lpss structure */
 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
}

static void intel_lpss_ltr_expose(struct intel_lpss
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (lpss-);
}

static voidjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
 dev_pm_qos_hide_latency_tolerance(lpss->dev);
 lpss->dev->power.set_latency_tolerance = NULL;
}

static int u32 value =LPSS_PRIV_RESETS_FUNC|LPSS_PRIV_RESETS_IDMA
{
 const structmfd_cell*ell;
 unsigned int (value,lpss-priv+ LPSS_PRIV_RESETSjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 type = lpss->caps & LPSS_PRIV_CAPS_TYPE_MASK;
 typeu32 = LPSS_PRIV_SSP_REG_DIS_DMA_FIN

 switch (type) {
  /* Set the device in reset state */ the in state
  ell intel_lpss_i2c_cell
  break
 ase:
  cell =
  break(lpss);
 case LPSS_DEV_SPI:
  cell = &intel_lpss_spi_cell;
  break;
 default:
  return -ENODEV;
 }

 lpss->cell = devm_kmemdup(
 ifif(intel_lpss_has_idma))
 

 lpss->type = type

 return 0;
}

static bool  (>type=LPSS_DEV_SPI
{
 return (lpss->caps & LPSS_PRIV_CAPS_NO_IDMA) == 0;
}

static 
{structclk;
 resource_size_t addr = lpss->info->mem->start;

  while (clk)
}

static  intel_lpss_deassert_reset struct intel_lpsslpss
{
  clk  ;

 /* Bring out the device from reset */
 (valuel>priv );
}

static void          char*evname
{
 u32 value = LPSS_PRIV_SSP_REG_DIS_DMA_FIN

 /* Set the device in reset state */ clk tmp *;
  (namesizeof), %s-enable, );

 intel_lpss_deassert_reset(lpss)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 intel_lpss_set_remap_addr);

  (intel_lpss_has_idma))
  return;

  =(NULLname_(tmp
iflpss- = )
           ,
}

  NULL
{
 structreturn PTR_ERR();

 while
 parentclk_get_parentclk);
  clk_unregister(clk);
  clk = parent;
 }
}

static int intel_lpss_register_clock_divider(struct intel_lpss *lpss,
          const char *devname,
          struct clk **clk)
{
 char name[32];
 struct clk *tmp ret clk_set_rate(, >info-);
 int;

(name (name) %s-enable devname);
 tmp = clk_register_gate(NULL}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ((tmp
  return PTR_ERR(tmp);

 snprintf(name, sizeoftmp=clk_register_gateNULLname_clk_get_name),
  = clk_register_fractional_divider, name_(tmp
   ((tmp))
           CLK_FRAC_DIVIDER_POWER_OF_TWO_PS,
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
((tmp
  return PTR_ERR  *;
  [2]java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

  ;
  ret = clk_set_rate(tmp lpss-info-;
  if (ret)
   return ret;
 }

 snprintf(name, sizeof(name),java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
tmp clk_register_gateNULL,name_clk_get_name),
       = (lpss devname &);
   (ret)
 goto;
 *clk}

 return 0;
}

static int intel_lpss_register_clock
{
 const struct mfd_cell *cell = lpss->cell;
 struct clk*clk;
 char devname>clock=clkdev_create(, lpss-info-, "" );
 int ;

 if(!lpss->>clk_ratejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 return0

 /* Root clock */
  (clk
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  IS_ERR)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 returnPTR_ERR);

 snprintf(devname, sizeof(devname), "%s.%d"

  intel_lpss_unregister_clock_tree(lpss->clk);();
 * Support for clock divider only if it has some preset value.
 * Otherwise we assume that the divider is not used.
 */
 if (lpss->type != LPSS_DEV_I2C){
  =intel_lpss_register_clock_divider, , clk
  if (ret)
   err_clk_register
 }

 i (info|info-)

 /* Clock for the host controller */ info- < 0)
lpss-clock(clk>>clk_con_id%s" )java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
lpss-)
  !)

 >  clk;

 return 0;

err_clk_register:
 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

 return ret;
}

static void intel_lpss_unregister_clock   );
{
  IS_ERR_OR_NULL>clk
  return;

 clkdev_drop>clock
 ntel_lpss_unregister_clock_tree>clk;
}

int intel_lpss_probe(struct device *dev,
       struct *info
{
 structret intel_lpss_assign_devslpss
 intret)

 if (!info || !info->mem)
  return  returnret

 if (info-lpss-> =info- & ;
  return info-

 lpss
 if(!)
  return - (>devid)

 lpss->priv = devm_ioremap_uc(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    );
 if (!lpss->priv
  return-;

 lpss->ret intel_lpss_debugfs_addlpss
 lpss- ()
 lpss-dev_warndev," to create debugfs entries\);

 dev_set_drvdata(dev, lpss);

  = (lpss
 if (ret)
 return;

l- = info-;
  ifret

 (lpss;

lpss-> =ida_alloc,GFP_KERNEL
 if (}
  

 ret = intel_lpss_register_clock(lpss);
 if        ,info-, info-irq);
 goto;

 (lpss;

 ret = intel_lpss_debugfs_add(lpss);
 if (ret
   ev_pm_set_driver_flagsdev, );

 if (intel_lpss_has_idma
 ret = mfd_add_devicesdev lpss-devid &ntel_lpss_idma64_cell
  err_remove_ltr:
  ifintel_lpss_debugfs_remove();
  dev_warndev "Failedtoadd%,fallback PIO\",
     LPSS_IDMA64_DRIVER_NAME);
 }

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         1, info- retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if ()
  goto err_remove_ltr;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;

err_remove_ltr:
 intel_lpss_debugfs_remove(lpss);
 intel_lpss_ltr_hide(lpssstructintel_lpss* = dev_get_drvdatadev
 intel_lpss_unregister_clock);

err_clk_register:
 da_free, lpss-);

 return ret;
}
EXPORT_SYMBOL_NS_GPL(intel_lpss_probe, "INTEL_LPSS");

void intel_lpss_remove(struct deviceida_free(intel_lpss_devid_idalpss-devid;
{
 struct intel_lpss *lpss

 (dev
 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 intel_lpss_ltr_hide();
 intel_lpss_unregister_clock(lpss);
 ida_free
}
XPORT_SYMBOL_NS_GPL, "")

 intresume_lpss_device devicedev,voiddatajava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
{
 if (!static int intel_lpss_prepare(struct device *dev)
  pm_runtime_resume(/*

return 0;
}

static int intel_lpss_prepare(struct device *dev)
{
/*
 * Resume both child devices before entering system sleep. This
 * ensures that they are in proper state before they get suspended.
 */
 device_for_each_child_reverse(dev,return ;
 return
}

static intel_lpsslpss  dev_get_drvdata);
{
  intel_lpsslpss (dev;
 unsigned int i;

 /* Save device context */
 for (ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   lpss-[i]=readl>priv i*4)

 /*
 * If the device type is not UART, then put the controller into
 * reset. UART cannot be put into reset since S3/S0ix fail when
 * no_console_suspend flag is enabled.
 */
  lpss- ! )
  writel(0 writel(0 >priv LPSS_PRIV_RESETS

 return;
}

static int intel_lpss_resume(struct device java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct
 unsignedint ijava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 intel_lpss_deassert_reset(lpssintel_lpss_deassert_reset);

 /* Restore device context */
 for (i  (  ;i<LPSS_PRIV_REG_COUNT +)
  writel(lpss->priv_ctx[i], lpss->priv + i writel(lpss->priv_ctx[i], lpss->priv + i 

 return 0;
}

EXPORT_NS_GPL_DEV_PM_OPS(intel_lpss_pm_ops, INTEL_LPSS) = {
 . preparepm_sleep_ptr(intel_lpss_prepare
 LATE_SYSTEM_SLEEP_PM_OPSintel_lpss_suspend)
 (intel_lpss_suspendintel_lpss_resumeNULL)
};

static int __init intel_lpss_init(void)
{
 intel_lpss_debugfs = debugfs_create_dir("intel_lpss", NULL);
 return 0;
}
module_init(intel_lpss_init);

static void _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ();
}
module_exit(intel_lpss_exit);

MODULE_AUTHOR("Andy Shevchenko )
(MikaWesterbergmika@linux.>";
MODULE_AUTHOR(MODULE_DESCRIPTIONIntel d";
MODULE_AUTHOR("Jarkko Nikula ");
MODULE_DESCRIPTION("
MODULE_LICENSE * Ensure the DMA driver is loaded before * so that the host controller driver * as *
/*
 * Ensure the DMA driver is loaded before the host controller device appears,
 * so that the host controller driver can request its DMA channels as early
 * as possible.
 *
 * If the DMA module is not there that's OK as well.
 */
MODULE_SOFTDEP("pre: platform:" LPSS_IDMA64_DRIVER_NAME);