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