drivers/soundwire/intel_init.c

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