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> 11 #include <linux/export.h> 12 #include <linux/io.h> 13 #include <linux/module.h> 14 #include <linux/platform_device.h> 15 #include <linux/soundwire/sdw_intel.h> 16 #include "intel.h" 17 18 #define SDW_LINK_TYPE 4 /* from Intel ACPI documentation */ 19 #define SDW_MAX_LINKS 4 20 #define SDW_SHIM_LCAP 0x0 21 #define SDW_SHIM_BASE 0x2C000 22 #define SDW_ALH_BASE 0x2C800 23 #define SDW_LINK_BASE 0x30000 24 #define SDW_LINK_SIZE 0x10000 25 26 static int link_mask; 27 module_param_named(sdw_link_mask, link_mask, int, 0444); 28 MODULE_PARM_DESC(sdw_link_mask, "Intel link mask (one bit per link)"); 29 30 static int sdw_intel_cleanup_pdev(struct sdw_intel_ctx *ctx) 31 { 32 struct sdw_intel_link_res *link = ctx->links; 33 int i; 34 35 if (!link) 36 return 0; 37 38 for (i = 0; i < ctx->count; i++) { 39 if (link->pdev) 40 platform_device_unregister(link->pdev); 41 link++; 42 } 43 44 kfree(ctx->links); 45 ctx->links = NULL; 46 47 return 0; 48 } 49 50 static struct sdw_intel_ctx 51 *sdw_intel_add_controller(struct sdw_intel_res *res) 52 { 53 struct platform_device_info pdevinfo; 54 struct platform_device *pdev; 55 struct sdw_intel_link_res *link; 56 struct sdw_intel_ctx *ctx; 57 struct acpi_device *adev; 58 int ret, i; 59 u8 count; 60 u32 caps; 61 62 if (acpi_bus_get_device(res->handle, &adev)) 63 return NULL; 64 65 /* Found controller, find links supported */ 66 count = 0; 67 ret = fwnode_property_read_u8_array(acpi_fwnode_handle(adev), 68 "mipi-sdw-master-count", &count, 1); 69 70 /* Don't fail on error, continue and use hw value */ 71 if (ret) { 72 dev_err(&adev->dev, 73 "Failed to read mipi-sdw-master-count: %d\n", ret); 74 count = SDW_MAX_LINKS; 75 } 76 77 /* Check SNDWLCAP.LCOUNT */ 78 caps = ioread32(res->mmio_base + SDW_SHIM_BASE + SDW_SHIM_LCAP); 79 caps &= GENMASK(2, 0); 80 81 /* Check HW supported vs property value and use min of two */ 82 count = min_t(u8, caps, count); 83 84 /* Check count is within bounds */ 85 if (count > SDW_MAX_LINKS) { 86 dev_err(&adev->dev, "Link count %d exceeds max %d\n", 87 count, SDW_MAX_LINKS); 88 return NULL; 89 } else if (!count) { 90 dev_warn(&adev->dev, "No SoundWire links detected\n"); 91 return NULL; 92 } 93 94 dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count); 95 96 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 97 if (!ctx) 98 return NULL; 99 100 ctx->count = count; 101 ctx->links = kcalloc(ctx->count, sizeof(*ctx->links), GFP_KERNEL); 102 if (!ctx->links) 103 goto link_err; 104 105 link = ctx->links; 106 107 /* Create SDW Master devices */ 108 for (i = 0; i < count; i++) { 109 if (link_mask && !(link_mask & BIT(i))) { 110 dev_dbg(&adev->dev, 111 "Link %d masked, will not be enabled\n", i); 112 link++; 113 continue; 114 } 115 116 link->registers = res->mmio_base + SDW_LINK_BASE 117 + (SDW_LINK_SIZE * i); 118 link->shim = res->mmio_base + SDW_SHIM_BASE; 119 link->alh = res->mmio_base + SDW_ALH_BASE; 120 121 link->ops = res->ops; 122 link->dev = res->dev; 123 124 memset(&pdevinfo, 0, sizeof(pdevinfo)); 125 126 pdevinfo.parent = res->parent; 127 pdevinfo.name = "int-sdw"; 128 pdevinfo.id = i; 129 pdevinfo.fwnode = acpi_fwnode_handle(adev); 130 131 pdev = platform_device_register_full(&pdevinfo); 132 if (IS_ERR(pdev)) { 133 dev_err(&adev->dev, 134 "platform device creation failed: %ld\n", 135 PTR_ERR(pdev)); 136 goto pdev_err; 137 } 138 139 link->pdev = pdev; 140 link++; 141 } 142 143 return ctx; 144 145 pdev_err: 146 sdw_intel_cleanup_pdev(ctx); 147 link_err: 148 kfree(ctx); 149 return NULL; 150 } 151 152 static acpi_status sdw_intel_acpi_cb(acpi_handle handle, u32 level, 153 void *cdata, void **return_value) 154 { 155 struct sdw_intel_res *res = cdata; 156 struct acpi_device *adev; 157 acpi_status status; 158 u64 adr; 159 160 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr); 161 if (ACPI_FAILURE(status)) 162 return AE_OK; /* keep going */ 163 164 if (acpi_bus_get_device(handle, &adev)) { 165 pr_err("%s: Couldn't find ACPI handle\n", __func__); 166 return AE_NOT_FOUND; 167 } 168 169 res->handle = handle; 170 171 /* 172 * On some Intel platforms, multiple children of the HDAS 173 * device can be found, but only one of them is the SoundWire 174 * controller. The SNDW device is always exposed with 175 * Name(_ADR, 0x40000000), with bits 31..28 representing the 176 * SoundWire link so filter accordingly 177 */ 178 if ((adr & GENMASK(31, 28)) >> 28 != SDW_LINK_TYPE) 179 return AE_OK; /* keep going */ 180 181 /* device found, stop namespace walk */ 182 return AE_CTRL_TERMINATE; 183 } 184 185 /** 186 * sdw_intel_init() - SoundWire Intel init routine 187 * @parent_handle: ACPI parent handle 188 * @res: resource data 189 * 190 * This scans the namespace and creates SoundWire link controller devices 191 * based on the info queried. 192 */ 193 void *sdw_intel_init(acpi_handle *parent_handle, struct sdw_intel_res *res) 194 { 195 acpi_status status; 196 197 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, 198 parent_handle, 1, 199 sdw_intel_acpi_cb, 200 NULL, res, NULL); 201 if (ACPI_FAILURE(status)) 202 return NULL; 203 204 return sdw_intel_add_controller(res); 205 } 206 207 /** 208 * sdw_intel_exit() - SoundWire Intel exit 209 * @arg: callback context 210 * 211 * Delete the controller instances created and cleanup 212 */ 213 void sdw_intel_exit(struct sdw_intel_ctx *ctx) 214 { 215 sdw_intel_cleanup_pdev(ctx); 216 kfree(ctx); 217 } 218 EXPORT_SYMBOL(sdw_intel_exit); 219 220 MODULE_LICENSE("Dual BSD/GPL"); 221 MODULE_DESCRIPTION("Intel Soundwire Init Library"); 222