1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Qualcomm Protection Domain mapper
4 *
5 * Copyright (c) 2023 Linaro Ltd.
6 */
7
8#include <linux/auxiliary_bus.h>
9#include <linux/kernel.h>
10#include <linux/mod_devicetable.h>
11#include <linux/module.h>
12#include <linux/of.h>
13#include <linux/refcount.h>
14#include <linux/slab.h>
15#include <linux/soc/qcom/qmi.h>
16
17#include "pdr_internal.h"
18
19#define SERVREG_QMI_VERSION 0x101
20#define SERVREG_QMI_INSTANCE 0
21
22#define TMS_SERVREG_SERVICE "tms/servreg"
23
24struct qcom_pdm_domain_data {
25 const char *domain;
26 u32 instance_id;
27 /* NULL-terminated array */
28 const char * services[];
29};
30
31struct qcom_pdm_domain {
32 struct list_head list;
33 const char *name;
34 u32 instance_id;
35};
36
37struct qcom_pdm_service {
38 struct list_head list;
39 struct list_head domains;
40 const char *name;
41};
42
43struct qcom_pdm_data {
44 refcount_t refcnt;
45 struct qmi_handle handle;
46 struct list_head services;
47};
48
49static DEFINE_MUTEX(qcom_pdm_mutex); /* protects __qcom_pdm_data */
50static struct qcom_pdm_data *__qcom_pdm_data;
51
52static struct qcom_pdm_service *qcom_pdm_find(struct qcom_pdm_data *data,
53 const char *name)
54{
55 struct qcom_pdm_service *service;
56
57 list_for_each_entry(service, &data->services, list) {
58 if (!strcmp(service->name, name))
59 return service;
60 }
61
62 return NULL;
63}
64
65static int qcom_pdm_add_service_domain(struct qcom_pdm_data *data,
66 const char *service_name,
67 const char *domain_name,
68 u32 instance_id)
69{
70 struct qcom_pdm_service *service;
71 struct qcom_pdm_domain *domain;
72
73 service = qcom_pdm_find(data, name: service_name);
74 if (service) {
75 list_for_each_entry(domain, &service->domains, list) {
76 if (!strcmp(domain->name, domain_name))
77 return -EBUSY;
78 }
79 } else {
80 service = kzalloc(sizeof(*service), GFP_KERNEL);
81 if (!service)
82 return -ENOMEM;
83
84 INIT_LIST_HEAD(list: &service->domains);
85 service->name = service_name;
86
87 list_add_tail(new: &service->list, head: &data->services);
88 }
89
90 domain = kzalloc(sizeof(*domain), GFP_KERNEL);
91 if (!domain) {
92 if (list_empty(head: &service->domains)) {
93 list_del(entry: &service->list);
94 kfree(objp: service);
95 }
96
97 return -ENOMEM;
98 }
99
100 domain->name = domain_name;
101 domain->instance_id = instance_id;
102 list_add_tail(new: &domain->list, head: &service->domains);
103
104 return 0;
105}
106
107static int qcom_pdm_add_domain(struct qcom_pdm_data *data,
108 const struct qcom_pdm_domain_data *domain)
109{
110 int ret;
111 int i;
112
113 ret = qcom_pdm_add_service_domain(data,
114 TMS_SERVREG_SERVICE,
115 domain_name: domain->domain,
116 instance_id: domain->instance_id);
117 if (ret)
118 return ret;
119
120 for (i = 0; domain->services[i]; i++) {
121 ret = qcom_pdm_add_service_domain(data,
122 service_name: domain->services[i],
123 domain_name: domain->domain,
124 instance_id: domain->instance_id);
125 if (ret)
126 return ret;
127 }
128
129 return 0;
130
131}
132
133static void qcom_pdm_free_domains(struct qcom_pdm_data *data)
134{
135 struct qcom_pdm_service *service, *tservice;
136 struct qcom_pdm_domain *domain, *tdomain;
137
138 list_for_each_entry_safe(service, tservice, &data->services, list) {
139 list_for_each_entry_safe(domain, tdomain, &service->domains, list) {
140 list_del(entry: &domain->list);
141 kfree(objp: domain);
142 }
143
144 list_del(entry: &service->list);
145 kfree(objp: service);
146 }
147}
148
149static void qcom_pdm_get_domain_list(struct qmi_handle *qmi,
150 struct sockaddr_qrtr *sq,
151 struct qmi_txn *txn,
152 const void *decoded)
153{
154 struct qcom_pdm_data *data = container_of(qmi, struct qcom_pdm_data, handle);
155 const struct servreg_get_domain_list_req *req = decoded;
156 struct servreg_get_domain_list_resp *rsp;
157 struct qcom_pdm_service *service;
158 u32 offset;
159 int ret;
160
161 rsp = kzalloc(sizeof(*rsp), GFP_KERNEL);
162 if (!rsp)
163 return;
164
165 offset = req->domain_offset_valid ? req->domain_offset : 0;
166
167 rsp->resp.result = QMI_RESULT_SUCCESS_V01;
168 rsp->resp.error = QMI_ERR_NONE_V01;
169
170 rsp->db_rev_count_valid = true;
171 rsp->db_rev_count = 1;
172
173 rsp->total_domains_valid = true;
174 rsp->total_domains = 0;
175
176 mutex_lock(&qcom_pdm_mutex);
177
178 service = qcom_pdm_find(data, name: req->service_name);
179 if (service) {
180 struct qcom_pdm_domain *domain;
181
182 rsp->domain_list_valid = true;
183 rsp->domain_list_len = 0;
184
185 list_for_each_entry(domain, &service->domains, list) {
186 u32 i = rsp->total_domains++;
187
188 if (i >= offset && i < SERVREG_DOMAIN_LIST_LENGTH) {
189 u32 j = rsp->domain_list_len++;
190
191 strscpy(rsp->domain_list[j].name, domain->name,
192 sizeof(rsp->domain_list[i].name));
193 rsp->domain_list[j].instance = domain->instance_id;
194
195 pr_debug("PDM: found %s / %d\n", domain->name,
196 domain->instance_id);
197 }
198 }
199 }
200
201 pr_debug("PDM: service '%s' offset %d returning %d domains (of %d)\n", req->service_name,
202 req->domain_offset_valid ? req->domain_offset : -1, rsp->domain_list_len, rsp->total_domains);
203
204 ret = qmi_send_response(qmi, sq, txn, SERVREG_GET_DOMAIN_LIST_REQ,
205 SERVREG_GET_DOMAIN_LIST_RESP_MAX_LEN,
206 ei: servreg_get_domain_list_resp_ei, c_struct: rsp);
207 if (ret)
208 pr_err("Error sending servreg response: %d\n", ret);
209
210 mutex_unlock(lock: &qcom_pdm_mutex);
211
212 kfree(objp: rsp);
213}
214
215static void qcom_pdm_pfr(struct qmi_handle *qmi,
216 struct sockaddr_qrtr *sq,
217 struct qmi_txn *txn,
218 const void *decoded)
219{
220 const struct servreg_loc_pfr_req *req = decoded;
221 struct servreg_loc_pfr_resp rsp = {};
222 int ret;
223
224 pr_warn_ratelimited("PDM: service '%s' crash: '%s'\n", req->service, req->reason);
225
226 rsp.rsp.result = QMI_RESULT_SUCCESS_V01;
227 rsp.rsp.error = QMI_ERR_NONE_V01;
228
229 ret = qmi_send_response(qmi, sq, txn, SERVREG_LOC_PFR_REQ,
230 SERVREG_LOC_PFR_RESP_MAX_LEN,
231 ei: servreg_loc_pfr_resp_ei, c_struct: &rsp);
232 if (ret)
233 pr_err("Error sending servreg response: %d\n", ret);
234}
235
236static const struct qmi_msg_handler qcom_pdm_msg_handlers[] = {
237 {
238 .type = QMI_REQUEST,
239 .msg_id = SERVREG_GET_DOMAIN_LIST_REQ,
240 .ei = servreg_get_domain_list_req_ei,
241 .decoded_size = sizeof(struct servreg_get_domain_list_req),
242 .fn = qcom_pdm_get_domain_list,
243 },
244 {
245 .type = QMI_REQUEST,
246 .msg_id = SERVREG_LOC_PFR_REQ,
247 .ei = servreg_loc_pfr_req_ei,
248 .decoded_size = sizeof(struct servreg_loc_pfr_req),
249 .fn = qcom_pdm_pfr,
250 },
251 { },
252};
253
254static const struct qcom_pdm_domain_data adsp_audio_pd = {
255 .domain = "msm/adsp/audio_pd",
256 .instance_id = 74,
257 .services = {
258 "avs/audio",
259 NULL,
260 },
261};
262
263static const struct qcom_pdm_domain_data adsp_charger_pd = {
264 .domain = "msm/adsp/charger_pd",
265 .instance_id = 74,
266 .services = { NULL },
267};
268
269static const struct qcom_pdm_domain_data adsp_root_pd = {
270 .domain = "msm/adsp/root_pd",
271 .instance_id = 74,
272 .services = { NULL },
273};
274
275static const struct qcom_pdm_domain_data adsp_root_pd_pdr = {
276 .domain = "msm/adsp/root_pd",
277 .instance_id = 74,
278 .services = {
279 "tms/pdr_enabled",
280 NULL,
281 },
282};
283
284static const struct qcom_pdm_domain_data adsp_sensor_pd = {
285 .domain = "msm/adsp/sensor_pd",
286 .instance_id = 74,
287 .services = { NULL },
288};
289
290static const struct qcom_pdm_domain_data msm8996_adsp_audio_pd = {
291 .domain = "msm/adsp/audio_pd",
292 .instance_id = 4,
293 .services = { NULL },
294};
295
296static const struct qcom_pdm_domain_data msm8996_adsp_root_pd = {
297 .domain = "msm/adsp/root_pd",
298 .instance_id = 4,
299 .services = { NULL },
300};
301
302static const struct qcom_pdm_domain_data cdsp_root_pd = {
303 .domain = "msm/cdsp/root_pd",
304 .instance_id = 76,
305 .services = { NULL },
306};
307
308static const struct qcom_pdm_domain_data slpi_root_pd = {
309 .domain = "msm/slpi/root_pd",
310 .instance_id = 90,
311 .services = { NULL },
312};
313
314static const struct qcom_pdm_domain_data slpi_sensor_pd = {
315 .domain = "msm/slpi/sensor_pd",
316 .instance_id = 90,
317 .services = { NULL },
318};
319
320static const struct qcom_pdm_domain_data mpss_root_pd = {
321 .domain = "msm/modem/root_pd",
322 .instance_id = 180,
323 .services = {
324 NULL,
325 },
326};
327
328static const struct qcom_pdm_domain_data mpss_root_pd_gps = {
329 .domain = "msm/modem/root_pd",
330 .instance_id = 180,
331 .services = {
332 "gps/gps_service",
333 NULL,
334 },
335};
336
337static const struct qcom_pdm_domain_data mpss_root_pd_gps_pdr = {
338 .domain = "msm/modem/root_pd",
339 .instance_id = 180,
340 .services = {
341 "gps/gps_service",
342 "tms/pdr_enabled",
343 NULL,
344 },
345};
346
347static const struct qcom_pdm_domain_data msm8996_mpss_root_pd = {
348 .domain = "msm/modem/root_pd",
349 .instance_id = 100,
350 .services = { NULL },
351};
352
353static const struct qcom_pdm_domain_data mpss_wlan_pd = {
354 .domain = "msm/modem/wlan_pd",
355 .instance_id = 180,
356 .services = {
357 "kernel/elf_loader",
358 "wlan/fw",
359 NULL,
360 },
361};
362
363static const struct qcom_pdm_domain_data *kaanapali_domains[] = {
364 &adsp_audio_pd,
365 &adsp_root_pd,
366 &adsp_sensor_pd,
367 &cdsp_root_pd,
368 &mpss_root_pd_gps,
369 NULL,
370};
371
372static const struct qcom_pdm_domain_data *msm8996_domains[] = {
373 &msm8996_adsp_audio_pd,
374 &msm8996_adsp_root_pd,
375 &msm8996_mpss_root_pd,
376 NULL,
377};
378
379static const struct qcom_pdm_domain_data *msm8998_domains[] = {
380 &mpss_root_pd,
381 &mpss_wlan_pd,
382 NULL,
383};
384
385static const struct qcom_pdm_domain_data *qcm2290_domains[] = {
386 &adsp_audio_pd,
387 &adsp_root_pd,
388 &adsp_sensor_pd,
389 &mpss_root_pd_gps,
390 &mpss_wlan_pd,
391 NULL,
392};
393
394static const struct qcom_pdm_domain_data *qcs404_domains[] = {
395 &adsp_audio_pd,
396 &adsp_root_pd,
397 &adsp_sensor_pd,
398 &cdsp_root_pd,
399 &mpss_root_pd,
400 &mpss_wlan_pd,
401 NULL,
402};
403
404static const struct qcom_pdm_domain_data *sc7180_domains[] = {
405 &adsp_audio_pd,
406 &adsp_root_pd_pdr,
407 &adsp_sensor_pd,
408 &mpss_root_pd_gps_pdr,
409 &mpss_wlan_pd,
410 NULL,
411};
412
413static const struct qcom_pdm_domain_data *sc7280_domains[] = {
414 &adsp_audio_pd,
415 &adsp_root_pd_pdr,
416 &adsp_charger_pd,
417 &adsp_sensor_pd,
418 &cdsp_root_pd,
419 &mpss_root_pd_gps_pdr,
420 NULL,
421};
422
423static const struct qcom_pdm_domain_data *sc8180x_domains[] = {
424 &adsp_audio_pd,
425 &adsp_root_pd,
426 &adsp_charger_pd,
427 &cdsp_root_pd,
428 &mpss_root_pd_gps,
429 &mpss_wlan_pd,
430 NULL,
431};
432
433static const struct qcom_pdm_domain_data *sc8280xp_domains[] = {
434 &adsp_audio_pd,
435 &adsp_root_pd_pdr,
436 &adsp_charger_pd,
437 &cdsp_root_pd,
438 NULL,
439};
440
441/* Unlike SDM660, SDM630/636 lack CDSP */
442static const struct qcom_pdm_domain_data *sdm630_domains[] = {
443 &adsp_audio_pd,
444 &adsp_root_pd,
445 &adsp_sensor_pd,
446 &mpss_root_pd,
447 &mpss_wlan_pd,
448 NULL,
449};
450
451static const struct qcom_pdm_domain_data *sdm660_domains[] = {
452 &adsp_audio_pd,
453 &adsp_root_pd,
454 &adsp_sensor_pd,
455 &cdsp_root_pd,
456 &mpss_root_pd,
457 &mpss_wlan_pd,
458 NULL,
459};
460
461static const struct qcom_pdm_domain_data *sdm670_domains[] = {
462 &adsp_audio_pd,
463 &adsp_root_pd,
464 &cdsp_root_pd,
465 &mpss_root_pd,
466 &mpss_wlan_pd,
467 NULL,
468};
469
470static const struct qcom_pdm_domain_data *sdm845_domains[] = {
471 &adsp_audio_pd,
472 &adsp_root_pd,
473 &cdsp_root_pd,
474 &mpss_root_pd,
475 &mpss_wlan_pd,
476 &slpi_root_pd,
477 &slpi_sensor_pd,
478 NULL,
479};
480
481static const struct qcom_pdm_domain_data *sm6115_domains[] = {
482 &adsp_audio_pd,
483 &adsp_root_pd,
484 &adsp_sensor_pd,
485 &cdsp_root_pd,
486 &mpss_root_pd_gps,
487 &mpss_wlan_pd,
488 NULL,
489};
490
491static const struct qcom_pdm_domain_data *sm6350_domains[] = {
492 &adsp_audio_pd,
493 &adsp_root_pd,
494 &adsp_sensor_pd,
495 &cdsp_root_pd,
496 &mpss_wlan_pd,
497 NULL,
498};
499
500static const struct qcom_pdm_domain_data *sm7150_domains[] = {
501 &adsp_audio_pd,
502 &adsp_root_pd,
503 &adsp_sensor_pd,
504 &cdsp_root_pd,
505 &mpss_root_pd_gps,
506 &mpss_wlan_pd,
507 NULL,
508};
509
510static const struct qcom_pdm_domain_data *sm8150_domains[] = {
511 &adsp_audio_pd,
512 &adsp_root_pd,
513 &cdsp_root_pd,
514 &mpss_root_pd_gps,
515 &mpss_wlan_pd,
516 NULL,
517};
518
519static const struct qcom_pdm_domain_data *sm8250_domains[] = {
520 &adsp_audio_pd,
521 &adsp_root_pd,
522 &cdsp_root_pd,
523 &slpi_root_pd,
524 &slpi_sensor_pd,
525 NULL,
526};
527
528static const struct qcom_pdm_domain_data *sm8350_domains[] = {
529 &adsp_audio_pd,
530 &adsp_root_pd_pdr,
531 &adsp_charger_pd,
532 &cdsp_root_pd,
533 &mpss_root_pd_gps,
534 &slpi_root_pd,
535 &slpi_sensor_pd,
536 NULL,
537};
538
539static const struct qcom_pdm_domain_data *sm8550_domains[] = {
540 &adsp_audio_pd,
541 &adsp_root_pd,
542 &adsp_charger_pd,
543 &adsp_sensor_pd,
544 &cdsp_root_pd,
545 &mpss_root_pd_gps,
546 NULL,
547};
548
549static const struct qcom_pdm_domain_data *x1e80100_domains[] = {
550 &adsp_audio_pd,
551 &adsp_root_pd,
552 &adsp_charger_pd,
553 &adsp_sensor_pd,
554 &cdsp_root_pd,
555 NULL,
556};
557
558static const struct of_device_id qcom_pdm_domains[] __maybe_unused = {
559 { .compatible = "qcom,apq8016", .data = NULL, },
560 { .compatible = "qcom,apq8064", .data = NULL, },
561 { .compatible = "qcom,apq8074", .data = NULL, },
562 { .compatible = "qcom,apq8084", .data = NULL, },
563 { .compatible = "qcom,apq8096", .data = msm8996_domains, },
564 { .compatible = "qcom,kaanapali", .data = kaanapali_domains, },
565 { .compatible = "qcom,msm8226", .data = NULL, },
566 { .compatible = "qcom,msm8909", .data = NULL, },
567 { .compatible = "qcom,msm8916", .data = NULL, },
568 { .compatible = "qcom,msm8939", .data = NULL, },
569 { .compatible = "qcom,msm8974", .data = NULL, },
570 { .compatible = "qcom,msm8996", .data = msm8996_domains, },
571 { .compatible = "qcom,msm8998", .data = msm8998_domains, },
572 { .compatible = "qcom,qcm2290", .data = qcm2290_domains, },
573 { .compatible = "qcom,qcm6490", .data = sc7280_domains, },
574 { .compatible = "qcom,qcs404", .data = qcs404_domains, },
575 { .compatible = "qcom,sc7180", .data = sc7180_domains, },
576 { .compatible = "qcom,sc7280", .data = sc7280_domains, },
577 { .compatible = "qcom,sc8180x", .data = sc8180x_domains, },
578 { .compatible = "qcom,sc8280xp", .data = sc8280xp_domains, },
579 { .compatible = "qcom,sdm630", .data = sdm630_domains, },
580 { .compatible = "qcom,sdm636", .data = sdm630_domains, },
581 { .compatible = "qcom,sda660", .data = sdm660_domains, },
582 { .compatible = "qcom,sdm660", .data = sdm660_domains, },
583 { .compatible = "qcom,sdm670", .data = sdm670_domains, },
584 { .compatible = "qcom,sdm845", .data = sdm845_domains, },
585 { .compatible = "qcom,sm4250", .data = sm6115_domains, },
586 { .compatible = "qcom,sm6115", .data = sm6115_domains, },
587 { .compatible = "qcom,sm6350", .data = sm6350_domains, },
588 { .compatible = "qcom,sm7150", .data = sm7150_domains, },
589 { .compatible = "qcom,sm7225", .data = sm6350_domains, },
590 { .compatible = "qcom,sm7325", .data = sc7280_domains, },
591 { .compatible = "qcom,sm8150", .data = sm8150_domains, },
592 { .compatible = "qcom,sm8250", .data = sm8250_domains, },
593 { .compatible = "qcom,sm8350", .data = sm8350_domains, },
594 { .compatible = "qcom,sm8450", .data = sm8350_domains, },
595 { .compatible = "qcom,sm8550", .data = sm8550_domains, },
596 { .compatible = "qcom,sm8650", .data = sm8550_domains, },
597 { .compatible = "qcom,sm8750", .data = sm8550_domains, },
598 { .compatible = "qcom,x1e80100", .data = x1e80100_domains, },
599 { .compatible = "qcom,x1p42100", .data = x1e80100_domains, },
600 {},
601};
602
603static void qcom_pdm_stop(struct qcom_pdm_data *data)
604{
605 qcom_pdm_free_domains(data);
606
607 /* The server is removed automatically */
608 qmi_handle_release(qmi: &data->handle);
609
610 kfree(objp: data);
611}
612
613static struct qcom_pdm_data *qcom_pdm_start(void)
614{
615 const struct qcom_pdm_domain_data * const *domains;
616 const struct of_device_id *match;
617 struct qcom_pdm_data *data;
618 struct device_node *root;
619 int ret, i;
620
621 root = of_find_node_by_path(path: "/");
622 if (!root)
623 return ERR_PTR(error: -ENODEV);
624
625 match = of_match_node(matches: qcom_pdm_domains, node: root);
626 of_node_put(node: root);
627 if (!match) {
628 pr_notice("PDM: no support for the platform, userspace daemon might be required.\n");
629 return ERR_PTR(error: -ENODEV);
630 }
631
632 domains = match->data;
633 if (!domains) {
634 pr_debug("PDM: no domains\n");
635 return ERR_PTR(error: -ENODEV);
636 }
637
638 data = kzalloc(sizeof(*data), GFP_KERNEL);
639 if (!data)
640 return ERR_PTR(error: -ENOMEM);
641
642 INIT_LIST_HEAD(list: &data->services);
643
644 ret = qmi_handle_init(qmi: &data->handle, SERVREG_GET_DOMAIN_LIST_REQ_MAX_LEN,
645 NULL, handlers: qcom_pdm_msg_handlers);
646 if (ret) {
647 kfree(objp: data);
648 return ERR_PTR(error: ret);
649 }
650
651 refcount_set(r: &data->refcnt, n: 1);
652
653 for (i = 0; domains[i]; i++) {
654 ret = qcom_pdm_add_domain(data, domain: domains[i]);
655 if (ret)
656 goto err_stop;
657 }
658
659 ret = qmi_add_server(qmi: &data->handle, SERVREG_LOCATOR_SERVICE,
660 SERVREG_QMI_VERSION, SERVREG_QMI_INSTANCE);
661 if (ret) {
662 pr_err("PDM: error adding server %d\n", ret);
663 goto err_stop;
664 }
665
666 return data;
667
668err_stop:
669 qcom_pdm_stop(data);
670
671 return ERR_PTR(error: ret);
672}
673
674static int qcom_pdm_probe(struct auxiliary_device *auxdev,
675 const struct auxiliary_device_id *id)
676
677{
678 struct qcom_pdm_data *data;
679 int ret = 0;
680
681 mutex_lock(&qcom_pdm_mutex);
682
683 if (!__qcom_pdm_data) {
684 data = qcom_pdm_start();
685
686 if (IS_ERR(ptr: data))
687 ret = PTR_ERR(ptr: data);
688 else
689 __qcom_pdm_data = data;
690 } else {
691 refcount_inc(r: &__qcom_pdm_data->refcnt);
692 }
693
694 auxiliary_set_drvdata(auxdev, data: __qcom_pdm_data);
695
696 mutex_unlock(lock: &qcom_pdm_mutex);
697
698 return ret;
699}
700
701static void qcom_pdm_remove(struct auxiliary_device *auxdev)
702{
703 struct qcom_pdm_data *data;
704
705 data = auxiliary_get_drvdata(auxdev);
706 if (!data)
707 return;
708
709 if (refcount_dec_and_mutex_lock(r: &data->refcnt, lock: &qcom_pdm_mutex)) {
710 __qcom_pdm_data = NULL;
711 qcom_pdm_stop(data);
712 mutex_unlock(lock: &qcom_pdm_mutex);
713 }
714}
715
716static const struct auxiliary_device_id qcom_pdm_table[] = {
717 { .name = "qcom_common.pd-mapper" },
718 {},
719};
720MODULE_DEVICE_TABLE(auxiliary, qcom_pdm_table);
721
722static struct auxiliary_driver qcom_pdm_drv = {
723 .name = "qcom-pdm-mapper",
724 .id_table = qcom_pdm_table,
725 .probe = qcom_pdm_probe,
726 .remove = qcom_pdm_remove,
727};
728module_auxiliary_driver(qcom_pdm_drv);
729
730MODULE_DESCRIPTION("Qualcomm Protection Domain Mapper");
731MODULE_LICENSE("GPL");
732

source code of linux/drivers/soc/qcom/qcom_pd_mapper.c