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
 20struct 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 */
 44struct 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 */
 64struct 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 */
 80struct rpmh_ctrlr {
 81	struct list_head cache;
 82	spinlock_t cache_lock;
 83	bool dirty;
 84	struct list_head batch_cache;
 85};
 86
 87struct 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 */
120struct 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
139int rpmh_rsc_send_data(struct rsc_drv *drv, const struct tcs_request *msg);
140int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv,
141			     const struct tcs_request *msg);
142void rpmh_rsc_invalidate(struct rsc_drv *drv);
143void rpmh_rsc_write_next_wakeup(struct rsc_drv *drv);
144
145void rpmh_tx_done(const struct tcs_request *msg);
146int rpmh_flush(struct rpmh_ctrlr *ctrlr);
147
148#endif /* __RPM_INTERNAL_H__ */