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