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