[mirror_ubuntu-jammy-kernel.git] / drivers / soundwire / intel_init.c

// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
// Copyright(c) 2015-17 Intel Corporation.

/*
 * SDW Intel Init Routines
 *
 * Initializes and creates SDW devices based on ACPI and Hardware values
 */

#include <linux/acpi.h>
#include <linux/export.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/auxiliary_bus.h>
#include <linux/pm_runtime.h>
#include <linux/soundwire/sdw_intel.h>
#include "cadence_master.h"
#include "intel.h"

static void intel_link_dev_release(struct device *dev)
{
	struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
	struct sdw_intel_link_dev *ldev = auxiliary_dev_to_sdw_intel_link_dev(auxdev);

	kfree(ldev);
}

/* alloc, init and add link devices */
static struct sdw_intel_link_dev *intel_link_dev_register(struct sdw_intel_res *res,
							  struct sdw_intel_ctx *ctx,
							  struct fwnode_handle *fwnode,
							  const char *name,
							  int link_id)
{
	struct sdw_intel_link_dev *ldev;
	struct sdw_intel_link_res *link;
	struct auxiliary_device *auxdev;
	int ret;

	ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
	if (!ldev)
		return ERR_PTR(-ENOMEM);

	auxdev = &ldev->auxdev;
	auxdev->name = name;
	auxdev->dev.parent = res->parent;
	auxdev->dev.fwnode = fwnode;
	auxdev->dev.release = intel_link_dev_release;

	/* we don't use an IDA since we already have a link ID */
	auxdev->id = link_id;

	/*
	 * keep a handle on the allocated memory, to be used in all other functions.
	 * Since the same pattern is used to skip links that are not enabled, there is
	 * no need to check if ctx->ldev[i] is NULL later on.
	 */
	ctx->ldev[link_id] = ldev;

	/* Add link information used in the driver probe */
	link = &ldev->link_res;
	link->mmio_base = res->mmio_base;
	link->registers = res->mmio_base + SDW_LINK_BASE
		+ (SDW_LINK_SIZE * link_id);
	link->shim = res->mmio_base + res->shim_base;
	link->alh = res->mmio_base + res->alh_base;

	link->ops = res->ops;
	link->dev = res->dev;

	link->clock_stop_quirks = res->clock_stop_quirks;
	link->shim_lock = &ctx->shim_lock;
	link->shim_mask = &ctx->shim_mask;
	link->link_mask = ctx->link_mask;

	/* now follow the two-step init/add sequence */
	ret = auxiliary_device_init(auxdev);
	if (ret < 0) {
		dev_err(res->parent, "failed to initialize link dev %s link_id %d\n",
			name, link_id);
		kfree(ldev);
		return ERR_PTR(ret);
	}

	ret = auxiliary_device_add(&ldev->auxdev);
	if (ret < 0) {
		dev_err(res->parent, "failed to add link dev %s link_id %d\n",
			ldev->auxdev.name, link_id);
		/* ldev will be freed with the put_device() and .release sequence */
		auxiliary_device_uninit(&ldev->auxdev);
		return ERR_PTR(ret);
	}

	return ldev;
}

static void intel_link_dev_unregister(struct sdw_intel_link_dev *ldev)
{
	auxiliary_device_delete(&ldev->auxdev);
	auxiliary_device_uninit(&ldev->auxdev);
}

static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx)
{
	struct sdw_intel_link_dev *ldev;
	u32 link_mask;
	int i;

	link_mask = ctx->link_mask;

	for (i = 0; i < ctx->count; i++) {
		if (!(link_mask & BIT(i)))
			continue;

		ldev = ctx->ldev[i];

		pm_runtime_disable(&ldev->auxdev.dev);
		if (!ldev->link_res.clock_stop_quirks)
			pm_runtime_put_noidle(ldev->link_res.dev);

		intel_link_dev_unregister(ldev);
	}

	return 0;
}

#define HDA_DSP_REG_ADSPIC2             (0x10)
#define HDA_DSP_REG_ADSPIS2             (0x14)
#define HDA_DSP_REG_ADSPIC2_SNDW        BIT(5)

/**
 * sdw_intel_enable_irq() - enable/disable Intel SoundWire IRQ
 * @mmio_base: The mmio base of the control register
 * @enable: true if enable
 */
