tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 <soc/qcom/tcs.h>
12
13#define TCS_TYPE_NR 4
14#define MAX_CMDS_PER_TCS 16
15#define MAX_TCS_PER_TYPE 3
16#define MAX_TCS_NR (MAX_TCS_PER_TYPE * TCS_TYPE_NR)
17#define MAX_TCS_SLOTS (MAX_CMDS_PER_TCS * MAX_TCS_PER_TYPE)
18
19struct rsc_drv;
20
21/**
22 * struct tcs_group: group of Trigger Command Sets (TCS) to send state requests
23 * to the controller
24 *
25 * @drv: The controller.
26 * @type: Type of the TCS in this group - active, sleep, wake.
27 * @mask: Mask of the TCSes relative to all the TCSes in the RSC.
28 * @offset: Start of the TCS group relative to the TCSes in the RSC.
29 * @num_tcs: Number of TCSes in this type.
30 * @ncpt: Number of commands in each TCS.
31 * @req: Requests that are sent from the TCS; only used for ACTIVE_ONLY
32 * transfers (could be on a wake/sleep TCS if we are borrowing for
33 * an ACTIVE_ONLY transfer).
34 * Start: grab drv->lock, set req, set tcs_in_use, drop drv->lock,
35 * trigger
36 * End: get irq, access req,
37 * grab drv->lock, clear tcs_in_use, drop drv->lock
38 * @slots: Indicates which of @cmd_addr are occupied; only used for
39 * SLEEP / WAKE TCSs. Things are tightly packed in the
40 * case that (ncpt < MAX_CMDS_PER_TCS). That is if ncpt = 2 and
41 * MAX_CMDS_PER_TCS = 16 then bit[2] = the first bit in 2nd TCS.
42 */
43struct tcs_group {
44 struct rsc_drv *drv;
45 int type;
46 u32 mask;
47 u32 offset;
48 int num_tcs;
49 int ncpt;
50 const struct tcs_request *req[MAX_TCS_PER_TYPE];
51 DECLARE_BITMAP(slots, MAX_TCS_SLOTS);
52};
53
54/**
55 * struct rpmh_request: the message to be sent to rpmh-rsc
56 *
57 * @msg: the request
58 * @cmd: the payload that will be part of the @msg
59 * @completion: triggered when request is done
60 * @dev: the device making the request
61 * @err: err return from the controller
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 int err;
70 bool needs_free;
71};
72
73/**
74 * struct rpmh_ctrlr: our representation of the controller
75 *
76 * @cache: the list of cached requests
77 * @cache_lock: synchronize access to the cache data
78 * @dirty: was the cache updated since flush
79 * @batch_cache: Cache sleep and wake requests sent as batch
80 */
81struct rpmh_ctrlr {
82 struct list_head cache;
83 spinlock_t cache_lock;
84 bool dirty;
85 struct list_head batch_cache;
86};
87
88/**
89 * struct rsc_drv: the Direct Resource Voter (DRV) of the
90 * Resource State Coordinator controller (RSC)
91 *
92 * @name: Controller identifier.
93 * @tcs_base: Start address of the TCS registers in this controller.
94 * @id: Instance id in the controller (Direct Resource Voter).
95 * @num_tcs: Number of TCSes in this DRV.
96 * @rsc_pm: CPU PM notifier for controller.
97 * Used when solver mode is not present.
98 * @cpus_in_pm: Number of CPUs not in idle power collapse.
99 * Used when solver mode is not present.
100 * @tcs: TCS groups.
101 * @tcs_in_use: S/W state of the TCS; only set for ACTIVE_ONLY
102 * transfers, but might show a sleep/wake TCS in use if
103 * it was borrowed for an active_only transfer. You
104 * must hold the lock in this struct (AKA drv->lock) in
105 * order to update this.
106 * @lock: Synchronize state of the controller. If RPMH's cache
107 * lock will also be held, the order is: drv->lock then
108 * cache_lock.
109 * @client: Handle to the DRV's client.
110 */
111struct rsc_drv {
112 const char *name;
113 void __iomem *tcs_base;
114 int id;
115 int num_tcs;
116 struct notifier_block rsc_pm;
117 atomic_t cpus_in_pm;
118 struct tcs_group tcs[TCS_TYPE_NR];
119 DECLARE_BITMAP(tcs_in_use, MAX_TCS_NR);
120 spinlock_t lock;
121 struct rpmh_ctrlr client;
122};
123
124int rpmh_rsc_send_data(struct rsc_drv *drv, const struct tcs_request *msg);
125int rpmh_rsc_write_ctrl_data(struct rsc_drv *drv,
126 const struct tcs_request *msg);
127void rpmh_rsc_invalidate(struct rsc_drv *drv);
128
129void rpmh_tx_done(const struct tcs_request *msg, int r);
130int rpmh_flush(struct rpmh_ctrlr *ctrlr);
131
132#endif /* __RPM_INTERNAL_H__ */