linux/drivers/mfd/intel-lpss.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Intel Sunrisepoint LPSS core support.
 *
 * Copyright (C) 2015, Intel Corporation
 *
 * Authors: Andy Shevchenko <[email protected]>
 *          Mika Westerberg <[email protected]>
 *          Heikki Krogerus <[email protected]>
 *          Jarkko Nikula <[email protected]>
 */

#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>
#include <linux/pm.h>
#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
#define LPSS_DEV_SIZE
#define LPSS_PRIV_OFFSET
#define LPSS_PRIV_SIZE
#define LPSS_PRIV_REG_COUNT
#define LPSS_IDMA64_OFFSET
#define LPSS_IDMA64_SIZE

/* Offsets from lpss->priv */
#define LPSS_PRIV_RESETS
#define LPSS_PRIV_RESETS_IDMA
#define LPSS_PRIV_RESETS_FUNC

#define LPSS_PRIV_ACTIVELTR
#define LPSS_PRIV_IDLELTR

#define LPSS_PRIV_LTR_REQ
#define LPSS_PRIV_LTR_SCALE_MASK
#define LPSS_PRIV_LTR_SCALE_1US
#define LPSS_PRIV_LTR_SCALE_32US
#define LPSS_PRIV_LTR_VALUE_MASK

#define LPSS_PRIV_SSP_REG
#define LPSS_PRIV_SSP_REG_DIS_DMA_FIN

#define LPSS_PRIV_REMAP_ADDR

#define LPSS_PRIV_CAPS
#define LPSS_PRIV_CAPS_NO_IDMA
#define LPSS_PRIV_CAPS_TYPE_MASK
#define LPSS_PRIV_CAPS_TYPE_SHIFT

/* This matches the type field in CAPS register */
enum intel_lpss_dev_type {};

struct intel_lpss {};

static const struct resource intel_lpss_dev_resources[] =;

static const struct resource intel_lpss_idma64_resources[] =;

/*
 * 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_cell intel_lpss_idma64_cell =;

static const struct mfd_cell intel_lpss_i2c_cell =;

static const struct mfd_cell intel_lpss_uart_cell =;

static const struct mfd_cell intel_lpss_spi_cell =;

static DEFINE_IDA(intel_lpss_devid_ida);
static struct dentry *intel_lpss_debugfs;

static void intel_lpss_cache_ltr(struct intel_lpss *lpss)
{}

static int intel_lpss_debugfs_add(struct intel_lpss *lpss)
{}

static void intel_lpss_debugfs_remove(struct intel_lpss *lpss)
{}

static void intel_lpss_ltr_set(struct device *dev, s32 val)
{}

static void intel_lpss_ltr_expose(struct intel_lpss *lpss)
{}

static void intel_lpss_ltr_hide(struct intel_lpss *lpss)
{}

static int intel_lpss_assign_devs(struct intel_lpss *lpss)
{}

static bool intel_lpss_has_idma(const struct intel_lpss *lpss)
{}

static void intel_lpss_set_remap_addr(const struct intel_lpss *lpss)
{}

static void intel_lpss_deassert_reset(const struct intel_lpss *lpss)
{}

static void intel_lpss_init_dev(const struct intel_lpss *lpss)
{}

static void intel_lpss_unregister_clock_tree(struct clk *clk)
{}

static int intel_lpss_register_clock_divider(struct intel_lpss *lpss,
					     const char *devname,
					     struct clk **clk)
{}

static int intel_lpss_register_clock(struct intel_lpss *lpss)
{}

static void intel_lpss_unregister_clock(struct intel_lpss *lpss)
{}

int intel_lpss_probe(struct device *dev,
		     const struct intel_lpss_platform_info *info)
{}
EXPORT_SYMBOL_NS_GPL();

void intel_lpss_remove(struct device *dev)
{}
EXPORT_SYMBOL_NS_GPL();

static int resume_lpss_device(struct device *dev, void *data)
{}

static int intel_lpss_prepare(struct device *dev)
{}

static int intel_lpss_suspend(struct device *dev)
{}

static int intel_lpss_resume(struct device *dev)
{}

EXPORT_NS_GPL_DEV_PM_OPS(intel_lpss_pm_ops, INTEL_LPSS) =;

static int __init intel_lpss_init(void)
{}
module_init();

static void __exit intel_lpss_exit(void)
{}
module_exit(intel_lpss_exit);

MODULE_AUTHOR();
MODULE_AUTHOR();
MODULE_AUTHOR();
MODULE_AUTHOR();
MODULE_DESCRIPTION();
MODULE_LICENSE();
/*
 * 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();