drivers/soc/qcom/rpmh-internal.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
   4  */
   5
   6
   7 #ifndef __RPM_INTERNAL_H__
   8 #define __RPM_INTERNAL_H__
   9
  10 #include <linux/bitmap.h>
  11 #include <linux/wait.h>
  12 #include <soc/qcom/tcs.h>
  13
  14 #define TCS_TYPE_NR                     4
  15 #define MAX_CMDS_PER_TCS                16
  16 #define MAX_TCS_PER_TYPE                3
  17 #define MAX_TCS_NR                      (MAX_TCS_PER_TYPE * TCS_TYPE_NR)
  18 #define MAX_TCS_SLOTS                   (MAX_CMDS_PER_TCS * MAX_TCS_PER_TYPE)
  19
  20 struct rsc_drv;
  21
  22 /**
  23  * struct tcs_group: group of Trigger Command Sets (TCS) to send state requests
  24  * to the controller
  25  *
  26  * @drv:       The controller.
  27  * @type:      Type of the TCS in this group - active, sleep, wake.
  28  * @mask:      Mask of the TCSes relative to all the TCSes in the RSC.
  29  * @offset:    Start of the TCS group relative to the TCSes in the RSC.
  30  * @num_tcs:   Number of TCSes in this type.
  31  * @ncpt:      Number of commands in each TCS.
  32  * @req:       Requests that are sent from the TCS; only used for ACTIVE_ONLY
  33  *             transfers (could be on a wake/sleep TCS if we are borrowing for
  34  *             an ACTIVE_ONLY transfer).
  35  *             Start: grab drv->lock, set req, set tcs_in_use, drop drv->lock,
  36  *                    trigger
  37  *             End: get irq, access req,
  38  *                  grab drv->lock, clear tcs_in_use, drop drv->lock
  39  * @slots:     Indicates which of @cmd_addr are occupied; only used for
  40  *             SLEEP / WAKE TCSs.  Things are tightly packed in the
  41  *             case that (ncpt < MAX_CMDS_PER_TCS).  That is if ncpt = 2 and
  42  *             MAX_CMDS_PER_TCS = 16 then bit[2] = the first bit in 2nd TCS.
  43  */
  44 struct tcs_group {
  45         struct rsc_drv *drv;
  46         int type;
  47         u32 mask;
  48         u32 offset;
  49         int num_tcs;
  50         int ncpt;
  51         const struct tcs_request *req[MAX_TCS_PER_TYPE];
  52         DECLARE_BITMAP(slots, MAX_TCS_SLOTS);
  53 };
  54
  55 /**
  56  * struct rpmh_request: the message to be sent to rpmh-rsc
  57  *
  58  * @msg: the request
  59  * @cmd: the payload that will be part of the @msg
  60  * @completion: triggered when request is done
  61  * @dev: the device making the request
  62  * @needs_free: check to free dynamically allocated request object
  63  */
  64 struct rpmh_request {
  65         struct tcs_request msg;
  66         struct tcs_cmd cmd[MAX_RPMH_PAYLOAD];
  67         struct completion *completion;
  68         const struct device *dev;
  69         bool needs_free;
  70 };
  71
  72 /**
  73  * struct rpmh_ctrlr: our representation of the controller
  74  *
  75  * @cache: the list of cached requests
  76  * @cache_lock: synchronize access to the cache data
  77  * @dirty: was the cache updated since flush
  78  * @batch_cache: Cache sleep and wake requests sent as batch
  79  */
  80 struct rpmh_ctrlr {
  81         struct list_head cache;
  82         spinlock_t cache_lock;
  83         bool dirty;
  84         struct list_head batch_cache;
  85 };
  86
  87 struct rsc_ver {
  88         u32 major;
  89         u32 minor;
  90 };
  91
  92 /**
  93  * struct rsc_drv: the Direct Resource Voter (DRV) of the
  94  * Resource State Coordinator controller (RSC)
  95  *
  96  * @name:               Controller identifier.
  97  * @base:               Start address of the DRV registers in this controller.
  98  * @tcs_base:           Start address of the TCS registers in this controller.
  99  * @id:                 Instance id in the controller (Direct Resource Voter).
 100  * @num_tcs:            Number of TCSes in this DRV.
 101  * @rsc_pm:             CPU PM notifier for controller.
 102  *                      Used when solver mode is not present.
 103  * @cpus_in_pm:         Number of CPUs not in idle power collapse.
 104  *                      Used when solver mode and "power-domains" is not present.
 105  * @genpd_nb:           PM Domain notifier for cluster genpd notifications.
 106  * @tcs:                TCS groups.
 107  * @tcs_in_use:         S/W state of the TCS; only set for ACTIVE_ONLY
 108  *                      transfers, but might show a sleep/wake TCS in use if
 109  *                      it was borrowed for an active_only transfer.  You
 110  *                      must hold the lock in this struct (AKA drv->lock) in
 111  *                      order to update this.
 112  * @lock:               Synchronize state of the controller.  If RPMH's cache
 113  *                      lock will also be held, the order is: drv->lock then
 114  *                      cache_lock.
 115  * @tcs_wait:           Wait queue used to wait for @tcs_in_use to free up a
 116  *                      slot
 117  * @client:             Handle to the DRV's client.
 118  * @dev:                RSC device.
 119  */
 120 struct rsc_drv {
 121         const char *name;
 122         void __iomem *base;
 123         void __iomem *tcs_base;
 124         int id;
 125         int num_tcs;
 126         struct notifier_block rsc_pm;
 127         struct notifier_block genpd_nb;
 128         atomic_t cpus_in_pm;
 129         struct tcs_group tcs[TCS_TYPE_NR];
 130         DECLARE_BITMAP(tcs_in_use, MAX_TCS_NR);
 131         spinlock_t lock;
 132         wait_queue_head_t tcs_wait;
 133         struct rpmh_ctrlr client;
 134         struct device *dev;
 135         struct rsc_ver ver;
 136         u32 *regs;
 137 };
 138
 139 int rpmh_rsc_send_data(struct rsc_drv *drv, const struct tcs_request *msg);
 140 int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv,
 141                              const struct tcs_request *msg);
 142 void rpmh_rsc_invalidate(struct rsc_drv *drv);
 143 void rpmh_rsc_write_next_wakeup(struct rsc_drv *drv);
 144
 145 void rpmh_tx_done(const struct tcs_request *msg);
 146 int rpmh_flush(struct rpmh_ctrlr *ctrlr);
 147
 148 #endif /* __RPM_INTERNAL_H__ */