~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/qcom/qdsp6/q6prm.c

Version: ~ [ linux-6.11.5 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.58 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.114 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.169 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.228 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.284 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.322 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /sound/soc/qcom/qdsp6/q6prm.c (Version linux-6.11.5) and /sound/soc/qcom/qdsp6/q6prm.c (Version linux-5.16.20)


  1 // SPDX-License-Identifier: GPL-2.0                 1 // SPDX-License-Identifier: GPL-2.0
  2 // Copyright (c) 2021, Linaro Limited               2 // Copyright (c) 2021, Linaro Limited
  3                                                     3 
  4 #include <linux/slab.h>                             4 #include <linux/slab.h>
  5 #include <linux/wait.h>                             5 #include <linux/wait.h>
  6 #include <linux/kernel.h>                           6 #include <linux/kernel.h>
  7 #include <linux/module.h>                           7 #include <linux/module.h>
  8 #include <linux/of.h>                               8 #include <linux/of.h>
  9 #include <linux/delay.h>                            9 #include <linux/delay.h>
 10 #include <linux/of_platform.h>                     10 #include <linux/of_platform.h>
 11 #include <linux/jiffies.h>                         11 #include <linux/jiffies.h>
 12 #include <linux/soc/qcom/apr.h>                    12 #include <linux/soc/qcom/apr.h>
 13 #include <dt-bindings/soc/qcom,gpr.h>              13 #include <dt-bindings/soc/qcom,gpr.h>
 14 #include <dt-bindings/sound/qcom,q6dsp-lpass-p     14 #include <dt-bindings/sound/qcom,q6dsp-lpass-ports.h>
 15 #include "q6apm.h"                             << 
 16 #include "q6prm.h"                                 15 #include "q6prm.h"
 17 #include "audioreach.h"                            16 #include "audioreach.h"
 18                                                    17 
 19 struct q6prm {                                     18 struct q6prm {
 20         struct device *dev;                        19         struct device *dev;
 21         gpr_device_t *gdev;                        20         gpr_device_t *gdev;
 22         wait_queue_head_t wait;                    21         wait_queue_head_t wait;
 23         struct gpr_ibasic_rsp_result_t result;     22         struct gpr_ibasic_rsp_result_t result;
 24         struct mutex lock;                         23         struct mutex lock;
 25 };                                                 24 };
 26                                                    25 
 27 #define PRM_CMD_REQUEST_HW_RSC          0x0100     26 #define PRM_CMD_REQUEST_HW_RSC          0x0100100F
 28 #define PRM_CMD_RSP_REQUEST_HW_RSC      0x0200     27 #define PRM_CMD_RSP_REQUEST_HW_RSC      0x02001002
 29 #define PRM_CMD_RELEASE_HW_RSC          0x0100     28 #define PRM_CMD_RELEASE_HW_RSC          0x01001010
 30 #define PRM_CMD_RSP_RELEASE_HW_RSC      0x0200     29 #define PRM_CMD_RSP_RELEASE_HW_RSC      0x02001003
 31 #define PARAM_ID_RSC_HW_CORE            0x0800     30 #define PARAM_ID_RSC_HW_CORE            0x08001032
 32 #define PARAM_ID_RSC_LPASS_CORE         0x0800     31 #define PARAM_ID_RSC_LPASS_CORE         0x0800102B
 33 #define PARAM_ID_RSC_AUDIO_HW_CLK       0x0800     32 #define PARAM_ID_RSC_AUDIO_HW_CLK       0x0800102C
 34                                                    33 
 35 struct prm_cmd_request_hw_core {                   34 struct prm_cmd_request_hw_core {
 36         struct apm_module_param_data param_dat     35         struct apm_module_param_data param_data;
 37         uint32_t hw_clk_id;                        36         uint32_t hw_clk_id;
 38 } __packed;                                        37 } __packed;
 39                                                    38 
 40 struct prm_cmd_request_rsc {                       39 struct prm_cmd_request_rsc {
 41         struct apm_module_param_data param_dat     40         struct apm_module_param_data param_data;
 42         uint32_t num_clk_id;                       41         uint32_t num_clk_id;
 43         struct audio_hw_clk_cfg clock_id;          42         struct audio_hw_clk_cfg clock_id;
 44 } __packed;                                        43 } __packed;
 45                                                    44 
 46 struct prm_cmd_release_rsc {                       45 struct prm_cmd_release_rsc {
 47         struct apm_module_param_data param_dat     46         struct apm_module_param_data param_data;
 48         uint32_t num_clk_id;                       47         uint32_t num_clk_id;
 49         struct audio_hw_clk_rel_cfg clock_id;      48         struct audio_hw_clk_rel_cfg clock_id;
 50 } __packed;                                        49 } __packed;
 51                                                    50 
 52 static int q6prm_send_cmd_sync(struct q6prm *p     51 static int q6prm_send_cmd_sync(struct q6prm *prm, struct gpr_pkt *pkt, uint32_t rsp_opcode)
 53 {                                                  52 {
 54         return audioreach_send_cmd_sync(prm->d     53         return audioreach_send_cmd_sync(prm->dev, prm->gdev, &prm->result, &prm->lock,
 55                                         NULL,      54                                         NULL, &prm->wait, pkt, rsp_opcode);
 56 }                                                  55 }
 57                                                    56 
 58 static int q6prm_set_hw_core_req(struct device     57 static int q6prm_set_hw_core_req(struct device *dev, uint32_t hw_block_id, bool enable)
 59 {                                                  58 {
 60         struct q6prm *prm = dev_get_drvdata(de     59         struct q6prm *prm = dev_get_drvdata(dev->parent);
 61         struct apm_module_param_data *param_da     60         struct apm_module_param_data *param_data;
 62         struct prm_cmd_request_hw_core *req;       61         struct prm_cmd_request_hw_core *req;
 63         gpr_device_t *gdev = prm->gdev;            62         gpr_device_t *gdev = prm->gdev;
 64         uint32_t opcode, rsp_opcode;               63         uint32_t opcode, rsp_opcode;
 65         struct gpr_pkt *pkt;                       64         struct gpr_pkt *pkt;
 66         int rc;                                    65         int rc;
 67                                                    66 
 68         if (enable) {                              67         if (enable) {
 69                 opcode = PRM_CMD_REQUEST_HW_RS     68                 opcode = PRM_CMD_REQUEST_HW_RSC;
 70                 rsp_opcode = PRM_CMD_RSP_REQUE     69                 rsp_opcode = PRM_CMD_RSP_REQUEST_HW_RSC;
 71         } else {                                   70         } else {
 72                 opcode = PRM_CMD_RELEASE_HW_RS     71                 opcode = PRM_CMD_RELEASE_HW_RSC;
 73                 rsp_opcode = PRM_CMD_RSP_RELEA     72                 rsp_opcode = PRM_CMD_RSP_RELEASE_HW_RSC;
 74         }                                          73         }
 75                                                    74 
 76         pkt = audioreach_alloc_cmd_pkt(sizeof(     75         pkt = audioreach_alloc_cmd_pkt(sizeof(*req), opcode, 0, gdev->svc.id, GPR_PRM_MODULE_IID);
 77         if (IS_ERR(pkt))                           76         if (IS_ERR(pkt))
 78                 return PTR_ERR(pkt);               77                 return PTR_ERR(pkt);
 79                                                    78 
 80         req = (void *)pkt + GPR_HDR_SIZE + APM     79         req = (void *)pkt + GPR_HDR_SIZE + APM_CMD_HDR_SIZE;
 81                                                    80 
 82         param_data = &req->param_data;             81         param_data = &req->param_data;
 83                                                    82 
 84         param_data->module_instance_id = GPR_P     83         param_data->module_instance_id = GPR_PRM_MODULE_IID;
 85         param_data->error_code = 0;                84         param_data->error_code = 0;
 86         param_data->param_id = PARAM_ID_RSC_HW     85         param_data->param_id = PARAM_ID_RSC_HW_CORE;
 87         param_data->param_size = sizeof(*req)      86         param_data->param_size = sizeof(*req) - APM_MODULE_PARAM_DATA_SIZE;
 88                                                    87 
 89         req->hw_clk_id = hw_block_id;              88         req->hw_clk_id = hw_block_id;
 90                                                    89 
 91         rc = q6prm_send_cmd_sync(prm, pkt, rsp     90         rc = q6prm_send_cmd_sync(prm, pkt, rsp_opcode);
 92                                                    91 
 93         kfree(pkt);                                92         kfree(pkt);
 94                                                    93 
 95         return rc;                                 94         return rc;
 96 }                                                  95 }
 97                                                    96 
 98 int q6prm_vote_lpass_core_hw(struct device *de     97 int q6prm_vote_lpass_core_hw(struct device *dev, uint32_t hw_block_id,
 99                              const char *clien     98                              const char *client_name, uint32_t *client_handle)
100 {                                                  99 {
101         return q6prm_set_hw_core_req(dev, hw_b    100         return q6prm_set_hw_core_req(dev, hw_block_id, true);
102                                                   101 
103 }                                                 102 }
104 EXPORT_SYMBOL_GPL(q6prm_vote_lpass_core_hw);      103 EXPORT_SYMBOL_GPL(q6prm_vote_lpass_core_hw);
105                                                   104 
106 int q6prm_unvote_lpass_core_hw(struct device *    105 int q6prm_unvote_lpass_core_hw(struct device *dev, uint32_t hw_block_id, uint32_t client_handle)
107 {                                                 106 {
108         return q6prm_set_hw_core_req(dev, hw_b    107         return q6prm_set_hw_core_req(dev, hw_block_id, false);
109 }                                                 108 }
110 EXPORT_SYMBOL_GPL(q6prm_unvote_lpass_core_hw);    109 EXPORT_SYMBOL_GPL(q6prm_unvote_lpass_core_hw);
111                                                   110 
112 static int q6prm_request_lpass_clock(struct de    111 static int q6prm_request_lpass_clock(struct device *dev, int clk_id, int clk_attr, int clk_root,
113                                      unsigned     112                                      unsigned int freq)
114 {                                                 113 {
115         struct q6prm *prm = dev_get_drvdata(de    114         struct q6prm *prm = dev_get_drvdata(dev->parent);
116         struct apm_module_param_data *param_da    115         struct apm_module_param_data *param_data;
117         struct prm_cmd_request_rsc *req;          116         struct prm_cmd_request_rsc *req;
118         gpr_device_t *gdev = prm->gdev;           117         gpr_device_t *gdev = prm->gdev;
119         struct gpr_pkt *pkt;                      118         struct gpr_pkt *pkt;
120         int rc;                                   119         int rc;
121                                                   120 
122         pkt = audioreach_alloc_cmd_pkt(sizeof(    121         pkt = audioreach_alloc_cmd_pkt(sizeof(*req), PRM_CMD_REQUEST_HW_RSC, 0, gdev->svc.id,
123                                        GPR_PRM    122                                        GPR_PRM_MODULE_IID);
124         if (IS_ERR(pkt))                          123         if (IS_ERR(pkt))
125                 return PTR_ERR(pkt);              124                 return PTR_ERR(pkt);
126                                                   125 
127         req = (void *)pkt + GPR_HDR_SIZE + APM    126         req = (void *)pkt + GPR_HDR_SIZE + APM_CMD_HDR_SIZE;
128                                                   127 
129         param_data = &req->param_data;            128         param_data = &req->param_data;
130                                                   129 
131         param_data->module_instance_id = GPR_P    130         param_data->module_instance_id = GPR_PRM_MODULE_IID;
132         param_data->error_code = 0;               131         param_data->error_code = 0;
133         param_data->param_id = PARAM_ID_RSC_AU    132         param_data->param_id = PARAM_ID_RSC_AUDIO_HW_CLK;
134         param_data->param_size = sizeof(*req)     133         param_data->param_size = sizeof(*req) - APM_MODULE_PARAM_DATA_SIZE;
135                                                   134 
136         req->num_clk_id = 1;                      135         req->num_clk_id = 1;
137         req->clock_id.clock_id = clk_id;          136         req->clock_id.clock_id = clk_id;
138         req->clock_id.clock_freq = freq;          137         req->clock_id.clock_freq = freq;
139         req->clock_id.clock_attri = clk_attr;     138         req->clock_id.clock_attri = clk_attr;
140         req->clock_id.clock_root = clk_root;      139         req->clock_id.clock_root = clk_root;
141                                                   140 
142         rc = q6prm_send_cmd_sync(prm, pkt, PRM    141         rc = q6prm_send_cmd_sync(prm, pkt, PRM_CMD_RSP_REQUEST_HW_RSC);
143                                                   142 
144         kfree(pkt);                               143         kfree(pkt);
145                                                   144 
146         return rc;                                145         return rc;
147 }                                                 146 }
148                                                   147 
149 static int q6prm_release_lpass_clock(struct de    148 static int q6prm_release_lpass_clock(struct device *dev, int clk_id, int clk_attr, int clk_root,
150                           unsigned int freq)      149                           unsigned int freq)
151 {                                                 150 {
152         struct q6prm *prm = dev_get_drvdata(de    151         struct q6prm *prm = dev_get_drvdata(dev->parent);
153         struct apm_module_param_data *param_da    152         struct apm_module_param_data *param_data;
154         struct prm_cmd_release_rsc *rel;          153         struct prm_cmd_release_rsc *rel;
155         gpr_device_t *gdev = prm->gdev;           154         gpr_device_t *gdev = prm->gdev;
156         struct gpr_pkt *pkt;                      155         struct gpr_pkt *pkt;
157         int rc;                                   156         int rc;
158                                                   157 
159         pkt = audioreach_alloc_cmd_pkt(sizeof(    158         pkt = audioreach_alloc_cmd_pkt(sizeof(*rel), PRM_CMD_RELEASE_HW_RSC, 0, gdev->svc.id,
160                                        GPR_PRM    159                                        GPR_PRM_MODULE_IID);
161         if (IS_ERR(pkt))                          160         if (IS_ERR(pkt))
162                 return PTR_ERR(pkt);              161                 return PTR_ERR(pkt);
163                                                   162 
164         rel = (void *)pkt + GPR_HDR_SIZE + APM    163         rel = (void *)pkt + GPR_HDR_SIZE + APM_CMD_HDR_SIZE;
165                                                   164 
166         param_data = &rel->param_data;            165         param_data = &rel->param_data;
167                                                   166 
168         param_data->module_instance_id = GPR_P    167         param_data->module_instance_id = GPR_PRM_MODULE_IID;
169         param_data->error_code = 0;               168         param_data->error_code = 0;
170         param_data->param_id = PARAM_ID_RSC_AU    169         param_data->param_id = PARAM_ID_RSC_AUDIO_HW_CLK;
171         param_data->param_size = sizeof(*rel)     170         param_data->param_size = sizeof(*rel) - APM_MODULE_PARAM_DATA_SIZE;
172                                                   171 
173         rel->num_clk_id = 1;                      172         rel->num_clk_id = 1;
174         rel->clock_id.clock_id = clk_id;          173         rel->clock_id.clock_id = clk_id;
175                                                   174 
176         rc = q6prm_send_cmd_sync(prm, pkt, PRM    175         rc = q6prm_send_cmd_sync(prm, pkt, PRM_CMD_RSP_RELEASE_HW_RSC);
177                                                   176 
178         kfree(pkt);                               177         kfree(pkt);
179                                                   178 
180         return rc;                                179         return rc;
181 }                                                 180 }
182                                                   181 
183 int q6prm_set_lpass_clock(struct device *dev,     182 int q6prm_set_lpass_clock(struct device *dev, int clk_id, int clk_attr, int clk_root,
184                           unsigned int freq)      183                           unsigned int freq)
185 {                                                 184 {
186         if (freq)                                 185         if (freq)
187                 return q6prm_request_lpass_clo !! 186                 return q6prm_request_lpass_clock(dev, clk_id, clk_attr, clk_attr, freq);
188                                                   187 
189         return q6prm_release_lpass_clock(dev,  !! 188         return q6prm_release_lpass_clock(dev, clk_id, clk_attr, clk_attr, freq);
190 }                                                 189 }
191 EXPORT_SYMBOL_GPL(q6prm_set_lpass_clock);         190 EXPORT_SYMBOL_GPL(q6prm_set_lpass_clock);
192                                                   191 
193 static int prm_callback(struct gpr_resp_pkt *d    192 static int prm_callback(struct gpr_resp_pkt *data, void *priv, int op)
194 {                                                 193 {
195         gpr_device_t *gdev = priv;                194         gpr_device_t *gdev = priv;
196         struct q6prm *prm = dev_get_drvdata(&g    195         struct q6prm *prm = dev_get_drvdata(&gdev->dev);
197         struct gpr_ibasic_rsp_result_t *result    196         struct gpr_ibasic_rsp_result_t *result;
198         struct gpr_hdr *hdr = &data->hdr;         197         struct gpr_hdr *hdr = &data->hdr;
199                                                   198 
200         switch (hdr->opcode) {                    199         switch (hdr->opcode) {
201         case PRM_CMD_RSP_REQUEST_HW_RSC:          200         case PRM_CMD_RSP_REQUEST_HW_RSC:
202         case PRM_CMD_RSP_RELEASE_HW_RSC:          201         case PRM_CMD_RSP_RELEASE_HW_RSC:
203                 result = data->payload;           202                 result = data->payload;
204                 prm->result.opcode = hdr->opco    203                 prm->result.opcode = hdr->opcode;
205                 prm->result.status = result->s    204                 prm->result.status = result->status;
206                 wake_up(&prm->wait);              205                 wake_up(&prm->wait);
207                 break;                            206                 break;
208         default:                                  207         default:
209                 break;                            208                 break;
210         }                                         209         }
211                                                   210 
212         return 0;                                 211         return 0;
213 }                                                 212 }
214                                                   213 
215 static int prm_probe(gpr_device_t *gdev)          214 static int prm_probe(gpr_device_t *gdev)
216 {                                                 215 {
217         struct device *dev = &gdev->dev;          216         struct device *dev = &gdev->dev;
218         struct q6prm *cc;                         217         struct q6prm *cc;
219                                                   218 
220         cc = devm_kzalloc(dev, sizeof(*cc), GF    219         cc = devm_kzalloc(dev, sizeof(*cc), GFP_KERNEL);
221         if (!cc)                                  220         if (!cc)
222                 return -ENOMEM;                   221                 return -ENOMEM;
223                                                   222 
224         cc->dev = dev;                            223         cc->dev = dev;
225         cc->gdev = gdev;                          224         cc->gdev = gdev;
226         mutex_init(&cc->lock);                    225         mutex_init(&cc->lock);
227         init_waitqueue_head(&cc->wait);           226         init_waitqueue_head(&cc->wait);
228         dev_set_drvdata(dev, cc);                 227         dev_set_drvdata(dev, cc);
229                                                   228 
230         if (!q6apm_is_adsp_ready())            << 
231                 return -EPROBE_DEFER;          << 
232                                                << 
233         return devm_of_platform_populate(dev);    229         return devm_of_platform_populate(dev);
234 }                                                 230 }
235                                                   231 
236 #ifdef CONFIG_OF                                  232 #ifdef CONFIG_OF
237 static const struct of_device_id prm_device_id    233 static const struct of_device_id prm_device_id[]  = {
238         { .compatible = "qcom,q6prm" },           234         { .compatible = "qcom,q6prm" },
239         {},                                       235         {},
240 };                                                236 };
241 MODULE_DEVICE_TABLE(of, prm_device_id);           237 MODULE_DEVICE_TABLE(of, prm_device_id);
242 #endif                                            238 #endif
243                                                   239 
244 static gpr_driver_t prm_driver = {                240 static gpr_driver_t prm_driver = {
245         .probe = prm_probe,                       241         .probe = prm_probe,
246         .gpr_callback = prm_callback,             242         .gpr_callback = prm_callback,
247         .driver = {                               243         .driver = {
248                 .name = "qcom-prm",               244                 .name = "qcom-prm",
249                 .of_match_table = of_match_ptr    245                 .of_match_table = of_match_ptr(prm_device_id),
250         },                                        246         },
251 };                                                247 };
252                                                   248 
253 module_gpr_driver(prm_driver);                    249 module_gpr_driver(prm_driver);
254 MODULE_DESCRIPTION("Q6 Proxy Resource Manager" !! 250 MODULE_DESCRIPTION("Audio Process Manager");
255 MODULE_LICENSE("GPL");                            251 MODULE_LICENSE("GPL");
256                                                   252 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php