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  * @err: err return from the controller
63  * @needs_free: check to free dynamically allocated request object
64  */
65 struct rpmh_request {
66 	struct tcs_request msg;
67 	struct tcs_cmd cmd[MAX_RPMH_PAYLOAD];
68 	struct completion *completion;
69 	const struct device *dev;
70 	int err;
71 	bool needs_free;
72 };
73 
74 /**
75  * struct rpmh_ctrlr: our representation of the controller
76  *
77  * @cache: the list of cached requests
78  * @cache_lock: synchronize access to the cache data
79  * @dirty: was the cache updated since flush
80  * @batch_cache: Cache sleep and wake requests sent as batch
81  */
82 struct rpmh_ctrlr {
83 	struct list_head cache;
84 	spinlock_t cache_lock;
85 	bool dirty;
86 	struct list_head batch_cache;
87 };
88 
89 /**
90  * struct rsc_drv: the Direct Resource Voter (DRV) of the
91  * Resource State Coordinator controller (RSC)
92  *
93  * @name:               Controller identifier.
94  * @tcs_base:           Start address of the TCS registers in this controller.
95  * @id:                 Instance id in the controller (Direct Resource Voter).
96  * @num_tcs:            Number of TCSes in this DRV.
97  * @rsc_pm:             CPU PM notifier for controller.
98  *                      Used when solver mode is not present.
99  * @cpus_in_pm:         Number of CPUs not in idle power collapse.
100  *                      Used when solver mode is not present.
101  * @tcs:                TCS groups.
102  * @tcs_in_use:         S/W state of the TCS; only set for ACTIVE_ONLY
103  *                      transfers, but might show a sleep/wake TCS in use if
104  *                      it was borrowed for an active_only transfer.  You
105  *                      must hold the lock in this struct (AKA drv->lock) in
106  *                      order to update this.
107  * @lock:               Synchronize state of the controller.  If RPMH's cache
108  *                      lock will also be held, the order is: drv->lock then
109  *                      cache_lock.
110  * @tcs_wait:           Wait queue used to wait for @tcs_in_use to free up a
111  *                      slot
112  * @client:             Handle to the DRV's client.
113  */
114 struct rsc_drv {
115 	const char *name;
116 	void __iomem *tcs_base;
117 	int id;
118 	int num_tcs;
119 	struct notifier_block rsc_pm;
120 	atomic_t cpus_in_pm;
121 	struct tcs_group tcs[TCS_TYPE_NR];
122 	DECLARE_BITMAP(tcs_in_use, MAX_TCS_NR);
123 	spinlock_t lock;
124 	wait_queue_head_t tcs_wait;
125 	struct rpmh_ctrlr client;
126 };
127 
128 int rpmh_rsc_send_data(struct rsc_drv *drv, const struct tcs_request *msg);
129 int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv,
130 			     const struct tcs_request *msg);
131 void rpmh_rsc_invalidate(struct rsc_drv *drv);
132 
133 void rpmh_tx_done(const struct tcs_request *msg, int r);
134 int rpmh_flush(struct rpmh_ctrlr *ctrlr);
135 
136 #endif /* __RPM_INTERNAL_H__ */
137