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/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 /* deprecated version of tag query */ 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); 881