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