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