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/interrupt.h> 13 #include <linux/io.h> 14 #include <linux/module.h> 15 #include <linux/platform_device.h> 16 #include <linux/soundwire/sdw_intel.h> 17 #include "cadence_master.h" 18 #include "intel.h" 19 20 #define SDW_LINK_TYPE 4 /* from Intel ACPI documentation */ 21 #define SDW_MAX_LINKS 4 22 #define SDW_SHIM_LCAP 0x0 23 #define SDW_SHIM_BASE 0x2C000 24 #define SDW_ALH_BASE 0x2C800 25 #define SDW_LINK_BASE 0x30000 26 #define SDW_LINK_SIZE 0x10000 27 28 static int ctrl_link_mask; 29 module_param_named(sdw_link_mask, ctrl_link_mask, int, 0444); 30 MODULE_PARM_DESC(sdw_link_mask, "Intel link mask (one bit per link)"); 31 32 static bool is_link_enabled(struct fwnode_handle *fw_node, int i) 33 { 34 struct fwnode_handle *link; 35 char name[32]; 36 u32 quirk_mask = 0; 37 38 /* Find master handle */ 39 snprintf(name, sizeof(name), 40 "mipi-sdw-link-%d-subproperties", i); 41 42 link = fwnode_get_named_child_node(fw_node, name); 43 if (!link) 44 return false; 45 46 fwnode_property_read_u32(link, 47 "intel-quirk-mask", 48 &quirk_mask); 49 50 if (quirk_mask & SDW_INTEL_QUIRK_MASK_BUS_DISABLE) 51 return false; 52 53 return true; 54 } 55 56 static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx) 57 { 58 struct sdw_intel_link_res *link = ctx->links; 59 u32 link_mask; 60 int i; 61 62 if (!link) 63 return 0; 64 65 link_mask = ctx->link_mask; 66 67 for (i = 0; i < ctx->count; i++, link++) { 68 if (!(link_mask & BIT(i))) 69 continue; 70 71 if (link->pdev) 72 platform_device_unregister(link->pdev); 73 } 74 75 return 0; 76 } 77 78 static int 79 sdw_intel_scan_controller(struct sdw_intel_acpi_info *info) 80 { 81 struct acpi_device *adev; 82 int ret, i; 83 u8 count; 84 85 if (acpi_bus_get_device(info->handle, &adev)) 86 return -EINVAL; 87 88 /* Found controller, find links supported */ 89 count = 0; 90 ret = fwnode_property_read_u8_array(acpi_fwnode_handle(adev), 91 "mipi-sdw-master-count", &count, 1); 92 93 /* 94 * In theory we could check the number of links supported in 95 * hardware, but in that step we cannot assume SoundWire IP is 96 * powered. 97 * 98 * In addition, if the BIOS doesn't even provide this 99 * 'master-count' property then all the inits based on link 100 * masks will fail as well. 101 * 102 * We will check the hardware capabilities in the startup() step 103 */ 104 105 if (ret) { 106 dev_err(&adev->dev, 107 "Failed to read mipi-sdw-master-count: %d\n", ret); 108 return -EINVAL; 109 } 110 111 /* Check count is within bounds */ 112 if (count > SDW_MAX_LINKS) { 113 dev_err(&adev->dev, "Link count %d exceeds max %d\n", 114 count, SDW_MAX_LINKS); 115 return -EINVAL; 116 } 117 118 if (!count) { 119 dev_warn(&adev->dev, "No SoundWire links detected\n"); 120 return -EINVAL; 121 } 122 dev_dbg(&adev->dev, "ACPI reports %d SDW Link devices\n", count); 123 124 info->count = count; 125 info->link_mask = 0; 126 127 for (i = 0; i < count; i++) { 128 if (ctrl_link_mask && !(ctrl_link_mask & BIT(i))) { 129 dev_dbg(&adev->dev, 130 "Link %d masked, will not be enabled\n", i); 131 continue; 132 } 133 134 if (!is_link_enabled(acpi_fwnode_handle(adev), i)) { 135 dev_dbg(&adev->dev, 136 "Link %d not selected in firmware\n", i); 137 continue; 138 } 139 140 info->link_mask |= BIT(i); 141 } 142 143 return 0; 144 } 145 146 #define HDA_DSP_REG_ADSPIC2 (0x10) 147 #define HDA_DSP_REG_ADSPIS2 (0x14) 148 #define HDA_DSP_REG_ADSPIC2_SNDW BIT(5) 149 150 /** 151 * sdw_intel_enable_irq() - enable/disable Intel SoundWire IRQ 152 * @mmio_base: The mmio base of the control register 153 * @enable: true if enable 154 */ 155 void sdw_intel_enable_irq(void __iomem *mmio_base, bool enable) 156 { 157 u32 val; 158 159 val = readl(mmio_base + HDA_DSP_REG_ADSPIC2); 160 161 if (enable) 162 val |= HDA_DSP_REG_ADSPIC2_SNDW; 163 else 164 val &= ~HDA_DSP_REG_ADSPIC2_SNDW; 165 166 writel(val, mmio_base + HDA_DSP_REG_ADSPIC2); 167 } 168 EXPORT_SYMBOL_NS(sdw_intel_enable_irq, SOUNDWIRE_INTEL_INIT); 169 170 irqreturn_t sdw_intel_thread(int irq, void *dev_id) 171 { 172 struct sdw_intel_ctx *ctx = dev_id; 173 struct sdw_intel_link_res *link; 174 175 list_for_each_entry(link, &ctx->link_list, list) 176 sdw_cdns_irq(irq, link->cdns); 177 178 sdw_intel_enable_irq(ctx->mmio_base, true); 179 return IRQ_HANDLED; 180 } 181 EXPORT_SYMBOL_NS(sdw_intel_thread, SOUNDWIRE_INTEL_INIT); 182 183 static struct sdw_intel_ctx 184 *sdw_intel_probe_controller(struct sdw_intel_res *res) 185 { 186 struct platform_device_info pdevinfo; 187 struct platform_device *pdev; 188 struct sdw_intel_link_res *link; 189 struct sdw_intel_ctx *ctx; 190 struct acpi_device *adev; 191 struct sdw_slave *slave; 192 struct list_head *node; 193 struct sdw_bus *bus; 194 u32 link_mask; 195 int num_slaves = 0; 196 int count; 197 int i; 198 199 if (!res) 200 return NULL; 201 202 if (acpi_bus_get_device(res->handle, &adev)) 203 return NULL; 204 205 if (!res->count) 206 return NULL; 207 208 count = res->count; 209 dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count); 210 211 ctx = devm_kzalloc(&adev->dev, sizeof(*ctx), GFP_KERNEL); 212 if (!ctx) 213 return NULL; 214 215 ctx->count = count; 216 ctx->links = devm_kcalloc(&adev->dev, ctx->count, 217 sizeof(*ctx->links), GFP_KERNEL); 218 if (!ctx->links) 219 return NULL; 220 221 ctx->count = count; 222 ctx->mmio_base = res->mmio_base; 223 ctx->link_mask = res->link_mask; 224 ctx->handle = res->handle; 225 mutex_init(&ctx->shim_lock); 226 227 link = ctx->links; 228 link_mask = ctx->link_mask; 229 230 INIT_LIST_HEAD(&ctx->link_list); 231 232 /* Create SDW Master devices */ 233 for (i = 0; i < count; i++, link++) { 234 if (!(link_mask & BIT(i))) { 235 dev_dbg(&adev->dev, 236 "Link %d masked, will not be enabled\n", i); 237 continue; 238 } 239 240 link->mmio_base = res->mmio_base; 241 link->registers = res->mmio_base + SDW_LINK_BASE 242 + (SDW_LINK_SIZE * i); 243 link->shim = res->mmio_base + SDW_SHIM_BASE; 244 link->alh = res->mmio_base + SDW_ALH_BASE; 245 246 link->ops = res->ops; 247 link->dev = res->dev; 248 249 link->shim_lock = &ctx->shim_lock; 250 link->shim_mask = &ctx->shim_mask; 251 252 memset(&pdevinfo, 0, sizeof(pdevinfo)); 253 254 pdevinfo.parent = res->parent; 255 pdevinfo.name = "intel-sdw"; 256 pdevinfo.id = i; 257 pdevinfo.fwnode = acpi_fwnode_handle(adev); 258 pdevinfo.data = link; 259 pdevinfo.size_data = sizeof(*link); 260 261 pdev = platform_device_register_full(&pdevinfo); 262 if (IS_ERR(pdev)) { 263 dev_err(&adev->dev, 264 "platform device creation failed: %ld\n", 265 PTR_ERR(pdev)); 266 goto err; 267 } 268 link->pdev = pdev; 269 link->cdns = platform_get_drvdata(pdev); 270 271 list_add_tail(&link->list, &ctx->link_list); 272 bus = &link->cdns->bus; 273 /* Calculate number of slaves */ 274 list_for_each(node, &bus->slaves) 275 num_slaves++; 276 } 277 278 ctx->ids = devm_kcalloc(&adev->dev, num_slaves, 279 sizeof(*ctx->ids), GFP_KERNEL); 280 if (!ctx->ids) 281 goto err; 282 283 ctx->num_slaves = num_slaves; 284 i = 0; 285 list_for_each_entry(link, &ctx->link_list, list) { 286 bus = &link->cdns->bus; 287 list_for_each_entry(slave, &bus->slaves, node) { 288 ctx->ids[i].id = slave->id; 289 ctx->ids[i].link_id = bus->link_id; 290 i++; 291 } 292 } 293 294 return ctx; 295 296 err: 297 ctx->count = i; 298 sdw_intel_cleanup(ctx); 299 return NULL; 300 } 301 302 static int 303 sdw_intel_startup_controller(struct sdw_intel_ctx *ctx) 304 { 305 struct acpi_device *adev; 306 struct sdw_intel_link_res *link; 307 u32 caps; 308 u32 link_mask; 309 int i; 310 311 if (acpi_bus_get_device(ctx->handle, &adev)) 312 return -EINVAL; 313 314 /* Check SNDWLCAP.LCOUNT */ 315 caps = ioread32(ctx->mmio_base + SDW_SHIM_BASE + SDW_SHIM_LCAP); 316 caps &= GENMASK(2, 0); 317 318 /* Check HW supported vs property value */ 319 if (caps < ctx->count) { 320 dev_err(&adev->dev, 321 "BIOS master count is larger than hardware capabilities\n"); 322 return -EINVAL; 323 } 324 325 if (!ctx->links) 326 return -EINVAL; 327 328 link = ctx->links; 329 link_mask = ctx->link_mask; 330 331 /* Startup SDW Master devices */ 332 for (i = 0; i < ctx->count; i++, link++) { 333 if (!(link_mask & BIT(i))) 334 continue; 335 336 intel_master_startup(link->pdev); 337 } 338 339 return 0; 340 } 341 342 static acpi_status sdw_intel_acpi_cb(acpi_handle handle, u32 level, 343 void *cdata, void **return_value) 344 { 345 struct sdw_intel_acpi_info *info = cdata; 346 struct acpi_device *adev; 347 acpi_status status; 348 u64 adr; 349 350 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr); 351 if (ACPI_FAILURE(status)) 352 return AE_OK; /* keep going */ 353 354 if (acpi_bus_get_device(handle, &adev)) { 355 pr_err("%s: Couldn't find ACPI handle\n", __func__); 356 return AE_NOT_FOUND; 357 } 358 359 info->handle = handle; 360 361 /* 362 * On some Intel platforms, multiple children of the HDAS 363 * device can be found, but only one of them is the SoundWire 364 * controller. The SNDW device is always exposed with 365 * Name(_ADR, 0x40000000), with bits 31..28 representing the 366 * SoundWire link so filter accordingly 367 */ 368 if ((adr & GENMASK(31, 28)) >> 28 != SDW_LINK_TYPE) 369 return AE_OK; /* keep going */ 370 371 /* device found, stop namespace walk */ 372 return AE_CTRL_TERMINATE; 373 } 374 375 /** 376 * sdw_intel_acpi_scan() - SoundWire Intel init routine 377 * @parent_handle: ACPI parent handle 378 * @info: description of what firmware/DSDT tables expose 379 * 380 * This scans the namespace and queries firmware to figure out which 381 * links to enable. A follow-up use of sdw_intel_probe() and 382 * sdw_intel_startup() is required for creation of devices and bus 383 * startup 384 */ 385 int sdw_intel_acpi_scan(acpi_handle *parent_handle, 386 struct sdw_intel_acpi_info *info) 387 { 388 acpi_status status; 389 390 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, 391 parent_handle, 1, 392 sdw_intel_acpi_cb, 393 NULL, info, NULL); 394 if (ACPI_FAILURE(status)) 395 return -ENODEV; 396 397 return sdw_intel_scan_controller(info); 398 } 399 EXPORT_SYMBOL_NS(sdw_intel_acpi_scan, SOUNDWIRE_INTEL_INIT); 400 401 /** 402 * sdw_intel_probe() - SoundWire Intel probe routine 403 * @res: resource data 404 * 405 * This registers a platform device for each Master handled by the controller, 406 * and SoundWire Master and Slave devices will be created by the platform 407 * device probe. All the information necessary is stored in the context, and 408 * the res argument pointer can be freed after this step. 409 * This function will be called after sdw_intel_acpi_scan() by SOF probe. 410 */ 411 struct sdw_intel_ctx 412 *sdw_intel_probe(struct sdw_intel_res *res) 413 { 414 return sdw_intel_probe_controller(res); 415 } 416 EXPORT_SYMBOL_NS(sdw_intel_probe, SOUNDWIRE_INTEL_INIT); 417 418 /** 419 * sdw_intel_startup() - SoundWire Intel startup 420 * @ctx: SoundWire context allocated in the probe 421 * 422 * Startup Intel SoundWire controller. This function will be called after 423 * Intel Audio DSP is powered up. 424 */ 425 int sdw_intel_startup(struct sdw_intel_ctx *ctx) 426 { 427 return sdw_intel_startup_controller(ctx); 428 } 429 EXPORT_SYMBOL_NS(sdw_intel_startup, SOUNDWIRE_INTEL_INIT); 430 /** 431 * sdw_intel_exit() - SoundWire Intel exit 432 * @ctx: SoundWire context allocated in the probe 433 * 434 * Delete the controller instances created and cleanup 435 */ 436 void sdw_intel_exit(struct sdw_intel_ctx *ctx) 437 { 438 sdw_intel_cleanup(ctx); 439 } 440 EXPORT_SYMBOL_NS(sdw_intel_exit, SOUNDWIRE_INTEL_INIT); 441 442 void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx) 443 { 444 struct sdw_intel_link_res *link; 445 u32 link_mask; 446 int i; 447 448 if (!ctx->links) 449 return; 450 451 link = ctx->links; 452 link_mask = ctx->link_mask; 453 454 /* Startup SDW Master devices */ 455 for (i = 0; i < ctx->count; i++, link++) { 456 if (!(link_mask & BIT(i))) 457 continue; 458 459 intel_master_process_wakeen_event(link->pdev); 460 } 461 } 462 EXPORT_SYMBOL_NS(sdw_intel_process_wakeen_event, SOUNDWIRE_INTEL_INIT); 463 464 MODULE_LICENSE("Dual BSD/GPL"); 465 MODULE_DESCRIPTION("Intel Soundwire Init Library"); 466