void sdw_intel_enable_irq(void __iomem *mmio_base, bool enable)
{
	u32 val;

	val = readl(mmio_base + HDA_DSP_REG_ADSPIC2);

	if (enable)
		val |= HDA_DSP_REG_ADSPIC2_SNDW;
	else
		val &= ~HDA_DSP_REG_ADSPIC2_SNDW;

	writel(val, mmio_base + HDA_DSP_REG_ADSPIC2);
}
EXPORT_SYMBOL_NS(sdw_intel_enable_irq, SOUNDWIRE_INTEL_INIT);

irqreturn_t sdw_intel_thread(int irq, void *dev_id)
{
	struct sdw_intel_ctx *ctx = dev_id;
	struct sdw_intel_link_res *link;

	list_for_each_entry(link, &ctx->link_list, list)
		sdw_cdns_irq(irq, link->cdns);

	sdw_intel_enable_irq(ctx->mmio_base, true);
	return IRQ_HANDLED;
}
EXPORT_SYMBOL_NS(sdw_intel_thread, SOUNDWIRE_INTEL_INIT);

static struct sdw_intel_ctx
*sdw_intel_probe_controller(struct sdw_intel_res *res)
{
	struct sdw_intel_link_res *link;
	struct sdw_intel_link_dev *ldev;
	struct sdw_intel_ctx *ctx;
	struct acpi_device *adev;
	struct sdw_slave *slave;
	struct list_head *node;
	struct sdw_bus *bus;
	u32 link_mask;
	int num_slaves = 0;
	int count;
	int i;

	if (!res)
		return NULL;

	if (acpi_bus_get_device(res->handle, &adev))
		return NULL;

	if (!res->count)
		return NULL;

	count = res->count;
	dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);

	/*
	 * we need to alloc/free memory manually and can't use devm:
	 * this routine may be called from a workqueue, and not from
	 * the parent .probe.
	 * If devm_ was used, the memory might never be freed on errors.
	 */
	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return NULL;

	ctx->count = count;

	/*
	 * allocate the array of pointers. The link-specific data is allocated
	 * as part of the first loop below and released with the auxiliary_device_uninit().
	 * If some links are disabled, the link pointer will remain NULL. Given that the
	 * number of links is small, this is simpler than using a list to keep track of links.
	 */
	ctx->ldev = kcalloc(ctx->count, sizeof(*ctx->ldev), GFP_KERNEL);
	if (!ctx->ldev) {
		kfree(ctx);
		return NULL;
	}

	ctx->mmio_base = res->mmio_base;
	ctx->shim_base = res->shim_base;
	ctx->alh_base = res->alh_base;
	ctx->link_mask = res->link_mask;
	ctx->handle = res->handle;
	mutex_init(&ctx->shim_lock);

	link_mask = ctx->link_mask;

	INIT_LIST_HEAD(&ctx->link_list);

	for (i = 0; i < count; i++) {
		if (!(link_mask & BIT(i)))
			continue;

		/*
		 * init and add a device for each link
		 *
		 * The name of the device will be soundwire_intel.link.[i],
		 * with the "soundwire_intel" module prefix automatically added
		 * by the auxiliary bus core.
		 */
		ldev = intel_link_dev_register(res,
					       ctx,
					       acpi_fwnode_handle(adev),
					       "link",
					       i);
		if (IS_ERR(ldev))
			goto err;

		link = &ldev->link_res;
		link->cdns = dev_get_drvdata(&ldev->auxdev.dev);

		if (!link->cdns) {
			dev_err(&adev->dev, "failed to get link->cdns\n");
			/*
			 * 1 will be subtracted from i in the err label, but we need to call
			 * intel_link_dev_unregister for this ldev, so plus 1 now
			 */
			i++;
			goto err;
		}
		list_add_tail(&link->list, &ctx->link_list);
		bus = &link->cdns->bus;
		/* Calculate number of slaves */
		list_for_each(node, &bus->slaves)
			num_slaves++;
	}

	ctx->ids = kcalloc(num_slaves, sizeof(*ctx->ids), GFP_KERNEL);
	if (!ctx->ids)
		goto err;

	ctx->num_slaves = num_slaves;
	i = 0;
	list_for_each_entry(link, &ctx->link_list, list) {
		bus = &link->cdns->bus;
		list_for_each_entry(slave, &bus->slaves, node) {
			ctx->ids[i].id = slave->id;
			ctx->ids[i].link_id = bus->link_id;
			i++;
		}
	}

	return ctx;

