drivers/soc/qcom/qcom_pd_mapper.c

   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
  24 struct qcom_pdm_domain_data {
  25         const char *domain;
  26         u32 instance_id;
  27         /* NULL-terminated array */
  28         const char * services[];
  29 };
  30
  31 struct qcom_pdm_domain {
  32         struct list_head list;
  33         const char *name;
  34         u32 instance_id;
  35 };
  36
  37 struct qcom_pdm_service {
  38         struct list_head list;
  39         struct list_head domains;
  40         const char *name;
  41 };
  42
  43 struct qcom_pdm_data {
  44         refcount_t refcnt;
  45         struct qmi_handle handle;
  46         struct list_head services;
  47 };
  48
  49 static DEFINE_MUTEX(qcom_pdm_mutex); /* protects __qcom_pdm_data */
  50 static struct qcom_pdm_data *__qcom_pdm_data;
  51
  52 static 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
  65 static 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, 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(&service->domains);
  85                 service->name = service_name;
  86
  87                 list_add_tail(&service->list, &data->services);
  88         }
  89
  90         domain = kzalloc(sizeof(*domain), GFP_KERNEL);
  91         if (!domain) {
  92                 if (list_empty(&service->domains)) {
  93                         list_del(&service->list);
  94                         kfree(service);
  95                 }
  96
  97                 return -ENOMEM;
  98         }
  99
 100         domain->name = domain_name;
 101         domain->instance_id = instance_id;
 102         list_add_tail(&domain->list, &service->domains);
 103
 104         return 0;
 105 }
 106
 107 static 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->domain,
 116                                           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                                                   domain->services[i],
 123                                                   domain->domain,
 124                                                   domain->instance_id);
 125                 if (ret)
 126                         return ret;
 127         }
 128
 129         return 0;
 130
 131 }
 132
 133 static 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(&domain->list);
 141                         kfree(domain);
 142                 }
 143
 144                 list_del(&service->list);
 145                 kfree(service);
 146         }
 147 }
 148
 149 static 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, 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                                 servreg_get_domain_list_resp_ei, rsp);
 207         if (ret)
 208                 pr_err("Error sending servreg response: %d\n", ret);
 209
 210         mutex_unlock(&qcom_pdm_mutex);
 211
 212         kfree(rsp);
 213 }
 214
 215 static 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                                 servreg_loc_pfr_resp_ei, &rsp);
 232         if (ret)
 233                 pr_err("Error sending servreg response: %d\n", ret);
 234 }
 235
 236 static 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
 254 static 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
 263 static const struct qcom_pdm_domain_data adsp_charger_pd = {
 264         .domain = "msm/adsp/charger_pd",
 265         .instance_id = 74,
 266         .services = { NULL },
 267 };
 268
 269 static const struct qcom_pdm_domain_data adsp_root_pd = {
 270         .domain = "msm/adsp/root_pd",
 271         .instance_id = 74,
 272         .services = { NULL },
 273 };
 274
 275 static 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
 284 static const struct qcom_pdm_domain_data adsp_sensor_pd = {
 285         .domain = "msm/adsp/sensor_pd",
 286         .instance_id = 74,
 287         .services = { NULL },
 288 };
 289
 290 static 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
 296 static 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
 302 static const struct qcom_pdm_domain_data cdsp_root_pd = {
 303         .domain = "msm/cdsp/root_pd",
 304         .instance_id = 76,
 305         .services = { NULL },
 306 };
 307
 308 static const struct qcom_pdm_domain_data slpi_root_pd = {
 309         .domain = "msm/slpi/root_pd",
 310         .instance_id = 90,
 311         .services = { NULL },
 312 };
 313
 314 static const struct qcom_pdm_domain_data slpi_sensor_pd = {
 315         .domain = "msm/slpi/sensor_pd",
 316         .instance_id = 90,
 317         .services = { NULL },
 318 };
 319
 320 static 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
 328 static 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
 337 static 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
 347 static 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
 353 static 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
 363 static const struct qcom_pdm_domain_data *msm8996_domains[] = {
 364         &msm8996_adsp_audio_pd,
 365         &msm8996_adsp_root_pd,
 366         &msm8996_mpss_root_pd,
 367         NULL,
 368 };
 369
 370 static const struct qcom_pdm_domain_data *msm8998_domains[] = {
 371         &mpss_root_pd,
 372         &mpss_wlan_pd,
 373         NULL,
 374 };
 375
 376 static const struct qcom_pdm_domain_data *qcm2290_domains[] = {
 377         &adsp_audio_pd,
 378         &adsp_root_pd,
 379         &adsp_sensor_pd,
 380         &mpss_root_pd_gps,
 381         &mpss_wlan_pd,
 382         NULL,
 383 };
 384
 385 static const struct qcom_pdm_domain_data *qcs404_domains[] = {
 386         &adsp_audio_pd,
 387         &adsp_root_pd,
 388         &adsp_sensor_pd,
 389         &cdsp_root_pd,
 390         &mpss_root_pd,
 391         &mpss_wlan_pd,
 392         NULL,
 393 };
 394
 395 static const struct qcom_pdm_domain_data *sc7180_domains[] = {
 396         &adsp_audio_pd,
 397         &adsp_root_pd_pdr,
 398         &adsp_sensor_pd,
 399         &mpss_root_pd_gps_pdr,
 400         &mpss_wlan_pd,
 401         NULL,
 402 };
 403
 404 static const struct qcom_pdm_domain_data *sc7280_domains[] = {
 405         &adsp_audio_pd,
 406         &adsp_root_pd_pdr,
 407         &adsp_charger_pd,
 408         &adsp_sensor_pd,
 409         &cdsp_root_pd,
 410         &mpss_root_pd_gps_pdr,
 411         NULL,
 412 };
 413
 414 static const struct qcom_pdm_domain_data *sc8180x_domains[] = {
 415         &adsp_audio_pd,
 416         &adsp_root_pd,
 417         &adsp_charger_pd,
 418         &cdsp_root_pd,
 419         &mpss_root_pd_gps,
 420         &mpss_wlan_pd,
 421         NULL,
 422 };
 423
 424 static const struct qcom_pdm_domain_data *sc8280xp_domains[] = {
 425         &adsp_audio_pd,
 426         &adsp_root_pd_pdr,
 427         &adsp_charger_pd,
 428         &cdsp_root_pd,
 429         NULL,
 430 };
 431
 432 static const struct qcom_pdm_domain_data *sdm660_domains[] = {
 433         &adsp_audio_pd,
 434         &adsp_root_pd,
 435         &adsp_sensor_pd,
 436         &cdsp_root_pd,
 437         &mpss_root_pd,
 438         &mpss_wlan_pd,
 439         NULL,
 440 };
 441
 442 static const struct qcom_pdm_domain_data *sdm670_domains[] = {
 443         &adsp_audio_pd,
 444         &adsp_root_pd,
 445         &cdsp_root_pd,
 446         &mpss_root_pd,
 447         &mpss_wlan_pd,
 448         NULL,
 449 };
 450
 451 static const struct qcom_pdm_domain_data *sdm845_domains[] = {
 452         &adsp_audio_pd,
 453         &adsp_root_pd,
 454         &cdsp_root_pd,
 455         &mpss_root_pd,
 456         &mpss_wlan_pd,
 457         &slpi_root_pd,
 458         &slpi_sensor_pd,
 459         NULL,
 460 };
 461
 462 static const struct qcom_pdm_domain_data *sm6115_domains[] = {
 463         &adsp_audio_pd,
 464         &adsp_root_pd,
 465         &adsp_sensor_pd,
 466         &cdsp_root_pd,
 467         &mpss_root_pd_gps,
 468         &mpss_wlan_pd,
 469         NULL,
 470 };
 471
 472 static const struct qcom_pdm_domain_data *sm6350_domains[] = {
 473         &adsp_audio_pd,
 474         &adsp_root_pd,
 475         &adsp_sensor_pd,
 476         &cdsp_root_pd,
 477         &mpss_wlan_pd,
 478         NULL,
 479 };
 480
 481 static const struct qcom_pdm_domain_data *sm8150_domains[] = {
 482         &adsp_audio_pd,
 483         &adsp_root_pd,
 484         &cdsp_root_pd,
 485         &mpss_root_pd_gps,
 486         &mpss_wlan_pd,
 487         NULL,
 488 };
 489
 490 static const struct qcom_pdm_domain_data *sm8250_domains[] = {
 491         &adsp_audio_pd,
 492         &adsp_root_pd,
 493         &cdsp_root_pd,
 494         &slpi_root_pd,
 495         &slpi_sensor_pd,
 496         NULL,
 497 };
 498
 499 static const struct qcom_pdm_domain_data *sm8350_domains[] = {
 500         &adsp_audio_pd,
 501         &adsp_root_pd_pdr,
 502         &adsp_charger_pd,
 503         &cdsp_root_pd,
 504         &mpss_root_pd_gps,
 505         &slpi_root_pd,
 506         &slpi_sensor_pd,
 507         NULL,
 508 };
 509
 510 static const struct qcom_pdm_domain_data *sm8550_domains[] = {
 511         &adsp_audio_pd,
 512         &adsp_root_pd,
 513         &adsp_charger_pd,
 514         &adsp_sensor_pd,
 515         &cdsp_root_pd,
 516         &mpss_root_pd_gps,
 517         NULL,
 518 };
 519
 520 static const struct qcom_pdm_domain_data *x1e80100_domains[] = {
 521         &adsp_audio_pd,
 522         &adsp_root_pd,
 523         &adsp_charger_pd,
 524         &adsp_sensor_pd,
 525         &cdsp_root_pd,
 526         NULL,
 527 };
 528
 529 static const struct of_device_id qcom_pdm_domains[] __maybe_unused = {
 530         { .compatible = "qcom,apq8016", .data = NULL, },
 531         { .compatible = "qcom,apq8064", .data = NULL, },
 532         { .compatible = "qcom,apq8074", .data = NULL, },
 533         { .compatible = "qcom,apq8084", .data = NULL, },
 534         { .compatible = "qcom,apq8096", .data = msm8996_domains, },
 535         { .compatible = "qcom,msm8226", .data = NULL, },
 536         { .compatible = "qcom,msm8909", .data = NULL, },
 537         { .compatible = "qcom,msm8916", .data = NULL, },
 538         { .compatible = "qcom,msm8939", .data = NULL, },
 539         { .compatible = "qcom,msm8974", .data = NULL, },
 540         { .compatible = "qcom,msm8996", .data = msm8996_domains, },
 541         { .compatible = "qcom,msm8998", .data = msm8998_domains, },
 542         { .compatible = "qcom,qcm2290", .data = qcm2290_domains, },
 543         { .compatible = "qcom,qcm6490", .data = sc7280_domains, },
 544         { .compatible = "qcom,qcs404", .data = qcs404_domains, },
 545         { .compatible = "qcom,sc7180", .data = sc7180_domains, },
 546         { .compatible = "qcom,sc7280", .data = sc7280_domains, },
 547         { .compatible = "qcom,sc8180x", .data = sc8180x_domains, },
 548         { .compatible = "qcom,sc8280xp", .data = sc8280xp_domains, },
 549         { .compatible = "qcom,sda660", .data = sdm660_domains, },
 550         { .compatible = "qcom,sdm660", .data = sdm660_domains, },
 551         { .compatible = "qcom,sdm670", .data = sdm670_domains, },
 552         { .compatible = "qcom,sdm845", .data = sdm845_domains, },
 553         { .compatible = "qcom,sm4250", .data = sm6115_domains, },
 554         { .compatible = "qcom,sm6115", .data = sm6115_domains, },
 555         { .compatible = "qcom,sm6350", .data = sm6350_domains, },
 556         { .compatible = "qcom,sm7325", .data = sc7280_domains, },
 557         { .compatible = "qcom,sm8150", .data = sm8150_domains, },
 558         { .compatible = "qcom,sm8250", .data = sm8250_domains, },
 559         { .compatible = "qcom,sm8350", .data = sm8350_domains, },
 560         { .compatible = "qcom,sm8450", .data = sm8350_domains, },
 561         { .compatible = "qcom,sm8550", .data = sm8550_domains, },
 562         { .compatible = "qcom,sm8650", .data = sm8550_domains, },
 563         { .compatible = "qcom,x1e80100", .data = x1e80100_domains, },
 564         {},
 565 };
 566
 567 static void qcom_pdm_stop(struct qcom_pdm_data *data)
 568 {
 569         qcom_pdm_free_domains(data);
 570
 571         /* The server is removed automatically */
 572         qmi_handle_release(&data->handle);
 573
 574         kfree(data);
 575 }
 576
 577 static struct qcom_pdm_data *qcom_pdm_start(void)
 578 {
 579         const struct qcom_pdm_domain_data * const *domains;
 580         const struct of_device_id *match;
 581         struct qcom_pdm_data *data;
 582         struct device_node *root;
 583         int ret, i;
 584
 585         root = of_find_node_by_path("/");
 586         if (!root)
 587                 return ERR_PTR(-ENODEV);
 588
 589         match = of_match_node(qcom_pdm_domains, root);
 590         of_node_put(root);
 591         if (!match) {
 592                 pr_notice("PDM: no support for the platform, userspace daemon might be required.\n");
 593                 return ERR_PTR(-ENODEV);
 594         }
 595
 596         domains = match->data;
 597         if (!domains) {
 598                 pr_debug("PDM: no domains\n");
 599                 return ERR_PTR(-ENODEV);
 600         }
 601
 602         data = kzalloc(sizeof(*data), GFP_KERNEL);
 603         if (!data)
 604                 return ERR_PTR(-ENOMEM);
 605
 606         INIT_LIST_HEAD(&data->services);
 607
 608         ret = qmi_handle_init(&data->handle, SERVREG_GET_DOMAIN_LIST_REQ_MAX_LEN,
 609                               NULL, qcom_pdm_msg_handlers);
 610         if (ret) {
 611                 kfree(data);
 612                 return ERR_PTR(ret);
 613         }
 614
 615         refcount_set(&data->refcnt, 1);
 616
 617         for (i = 0; domains[i]; i++) {
 618                 ret = qcom_pdm_add_domain(data, domains[i]);
 619                 if (ret)
 620                         goto err_stop;
 621         }
 622
 623         ret = qmi_add_server(&data->handle, SERVREG_LOCATOR_SERVICE,
 624                              SERVREG_QMI_VERSION, SERVREG_QMI_INSTANCE);
 625         if (ret) {
 626                 pr_err("PDM: error adding server %d\n", ret);
 627                 goto err_stop;
 628         }
 629
 630         return data;
 631
 632 err_stop:
 633         qcom_pdm_stop(data);
 634
 635         return ERR_PTR(ret);
 636 }
 637
 638 static int qcom_pdm_probe(struct auxiliary_device *auxdev,
 639                           const struct auxiliary_device_id *id)
 640
 641 {
 642         struct qcom_pdm_data *data;
 643         int ret = 0;
 644
 645         mutex_lock(&qcom_pdm_mutex);
 646
 647         if (!__qcom_pdm_data) {
 648                 data = qcom_pdm_start();
 649
 650                 if (IS_ERR(data))
 651                         ret = PTR_ERR(data);
 652                 else
 653                         __qcom_pdm_data = data;
 654         } else {
 655                 refcount_inc(&__qcom_pdm_data->refcnt);
 656         }
 657
 658         auxiliary_set_drvdata(auxdev, __qcom_pdm_data);
 659
 660         mutex_unlock(&qcom_pdm_mutex);
 661
 662         return ret;
 663 }
 664
 665 static void qcom_pdm_remove(struct auxiliary_device *auxdev)
 666 {
 667         struct qcom_pdm_data *data;
 668
 669         data = auxiliary_get_drvdata(auxdev);
 670         if (!data)
 671                 return;
 672
 673         if (refcount_dec_and_mutex_lock(&data->refcnt, &qcom_pdm_mutex)) {
 674                 __qcom_pdm_data = NULL;
 675                 qcom_pdm_stop(data);
 676                 mutex_unlock(&qcom_pdm_mutex);
 677         }
 678 }
 679
 680 static const struct auxiliary_device_id qcom_pdm_table[] = {
 681         { .name = "qcom_common.pd-mapper" },
 682         {},
 683 };
 684 MODULE_DEVICE_TABLE(auxiliary, qcom_pdm_table);
 685
 686 static struct auxiliary_driver qcom_pdm_drv = {
 687         .name = "qcom-pdm-mapper",
 688         .id_table = qcom_pdm_table,
 689         .probe = qcom_pdm_probe,
 690         .remove = qcom_pdm_remove,
 691 };
 692 module_auxiliary_driver(qcom_pdm_drv);
 693
 694 MODULE_DESCRIPTION("Qualcomm Protection Domain Mapper");
 695 MODULE_LICENSE("GPL");