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