err:
	while (i--) {
		if (!(link_mask & BIT(i)))
			continue;
		ldev = ctx->ldev[i];
		intel_link_dev_unregister(ldev);
	}
	kfree(ctx->ldev);
	kfree(ctx);
	return NULL;
}

static int
sdw_intel_startup_controller(struct sdw_intel_ctx *ctx)
{
	struct acpi_device *adev;
	struct sdw_intel_link_dev *ldev;
	u32 caps;
	u32 link_mask;
	int i;

	if (acpi_bus_get_device(ctx->handle, &adev))
		return -EINVAL;

	/* Check SNDWLCAP.LCOUNT */
	caps = ioread32(ctx->mmio_base + ctx->shim_base + SDW_SHIM_LCAP);
	caps &= GENMASK(2, 0);

	/* Check HW supported vs property value */
	if (caps < ctx->count) {
		dev_err(&adev->dev,
			"BIOS master count is larger than hardware capabilities\n");
		return -EINVAL;
	}

	if (!ctx->ldev)
		return -EINVAL;

	link_mask = ctx->link_mask;

	/* Startup SDW Master devices */
	for (i = 0; i < ctx->count; i++) {
		if (!(link_mask & BIT(i)))
			continue;

		ldev = ctx->ldev[i];

		intel_link_startup(&ldev->auxdev);

		if (!ldev->link_res.clock_stop_quirks) {
			/*
			 * we need to prevent the parent PCI device
			 * from entering pm_runtime suspend, so that
			 * power rails to the SoundWire IP are not
			 * turned off.
			 */
			pm_runtime_get_noresume(ldev->link_res.dev);
		}
	}

	return 0;
}

/**
 * sdw_intel_probe() - SoundWire Intel probe routine
 * @res: resource data
 *
 * This registers an auxiliary device for each Master handled by the controller,
 * and SoundWire Master and Slave devices will be created by the auxiliary
 * device probe. All the information necessary is stored in the context, and
 * the res argument pointer can be freed after this step.
 * This function will be called after sdw_intel_acpi_scan() by SOF probe.
 */
struct sdw_intel_ctx
*sdw_intel_probe(struct sdw_intel_res *res)
{
	return sdw_intel_probe_controller(res);
}
EXPORT_SYMBOL_NS(sdw_intel_probe, SOUNDWIRE_INTEL_INIT);

/**
 * sdw_intel_startup() - SoundWire Intel startup
 * @ctx: SoundWire context allocated in the probe
 *
 * Startup Intel SoundWire controller. This function will be called after
 * Intel Audio DSP is powered up.
 */
int sdw_intel_startup(struct sdw_intel_ctx *ctx)
{
	return sdw_intel_startup_controller(ctx);
}
EXPORT_SYMBOL_NS(sdw_intel_startup, SOUNDWIRE_INTEL_INIT);
/**
 * sdw_intel_exit() - SoundWire Intel exit
 * @ctx: SoundWire context allocated in the probe
 *
 * Delete the controller instances created and cleanup
 */
void sdw_intel_exit(struct sdw_intel_ctx *ctx)
{
	sdw_intel_cleanup(ctx);
	kfree(ctx->ids);
	kfree(ctx->ldev);
	kfree(ctx);
}
EXPORT_SYMBOL_NS(sdw_intel_exit, SOUNDWIRE_INTEL_INIT);

void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx)
{
	struct sdw_intel_link_dev *ldev;
	u32 link_mask;
	int i;

	if (!ctx->ldev)
		return;

	link_mask = ctx->link_mask;

	/* Startup SDW Master devices */
	for (i = 0; i < ctx->count; i++) {
		if (!(link_mask & BIT(i)))
			continue;

		ldev = ctx->ldev[i];

		intel_link_process_wakeen_event(&ldev->auxdev);
	}
}
EXPORT_SYMBOL_NS(sdw_intel_process_wakeen_event, SOUNDWIRE_INTEL_INIT);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Intel Soundwire Init Library");
Commit	Line	Data
d62a7d41 VK	1	// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
	2	// Copyright(c) 2015-17 Intel Corporation.
	3
	4	/*
	5	* SDW Intel Init Routines
	6	*
	7	* Initializes and creates SDW devices based on ACPI and Hardware values
	8	*/
	9
	10	#include <linux/acpi.h>
