xref: /openbmc/linux/drivers/firmware/tegra/bpmp.c (revision 0ad53fe3) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
4  */
5 
6 #include <linux/clk/tegra.h>
7 #include <linux/genalloc.h>
8 #include <linux/mailbox_client.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/of_address.h>
12 #include <linux/of_device.h>
13 #include <linux/platform_device.h>
14 #include <linux/pm.h>
15 #include <linux/semaphore.h>
16 #include <linux/sched/clock.h>
17 
18 #include <soc/tegra/bpmp.h>
19 #include <soc/tegra/bpmp-abi.h>
20 #include <soc/tegra/ivc.h>
21 
22 #include "bpmp-private.h"
23 
24 #define MSG_ACK		BIT(0)
25 #define MSG_RING	BIT(1)
26 #define TAG_SZ		32
27 
28 static inline struct tegra_bpmp *
29 mbox_client_to_bpmp(struct mbox_client *client)
30 {
31 	return container_of(client, struct tegra_bpmp, mbox.client);
32 }
33 
34 static inline const struct tegra_bpmp_ops *
35 channel_to_ops(struct tegra_bpmp_channel *channel)
36 {
37 	struct tegra_bpmp *bpmp = channel->bpmp;
38 
39 	return bpmp->soc->ops;
40 }
41 
42 struct tegra_bpmp *tegra_bpmp_get(struct device *dev)
43 {
44 	struct platform_device *pdev;
45 	struct tegra_bpmp *bpmp;
46 	struct device_node *np;
47 
48 	np = of_parse_phandle(dev->of_node, "nvidia,bpmp", 0);
49 	if (!np)
50 		return ERR_PTR(-ENOENT);
51 
52 	pdev = of_find_device_by_node(np);
53 	if (!pdev) {
54 		bpmp = ERR_PTR(-ENODEV);
55 		goto put;
56 	}
57 
58 	bpmp = platform_get_drvdata(pdev);
59 	if (!bpmp) {
60 		bpmp = ERR_PTR(-EPROBE_DEFER);
61 		put_device(&pdev->dev);
62 		goto put;
63 	}
64 
65 put:
66 	of_node_put(np);
67 	return bpmp;
68 }
69 EXPORT_SYMBOL_GPL(tegra_bpmp_get);
70 
71 void tegra_bpmp_put(struct tegra_bpmp *bpmp)
72 {
73 	if (bpmp)
74 		put_device(bpmp->dev);
75 }
76 EXPORT_SYMBOL_GPL(tegra_bpmp_put);
77 
78 static int
79 tegra_bpmp_channel_get_thread_index(struct tegra_bpmp_channel *channel)
80 {
81 	struct tegra_bpmp *bpmp = channel->bpmp;
82 	unsigned int count;
83 	int index;
84 
85 	count = bpmp->soc->channels.thread.count;
86 
87 	index = channel - channel->bpmp->threaded_channels;
88 	if (index < 0 || index >= count)
89 		return -EINVAL;
90 
91 	return index;
92 }
93 
94 static bool tegra_bpmp_message_valid(const struct tegra_bpmp_message *msg)
95 {
96 	return (msg->tx.size <= MSG_DATA_MIN_SZ) &&
97 	       (msg->rx.size <= MSG_DATA_MIN_SZ) &&
98 	       (msg->tx.size == 0 || msg->tx.data) &&
99 	       (msg->rx.size == 0 || msg->rx.data);
100 }
101 
102 static bool tegra_bpmp_is_response_ready(struct tegra_bpmp_channel *channel)
103 {
104 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
105 
106 	return ops->is_response_ready(channel);
107 }
108 
109 static bool tegra_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)
110 {
111 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
112 
113 	return ops->is_request_ready(channel);
114 }
115 
116 static int tegra_bpmp_wait_response(struct tegra_bpmp_channel *channel)
117 {
118 	unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;
119 	ktime_t end;
120 
121 	end = ktime_add_us(ktime_get(), timeout);
122 
123 	do {
124 		if (tegra_bpmp_is_response_ready(channel))
125 			return 0;
126 	} while (ktime_before(ktime_get(), end));
127 
128 	return -ETIMEDOUT;
129 }
130 
131 static int tegra_bpmp_ack_response(struct tegra_bpmp_channel *channel)
132 {
133 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
134 
135 	return ops->ack_response(channel);
136 }
137 
138 static int tegra_bpmp_ack_request(struct tegra_bpmp_channel *channel)
139 {
140 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
141 
142 	return ops->ack_request(channel);
143 }
144 
145 static bool
146 tegra_bpmp_is_request_channel_free(struct tegra_bpmp_channel *channel)
147 {
148 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
149 
150 	return ops->is_request_channel_free(channel);
151 }
152 
153 static bool
154 tegra_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)
155 {
156 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
157 
158 	return ops->is_response_channel_free(channel);
159 }
160 
161 static int
162 tegra_bpmp_wait_request_channel_free(struct tegra_bpmp_channel *channel)
163 {
164 	unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;
165 	ktime_t start, now;
166 
167 	start = ns_to_ktime(local_clock());
168 
169 	do {
170 		if (tegra_bpmp_is_request_channel_free(channel))
171 			return 0;
172 
173 		now = ns_to_ktime(local_clock());
174 	} while (ktime_us_delta(now, start) < timeout);
175 
176 	return -ETIMEDOUT;
177 }
178 
179 static int tegra_bpmp_post_request(struct tegra_bpmp_channel *channel)
180 {
181 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
182 
183 	return ops->post_request(channel);
184 }
185 
186 static int tegra_bpmp_post_response(struct tegra_bpmp_channel *channel)
187 {
188 	const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
189 
190 	return ops->post_response(channel);
191 }
192 
193 static int tegra_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
194 {
195 	return bpmp->soc->ops->ring_doorbell(bpmp);
196 }
197 
198 static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
199 					 void *data, size_t size, int *ret)
200 {
201 	int err;
202 
203 	if (data && size > 0)
204 		memcpy(data, channel->ib->data, size);
205 
206 	err = tegra_bpmp_ack_response(channel);
207 	if (err < 0)
208 		return err;
209 
210 	*ret = channel->ib->code;
211 
212 	return 0;
213 }
214 
215 static ssize_t tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
216 				       void *data, size_t size, int *ret)
217 {
218 	struct tegra_bpmp *bpmp = channel->bpmp;
219 	unsigned long flags;
220 	ssize_t err;
221 	int index;
222 
223 	index = tegra_bpmp_channel_get_thread_index(channel);
224 	if (index < 0) {
225 		err = index;
226 		goto unlock;
227 	}
228 
229 	spin_lock_irqsave(&bpmp->lock, flags);
230 	err = __tegra_bpmp_channel_read(channel, data, size, ret);
231 	clear_bit(index, bpmp->threaded.allocated);
232 	spin_unlock_irqrestore(&bpmp->lock, flags);
233 
234 unlock:
235 	up(&bpmp->threaded.lock);
236 
237 	return err;
238 }
239 
240 static ssize_t __tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,
241 					  unsigned int mrq, unsigned long flags,
242 					  const void *data, size_t size)
243 {
244 	channel->ob->code = mrq;
245 	channel->ob->flags = flags;
246 
247 	if (data && size > 0)
248 		memcpy(channel->ob->data, data, size);
249 
250 	return tegra_bpmp_post_request(channel);
251 }
252 
253 static struct tegra_bpmp_channel *
254 tegra_bpmp_write_threaded(struct tegra_bpmp *bpmp, unsigned int mrq,
255 			  const void *data, size_t size)
256 {
257 	unsigned long timeout = bpmp->soc->channels.thread.timeout;
258 	unsigned int count = bpmp->soc->channels.thread.count;
259 	struct tegra_bpmp_channel *channel;
260 	unsigned long flags;
261 	unsigned int index;
262 	int err;
263 
264 	err = down_timeout(&bpmp->threaded.lock, usecs_to_jiffies(timeout));
265 	if (err < 0)
266 		return ERR_PTR(err);
267 
268 	spin_lock_irqsave(&bpmp->lock, flags);
269 
270 	index = find_first_zero_bit(bpmp->threaded.allocated, count);
271 	if (index == count) {
272 		err = -EBUSY;
273 		goto unlock;
274 	}
275 
276 	channel = &bpmp->threaded_channels[index];
277 
278 	if (!tegra_bpmp_is_request_channel_free(channel)) {
279 		err = -EBUSY;
280 		goto unlock;
281 	}
282 
283 	set_bit(index, bpmp->threaded.allocated);
284 
285 	err = __tegra_bpmp_channel_write(channel, mrq, MSG_ACK | MSG_RING,
286 					 data, size);
287 	if (err < 0)
288 		goto clear_allocated;
289 
290 	set_bit(index, bpmp->threaded.busy);
291 
292 	spin_unlock_irqrestore(&bpmp->lock, flags);
293 	return channel;
294 
295 clear_allocated:
296 	clear_bit(index, bpmp->threaded.allocated);
297 unlock:
298 	spin_unlock_irqrestore(&bpmp->lock, flags);
299 	up(&bpmp->threaded.lock);
300 
301 	return ERR_PTR(err);
302 }
303 
304 static ssize_t tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,
305 					unsigned int mrq, unsigned long flags,
306 					const void *data, size_t size)
307 {
308 	int err;
309 
310 	err = tegra_bpmp_wait_request_channel_free(channel);
311 	if (err < 0)
312 		return err;
313 
314 	return __tegra_bpmp_channel_write(channel, mrq, flags, data, size);
315 }
316 
317 int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,
318 			       struct tegra_bpmp_message *msg)
319 {
320 	struct tegra_bpmp_channel *channel;
321 	int err;
322 
323 	if (WARN_ON(!irqs_disabled()))
324 		return -EPERM;
325 
326 	if (!tegra_bpmp_message_valid(msg))
327 		return -EINVAL;
328 
329 	channel = bpmp->tx_channel;
330 
331 	spin_lock(&bpmp->atomic_tx_lock);
332 
333 	err = tegra_bpmp_channel_write(channel, msg->mrq, MSG_ACK,
334 				       msg->tx.data, msg->tx.size);
335 	if (err < 0) {
336 		spin_unlock(&bpmp->atomic_tx_lock);
337 		return err;
338 	}
339 
340 	spin_unlock(&bpmp->atomic_tx_lock);
341 
342 	err = tegra_bpmp_ring_doorbell(bpmp);
343 	if (err < 0)
344 		return err;
345 
346 	err = tegra_bpmp_wait_response(channel);
347 	if (err < 0)
348 		return err;
349 
350 	return __tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size,
351 					 &msg->rx.ret);
352 }
353 EXPORT_SYMBOL_GPL(tegra_bpmp_transfer_atomic);
354 
355 int tegra_bpmp_transfer(struct tegra_bpmp *bpmp,
356 			struct tegra_bpmp_message *msg)
357 {
358 	struct tegra_bpmp_channel *channel;
359 	unsigned long timeout;
360 	int err;
361 
362 	if (WARN_ON(irqs_disabled()))
363 		return -EPERM;
364 
365 	if (!tegra_bpmp_message_valid(msg))
366 		return -EINVAL;
367 
368 	channel = tegra_bpmp_write_threaded(bpmp, msg->mrq, msg->tx.data,
369 					    msg->tx.size);
370 	if (IS_ERR(channel))
371 		return PTR_ERR(channel);
372 
373 	err = tegra_bpmp_ring_doorbell(bpmp);
374 	if (err < 0)
375 		return err;
376 
377 	timeout = usecs_to_jiffies(bpmp->soc->channels.thread.timeout);
378 
379 	err = wait_for_completion_timeout(&channel->completion, timeout);
380 	if (err == 0)
381 		return -ETIMEDOUT;
382 
383 	return tegra_bpmp_channel_read(channel, msg->rx.data, msg->rx.size,
384 				       &msg->rx.ret);
385 }
386 EXPORT_SYMBOL_GPL(tegra_bpmp_transfer);
387 
388 static struct tegra_bpmp_mrq *tegra_bpmp_find_mrq(struct tegra_bpmp *bpmp,
389 						  unsigned int mrq)
390 {
391 	struct tegra_bpmp_mrq *entry;
392 
393 	list_for_each_entry(entry, &bpmp->mrqs, list)
394 		if (entry->mrq == mrq)
395 			return entry;
396 
397 	return NULL;
398 }
399 
400 void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,
401 			   const void *data, size_t size)
402 {
403 	unsigned long flags = channel->ib->flags;
404 	struct tegra_bpmp *bpmp = channel->bpmp;
405 	int err;
406 
407 	if (WARN_ON(size > MSG_DATA_MIN_SZ))
408 		return;
409 
410 	err = tegra_bpmp_ack_request(channel);
411 	if (WARN_ON(err < 0))
412 		return;
413 
414 	if ((flags & MSG_ACK) == 0)
415 		return;
416 
417 	if (WARN_ON(!tegra_bpmp_is_response_channel_free(channel)))
418 		return;
419 
420 	channel->ob->code = code;
421 
422 	if (data && size > 0)
423 		memcpy(channel->ob->data, data, size);
424 
425 	err = tegra_bpmp_post_response(channel);
426 	if (WARN_ON(err < 0))
427 		return;
428 
429 	if (flags & MSG_RING) {
430 		err = tegra_bpmp_ring_doorbell(bpmp);
431 		if (WARN_ON(err < 0))
432 			return;
433 	}
434 }
435 EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return);
436 
437 static void tegra_bpmp_handle_mrq(struct tegra_bpmp *bpmp,
438 				  unsigned int mrq,
439 				  struct tegra_bpmp_channel *channel)
440 {
441 	struct tegra_bpmp_mrq *entry;
442 	u32 zero = 0;
443 
444 	spin_lock(&bpmp->lock);
445 
446 	entry = tegra_bpmp_find_mrq(bpmp, mrq);
447 	if (!entry) {
448 		spin_unlock(&bpmp->lock);
449 		tegra_bpmp_mrq_return(channel, -EINVAL, &zero, sizeof(zero));
450 		return;
451 	}
452 
453 	entry->handler(mrq, channel, entry->data);
454 
455 	spin_unlock(&bpmp->lock);
456 }
457 
458 int tegra_bpmp_request_mrq(struct tegra_bpmp *bpmp, unsigned int mrq,
459 			   tegra_bpmp_mrq_handler_t handler, void *data)
460 {
461 	struct tegra_bpmp_mrq *entry;
462 	unsigned long flags;
463 
464 	if (!handler)
465 		return -EINVAL;
466 
467 	entry = devm_kzalloc(bpmp->dev, sizeof(*entry), GFP_KERNEL);
468 	if (!entry)
469 		return -ENOMEM;
470 
471 	spin_lock_irqsave(&bpmp->lock, flags);
472 
473 	entry->mrq = mrq;
474 	entry->handler = handler;
475 	entry->data = data;
476 	list_add(&entry->list, &bpmp->mrqs);
477 
478 	spin_unlock_irqrestore(&bpmp->lock, flags);
479 
480 	return 0;
481 }
482 EXPORT_SYMBOL_GPL(tegra_bpmp_request_mrq);
483 
484 void tegra_bpmp_free_mrq(struct tegra_bpmp *bpmp, unsigned int mrq, void *data)
485 {
486 	struct tegra_bpmp_mrq *entry;
487 	unsigned long flags;
488 
489 	spin_lock_irqsave(&bpmp->lock, flags);
490 
491 	entry = tegra_bpmp_find_mrq(bpmp, mrq);
492 	if (!entry)
493 		goto unlock;
494 
495 	list_del(&entry->list);
496 	devm_kfree(bpmp->dev, entry);
497 
498 unlock:
499 	spin_unlock_irqrestore(&bpmp->lock, flags);
500 }
501 EXPORT_SYMBOL_GPL(tegra_bpmp_free_mrq);
502 
503 bool tegra_bpmp_mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)
504 {
505 	struct mrq_query_abi_request req = { .mrq = cpu_to_le32(mrq) };
506 	struct mrq_query_abi_response resp;
507 	struct tegra_bpmp_message msg = {
508 		.mrq = MRQ_QUERY_ABI,
509 		.tx = {
510 			.data = &req,
511 			.size = sizeof(req),
512 		},
513 		.rx = {
514 			.data = &resp,
515 			.size = sizeof(resp),
516 		},
517 	};
518 	int err;
519 
520 	err = tegra_bpmp_transfer(bpmp, &msg);
521 	if (err || msg.rx.ret)
522 		return false;
523 
524 	return resp.status == 0;
525 }
526 EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_is_supported);
527 
528 static void tegra_bpmp_mrq_handle_ping(unsigned int mrq,
529 				       struct tegra_bpmp_channel *channel,
530 				       void *data)
531 {
532 	struct mrq_ping_request *request;
533 	struct mrq_ping_response response;
534 
535 	request = (struct mrq_ping_request *)channel->ib->data;
536 
537 	memset(&response, 0, sizeof(response));
538 	response.reply = request->challenge << 1;
539 
540 	tegra_bpmp_mrq_return(channel, 0, &response, sizeof(response));
541 }
542 
543 static int tegra_bpmp_ping(struct tegra_bpmp *bpmp)
544 {
545 	struct mrq_ping_response response;
546 	struct mrq_ping_request request;
547 	struct tegra_bpmp_message msg;
548 	unsigned long flags;
549 	ktime_t start, end;
550 	int err;
551 
552 	memset(&request, 0, sizeof(request));
553 	request.challenge = 1;
554 
555 	memset(&response, 0, sizeof(response));
556 
557 	memset(&msg, 0, sizeof(msg));
558 	msg.mrq = MRQ_PING;
559 	msg.tx.data = &request;
560 	msg.tx.size = sizeof(request);
561 	msg.rx.data = &response;
562 	msg.rx.size = sizeof(response);
563 
564 	local_irq_save(flags);
565 	start = ktime_get();
566 	err = tegra_bpmp_transfer_atomic(bpmp, &msg);
567 	end = ktime_get();
568 	local_irq_restore(flags);
569 
570 	if (!err)
571 		dev_dbg(bpmp->dev,
572 			"ping ok: challenge: %u, response: %u, time: %lld\n",
573 			request.challenge, response.reply,
574 			ktime_to_us(ktime_sub(end, start)));
575 
576 	return err;
577 }
578 
579 /* deprecated version of tag query */
580 static int tegra_bpmp_get_firmware_tag_old(struct tegra_bpmp *bpmp, char *tag,
581 					   size_t size)
582 {
583 	struct mrq_query_tag_request request;
584 	struct tegra_bpmp_message msg;
585 	unsigned long flags;
586 	dma_addr_t phys;
587 	void *virt;
588 	int err;
589 
590 	if (size != TAG_SZ)
591 		return -EINVAL;
592 
593 	virt = dma_alloc_coherent(bpmp->dev, TAG_SZ, &phys,
594 				  GFP_KERNEL | GFP_DMA32);
595 	if (!virt)
596 		return -ENOMEM;
597 
598 	memset(&request, 0, sizeof(request));
599 	request.addr = phys;
600 
601 	memset(&msg, 0, sizeof(msg));
602 	msg.mrq = MRQ_QUERY_TAG;
603 	msg.tx.data = &request;
604 	msg.tx.size = sizeof(request);
605 
606 	local_irq_save(flags);
607 	err = tegra_bpmp_transfer_atomic(bpmp, &msg);
608 	local_irq_restore(flags);
609 
610 	if (err == 0)
611 		memcpy(tag, virt, TAG_SZ);
612 
613 	dma_free_coherent(bpmp->dev, TAG_SZ, virt, phys);
614 
615 	return err;
616 }
617 
618 static int tegra_bpmp_get_firmware_tag(struct tegra_bpmp *bpmp, char *tag,
619 				       size_t size)
620 {
621 	if (tegra_bpmp_mrq_is_supported(bpmp, MRQ_QUERY_FW_TAG)) {
622 		struct mrq_query_fw_tag_response resp;
623 		struct tegra_bpmp_message msg = {
624 			.mrq = MRQ_QUERY_FW_TAG,
625 			.rx = {
626 				.data = &resp,
627 				.size = sizeof(resp),
628 			},
629 		};
630 		int err;
631 
632 		if (size != sizeof(resp.tag))
633 			return -EINVAL;
634 
635 		err = tegra_bpmp_transfer(bpmp, &msg);
636 
637 		if (err)
638 			return err;
639 		if (msg.rx.ret < 0)
640 			return -EINVAL;
641 
642 		memcpy(tag, resp.tag, sizeof(resp.tag));
643 		return 0;
644 	}
645 
646 	return tegra_bpmp_get_firmware_tag_old(bpmp, tag, size);
647 }
648 
649 static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel)
650 {
651 	unsigned long flags = channel->ob->flags;
652 
653 	if ((flags & MSG_RING) == 0)
654 		return;
655 
656 	complete(&channel->completion);
657 }
658 
659 void tegra_bpmp_handle_rx(struct tegra_bpmp *bpmp)
660 {
661 	struct tegra_bpmp_channel *channel;
662 	unsigned int i, count;
663 	unsigned long *busy;
664 
665 	channel = bpmp->rx_channel;
666 	count = bpmp->soc->channels.thread.count;
667 	busy = bpmp->threaded.busy;
668 
669 	if (tegra_bpmp_is_request_ready(channel))
670 		tegra_bpmp_handle_mrq(bpmp, channel->ib->code, channel);
671 
672 	spin_lock(&bpmp->lock);
673 
674 	for_each_set_bit(i, busy, count) {
675 		struct tegra_bpmp_channel *channel;
676 
677 		channel = &bpmp->threaded_channels[i];
678 
679 		if (tegra_bpmp_is_response_ready(channel)) {
680 			tegra_bpmp_channel_signal(channel);
681 			clear_bit(i, busy);
682 		}
683 	}
684 
685 	spin_unlock(&bpmp->lock);
686 }
687 
688 static int tegra_bpmp_probe(struct platform_device *pdev)
689 {
690 	struct tegra_bpmp *bpmp;
691 	char tag[TAG_SZ];
692 	size_t size;
693 	int err;
694 
695 	bpmp = devm_kzalloc(&pdev->dev, sizeof(*bpmp), GFP_KERNEL);
696 	if (!bpmp)
697 		return -ENOMEM;
698 
699 	bpmp->soc = of_device_get_match_data(&pdev->dev);
700 	bpmp->dev = &pdev->dev;
701 
702 	INIT_LIST_HEAD(&bpmp->mrqs);
703 	spin_lock_init(&bpmp->lock);
704 
705 	bpmp->threaded.count = bpmp->soc->channels.thread.count;
706 	sema_init(&bpmp->threaded.lock, bpmp->threaded.count);
707 
708 	size = BITS_TO_LONGS(bpmp->threaded.count) * sizeof(long);
709 
710 	bpmp->threaded.allocated = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
711 	if (!bpmp->threaded.allocated)
712 		return -ENOMEM;
713 
714 	bpmp->threaded.busy = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
715 	if (!bpmp->threaded.busy)
716 		return -ENOMEM;
717 
718 	spin_lock_init(&bpmp->atomic_tx_lock);
719 	bpmp->tx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->tx_channel),
720 					GFP_KERNEL);
721 	if (!bpmp->tx_channel)
722 		return -ENOMEM;
723 
724 	bpmp->rx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->rx_channel),
725 	                                GFP_KERNEL);
726 	if (!bpmp->rx_channel)
727 		return -ENOMEM;
728 
729 	bpmp->threaded_channels = devm_kcalloc(&pdev->dev, bpmp->threaded.count,
730 					       sizeof(*bpmp->threaded_channels),
731 					       GFP_KERNEL);
732 	if (!bpmp->threaded_channels)
733 		return -ENOMEM;
734 
735 	err = bpmp->soc->ops->init(bpmp);
736 	if (err < 0)
737 		return err;
738 
739 	err = tegra_bpmp_request_mrq(bpmp, MRQ_PING,
740 				     tegra_bpmp_mrq_handle_ping, bpmp);
741 	if (err < 0)
742 		goto deinit;
743 
744 	err = tegra_bpmp_ping(bpmp);
745 	if (err < 0) {
746 		dev_err(&pdev->dev, "failed to ping BPMP: %d\n", err);
747 		goto free_mrq;
748 	}
749 
750 	err = tegra_bpmp_get_firmware_tag(bpmp, tag, sizeof(tag));
751 	if (err < 0) {
752 		dev_err(&pdev->dev, "failed to get firmware tag: %d\n", err);
753 		goto free_mrq;
754 	}
755 
756 	dev_info(&pdev->dev, "firmware: %.*s\n", (int)sizeof(tag), tag);
757 
758 	platform_set_drvdata(pdev, bpmp);
759 
760 	err = of_platform_default_populate(pdev->dev.of_node, NULL, &pdev->dev);
761 	if (err < 0)
762 		goto free_mrq;
763 
764 	if (of_find_property(pdev->dev.of_node, "#clock-cells", NULL)) {
765 		err = tegra_bpmp_init_clocks(bpmp);
766 		if (err < 0)
767 			goto free_mrq;
768 	}
769 
770 	if (of_find_property(pdev->dev.of_node, "#reset-cells", NULL)) {
771 		err = tegra_bpmp_init_resets(bpmp);
772 		if (err < 0)
773 			goto free_mrq;
774 	}
775 
776 	if (of_find_property(pdev->dev.of_node, "#power-domain-cells", NULL)) {
777 		err = tegra_bpmp_init_powergates(bpmp);
778 		if (err < 0)
779 			goto free_mrq;
780 	}
781 
782 	err = tegra_bpmp_init_debugfs(bpmp);
783 	if (err < 0)
784 		dev_err(&pdev->dev, "debugfs initialization failed: %d\n", err);
785 
786 	return 0;
787 
788 free_mrq:
789 	tegra_bpmp_free_mrq(bpmp, MRQ_PING, bpmp);
790 deinit:
791 	if (bpmp->soc->ops->deinit)
792 		bpmp->soc->ops->deinit(bpmp);
793 
794 	return err;
795 }
796 
797 static int __maybe_unused tegra_bpmp_resume(struct device *dev)
798 {
799 	struct tegra_bpmp *bpmp = dev_get_drvdata(dev);
800 
801 	if (bpmp->soc->ops->resume)
802 		return bpmp->soc->ops->resume(bpmp);
803 	else
804 		return 0;
805 }
806 
807 static const struct dev_pm_ops tegra_bpmp_pm_ops = {
808 	.resume_noirq = tegra_bpmp_resume,
809 };
810 
811 #if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
812     IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC) || \
813     IS_ENABLED(CONFIG_ARCH_TEGRA_234_SOC)
814 static const struct tegra_bpmp_soc tegra186_soc = {
815 	.channels = {
816 		.cpu_tx = {
817 			.offset = 3,
818 			.timeout = 60 * USEC_PER_SEC,
819 		},
820 		.thread = {
821 			.offset = 0,
822 			.count = 3,
823 			.timeout = 600 * USEC_PER_SEC,
824 		},
825 		.cpu_rx = {
826 			.offset = 13,
827 			.timeout = 0,
828 		},
829 	},
830 	.ops = &tegra186_bpmp_ops,
831 	.num_resets = 193,
832 };
833 #endif
834 
835 #if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
836 static const struct tegra_bpmp_soc tegra210_soc = {
837 	.channels = {
838 		.cpu_tx = {
839 			.offset = 0,
840 			.count = 1,
841 			.timeout = 60 * USEC_PER_SEC,
842 		},
843 		.thread = {
844 			.offset = 4,
845 			.count = 1,
846 			.timeout = 600 * USEC_PER_SEC,
847 		},
848 		.cpu_rx = {
849 			.offset = 8,
850 			.count = 1,
851 			.timeout = 0,
852 		},
853 	},
854 	.ops = &tegra210_bpmp_ops,
855 };
856 #endif
857 
858 static const struct of_device_id tegra_bpmp_match[] = {
859 #if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
860     IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC) || \
861     IS_ENABLED(CONFIG_ARCH_TEGRA_234_SOC)
862 	{ .compatible = "nvidia,tegra186-bpmp", .data = &tegra186_soc },
863 #endif
864 #if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
865 	{ .compatible = "nvidia,tegra210-bpmp", .data = &tegra210_soc },
866 #endif
867 	{ }
868 };
869 
870 static struct platform_driver tegra_bpmp_driver = {
871 	.driver = {
872 		.name = "tegra-bpmp",
873 		.of_match_table = tegra_bpmp_match,
874 		.pm = &tegra_bpmp_pm_ops,
875 		.suppress_bind_attrs = true,
876 	},
877 	.probe = tegra_bpmp_probe,
878 };
879 builtin_platform_driver(tegra_bpmp_driver);
880