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/auxiliary_bus.h> 16 #include <linux/pm_runtime.h> 17 #include <linux/soundwire/sdw_intel.h> 18 #include "cadence_master.h" 19 #include "bus.h" 20 #include "intel.h" 21 #include "intel_auxdevice.h" 22 23 static void intel_link_dev_release(struct device *dev) 24 { 25 struct auxiliary_device *auxdev = to_auxiliary_dev(dev); 26 struct sdw_intel_link_dev *ldev = auxiliary_dev_to_sdw_intel_link_dev(auxdev); 27 28 kfree(ldev); 29 } 30 31 /* alloc, init and add link devices */ 32 static struct sdw_intel_link_dev *intel_link_dev_register(struct sdw_intel_res *res, 33 struct sdw_intel_ctx *ctx, 34 struct fwnode_handle *fwnode, 35 const char *name, 36 int link_id) 37 { 38 struct sdw_intel_link_dev *ldev; 39 struct sdw_intel_link_res *link; 40 struct auxiliary_device *auxdev; 41 int ret; 42 43 ldev = kzalloc_obj(*ldev); 44 if (!ldev) 45 return ERR_PTR(-ENOMEM); 46 47 auxdev = &ldev->auxdev; 48 auxdev->name = name; 49 auxdev->dev.parent = res->parent; 50 auxdev->dev.fwnode = fwnode; 51 auxdev->dev.release = intel_link_dev_release; 52 53 /* we don't use an IDA since we already have a link ID */ 54 auxdev->id = link_id; 55 56 /* 57 * keep a handle on the allocated memory, to be used in all other functions. 58 * Since the same pattern is used to skip links that are not enabled, there is 59 * no need to check if ctx->ldev[i] is NULL later on. 60 */ 61 ctx->ldev[link_id] = ldev; 62 63 /* Add link information used in the driver probe */ 64 link = &ldev->link_res; 65 link->hw_ops = res->hw_ops; 66 link->mmio_base = res->mmio_base; 67 if (!res->ext) { 68 link->registers = res->mmio_base + SDW_LINK_BASE 69 + (SDW_LINK_SIZE * link_id); 70 link->ip_offset = 0; 71 link->shim = res->mmio_base + res->shim_base; 72 link->alh = res->mmio_base + res->alh_base; 73 link->shim_lock = &ctx->shim_lock; 74 } else { 75 link->registers = res->mmio_base + SDW_IP_BASE(link_id); 76 link->ip_offset = SDW_CADENCE_MCP_IP_OFFSET; 77 link->shim = res->mmio_base + SDW_SHIM2_GENERIC_BASE(link_id); 78 link->shim_vs = res->mmio_base + SDW_SHIM2_VS_BASE(link_id); 79 link->shim_lock = res->eml_lock; 80 link->mic_privacy = res->mic_privacy; 81 } 82 83 link->ops = res->ops; 84 link->dev = res->dev; 85 86 link->clock_stop_quirks = res->clock_stop_quirks; 87 link->shim_mask = &ctx->shim_mask; 88 link->link_mask = ctx->link_mask; 89 90 link->hbus = res->hbus; 91 92 /* now follow the two-step init/add sequence */ 93 ret = auxiliary_device_init(auxdev); 94 if (ret < 0) { 95 dev_err(res->parent, "failed to initialize link dev %s link_id %d\n", 96 name, link_id); 97 kfree(ldev); 98 return ERR_PTR(ret); 99 } 100 101 ret = auxiliary_device_add(&ldev->auxdev); 102 if (ret < 0) { 103 dev_err(res->parent, "failed to add link dev %s link_id %d\n", 104 ldev->auxdev.name, link_id); 105 /* ldev will be freed with the put_device() and .release sequence */ 106 auxiliary_device_uninit(&ldev->auxdev); 107 return ERR_PTR(ret); 108 } 109 110 return ldev; 111 } 112 113 static void intel_link_dev_unregister(struct sdw_intel_link_dev *ldev) 114 { 115 auxiliary_device_delete(&ldev->auxdev); 116 auxiliary_device_uninit(&ldev->auxdev); 117 } 118 119 static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx) 120 { 121 struct sdw_intel_link_dev *ldev; 122 u32 link_mask; 123 int i; 124 125 link_mask = ctx->link_mask; 126 127 for (i = 0; i < ctx->count; i++) { 128 if (!(link_mask & BIT(i))) 129 continue; 130 131 ldev = ctx->ldev[i]; 132 133 pm_runtime_disable(&ldev->auxdev.dev); 134 if (!ldev->link_res.clock_stop_quirks) 135 pm_runtime_put_noidle(ldev->link_res.dev); 136 137 intel_link_dev_unregister(ldev); 138 } 139 140 return 0; 141 } 142 143 irqreturn_t sdw_intel_thread(int irq, void *dev_id) 144 { 145 struct sdw_intel_ctx *ctx = dev_id; 146 struct sdw_intel_link_res *link; 147 148 list_for_each_entry(link, &ctx->link_list, list) 149 sdw_cdns_irq(irq, link->cdns); 150 151 return IRQ_HANDLED; 152 } 153 EXPORT_SYMBOL_NS(sdw_intel_thread, "SOUNDWIRE_INTEL_INIT"); 154 155 static struct sdw_intel_ctx 156 *sdw_intel_probe_controller(struct sdw_intel_res *res) 157 { 158 struct sdw_intel_link_res *link; 159 struct sdw_intel_link_dev *ldev; 160 struct sdw_intel_ctx *ctx; 161 struct acpi_device *adev; 162 struct sdw_slave *slave; 163 struct list_head *node; 164 struct sdw_bus *bus; 165 u32 link_mask; 166 int num_slaves = 0; 167 int count; 168 int i; 169 170 if (!res) 171 return NULL; 172 173 adev = acpi_fetch_acpi_dev(res->handle); 174 if (!adev) 175 return NULL; 176 177 if (!res->count) 178 return NULL; 179 180 count = res->count; 181 dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count); 182 183 /* 184 * we need to alloc/free memory manually and can't use devm: 185 * this routine may be called from a workqueue, and not from 186 * the parent .probe. 187 * If devm_ was used, the memory might never be freed on errors. 188 */ 189 ctx = kzalloc_obj(*ctx); 190 if (!ctx) 191 return NULL; 192 193 ctx->count = count; 194 195 /* 196 * allocate the array of pointers. The link-specific data is allocated 197 * as part of the first loop below and released with the auxiliary_device_uninit(). 198 * If some links are disabled, the link pointer will remain NULL. Given that the 199 * number of links is small, this is simpler than using a list to keep track of links. 200 */ 201 ctx->ldev = kzalloc_objs(*ctx->ldev, ctx->count); 202 if (!ctx->ldev) { 203 kfree(ctx); 204 return NULL; 205 } 206 207 ctx->mmio_base = res->mmio_base; 208 ctx->shim_base = res->shim_base; 209 ctx->alh_base = res->alh_base; 210 ctx->link_mask = res->link_mask; 211 ctx->handle = res->handle; 212 mutex_init(&ctx->shim_lock); 213 214 link_mask = ctx->link_mask; 215 216 INIT_LIST_HEAD(&ctx->link_list); 217 218 for (i = 0; i < count; i++) { 219 if (!(link_mask & BIT(i))) 220 continue; 221 222 /* 223 * init and add a device for each link 224 * 225 * The name of the device will be soundwire_intel.link.[i], 226 * with the "soundwire_intel" module prefix automatically added 227 * by the auxiliary bus core. 228 */ 229 ldev = intel_link_dev_register(res, 230 ctx, 231 acpi_fwnode_handle(adev), 232 "link", 233 i); 234 if (IS_ERR(ldev)) 235 goto err; 236 237 link = &ldev->link_res; 238 link->cdns = auxiliary_get_drvdata(&ldev->auxdev); 239 240 if (!link->cdns) { 241 dev_err(&adev->dev, "failed to get link->cdns\n"); 242 /* 243 * 1 will be subtracted from i in the err label, but we need to call 244 * intel_link_dev_unregister for this ldev, so plus 1 now 245 */ 246 i++; 247 goto err; 248 } 249 list_add_tail(&link->list, &ctx->link_list); 250 bus = &link->cdns->bus; 251 /* Calculate number of slaves */ 252 list_for_each(node, &bus->slaves) 253 num_slaves++; 254 } 255 256 ctx->peripherals = kmalloc_flex(*ctx->peripherals, array, num_slaves); 257 if (!ctx->peripherals) 258 goto err; 259 ctx->peripherals->num_peripherals = num_slaves; 260 i = 0; 261 list_for_each_entry(link, &ctx->link_list, list) { 262 bus = &link->cdns->bus; 263 list_for_each_entry(slave, &bus->slaves, node) { 264 ctx->peripherals->array[i] = slave; 265 i++; 266 } 267 } 268 269 return ctx; 270 271 err: 272 while (i--) { 273 if (!(link_mask & BIT(i))) 274 continue; 275 ldev = ctx->ldev[i]; 276 intel_link_dev_unregister(ldev); 277 } 278 kfree(ctx->ldev); 279 kfree(ctx); 280 return NULL; 281 } 282 283 static int 284 sdw_intel_startup_controller(struct sdw_intel_ctx *ctx) 285 { 286 struct acpi_device *adev = acpi_fetch_acpi_dev(ctx->handle); 287 struct sdw_intel_link_dev *ldev; 288 u32 link_mask; 289 int i; 290 291 if (!adev) 292 return -EINVAL; 293 294 if (!ctx->ldev) 295 return -EINVAL; 296 297 link_mask = ctx->link_mask; 298 299 /* Startup SDW Master devices */ 300 for (i = 0; i < ctx->count; i++) { 301 if (!(link_mask & BIT(i))) 302 continue; 303 304 ldev = ctx->ldev[i]; 305 306 intel_link_startup(&ldev->auxdev); 307 308 if (!ldev->link_res.clock_stop_quirks) { 309 /* 310 * we need to prevent the parent PCI device 311 * from entering pm_runtime suspend, so that 312 * power rails to the SoundWire IP are not 313 * turned off. 314 */ 315 pm_runtime_get_noresume(ldev->link_res.dev); 316 } 317 } 318 319 return 0; 320 } 321 322 /** 323 * sdw_intel_probe() - SoundWire Intel probe routine 324 * @res: resource data 325 * 326 * This registers an auxiliary device for each Master handled by the controller, 327 * and SoundWire Master and Slave devices will be created by the auxiliary 328 * device probe. All the information necessary is stored in the context, and 329 * the res argument pointer can be freed after this step. 330 * This function will be called after sdw_intel_acpi_scan() by SOF probe. 331 */ 332 struct sdw_intel_ctx 333 *sdw_intel_probe(struct sdw_intel_res *res) 334 { 335 return sdw_intel_probe_controller(res); 336 } 337 EXPORT_SYMBOL_NS(sdw_intel_probe, "SOUNDWIRE_INTEL_INIT"); 338 339 /** 340 * sdw_intel_startup() - SoundWire Intel startup 341 * @ctx: SoundWire context allocated in the probe 342 * 343 * Startup Intel SoundWire controller. This function will be called after 344 * Intel Audio DSP is powered up. 345 */ 346 int sdw_intel_startup(struct sdw_intel_ctx *ctx) 347 { 348 return sdw_intel_startup_controller(ctx); 349 } 350 EXPORT_SYMBOL_NS(sdw_intel_startup, "SOUNDWIRE_INTEL_INIT"); 351 /** 352 * sdw_intel_exit() - SoundWire Intel exit 353 * @ctx: SoundWire context allocated in the probe 354 * 355 * Delete the controller instances created and cleanup 356 */ 357 void sdw_intel_exit(struct sdw_intel_ctx *ctx) 358 { 359 struct sdw_intel_link_res *link; 360 361 /* we first resume links and devices and wait synchronously before the cleanup */ 362 list_for_each_entry(link, &ctx->link_list, list) { 363 struct sdw_bus *bus = &link->cdns->bus; 364 int ret; 365 366 ret = device_for_each_child(bus->dev, NULL, intel_resume_child_device); 367 if (ret < 0) 368 dev_err(bus->dev, "%s: intel_resume_child_device failed: %d\n", 369 __func__, ret); 370 } 371 372 sdw_intel_cleanup(ctx); 373 kfree(ctx->peripherals); 374 kfree(ctx->ldev); 375 kfree(ctx); 376 } 377 EXPORT_SYMBOL_NS(sdw_intel_exit, "SOUNDWIRE_INTEL_INIT"); 378 379 void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx) 380 { 381 struct sdw_intel_link_dev *ldev; 382 u32 link_mask; 383 int i; 384 385 if (!ctx->ldev) 386 return; 387 388 link_mask = ctx->link_mask; 389 390 /* Startup SDW Master devices */ 391 for (i = 0; i < ctx->count; i++) { 392 if (!(link_mask & BIT(i))) 393 continue; 394 395 ldev = ctx->ldev[i]; 396 397 intel_link_process_wakeen_event(&ldev->auxdev); 398 } 399 } 400 EXPORT_SYMBOL_NS(sdw_intel_process_wakeen_event, "SOUNDWIRE_INTEL_INIT"); 401 402 MODULE_LICENSE("Dual BSD/GPL"); 403 MODULE_DESCRIPTION("Intel Soundwire Init Library"); 404