4abbd783	11	#include <linux/export.h>
4a98a6b2	12	#include <linux/interrupt.h>
3fc40449	13	#include <linux/io.h>
4abbd783	14	#include <linux/module.h>
29a269c6	15	#include <linux/auxiliary_bus.h>
ebf878ed	16	#include <linux/pm_runtime.h>
d62a7d41	17	#include <linux/soundwire/sdw_intel.h>
b6109dd6	18	#include "cadence_master.h"
d62a7d41 VK	19	#include "intel.h"
d62a7d41 VK	20
29a269c6 PLB	21	static void intel_link_dev_release(struct device *dev)
	22	{
	23	struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
	24	struct sdw_intel_link_dev *ldev = auxiliary_dev_to_sdw_intel_link_dev(auxdev);
	25
	26	kfree(ldev);
	27	}
	28
	29	/* alloc, init and add link devices */
	30	static struct sdw_intel_link_dev intel_link_dev_register(struct sdw_intel_res res,
	31	struct sdw_intel_ctx *ctx,
	32	struct fwnode_handle *fwnode,
	33	const char *name,
	34	int link_id)
	35	{
	36	struct sdw_intel_link_dev *ldev;
	37	struct sdw_intel_link_res *link;
	38	struct auxiliary_device *auxdev;
	39	int ret;
	40
	41	ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
	42	if (!ldev)
	43	return ERR_PTR(-ENOMEM);
	44
	45	auxdev = &ldev->auxdev;
	46	auxdev->name = name;
	47	auxdev->dev.parent = res->parent;
	48	auxdev->dev.fwnode = fwnode;
	49	auxdev->dev.release = intel_link_dev_release;
	50
	51	/* we don't use an IDA since we already have a link ID */
	52	auxdev->id = link_id;
	53
	54	/*
	55	* keep a handle on the allocated memory, to be used in all other functions.
	56	* Since the same pattern is used to skip links that are not enabled, there is
	57	* no need to check if ctx->ldev[i] is NULL later on.
	58	*/
	59	ctx->ldev[link_id] = ldev;
	60
	61	/* Add link information used in the driver probe */
	62	link = &ldev->link_res;
	63	link->mmio_base = res->mmio_base;
	64	link->registers = res->mmio_base + SDW_LINK_BASE
	65	+ (SDW_LINK_SIZE * link_id);
60e9feb7 BL	66	link->shim = res->mmio_base + res->shim_base;
60e9feb7 BL	67	link->alh = res->mmio_base + res->alh_base;
29a269c6 PLB	68
	69	link->ops = res->ops;
	70	link->dev = res->dev;
	71
	72	link->clock_stop_quirks = res->clock_stop_quirks;
	73	link->shim_lock = &ctx->shim_lock;
	74	link->shim_mask = &ctx->shim_mask;
	75	link->link_mask = ctx->link_mask;
	76
	77	/* now follow the two-step init/add sequence */
	78	ret = auxiliary_device_init(auxdev);
	79	if (ret < 0) {
	80	dev_err(res->parent, "failed to initialize link dev %s link_id %d\n",
	81	name, link_id);
	82	kfree(ldev);
	83	return ERR_PTR(ret);
	84	}
	85
	86	ret = auxiliary_device_add(&ldev->auxdev);
	87	if (ret < 0) {
	88	dev_err(res->parent, "failed to add link dev %s link_id %d\n",
	89	ldev->auxdev.name, link_id);
	90	/* ldev will be freed with the put_device() and .release sequence */
	91	auxiliary_device_uninit(&ldev->auxdev);
	92	return ERR_PTR(ret);
	93	}
	94
	95	return ldev;
	96	}
	97
	98	static void intel_link_dev_unregister(struct sdw_intel_link_dev *ldev)
	99	{
	100	auxiliary_device_delete(&ldev->auxdev);
	101	auxiliary_device_uninit(&ldev->auxdev);
	102	}
	103
