drivers/soc/qcom/pdr_interface.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2020 The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/string.h>
   9 #include <linux/workqueue.h>
  10
  11 #include "pdr_internal.h"
  12
  13 struct pdr_service {
  14         char service_name[SERVREG_NAME_LENGTH + 1];
  15         char service_path[SERVREG_NAME_LENGTH + 1];
  16
  17         struct sockaddr_qrtr addr;
  18
  19         unsigned int instance;
  20         unsigned int service;
  21         u8 service_data_valid;
  22         u32 service_data;
  23         int state;
  24
  25         bool need_notifier_register;
  26         bool need_notifier_remove;
  27         bool need_locator_lookup;
  28         bool service_connected;
  29
  30         struct list_head node;
  31 };
  32
  33 struct pdr_handle {
  34         struct qmi_handle locator_hdl;
  35         struct qmi_handle notifier_hdl;
  36
  37         struct sockaddr_qrtr locator_addr;
  38
  39         struct list_head lookups;
  40         struct list_head indack_list;
  41
  42         /* control access to pdr lookup/indack lists */
  43         struct mutex list_lock;
  44
  45         /* serialize pd status invocation */
  46         struct mutex status_lock;
  47
  48         /* control access to the locator state */
  49         struct mutex lock;
  50
  51         bool locator_init_complete;
  52
  53         struct work_struct locator_work;
  54         struct work_struct notifier_work;
  55         struct work_struct indack_work;
  56
  57         struct workqueue_struct *notifier_wq;
  58         struct workqueue_struct *indack_wq;
  59
  60         void (*status)(int state, char *service_path, void *priv);
  61         void *priv;
  62 };
  63
  64 struct pdr_list_node {
  65         enum servreg_service_state curr_state;
  66         u16 transaction_id;
  67         struct pdr_service *pds;
  68         struct list_head node;
  69 };
  70
  71 static int pdr_locator_new_server(struct qmi_handle *qmi,
  72                                   struct qmi_service *svc)
  73 {
  74         struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
  75                                               locator_hdl);
  76         struct pdr_service *pds;
  77
  78         /* Create a local client port for QMI communication */
  79         pdr->locator_addr.sq_family = AF_QIPCRTR;
  80         pdr->locator_addr.sq_node = svc->node;
  81         pdr->locator_addr.sq_port = svc->port;
  82
  83         mutex_lock(&pdr->lock);
  84         pdr->locator_init_complete = true;
  85         mutex_unlock(&pdr->lock);
  86
  87         /* Service pending lookup requests */
  88         mutex_lock(&pdr->list_lock);
  89         list_for_each_entry(pds, &pdr->lookups, node) {
  90                 if (pds->need_locator_lookup)
  91                         schedule_work(&pdr->locator_work);
  92         }
  93         mutex_unlock(&pdr->list_lock);
  94
  95         return 0;
  96 }
  97
  98 static void pdr_locator_del_server(struct qmi_handle *qmi,
  99                                    struct qmi_service *svc)
 100 {
 101         struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
 102                                               locator_hdl);
 103
 104         mutex_lock(&pdr->lock);
 105         pdr->locator_init_complete = false;
 106         mutex_unlock(&pdr->lock);
 107
 108         pdr->locator_addr.sq_node = 0;
 109         pdr->locator_addr.sq_port = 0;
 110 }
 111
 112 static struct qmi_ops pdr_locator_ops = {
 113         .new_server = pdr_locator_new_server,
 114         .del_server = pdr_locator_del_server,
 115 };
 116
 117 static int pdr_register_listener(struct pdr_handle *pdr,
 118                                  struct pdr_service *pds,
 119                                  bool enable)
 120 {
 121         struct servreg_register_listener_resp resp;
 122         struct servreg_register_listener_req req;
 123         struct qmi_txn txn;
 124         int ret;
 125
 126         ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
 127                            servreg_register_listener_resp_ei,
 128                            &resp);
 129         if (ret < 0)
 130                 return ret;
 131
 132         req.enable = enable;
 133         strcpy(req.service_path, pds->service_path);
 134
 135         ret = qmi_send_request(&pdr->notifier_hdl, &pds->addr,
 136                                &txn, SERVREG_REGISTER_LISTENER_REQ,
 137                                SERVREG_REGISTER_LISTENER_REQ_LEN,
 138                                servreg_register_listener_req_ei,
 139                                &req);
 140         if (ret < 0) {
 141                 qmi_txn_cancel(&txn);
 142                 return ret;
 143         }
 144
 145         ret = qmi_txn_wait(&txn, 5 * HZ);
 146         if (ret < 0) {
 147                 pr_err("PDR: %s register listener txn wait failed: %d\n",
 148                        pds->service_path, ret);
 149                 return ret;
 150         }
 151
 152         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
 153                 pr_err("PDR: %s register listener failed: 0x%x\n",
 154                        pds->service_path, resp.resp.error);
 155                 return ret;
 156         }
 157
 158         if ((int)resp.curr_state < INT_MIN || (int)resp.curr_state > INT_MAX)
 159                 pr_err("PDR: %s notification state invalid: 0x%x\n",
 160                        pds->service_path, resp.curr_state);
 161
 162         pds->state = resp.curr_state;
 163
 164         return 0;
 165 }
 166
 167 static void pdr_notifier_work(struct work_struct *work)
 168 {
 169         struct pdr_handle *pdr = container_of(work, struct pdr_handle,
 170                                               notifier_work);
 171         struct pdr_service *pds;
 172         int ret;
 173
 174         mutex_lock(&pdr->list_lock);
 175         list_for_each_entry(pds, &pdr->lookups, node) {
 176                 if (pds->service_connected) {
 177                         if (!pds->need_notifier_register)
 178                                 continue;
 179
 180                         pds->need_notifier_register = false;
 181                         ret = pdr_register_listener(pdr, pds, true);
 182                         if (ret < 0)
 183                                 pds->state = SERVREG_SERVICE_STATE_DOWN;
 184                 } else {
 185                         if (!pds->need_notifier_remove)
 186                                 continue;
 187
 188                         pds->need_notifier_remove = false;
 189                         pds->state = SERVREG_SERVICE_STATE_DOWN;
 190                 }
 191
 192                 mutex_lock(&pdr->status_lock);
 193                 pdr->status(pds->state, pds->service_path, pdr->priv);
 194                 mutex_unlock(&pdr->status_lock);
 195         }
 196         mutex_unlock(&pdr->list_lock);
 197 }
 198
 199 static int pdr_notifier_new_server(struct qmi_handle *qmi,
 200                                    struct qmi_service *svc)
 201 {
 202         struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
 203                                               notifier_hdl);
 204         struct pdr_service *pds;
 205
 206         mutex_lock(&pdr->list_lock);
 207         list_for_each_entry(pds, &pdr->lookups, node) {
 208                 if (pds->service == svc->service &&
 209                     pds->instance == svc->instance) {
 210                         pds->service_connected = true;
 211                         pds->need_notifier_register = true;
 212                         pds->addr.sq_family = AF_QIPCRTR;
 213                         pds->addr.sq_node = svc->node;
 214                         pds->addr.sq_port = svc->port;
 215                         queue_work(pdr->notifier_wq, &pdr->notifier_work);
 216                 }
 217         }
 218         mutex_unlock(&pdr->list_lock);
 219
 220         return 0;
 221 }
 222
 223 static void pdr_notifier_del_server(struct qmi_handle *qmi,
 224                                     struct qmi_service *svc)
 225 {
 226         struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
 227                                               notifier_hdl);
 228         struct pdr_service *pds;
 229
 230         mutex_lock(&pdr->list_lock);
 231         list_for_each_entry(pds, &pdr->lookups, node) {
 232                 if (pds->service == svc->service &&
 233                     pds->instance == svc->instance) {
 234                         pds->service_connected = false;
 235                         pds->need_notifier_remove = true;
 236                         pds->addr.sq_node = 0;
 237                         pds->addr.sq_port = 0;
 238                         queue_work(pdr->notifier_wq, &pdr->notifier_work);
 239                 }
 240         }
 241         mutex_unlock(&pdr->list_lock);
 242 }
 243
 244 static struct qmi_ops pdr_notifier_ops = {
 245         .new_server = pdr_notifier_new_server,
 246         .del_server = pdr_notifier_del_server,
 247 };
 248
 249 static int pdr_send_indack_msg(struct pdr_handle *pdr, struct pdr_service *pds,
 250                                u16 tid)
 251 {
 252         struct servreg_set_ack_resp resp;
 253         struct servreg_set_ack_req req;
 254         struct qmi_txn txn;
 255         int ret;
 256
 257         ret = qmi_txn_init(&pdr->notifier_hdl, &txn, servreg_set_ack_resp_ei,
 258                            &resp);
 259         if (ret < 0)
 260                 return ret;
 261
 262         req.transaction_id = tid;
 263         strcpy(req.service_path, pds->service_path);
 264
 265         ret = qmi_send_request(&pdr->notifier_hdl, &pds->addr,
 266                                &txn, SERVREG_SET_ACK_REQ,
 267                                SERVREG_SET_ACK_REQ_LEN,
 268                                servreg_set_ack_req_ei,
 269                                &req);
 270
 271         /* Skip waiting for response */
 272         qmi_txn_cancel(&txn);
 273         return ret;
 274 }
 275
 276 static void pdr_indack_work(struct work_struct *work)
 277 {
 278         struct pdr_handle *pdr = container_of(work, struct pdr_handle,
 279                                               indack_work);
 280         struct pdr_list_node *ind, *tmp;
 281         struct pdr_service *pds;
 282
 283         list_for_each_entry_safe(ind, tmp, &pdr->indack_list, node) {
 284                 pds = ind->pds;
 285                 pdr_send_indack_msg(pdr, pds, ind->transaction_id);
 286
 287                 mutex_lock(&pdr->status_lock);
 288                 pds->state = ind->curr_state;
 289                 pdr->status(pds->state, pds->service_path, pdr->priv);
 290                 mutex_unlock(&pdr->status_lock);
 291
 292                 mutex_lock(&pdr->list_lock);
 293                 list_del(&ind->node);
 294                 mutex_unlock(&pdr->list_lock);
 295
 296                 kfree(ind);
 297         }
 298 }
 299
 300 static void pdr_indication_cb(struct qmi_handle *qmi,
 301                               struct sockaddr_qrtr *sq,
 302                               struct qmi_txn *txn, const void *data)
 303 {
 304         struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
 305                                               notifier_hdl);
 306         const struct servreg_state_updated_ind *ind_msg = data;
 307         struct pdr_list_node *ind;
 308         struct pdr_service *pds;
 309         bool found = false;
 310
 311         if (!ind_msg || !ind_msg->service_path[0] ||
 312             strlen(ind_msg->service_path) > SERVREG_NAME_LENGTH)
 313                 return;
 314
 315         mutex_lock(&pdr->list_lock);
 316         list_for_each_entry(pds, &pdr->lookups, node) {
 317                 if (strcmp(pds->service_path, ind_msg->service_path))
 318                         continue;
 319
 320                 found = true;
 321                 break;
 322         }
 323         mutex_unlock(&pdr->list_lock);
 324
 325         if (!found)
 326                 return;
 327
 328         pr_info("PDR: Indication received from %s, state: 0x%x, trans-id: %d\n",
 329                 ind_msg->service_path, ind_msg->curr_state,
 330                 ind_msg->transaction_id);
 331
 332         ind = kzalloc(sizeof(*ind), GFP_KERNEL);
 333         if (!ind)
 334                 return;
 335
 336         ind->transaction_id = ind_msg->transaction_id;
 337         ind->curr_state = ind_msg->curr_state;
 338         ind->pds = pds;
 339
 340         mutex_lock(&pdr->list_lock);
 341         list_add_tail(&ind->node, &pdr->indack_list);
 342         mutex_unlock(&pdr->list_lock);
 343
 344         queue_work(pdr->indack_wq, &pdr->indack_work);
 345 }
 346
 347 static struct qmi_msg_handler qmi_indication_handler[] = {
 348         {
 349                 .type = QMI_INDICATION,
 350                 .msg_id = SERVREG_STATE_UPDATED_IND_ID,
 351                 .ei = servreg_state_updated_ind_ei,
 352                 .decoded_size = sizeof(struct servreg_state_updated_ind),
 353                 .fn = pdr_indication_cb,
 354         },
 355         {}
 356 };
 357
 358 static int pdr_get_domain_list(struct servreg_get_domain_list_req *req,
 359                                struct servreg_get_domain_list_resp *resp,
 360                                struct pdr_handle *pdr)
 361 {
 362         struct qmi_txn txn;
 363         int ret;
 364
 365         ret = qmi_txn_init(&pdr->locator_hdl, &txn,
 366                            servreg_get_domain_list_resp_ei, resp);
 367         if (ret < 0)
 368                 return ret;
 369
 370         ret = qmi_send_request(&pdr->locator_hdl,
 371                                &pdr->locator_addr,
 372                                &txn, SERVREG_GET_DOMAIN_LIST_REQ,
 373                                SERVREG_GET_DOMAIN_LIST_REQ_MAX_LEN,
 374                                servreg_get_domain_list_req_ei,
 375                                req);
 376         if (ret < 0) {
 377                 qmi_txn_cancel(&txn);
 378                 return ret;
 379         }
 380
 381         ret = qmi_txn_wait(&txn, 5 * HZ);
 382         if (ret < 0) {
 383                 pr_err("PDR: %s get domain list txn wait failed: %d\n",
 384                        req->service_name, ret);
 385                 return ret;
 386         }
 387
 388         if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
 389                 pr_err("PDR: %s get domain list failed: 0x%x\n",
 390                        req->service_name, resp->resp.error);
 391                 return -EREMOTEIO;
 392         }
 393
 394         return 0;
 395 }
 396
 397 static int pdr_locate_service(struct pdr_handle *pdr, struct pdr_service *pds)
 398 {
 399         struct servreg_get_domain_list_resp *resp;
 400         struct servreg_get_domain_list_req req;
 401         struct servreg_location_entry *entry;
 402         int domains_read = 0;
 403         int ret, i;
 404
 405         resp = kzalloc(sizeof(*resp), GFP_KERNEL);
 406         if (!resp)
 407                 return -ENOMEM;
 408
 409         /* Prepare req message */
 410         strcpy(req.service_name, pds->service_name);
 411         req.domain_offset_valid = true;
 412         req.domain_offset = 0;
 413
 414         do {
 415                 req.domain_offset = domains_read;
 416                 ret = pdr_get_domain_list(&req, resp, pdr);
 417                 if (ret < 0)
 418                         goto out;
 419
 420                 for (i = domains_read; i < resp->domain_list_len; i++) {
 421                         entry = &resp->domain_list[i];
 422
 423                         if (strnlen(entry->name, sizeof(entry->name)) == sizeof(entry->name))
 424                                 continue;
 425
 426                         if (!strcmp(entry->name, pds->service_path)) {
 427                                 pds->service_data_valid = entry->service_data_valid;
 428                                 pds->service_data = entry->service_data;
 429                                 pds->instance = entry->instance;
 430                                 goto out;
 431                         }
 432                 }
 433
 434                 /* Update ret to indicate that the service is not yet found */
 435                 ret = -ENXIO;
 436
 437                 /* Always read total_domains from the response msg */
 438                 if (resp->domain_list_len > resp->total_domains)
 439                         resp->domain_list_len = resp->total_domains;
 440
 441                 domains_read += resp->domain_list_len;
 442         } while (domains_read < resp->total_domains);
 443 out:
 444         kfree(resp);
 445         return ret;
 446 }
 447
 448 static void pdr_notify_lookup_failure(struct pdr_handle *pdr,
 449                                       struct pdr_service *pds,
 450                                       int err)
 451 {
 452         pr_err("PDR: service lookup for %s failed: %d\n",
 453                pds->service_name, err);
 454
 455         if (err == -ENXIO)
 456                 return;
 457
 458         list_del(&pds->node);
 459         pds->state = SERVREG_LOCATOR_ERR;
 460         mutex_lock(&pdr->status_lock);
 461         pdr->status(pds->state, pds->service_path, pdr->priv);
 462         mutex_unlock(&pdr->status_lock);
 463         kfree(pds);
 464 }
 465
 466 static void pdr_locator_work(struct work_struct *work)
 467 {
 468         struct pdr_handle *pdr = container_of(work, struct pdr_handle,
 469                                               locator_work);
 470         struct pdr_service *pds, *tmp;
 471         int ret = 0;
 472
 473         /* Bail out early if the SERVREG LOCATOR QMI service is not up */
 474         mutex_lock(&pdr->lock);
 475         if (!pdr->locator_init_complete) {
 476                 mutex_unlock(&pdr->lock);
 477                 pr_debug("PDR: SERVICE LOCATOR service not available\n");
 478                 return;
 479         }
 480         mutex_unlock(&pdr->lock);
 481
 482         mutex_lock(&pdr->list_lock);
 483         list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
 484                 if (!pds->need_locator_lookup)
 485                         continue;
 486
 487                 ret = pdr_locate_service(pdr, pds);
 488                 if (ret < 0) {
 489                         pdr_notify_lookup_failure(pdr, pds, ret);
 490                         continue;
 491                 }
 492
 493                 ret = qmi_add_lookup(&pdr->notifier_hdl, pds->service, 1,
 494                                      pds->instance);
 495                 if (ret < 0) {
 496                         pdr_notify_lookup_failure(pdr, pds, ret);
 497                         continue;
 498                 }
 499
 500                 pds->need_locator_lookup = false;
 501         }
 502         mutex_unlock(&pdr->list_lock);
 503 }
 504
 505 /**
 506  * pdr_add_lookup() - register a tracking request for a PD
 507  * @pdr:                PDR client handle
 508  * @service_name:       service name of the tracking request
 509  * @service_path:       service path of the tracking request
 510  *
 511  * Registering a pdr lookup allows for tracking the life cycle of the PD.
 512  *
 513  * Return: pdr_service object on success, ERR_PTR on failure. -EALREADY is
 514  * returned if a lookup is already in progress for the given service path.
 515  */
 516 struct pdr_service *pdr_add_lookup(struct pdr_handle *pdr,
 517                                    const char *service_name,
 518                                    const char *service_path)
 519 {
 520         struct pdr_service *pds, *tmp;
 521         int ret;
 522
 523         if (IS_ERR_OR_NULL(pdr))
 524                 return ERR_PTR(-EINVAL);
 525
 526         if (!service_name || strlen(service_name) > SERVREG_NAME_LENGTH ||
 527             !service_path || strlen(service_path) > SERVREG_NAME_LENGTH)
 528                 return ERR_PTR(-EINVAL);
 529
 530         pds = kzalloc(sizeof(*pds), GFP_KERNEL);
 531         if (!pds)
 532                 return ERR_PTR(-ENOMEM);
 533
 534         pds->service = SERVREG_NOTIFIER_SERVICE;
 535         strcpy(pds->service_name, service_name);
 536         strcpy(pds->service_path, service_path);
 537         pds->need_locator_lookup = true;
 538
 539         mutex_lock(&pdr->list_lock);
 540         list_for_each_entry(tmp, &pdr->lookups, node) {
 541                 if (strcmp(tmp->service_path, service_path))
 542                         continue;
 543
 544                 mutex_unlock(&pdr->list_lock);
 545                 ret = -EALREADY;
 546                 goto err;
 547         }
 548
 549         list_add(&pds->node, &pdr->lookups);
 550         mutex_unlock(&pdr->list_lock);
 551
 552         schedule_work(&pdr->locator_work);
 553
 554         return pds;
 555 err:
 556         kfree(pds);
 557         return ERR_PTR(ret);
 558 }
 559 EXPORT_SYMBOL(pdr_add_lookup);
 560
 561 /**
 562  * pdr_restart_pd() - restart PD
 563  * @pdr:        PDR client handle
 564  * @pds:        PD service handle
 565  *
 566  * Restarts the PD tracked by the PDR client handle for a given service path.
 567  *
 568  * Return: 0 on success, negative errno on failure.
 569  */
 570 int pdr_restart_pd(struct pdr_handle *pdr, struct pdr_service *pds)
 571 {
 572         struct servreg_restart_pd_resp resp;
 573         struct servreg_restart_pd_req req;
 574         struct sockaddr_qrtr addr;
 575         struct pdr_service *tmp;
 576         struct qmi_txn txn;
 577         int ret;
 578
 579         if (IS_ERR_OR_NULL(pdr) || IS_ERR_OR_NULL(pds))
 580                 return -EINVAL;
 581
 582         mutex_lock(&pdr->list_lock);
 583         list_for_each_entry(tmp, &pdr->lookups, node) {
 584                 if (tmp != pds)
 585                         continue;
 586
 587                 if (!pds->service_connected)
 588                         break;
 589
 590                 /* Prepare req message */
 591                 strcpy(req.service_path, pds->service_path);
 592                 addr = pds->addr;
 593                 break;
 594         }
 595         mutex_unlock(&pdr->list_lock);
 596
 597         if (!req.service_path[0])
 598                 return -EINVAL;
 599
 600         ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
 601                            servreg_restart_pd_resp_ei,
 602                            &resp);
 603         if (ret < 0)
 604                 return ret;
 605
 606         ret = qmi_send_request(&pdr->notifier_hdl, &addr,
 607                                &txn, SERVREG_RESTART_PD_REQ,
 608                                SERVREG_RESTART_PD_REQ_MAX_LEN,
 609                                servreg_restart_pd_req_ei, &req);
 610         if (ret < 0) {
 611                 qmi_txn_cancel(&txn);
 612                 return ret;
 613         }
 614
 615         ret = qmi_txn_wait(&txn, 5 * HZ);
 616         if (ret < 0) {
 617                 pr_err("PDR: %s PD restart txn wait failed: %d\n",
 618                        req.service_path, ret);
 619                 return ret;
 620         }
 621
 622         /* Check response if PDR is disabled */
 623         if (resp.resp.result == QMI_RESULT_FAILURE_V01 &&
 624             resp.resp.error == QMI_ERR_DISABLED_V01) {
 625                 pr_err("PDR: %s PD restart is disabled: 0x%x\n",
 626                        req.service_path, resp.resp.error);
 627                 return -EOPNOTSUPP;
 628         }
 629
 630         /* Check the response for other error case*/
 631         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
 632                 pr_err("PDR: %s request for PD restart failed: 0x%x\n",
 633                        req.service_path, resp.resp.error);
 634                 return -EREMOTEIO;
 635         }
 636
 637         return 0;
 638 }
 639 EXPORT_SYMBOL(pdr_restart_pd);
 640
 641 /**
 642  * pdr_handle_alloc() - initialize the PDR client handle
 643  * @status:     function to be called on PD state change
 644  * @priv:       handle for client's use
 645  *
 646  * Initializes the PDR client handle to allow for tracking/restart of PDs.
 647  *
 648  * Return: pdr_handle object on success, ERR_PTR on failure.
 649  */
 650 struct pdr_handle *pdr_handle_alloc(void (*status)(int state,
 651                                                    char *service_path,
 652                                                    void *priv), void *priv)
 653 {
 654         struct pdr_handle *pdr;
 655         int ret;
 656
 657         if (!status)
 658                 return ERR_PTR(-EINVAL);
 659
 660         pdr = kzalloc(sizeof(*pdr), GFP_KERNEL);
 661         if (!pdr)
 662                 return ERR_PTR(-ENOMEM);
 663
 664         pdr->status = status;
 665         pdr->priv = priv;
 666
 667         mutex_init(&pdr->status_lock);
 668         mutex_init(&pdr->list_lock);
 669         mutex_init(&pdr->lock);
 670
 671         INIT_LIST_HEAD(&pdr->lookups);
 672         INIT_LIST_HEAD(&pdr->indack_list);
 673
 674         INIT_WORK(&pdr->locator_work, pdr_locator_work);
 675         INIT_WORK(&pdr->notifier_work, pdr_notifier_work);
 676         INIT_WORK(&pdr->indack_work, pdr_indack_work);
 677
 678         pdr->notifier_wq = create_singlethread_workqueue("pdr_notifier_wq");
 679         if (!pdr->notifier_wq) {
 680                 ret = -ENOMEM;
 681                 goto free_pdr_handle;
 682         }
 683
 684         pdr->indack_wq = alloc_ordered_workqueue("pdr_indack_wq", WQ_HIGHPRI);
 685         if (!pdr->indack_wq) {
 686                 ret = -ENOMEM;
 687                 goto destroy_notifier;
 688         }
 689
 690         ret = qmi_handle_init(&pdr->locator_hdl,
 691                               SERVREG_GET_DOMAIN_LIST_RESP_MAX_LEN,
 692                               &pdr_locator_ops, NULL);
 693         if (ret < 0)
 694                 goto destroy_indack;
 695
 696         ret = qmi_add_lookup(&pdr->locator_hdl, SERVREG_LOCATOR_SERVICE, 1, 1);
 697         if (ret < 0)
 698                 goto release_qmi_handle;
 699
 700         ret = qmi_handle_init(&pdr->notifier_hdl,
 701                               SERVREG_STATE_UPDATED_IND_MAX_LEN,
 702                               &pdr_notifier_ops,
 703                               qmi_indication_handler);
 704         if (ret < 0)
 705                 goto release_qmi_handle;
 706
 707         return pdr;
 708
 709 release_qmi_handle:
 710         qmi_handle_release(&pdr->locator_hdl);
 711 destroy_indack:
 712         destroy_workqueue(pdr->indack_wq);
 713 destroy_notifier:
 714         destroy_workqueue(pdr->notifier_wq);
 715 free_pdr_handle:
 716         kfree(pdr);
 717
 718         return ERR_PTR(ret);
 719 }
 720 EXPORT_SYMBOL(pdr_handle_alloc);
 721
 722 /**
 723  * pdr_handle_release() - release the PDR client handle
 724  * @pdr:        PDR client handle
 725  *
 726  * Cleans up pending tracking requests and releases the underlying qmi handles.
 727  */
 728 void pdr_handle_release(struct pdr_handle *pdr)
 729 {
 730         struct pdr_service *pds, *tmp;
 731
 732         if (IS_ERR_OR_NULL(pdr))
 733                 return;
 734
 735         mutex_lock(&pdr->list_lock);
 736         list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
 737                 list_del(&pds->node);
 738                 kfree(pds);
 739         }
 740         mutex_unlock(&pdr->list_lock);
 741
 742         cancel_work_sync(&pdr->locator_work);
 743         cancel_work_sync(&pdr->notifier_work);
 744         cancel_work_sync(&pdr->indack_work);
 745
 746         destroy_workqueue(pdr->notifier_wq);
 747         destroy_workqueue(pdr->indack_wq);
 748
 749         qmi_handle_release(&pdr->locator_hdl);
 750         qmi_handle_release(&pdr->notifier_hdl);
 751
 752         kfree(pdr);
 753 }
 754 EXPORT_SYMBOL(pdr_handle_release);
 755
 756 MODULE_LICENSE("GPL v2");
 757 MODULE_DESCRIPTION("Qualcomm Protection Domain Restart helpers");