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(sizeof(*ldev), GFP_KERNEL); 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 } 81 82 link->ops = res->ops; 83 link->dev = res->dev; 84 85 link->clock_stop_quirks = res->clock_stop_quirks; 86 link->shim_mask = &ctx->shim_mask; 87 link->link_mask = ctx->link_mask; 88 89 link->hbus = res->hbus; 90 91 /* now follow the two-step init/add sequence */ 92 ret = auxiliary_device_init(auxdev); 93 if (ret < 0) { 94 dev_err(res->parent, "failed to initialize link dev %s link_id %d\n", 95 name, link_id); 96 kfree(ldev); 97 return ERR_PTR(ret); 98 } 99 100 ret = auxiliary_device_add(&ldev->auxdev); 101 if (ret < 0) { 102 dev_err(res->parent, "failed to add link dev %s link_id %d\n", 103 ldev->auxdev.name, link_id); 104 /* ldev will be freed with the put_device() and .release sequence */ 105 auxiliary_device_uninit(&ldev->auxdev); 106 return ERR_PTR(ret); 107 } 108 109 return ldev; 110 } 111 112 static void intel_link_dev_unregister(struct sdw_intel_link_dev *ldev) 113 { 114 auxiliary_device_delete(&ldev->auxdev); 115 auxiliary_device_uninit(&ldev->auxdev); 116 } 117 118 static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx) 119 { 120 struct sdw_intel_link_dev *ldev; 121 u32 link_mask; 122 int i; 123 124 link_mask = ctx->link_mask; 125 126 for (i = 0; i < ctx->count; i++) { 127 if (!(link_mask & BIT(i))) 128 continue; 129 130 ldev = ctx->ldev[i]; 131 132 pm_runtime_disable(&ldev->auxdev.dev); 133 if (!ldev->link_res.clock_stop_quirks) 134 pm_runtime_put_noidle(ldev->link_res.dev); 135 136 intel_link_dev_unregister(ldev); 137 } 138 139 return 0; 140 } 141 142 irqreturn_t sdw_intel_thread(int irq, void *dev_id) 143 { 144 struct sdw_intel_ctx *ctx = dev_id; 145 struct sdw_intel_link_res *link; 146 147 list_for_each_entry(link, &ctx->link_list, list) 148 sdw_cdns_irq(irq, link->cdns); 149 150 return IRQ_HANDLED; 151 } 152 EXPORT_SYMBOL_NS(sdw_intel_thread, SOUNDWIRE_INTEL_INIT); 153 154 static struct sdw_intel_ctx 155 *sdw_intel_probe_controller(struct sdw_intel_res *res) 156 { 157 struct sdw_intel_link_res *link; 158 struct sdw_intel_link_dev *ldev; 159 struct sdw_intel_ctx *ctx; 160 struct acpi_device *adev; 161 struct sdw_slave *slave; 162 struct list_head *node; 163 struct sdw_bus *bus; 164 u32 link_mask; 165 int num_slaves = 0; 166 int count; 167 int i; 168 169 if (!res) 170 return NULL; 171 172 adev = acpi_fetch_acpi_dev(res->handle); 173 if (!adev) 174 return NULL; 175 176 if (!res->count) 177 return NULL; 178 179 count = res->count; 180 dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count); 181 182 /* 183 * we need to alloc/free memory manually and can't use devm: 184 * this routine may be called from a workqueue, and not from 185 * the parent .probe. 186 * If devm_ was used, the memory might never be freed on errors. 187 */ 188 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 189 if (!ctx) 190 return NULL; 191 192 ctx->count = count; 193 194 /* 195 * allocate the array of pointers. The link-specific data is allocated 196 * as part of the first loop below and released with the auxiliary_device_uninit(). 197 * If some links are disabled, the link pointer will remain NULL. Given that the 198 * number of links is small, this is simpler than using a list to keep track of links. 199 */ 200 ctx->ldev = kcalloc(ctx->count, sizeof(*ctx->ldev), GFP_KERNEL); 201 if (!ctx->ldev) { 202 kfree(ctx); 203 return NULL; 204 } 205 206 ctx->mmio_base = res->mmio_base; 207 ctx->shim_base = res->shim_base; 208 ctx->alh_base = res->alh_base; 209 ctx->link_mask = res->link_mask; 210 ctx->handle = res->handle; 211 mutex_init(&ctx->shim_lock); 212 213 link_mask = ctx->link_mask; 214 215 INIT_LIST_HEAD(&ctx->link_list); 216 217 for (i = 0; i < count; i++) { 218 if (!(link_mask & BIT(i))) 219 continue; 220 221 /* 222 * init and add a device for each link 223 * 224 * The name of the device will be soundwire_intel.link.[i], 225 * with the "soundwire_intel" module prefix automatically added 226 * by the auxiliary bus core. 227 */ 228 ldev = intel_link_dev_register(res, 229 ctx, 230 acpi_fwnode_handle(adev), 231 "link", 232 i); 233 if (IS_ERR(ldev)) 234 goto err; 235 236 link = &ldev->link_res; 237 link->cdns = auxiliary_get_drvdata(&ldev->auxdev); 238 239 if (!link->cdns) { 240 dev_err(&adev->dev, "failed to get link->cdns\n"); 241 /* 242 * 1 will be subtracted from i in the err label, but we need to call 243 * intel_link_dev_unregister for this ldev, so plus 1 now 244 */ 245 i++; 246 goto err; 247 } 248 list_add_tail(&link->list, &ctx->link_list); 249 bus = &link->cdns->bus; 250 /* Calculate number of slaves */ 251 list_for_each(node, &bus->slaves) 252 num_slaves++; 253 } 254 255 ctx->peripherals = kmalloc(struct_size(ctx->peripherals, array, num_slaves), 256 GFP_KERNEL); 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