6d2c6669	104	static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx)
d62a7d41	105	{
29a269c6	106	struct sdw_intel_link_dev *ldev;
6d2c6669	107	u32 link_mask;
d62a7d41 VK	108	int i;
d62a7d41 VK	109
6d2c6669 PLB	110	link_mask = ctx->link_mask;
6d2c6669 PLB	111
29a269c6	112	for (i = 0; i < ctx->count; i++) {
6d2c6669 PLB	113	if (!(link_mask & BIT(i)))
	114	continue;
	115
29a269c6	116	ldev = ctx->ldev[i];
ab996b29	117
29a269c6 PLB	118	pm_runtime_disable(&ldev->auxdev.dev);
	119	if (!ldev->link_res.clock_stop_quirks)
	120	pm_runtime_put_noidle(ldev->link_res.dev);
	121
	122	intel_link_dev_unregister(ldev);
d62a7d41 VK	123	}
d62a7d41 VK	124
d62a7d41 VK	125	return 0;
	126	}
	127
12b16146 PLB	128	#define HDA_DSP_REG_ADSPIC2 (0x10)
	129	#define HDA_DSP_REG_ADSPIS2 (0x14)
	130	#define HDA_DSP_REG_ADSPIC2_SNDW BIT(5)
	131
	132	/**
	133	* sdw_intel_enable_irq() - enable/disable Intel SoundWire IRQ
	134	* @mmio_base: The mmio base of the control register
	135	* @enable: true if enable
	136	*/
	137	void sdw_intel_enable_irq(void __iomem *mmio_base, bool enable)
	138	{
	139	u32 val;
	140
	141	val = readl(mmio_base + HDA_DSP_REG_ADSPIC2);
	142
	143	if (enable)
	144	val \|= HDA_DSP_REG_ADSPIC2_SNDW;
	145	else
	146	val &= ~HDA_DSP_REG_ADSPIC2_SNDW;
	147
	148	writel(val, mmio_base + HDA_DSP_REG_ADSPIC2);
	149	}
8459cea7	150	EXPORT_SYMBOL_NS(sdw_intel_enable_irq, SOUNDWIRE_INTEL_INIT);
12b16146	151
4a98a6b2 BL	152	irqreturn_t sdw_intel_thread(int irq, void *dev_id)
	153	{
	154	struct sdw_intel_ctx *ctx = dev_id;
	155	struct sdw_intel_link_res *link;
	156
	157	list_for_each_entry(link, &ctx->link_list, list)
	158	sdw_cdns_irq(irq, link->cdns);
	159
	160	sdw_intel_enable_irq(ctx->mmio_base, true);
	161	return IRQ_HANDLED;
	162	}
	163	EXPORT_SYMBOL_NS(sdw_intel_thread, SOUNDWIRE_INTEL_INIT);
	164
6d2c6669 PLB	165	static struct sdw_intel_ctx
	166	sdw_intel_probe_controller(struct sdw_intel_res res)
	167	{
6d2c6669	168	struct sdw_intel_link_res *link;
29a269c6	169	struct sdw_intel_link_dev *ldev;
6d2c6669 PLB	170	struct sdw_intel_ctx *ctx;
6d2c6669 PLB	171	struct acpi_device *adev;
a8184403 BL	172	struct sdw_slave *slave;
	173	struct list_head *node;
	174	struct sdw_bus *bus;
6d2c6669	175	u32 link_mask;
a8184403	176	int num_slaves = 0;
6d2c6669 PLB	177	int count;
	178	int i;
	179
	180	if (!res)
	181	return NULL;
	182
	183	if (acpi_bus_get_device(res->handle, &adev))
	184	return NULL;
	185
	186	if (!res->count)
	187	return NULL;
	188
	189	count = res->count;
d62a7d41 VK	190	dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);
d62a7d41 VK	191
29a269c6 PLB	192	/*
	193	* we need to alloc/free memory manually and can't use devm:
	194	* this routine may be called from a workqueue, and not from
	195	* the parent .probe.
	196	* If devm_ was used, the memory might never be freed on errors.
	197	*/
	198	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
d62a7d41 VK	199	if (!ctx)
	200	return NULL;
	201
	202	ctx->count = count;
