// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)/* * SoundWire AMD Manager Initialize routines * * Initializes and creates SDW devices based on ACPI and Hardware values * * Copyright 2024 Advanced Micro Devices, Inc. */ #include <linux/acpi.h>#include <linux/cleanup.h>#include <linux/export.h>#include <linux/io.h>#include <linux/module.h>#include <linux/platform_device.h> #include "amd_init.h" #define ACP_PAD_PULLDOWN_CTRL				0x0001448#define ACP_SW_PAD_KEEPER_EN				0x0001454#define AMD_SDW0_PAD_CTRL_MASK				0x60#define AMD_SDW1_PAD_CTRL_MASK				5#define AMD_SDW_PAD_CTRL_MASK		(AMD_SDW0_PAD_CTRL_MASK | AMD_SDW1_PAD_CTRL_MASK)#define AMD_SDW0_PAD_EN					1#define AMD_SDW1_PAD_EN					0x10#define AMD_SDW_PAD_EN			(AMD_SDW0_PAD_EN | AMD_SDW1_PAD_EN) static int amd_enable_sdw_pads(void __iomem *mmio, u32 link_mask, struct device *dev){	u32 pad_keeper_en, pad_pulldown_ctrl_mask; 	switch (link_mask) {	case 1:		pad_keeper_en = AMD_SDW0_PAD_EN;		pad_pulldown_ctrl_mask = AMD_SDW0_PAD_CTRL_MASK;		break;	case 2:		pad_keeper_en = AMD_SDW1_PAD_EN;		pad_pulldown_ctrl_mask = AMD_SDW1_PAD_CTRL_MASK;		break;	case 3:		pad_keeper_en = AMD_SDW_PAD_EN;		pad_pulldown_ctrl_mask = AMD_SDW_PAD_CTRL_MASK;		break;	default:		dev_err(dev, "No SDW Links are enabled\n");		return -ENODEV;	} 	amd_updatel(mmio, ACP_SW_PAD_KEEPER_EN, pad_keeper_en, pad_keeper_en);	amd_updatel(mmio, ACP_PAD_PULLDOWN_CTRL, pad_pulldown_ctrl_mask, 0); 	return 0;} static int sdw_amd_cleanup(struct sdw_amd_ctx *ctx){	int i; 	for (i = 0; i < ctx->count; i++) {		if (!(ctx->link_mask & BIT(i)))			continue;		platform_device_unregister(ctx->pdev[i]);	} 	return 0;} static struct sdw_amd_ctx *sdw_amd_probe_controller(struct sdw_amd_res *res){	struct sdw_amd_ctx *ctx;	struct acpi_device *adev;	struct acp_sdw_pdata sdw_pdata[2];	struct platform_device_info pdevinfo[2];	u32 link_mask;	int count, index;	int ret; 	if (!res)		return NULL; 	adev = acpi_fetch_acpi_dev(res->handle);	if (!adev)		return NULL; 	if (!res->count)		return NULL; 	count = res->count;	dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);	ret = amd_enable_sdw_pads(res->mmio_base, res->link_mask, res->parent);	if (ret)		return NULL; 	/*	 * 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_obj(*ctx);	if (!ctx)		return NULL; 	ctx->count = count;	ctx->link_mask = res->link_mask;	struct resource *sdw_res __free(kfree) = kzalloc_obj(*sdw_res);	if (!sdw_res) {		kfree(ctx);		return NULL;	}	sdw_res->flags = IORESOURCE_MEM;	sdw_res->start = res->addr;	sdw_res->end = res->addr + res->reg_range;	memset(&pdevinfo, 0, sizeof(pdevinfo));	link_mask = ctx->link_mask;	for (index = 0; index < count; index++) {		if (!(link_mask & BIT(index)))			continue; 		sdw_pdata[index].instance = index;		sdw_pdata[index].acp_sdw_lock = res->acp_lock;		sdw_pdata[index].acp_rev = res->acp_rev;		pdevinfo[index].name = "amd_sdw_manager";		pdevinfo[index].id = index;		pdevinfo[index].parent = res->parent;		pdevinfo[index].num_res = 1;		pdevinfo[index].res = sdw_res;		pdevinfo[index].data = &sdw_pdata[index];		pdevinfo[index].size_data = sizeof(struct acp_sdw_pdata);		pdevinfo[index].fwnode = acpi_fwnode_handle(adev);		ctx->pdev[index] = platform_device_register_full(&pdevinfo[index]);		if (IS_ERR(ctx->pdev[index]))			goto err;	}	return ctx;err:	while (index--) {		if (!(link_mask & BIT(index)))			continue; 		platform_device_unregister(ctx->pdev[index]);	} 	kfree(ctx);	return NULL;} static int sdw_amd_startup(struct sdw_amd_ctx *ctx){	struct amd_sdw_manager *amd_manager;	int i, ret; 	/* Startup SDW Manager devices */	for (i = 0; i < ctx->count; i++) {		if (!(ctx->link_mask & BIT(i)))			continue;		amd_manager = dev_get_drvdata(&ctx->pdev[i]->dev);		ret = amd_sdw_manager_start(amd_manager);		if (ret)			return ret;	} 	return 0;} int sdw_amd_probe(struct sdw_amd_res *res, struct sdw_amd_ctx **sdw_ctx){	*sdw_ctx = sdw_amd_probe_controller(res);	if (!*sdw_ctx)		return -ENODEV; 	return sdw_amd_startup(*sdw_ctx);}EXPORT_SYMBOL_NS(sdw_amd_probe, "SOUNDWIRE_AMD_INIT"); void sdw_amd_exit(struct sdw_amd_ctx *ctx){	sdw_amd_cleanup(ctx);	kfree(ctx->peripherals);	kfree(ctx);}EXPORT_SYMBOL_NS(sdw_amd_exit, "SOUNDWIRE_AMD_INIT"); int sdw_amd_get_slave_info(struct sdw_amd_ctx *ctx){	struct amd_sdw_manager *amd_manager;	struct sdw_bus *bus;	struct sdw_slave *slave;	struct list_head *node;	int index;	int i = 0;	int num_slaves = 0; 	for (index = 0; index < ctx->count; index++) {		if (!(ctx->link_mask & BIT(index)))			continue;		amd_manager = dev_get_drvdata(&ctx->pdev[index]->dev);		if (!amd_manager)			return -ENODEV;		bus = &amd_manager->bus;		/* Calculate number of slaves */		list_for_each(node, &bus->slaves)			num_slaves++;	} 	ctx->peripherals = kmalloc_flex(*ctx->peripherals, array, num_slaves);	if (!ctx->peripherals)		return -ENOMEM;	ctx->peripherals->num_peripherals = num_slaves;	for (index = 0; index < ctx->count; index++) {		if (!(ctx->link_mask & BIT(index)))			continue;		amd_manager = dev_get_drvdata(&ctx->pdev[index]->dev);		if (amd_manager) {			bus = &amd_manager->bus;			list_for_each_entry(slave, &bus->slaves, node) {				ctx->peripherals->array[i] = slave;				i++;			}		}	}	return 0;}EXPORT_SYMBOL_NS(sdw_amd_get_slave_info, "SOUNDWIRE_AMD_INIT"); MODULE_AUTHOR("Vijendar.Mukunda@amd.com");MODULE_DESCRIPTION("AMD SoundWire Init Library");MODULE_LICENSE("Dual BSD/GPL");