drivers/net/ipa/ipa_power.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
   4  * Copyright (C) 2018-2021 Linaro Ltd.
   5  */
   6
   7 #include <linux/clk.h>
   8 #include <linux/device.h>
   9 #include <linux/interconnect.h>
  10 #include <linux/pm.h>
  11 #include <linux/pm_runtime.h>
  12 #include <linux/bitops.h>
  13
  14 #include "linux/soc/qcom/qcom_aoss.h"
  15
  16 #include "ipa.h"
  17 #include "ipa_power.h"
  18 #include "ipa_endpoint.h"
  19 #include "ipa_modem.h"
  20 #include "ipa_data.h"
  21
  22 /**
  23  * DOC: IPA Power Management
  24  *
  25  * The IPA hardware is enabled when the IPA core clock and all the
  26  * interconnects (buses) it depends on are enabled.  Runtime power
  27  * management is used to determine whether the core clock and
  28  * interconnects are enabled, and if not in use to be suspended
  29  * automatically.
  30  *
  31  * The core clock currently runs at a fixed clock rate when enabled,
  32  * an all interconnects use a fixed average and peak bandwidth.
  33  */
  34
  35 #define IPA_AUTOSUSPEND_DELAY   500     /* milliseconds */
  36
  37 /**
  38  * enum ipa_power_flag - IPA power flags
  39  * @IPA_POWER_FLAG_RESUMED:     Whether resume from suspend has been signaled
  40  * @IPA_POWER_FLAG_SYSTEM:      Hardware is system (not runtime) suspended
  41  * @IPA_POWER_FLAG_STOPPED:     Modem TX is disabled by ipa_start_xmit()
  42  * @IPA_POWER_FLAG_STARTED:     Modem TX was enabled by ipa_runtime_resume()
  43  * @IPA_POWER_FLAG_COUNT:       Number of defined power flags
  44  */
  45 enum ipa_power_flag {
  46         IPA_POWER_FLAG_RESUMED,
  47         IPA_POWER_FLAG_SYSTEM,
  48         IPA_POWER_FLAG_STOPPED,
  49         IPA_POWER_FLAG_STARTED,
  50         IPA_POWER_FLAG_COUNT,           /* Last; not a flag */
  51 };
  52
  53 /**
  54  * struct ipa_power - IPA power management information
  55  * @dev:                IPA device pointer
  56  * @core:               IPA core clock
  57  * @qmp:                QMP handle for AOSS communication
  58  * @spinlock:           Protects modem TX queue enable/disable
  59  * @flags:              Boolean state flags
  60  * @interconnect_count: Number of elements in interconnect[]
  61  * @interconnect:       Interconnect array
  62  */
  63 struct ipa_power {
  64         struct device *dev;
  65         struct clk *core;
  66         struct qmp *qmp;
  67         spinlock_t spinlock;    /* used with STOPPED/STARTED power flags */
  68         DECLARE_BITMAP(flags, IPA_POWER_FLAG_COUNT);
  69         u32 interconnect_count;
  70         struct icc_bulk_data interconnect[];
  71 };
  72
  73 /* Initialize interconnects required for IPA operation */
  74 static int ipa_interconnect_init(struct ipa_power *power,
  75                                  const struct ipa_interconnect_data *data)
  76 {
  77         struct icc_bulk_data *interconnect;
  78         int ret;
  79         u32 i;
  80
  81         /* Initialize our interconnect data array for bulk operations */
  82         interconnect = &power->interconnect[0];
  83         for (i = 0; i < power->interconnect_count; i++) {
  84                 /* interconnect->path is filled in by of_icc_bulk_get() */
  85                 interconnect->name = data->name;
  86                 interconnect->avg_bw = data->average_bandwidth;
  87                 interconnect->peak_bw = data->peak_bandwidth;
  88                 data++;
  89                 interconnect++;
  90         }
  91
  92         ret = of_icc_bulk_get(power->dev, power->interconnect_count,
  93                               power->interconnect);
  94         if (ret)
  95                 return ret;
  96
  97         /* All interconnects are initially disabled */
  98         icc_bulk_disable(power->interconnect_count, power->interconnect);
  99
 100         /* Set the bandwidth values to be used when enabled */
 101         ret = icc_bulk_set_bw(power->interconnect_count, power->interconnect);
 102         if (ret)
 103                 icc_bulk_put(power->interconnect_count, power->interconnect);
 104
 105         return ret;
 106 }
 107
 108 /* Inverse of ipa_interconnect_init() */
 109 static void ipa_interconnect_exit(struct ipa_power *power)
 110 {
 111         icc_bulk_put(power->interconnect_count, power->interconnect);
 112 }
 113
 114 /* Enable IPA power, enabling interconnects and the core clock */
 115 static int ipa_power_enable(struct ipa *ipa)
 116 {
 117         struct ipa_power *power = ipa->power;
 118         int ret;
 119
 120         ret = icc_bulk_enable(power->interconnect_count, power->interconnect);
 121         if (ret)
 122                 return ret;
 123
 124         ret = clk_prepare_enable(power->core);
 125         if (ret) {
 126                 dev_err(power->dev, "error %d enabling core clock\n", ret);
 127                 icc_bulk_disable(power->interconnect_count,
 128                                  power->interconnect);
 129         }
 130
 131         return ret;
 132 }
 133
 134 /* Inverse of ipa_power_enable() */
 135 static void ipa_power_disable(struct ipa *ipa)
 136 {
 137         struct ipa_power *power = ipa->power;
 138
 139         clk_disable_unprepare(power->core);
 140
 141         icc_bulk_disable(power->interconnect_count, power->interconnect);
 142 }
 143
 144 static int ipa_runtime_suspend(struct device *dev)
 145 {
 146         struct ipa *ipa = dev_get_drvdata(dev);
 147
 148         /* Endpoints aren't usable until setup is complete */
 149         if (ipa->setup_complete) {
 150                 __clear_bit(IPA_POWER_FLAG_RESUMED, ipa->power->flags);
 151                 ipa_endpoint_suspend(ipa);
 152                 gsi_suspend(&ipa->gsi);
 153         }
 154
 155         ipa_power_disable(ipa);
 156
 157         return 0;
 158 }
 159
 160 static int ipa_runtime_resume(struct device *dev)
 161 {
 162         struct ipa *ipa = dev_get_drvdata(dev);
 163         int ret;
 164
 165         ret = ipa_power_enable(ipa);
 166         if (WARN_ON(ret < 0))
 167                 return ret;
 168
 169         /* Endpoints aren't usable until setup is complete */
 170         if (ipa->setup_complete) {
 171                 gsi_resume(&ipa->gsi);
 172                 ipa_endpoint_resume(ipa);
 173         }
 174
 175         return 0;
 176 }
 177
 178 static int ipa_suspend(struct device *dev)
 179 {
 180         struct ipa *ipa = dev_get_drvdata(dev);
 181
 182         __set_bit(IPA_POWER_FLAG_SYSTEM, ipa->power->flags);
 183
 184         return pm_runtime_force_suspend(dev);
 185 }
 186
 187 static int ipa_resume(struct device *dev)
 188 {
 189         struct ipa *ipa = dev_get_drvdata(dev);
 190         int ret;
 191
 192         ret = pm_runtime_force_resume(dev);
 193
 194         __clear_bit(IPA_POWER_FLAG_SYSTEM, ipa->power->flags);
 195
 196         return ret;
 197 }
 198
 199 /* Return the current IPA core clock rate */
 200 u32 ipa_core_clock_rate(struct ipa *ipa)
 201 {
 202         return ipa->power ? (u32)clk_get_rate(ipa->power->core) : 0;
 203 }
 204
 205 /**
 206  * ipa_suspend_handler() - Handle the suspend IPA interrupt
 207  * @ipa:        IPA pointer
 208  * @irq_id:     IPA interrupt type (unused)
 209  *
 210  * If an RX endpoint is suspended, and the IPA has a packet destined for
 211  * that endpoint, the IPA generates a SUSPEND interrupt to inform the AP
 212  * that it should resume the endpoint.  If we get one of these interrupts
 213  * we just wake up the system.
 214  */
 215 static void ipa_suspend_handler(struct ipa *ipa, enum ipa_irq_id irq_id)
 216 {
 217         /* To handle an IPA interrupt we will have resumed the hardware
 218          * just to handle the interrupt, so we're done.  If we are in a
 219          * system suspend, trigger a system resume.
 220          */
 221         if (!__test_and_set_bit(IPA_POWER_FLAG_RESUMED, ipa->power->flags))
 222                 if (test_bit(IPA_POWER_FLAG_SYSTEM, ipa->power->flags))
 223                         pm_wakeup_dev_event(&ipa->pdev->dev, 0, true);
 224
 225         /* Acknowledge/clear the suspend interrupt on all endpoints */
 226         ipa_interrupt_suspend_clear_all(ipa->interrupt);
 227 }
 228
 229 /* The next few functions coordinate stopping and starting the modem
 230  * network device transmit queue.
 231  *
 232  * Transmit can be running concurrent with power resume, and there's a
 233  * chance the resume completes before the transmit path stops the queue,
 234  * leaving the queue in a stopped state.  The next two functions are used
 235  * to avoid this: ipa_power_modem_queue_stop() is used by ipa_start_xmit()
 236  * to conditionally stop the TX queue; and ipa_power_modem_queue_start()
 237  * is used by ipa_runtime_resume() to conditionally restart it.
 238  *
 239  * Two flags and a spinlock are used.  If the queue is stopped, the STOPPED
 240  * power flag is set.  And if the queue is started, the STARTED flag is set.
 241  * The queue is only started on resume if the STOPPED flag is set.  And the
 242  * queue is only started in ipa_start_xmit() if the STARTED flag is *not*
 243  * set.  As a result, the queue remains operational if the two activites
 244  * happen concurrently regardless of the order they complete.  The spinlock
 245  * ensures the flag and TX queue operations are done atomically.
 246  *
 247  * The first function stops the modem netdev transmit queue, but only if
 248  * the STARTED flag is *not* set.  That flag is cleared if it was set.
 249  * If the queue is stopped, the STOPPED flag is set.  This is called only
 250  * from the power ->runtime_resume operation.
 251  */
 252 void ipa_power_modem_queue_stop(struct ipa *ipa)
 253 {
 254         struct ipa_power *power = ipa->power;
 255         unsigned long flags;
 256
 257         spin_lock_irqsave(&power->spinlock, flags);
 258
 259         if (!__test_and_clear_bit(IPA_POWER_FLAG_STARTED, power->flags)) {
 260                 netif_stop_queue(ipa->modem_netdev);
 261                 __set_bit(IPA_POWER_FLAG_STOPPED, power->flags);
 262         }
 263
 264         spin_unlock_irqrestore(&power->spinlock, flags);
 265 }
 266
 267 /* This function starts the modem netdev transmit queue, but only if the
 268  * STOPPED flag is set.  That flag is cleared if it was set.  If the queue
 269  * was restarted, the STARTED flag is set; this allows ipa_start_xmit()
 270  * to skip stopping the queue in the event of a race.
 271  */
 272 void ipa_power_modem_queue_wake(struct ipa *ipa)
 273 {
 274         struct ipa_power *power = ipa->power;
 275         unsigned long flags;
 276
 277         spin_lock_irqsave(&power->spinlock, flags);
 278
 279         if (__test_and_clear_bit(IPA_POWER_FLAG_STOPPED, power->flags)) {
 280                 __set_bit(IPA_POWER_FLAG_STARTED, power->flags);
 281                 netif_wake_queue(ipa->modem_netdev);
 282         }
 283
 284         spin_unlock_irqrestore(&power->spinlock, flags);
 285 }
 286
 287 /* This function clears the STARTED flag once the TX queue is operating */
 288 void ipa_power_modem_queue_active(struct ipa *ipa)
 289 {
 290         clear_bit(IPA_POWER_FLAG_STARTED, ipa->power->flags);
 291 }
 292
 293 static int ipa_power_retention_init(struct ipa_power *power)
 294 {
 295         struct qmp *qmp = qmp_get(power->dev);
 296
 297         if (IS_ERR(qmp)) {
 298                 if (PTR_ERR(qmp) == -EPROBE_DEFER)
 299                         return -EPROBE_DEFER;
 300
 301                 /* We assume any other error means it's not defined/needed */
 302                 qmp = NULL;
 303         }
 304         power->qmp = qmp;
 305
 306         return 0;
 307 }
 308
 309 static void ipa_power_retention_exit(struct ipa_power *power)
 310 {
 311         qmp_put(power->qmp);
 312         power->qmp = NULL;
 313 }
 314
 315 /* Control register retention on power collapse */
 316 void ipa_power_retention(struct ipa *ipa, bool enable)
 317 {
 318         static const char fmt[] = "{ class: bcm, res: ipa_pc, val: %c }";
 319         struct ipa_power *power = ipa->power;
 320         char buf[36];   /* Exactly enough for fmt[]; size a multiple of 4 */
 321         int ret;
 322
 323         if (!power->qmp)
 324                 return;         /* Not needed on this platform */
 325
 326         (void)snprintf(buf, sizeof(buf), fmt, enable ? '1' : '0');
 327
 328         ret = qmp_send(power->qmp, buf, sizeof(buf));
 329         if (ret)
 330                 dev_err(power->dev, "error %d sending QMP %sable request\n",
 331                         ret, enable ? "en" : "dis");
 332 }
 333
 334 int ipa_power_setup(struct ipa *ipa)
 335 {
 336         int ret;
 337
 338         ipa_interrupt_add(ipa->interrupt, IPA_IRQ_TX_SUSPEND,
 339                           ipa_suspend_handler);
 340
 341         ret = device_init_wakeup(&ipa->pdev->dev, true);
 342         if (ret)
 343                 ipa_interrupt_remove(ipa->interrupt, IPA_IRQ_TX_SUSPEND);
 344
 345         return ret;
 346 }
 347
 348 void ipa_power_teardown(struct ipa *ipa)
 349 {
 350         (void)device_init_wakeup(&ipa->pdev->dev, false);
 351         ipa_interrupt_remove(ipa->interrupt, IPA_IRQ_TX_SUSPEND);
 352 }
 353
 354 /* Initialize IPA power management */
 355 struct ipa_power *
 356 ipa_power_init(struct device *dev, const struct ipa_power_data *data)
 357 {
 358         struct ipa_power *power;
 359         struct clk *clk;
 360         size_t size;
 361         int ret;
 362
 363         clk = clk_get(dev, "core");
 364         if (IS_ERR(clk)) {
 365                 dev_err_probe(dev, PTR_ERR(clk), "error getting core clock\n");
 366
 367                 return ERR_CAST(clk);
 368         }
 369
 370         ret = clk_set_rate(clk, data->core_clock_rate);
 371         if (ret) {
 372                 dev_err(dev, "error %d setting core clock rate to %u\n",
 373                         ret, data->core_clock_rate);
 374                 goto err_clk_put;
 375         }
 376
 377         size = struct_size(power, interconnect, data->interconnect_count);
 378         power = kzalloc(size, GFP_KERNEL);
 379         if (!power) {
 380                 ret = -ENOMEM;
 381                 goto err_clk_put;
 382         }
 383         power->dev = dev;
 384         power->core = clk;
 385         spin_lock_init(&power->spinlock);
 386         power->interconnect_count = data->interconnect_count;
 387
 388         ret = ipa_interconnect_init(power, data->interconnect_data);
 389         if (ret)
 390                 goto err_kfree;
 391
 392         ret = ipa_power_retention_init(power);
 393         if (ret)
 394                 goto err_interconnect_exit;
 395
 396         pm_runtime_set_autosuspend_delay(dev, IPA_AUTOSUSPEND_DELAY);
 397         pm_runtime_use_autosuspend(dev);
 398         pm_runtime_enable(dev);
 399
 400         return power;
 401
 402 err_interconnect_exit:
 403         ipa_interconnect_exit(power);
 404 err_kfree:
 405         kfree(power);
 406 err_clk_put:
 407         clk_put(clk);
 408
 409         return ERR_PTR(ret);
 410 }
 411
 412 /* Inverse of ipa_power_init() */
 413 void ipa_power_exit(struct ipa_power *power)
 414 {
 415         struct device *dev = power->dev;
 416         struct clk *clk = power->core;
 417
 418         pm_runtime_disable(dev);
 419         pm_runtime_dont_use_autosuspend(dev);
 420         ipa_power_retention_exit(power);
 421         ipa_interconnect_exit(power);
 422         kfree(power);
 423         clk_put(clk);
 424 }
 425
 426 const struct dev_pm_ops ipa_pm_ops = {
 427         .suspend                = ipa_suspend,
 428         .resume                 = ipa_resume,
 429         .runtime_suspend        = ipa_runtime_suspend,
 430         .runtime_resume         = ipa_runtime_resume,
 431 };