29a269c6 PLB	203
	204	/*
	205	* allocate the array of pointers. The link-specific data is allocated
	206	* as part of the first loop below and released with the auxiliary_device_uninit().
	207	* If some links are disabled, the link pointer will remain NULL. Given that the
	208	* number of links is small, this is simpler than using a list to keep track of links.
	209	*/
	210	ctx->ldev = kcalloc(ctx->count, sizeof(*ctx->ldev), GFP_KERNEL);
	211	if (!ctx->ldev) {
	212	kfree(ctx);
dd906cc6	213	return NULL;
29a269c6	214	}
d62a7d41	215
6d2c6669	216	ctx->mmio_base = res->mmio_base;
60e9feb7 BL	217	ctx->shim_base = res->shim_base;
60e9feb7 BL	218	ctx->alh_base = res->alh_base;
6d2c6669 PLB	219	ctx->link_mask = res->link_mask;
6d2c6669 PLB	220	ctx->handle = res->handle;
4a17c441	221	mutex_init(&ctx->shim_lock);
6d2c6669	222
6d2c6669	223	link_mask = ctx->link_mask;
d62a7d41	224
4a98a6b2 BL	225	INIT_LIST_HEAD(&ctx->link_list);
4a98a6b2 BL	226
29a269c6 PLB	227	for (i = 0; i < count; i++) {
29a269c6 PLB	228	if (!(link_mask & BIT(i)))
50302fc7	229	continue;
50302fc7	230
29a269c6 PLB	231	/*
	232	* init and add a device for each link
	233	*
	234	* The name of the device will be soundwire_intel.link.[i],
	235	* with the "soundwire_intel" module prefix automatically added
	236	* by the auxiliary bus core.
	237	*/
	238	ldev = intel_link_dev_register(res,
	239	ctx,
	240	acpi_fwnode_handle(adev),
	241	"link",
	242	i);
	243	if (IS_ERR(ldev))
6d2c6669	244	goto err;
29a269c6 PLB	245
	246	link = &ldev->link_res;
	247	link->cdns = dev_get_drvdata(&ldev->auxdev.dev);
4a98a6b2	248
14968dd3 BL	249	if (!link->cdns) {
	250	dev_err(&adev->dev, "failed to get link->cdns\n");
	251	/*
	252	* 1 will be subtracted from i in the err label, but we need to call
	253	* intel_link_dev_unregister for this ldev, so plus 1 now
	254	*/
	255	i++;
	256	goto err;
	257	}
4a98a6b2	258	list_add_tail(&link->list, &ctx->link_list);
a8184403 BL	259	bus = &link->cdns->bus;
	260	/* Calculate number of slaves */
	261	list_for_each(node, &bus->slaves)
	262	num_slaves++;
	263	}
	264
29a269c6	265	ctx->ids = kcalloc(num_slaves, sizeof(*ctx->ids), GFP_KERNEL);
a8184403 BL	266	if (!ctx->ids)
	267	goto err;
	268
	269	ctx->num_slaves = num_slaves;
	270	i = 0;
	271	list_for_each_entry(link, &ctx->link_list, list) {
	272	bus = &link->cdns->bus;
	273	list_for_each_entry(slave, &bus->slaves, node) {
	274	ctx->ids[i].id = slave->id;
	275	ctx->ids[i].link_id = bus->link_id;
	276	i++;
	277	}
d62a7d41 VK	278	}
	279
	280	return ctx;
	281
6d2c6669	282	err:
29a269c6 PLB	283	while (i--) {
	284	if (!(link_mask & BIT(i)))
	285	continue;
	286	ldev = ctx->ldev[i];
	287	intel_link_dev_unregister(ldev);
	288	}
	289	kfree(ctx->ldev);
	290	kfree(ctx);
d62a7d41 VK	291	return NULL;
	292	}
	293
6d2c6669 PLB	294	static int
	295	sdw_intel_startup_controller(struct sdw_intel_ctx *ctx)
	296	{
	297	struct acpi_device *adev;
29a269c6	298	struct sdw_intel_link_dev *ldev;
6d2c6669 PLB	299	u32 caps;
	300	u32 link_mask;
	301	int i;
	302
	303	if (acpi_bus_get_device(ctx->handle, &adev))
	304	return -EINVAL;
	305
	306	/* Check SNDWLCAP.LCOUNT */
60e9feb7	307	caps = ioread32(ctx->mmio_base + ctx->shim_base + SDW_SHIM_LCAP);
6d2c6669 PLB	308	caps &= GENMASK(2, 0);
	309
	310	/* Check HW supported vs property value */
	311	if (caps < ctx->count) {
	312	dev_err(&adev->dev,
	313	"BIOS master count is larger than hardware capabilities\n");
	314	return -EINVAL;
	315	}
	316
29a269c6	317	if (!ctx->ldev)
6d2c6669 PLB	318	return -EINVAL;
6d2c6669 PLB	319
6d2c6669 PLB	320	link_mask = ctx->link_mask;
	321
	322	/* Startup SDW Master devices */
29a269c6	323	for (i = 0; i < ctx->count; i++) {
6d2c6669 PLB	324	if (!(link_mask & BIT(i)))
	325	continue;
	326
29a269c6 PLB	327	ldev = ctx->ldev[i];
	328
	329	intel_link_startup(&ldev->auxdev);
ab996b29	330
29a269c6	331	if (!ldev->link_res.clock_stop_quirks) {
ab996b29 PLB	332	/*
	333	* we need to prevent the parent PCI device
	334	* from entering pm_runtime suspend, so that
	335	* power rails to the SoundWire IP are not
	336	* turned off.
	337	*/
29a269c6	338	pm_runtime_get_noresume(ldev->link_res.dev);
ab996b29	339	}
6d2c6669 PLB	340	}
	341
	342	return 0;
	343	}
	344
