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