6d2c6669 PLB	345	/**
	346	* sdw_intel_probe() - SoundWire Intel probe routine
	347	* @res: resource data
	348	*
29a269c6 PLB	349	* This registers an auxiliary device for each Master handled by the controller,
29a269c6 PLB	350	* and SoundWire Master and Slave devices will be created by the auxiliary
6d2c6669 PLB	351	* device probe. All the information necessary is stored in the context, and
	352	* the res argument pointer can be freed after this step.
	353	* This function will be called after sdw_intel_acpi_scan() by SOF probe.
	354	*/
	355	struct sdw_intel_ctx
	356	sdw_intel_probe(struct sdw_intel_res res)
	357	{
	358	return sdw_intel_probe_controller(res);
	359	}
8459cea7	360	EXPORT_SYMBOL_NS(sdw_intel_probe, SOUNDWIRE_INTEL_INIT);
6d2c6669 PLB	361
	362	/**
	363	* sdw_intel_startup() - SoundWire Intel startup
	364	* @ctx: SoundWire context allocated in the probe
	365	*
	366	* Startup Intel SoundWire controller. This function will be called after
	367	* Intel Audio DSP is powered up.
	368	*/
	369	int sdw_intel_startup(struct sdw_intel_ctx *ctx)
	370	{
	371	return sdw_intel_startup_controller(ctx);
	372	}
8459cea7	373	EXPORT_SYMBOL_NS(sdw_intel_startup, SOUNDWIRE_INTEL_INIT);
d62a7d41 VK	374	/**
d62a7d41 VK	375	* sdw_intel_exit() - SoundWire Intel exit
6d2c6669	376	* @ctx: SoundWire context allocated in the probe
d62a7d41 VK	377	*
	378	* Delete the controller instances created and cleanup
	379	*/
f98f690f	380	void sdw_intel_exit(struct sdw_intel_ctx *ctx)
d62a7d41	381	{
6d2c6669	382	sdw_intel_cleanup(ctx);
29a269c6 PLB	383	kfree(ctx->ids);
	384	kfree(ctx->ldev);
	385	kfree(ctx);
d62a7d41	386	}
8459cea7	387	EXPORT_SYMBOL_NS(sdw_intel_exit, SOUNDWIRE_INTEL_INIT);
d62a7d41	388
ab2c9132 RW	389	void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx)
ab2c9132 RW	390	{
29a269c6	391	struct sdw_intel_link_dev *ldev;
ab2c9132 RW	392	u32 link_mask;
	393	int i;
	394
29a269c6	395	if (!ctx->ldev)
ab2c9132 RW	396	return;
ab2c9132 RW	397
ab2c9132 RW	398	link_mask = ctx->link_mask;
	399
	400	/* Startup SDW Master devices */
29a269c6	401	for (i = 0; i < ctx->count; i++) {
ab2c9132 RW	402	if (!(link_mask & BIT(i)))
	403	continue;
	404
29a269c6 PLB	405	ldev = ctx->ldev[i];
	406
	407	intel_link_process_wakeen_event(&ldev->auxdev);
ab2c9132 RW	408	}
	409	}
	410	EXPORT_SYMBOL_NS(sdw_intel_process_wakeen_event, SOUNDWIRE_INTEL_INIT);
	411
d62a7d41 VK	412	MODULE_LICENSE("Dual BSD/GPL");
d62a7d41 VK	413	MODULE_DESCRIPTION("Intel Soundwire Init Library");