902 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.4 */5 6#include <linux/cleanup.h>7#include <linux/clk/tegra.h>8#include <linux/genalloc.h>9#include <linux/mailbox_client.h>10#include <linux/module.h>11#include <linux/of.h>12#include <linux/of_platform.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 3227 28static inline const struct tegra_bpmp_ops *29channel_to_ops(struct tegra_bpmp_channel *channel)30{31 struct tegra_bpmp *bpmp = channel->bpmp;32 33 return bpmp->soc->ops;34}35 36struct tegra_bpmp *tegra_bpmp_get(struct device *dev)37{38 struct device_node *np __free(device_node);39 struct platform_device *pdev;40 struct tegra_bpmp *bpmp;41 42 np = of_parse_phandle(dev->of_node, "nvidia,bpmp", 0);43 if (!np)44 return ERR_PTR(-ENOENT);45 46 pdev = of_find_device_by_node(np);47 if (!pdev)48 return ERR_PTR(-ENODEV);49 50 bpmp = platform_get_drvdata(pdev);51 if (!bpmp) {52 put_device(&pdev->dev);53 return ERR_PTR(-EPROBE_DEFER);54 }55 56 return bpmp;57}58EXPORT_SYMBOL_GPL(tegra_bpmp_get);59 60void tegra_bpmp_put(struct tegra_bpmp *bpmp)61{62 if (bpmp)63 put_device(bpmp->dev);64}65EXPORT_SYMBOL_GPL(tegra_bpmp_put);66 67static int68tegra_bpmp_channel_get_thread_index(struct tegra_bpmp_channel *channel)69{70 struct tegra_bpmp *bpmp = channel->bpmp;71 unsigned int count;72 int index;73 74 count = bpmp->soc->channels.thread.count;75 76 index = channel - channel->bpmp->threaded_channels;77 if (index < 0 || index >= count)78 return -EINVAL;79 80 return index;81}82 83static bool tegra_bpmp_message_valid(const struct tegra_bpmp_message *msg)84{85 return (msg->tx.size <= MSG_DATA_MIN_SZ) &&86 (msg->rx.size <= MSG_DATA_MIN_SZ) &&87 (msg->tx.size == 0 || msg->tx.data) &&88 (msg->rx.size == 0 || msg->rx.data);89}90 91static bool tegra_bpmp_is_response_ready(struct tegra_bpmp_channel *channel)92{93 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);94 95 return ops->is_response_ready(channel);96}97 98static bool tegra_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)99{100 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);101 102 return ops->is_request_ready(channel);103}104 105static int tegra_bpmp_wait_response(struct tegra_bpmp_channel *channel)106{107 unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;108 ktime_t end;109 110 end = ktime_add_us(ktime_get(), timeout);111 112 do {113 if (tegra_bpmp_is_response_ready(channel))114 return 0;115 } while (ktime_before(ktime_get(), end));116 117 return -ETIMEDOUT;118}119 120static int tegra_bpmp_ack_response(struct tegra_bpmp_channel *channel)121{122 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);123 124 return ops->ack_response(channel);125}126 127static int tegra_bpmp_ack_request(struct tegra_bpmp_channel *channel)128{129 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);130 131 return ops->ack_request(channel);132}133 134static bool135tegra_bpmp_is_request_channel_free(struct tegra_bpmp_channel *channel)136{137 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);138 139 return ops->is_request_channel_free(channel);140}141 142static bool143tegra_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)144{145 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);146 147 return ops->is_response_channel_free(channel);148}149 150static int151tegra_bpmp_wait_request_channel_free(struct tegra_bpmp_channel *channel)152{153 unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;154 ktime_t start, now;155 156 start = ns_to_ktime(local_clock());157 158 do {159 if (tegra_bpmp_is_request_channel_free(channel))160 return 0;161 162 now = ns_to_ktime(local_clock());163 } while (ktime_us_delta(now, start) < timeout);164 165 return -ETIMEDOUT;166}167 168static int tegra_bpmp_post_request(struct tegra_bpmp_channel *channel)169{170 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);171 172 return ops->post_request(channel);173}174 175static int tegra_bpmp_post_response(struct tegra_bpmp_channel *channel)176{177 const struct tegra_bpmp_ops *ops = channel_to_ops(channel);178 179 return ops->post_response(channel);180}181 182static int tegra_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)183{184 return bpmp->soc->ops->ring_doorbell(bpmp);185}186 187static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,188 void *data, size_t size, int *ret)189{190 int err;191 192 if (data && size > 0)193 tegra_bpmp_mb_read(data, &channel->ib, size);194 195 err = tegra_bpmp_ack_response(channel);196 if (err < 0)197 return err;198 199 *ret = tegra_bpmp_mb_read_field(&channel->ib, code);200 201 return 0;202}203 204static ssize_t tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,205 void *data, size_t size, int *ret)206{207 struct tegra_bpmp *bpmp = channel->bpmp;208 unsigned long flags;209 ssize_t err;210 int index;211 212 index = tegra_bpmp_channel_get_thread_index(channel);213 if (index < 0) {214 err = index;215 goto unlock;216 }217 218 spin_lock_irqsave(&bpmp->lock, flags);219 err = __tegra_bpmp_channel_read(channel, data, size, ret);220 clear_bit(index, bpmp->threaded.allocated);221 spin_unlock_irqrestore(&bpmp->lock, flags);222 223unlock:224 up(&bpmp->threaded.lock);225 226 return err;227}228 229static ssize_t __tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,230 unsigned int mrq, unsigned long flags,231 const void *data, size_t size)232{233 tegra_bpmp_mb_write_field(&channel->ob, code, mrq);234 tegra_bpmp_mb_write_field(&channel->ob, flags, flags);235 236 if (data && size > 0)237 tegra_bpmp_mb_write(&channel->ob, data, size);238 239 return tegra_bpmp_post_request(channel);240}241 242static struct tegra_bpmp_channel *243tegra_bpmp_write_threaded(struct tegra_bpmp *bpmp, unsigned int mrq,244 const void *data, size_t size)245{246 unsigned long timeout = bpmp->soc->channels.thread.timeout;247 unsigned int count = bpmp->soc->channels.thread.count;248 struct tegra_bpmp_channel *channel;249 unsigned long flags;250 unsigned int index;251 int err;252 253 err = down_timeout(&bpmp->threaded.lock, usecs_to_jiffies(timeout));254 if (err < 0)255 return ERR_PTR(err);256 257 spin_lock_irqsave(&bpmp->lock, flags);258 259 index = find_first_zero_bit(bpmp->threaded.allocated, count);260 if (index == count) {261 err = -EBUSY;262 goto unlock;263 }264 265 channel = &bpmp->threaded_channels[index];266 267 if (!tegra_bpmp_is_request_channel_free(channel)) {268 err = -EBUSY;269 goto unlock;270 }271 272 set_bit(index, bpmp->threaded.allocated);273 274 err = __tegra_bpmp_channel_write(channel, mrq, MSG_ACK | MSG_RING,275 data, size);276 if (err < 0)277 goto clear_allocated;278 279 set_bit(index, bpmp->threaded.busy);280 281 spin_unlock_irqrestore(&bpmp->lock, flags);282 return channel;283 284clear_allocated:285 clear_bit(index, bpmp->threaded.allocated);286unlock:287 spin_unlock_irqrestore(&bpmp->lock, flags);288 up(&bpmp->threaded.lock);289 290 return ERR_PTR(err);291}292 293static ssize_t tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,294 unsigned int mrq, unsigned long flags,295 const void *data, size_t size)296{297 int err;298 299 err = tegra_bpmp_wait_request_channel_free(channel);300 if (err < 0)301 return err;302 303 return __tegra_bpmp_channel_write(channel, mrq, flags, data, size);304}305 306static int __maybe_unused tegra_bpmp_resume(struct device *dev);307 308int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,309 struct tegra_bpmp_message *msg)310{311 struct tegra_bpmp_channel *channel;312 int err;313 314 if (WARN_ON(!irqs_disabled()))315 return -EPERM;316 317 if (!tegra_bpmp_message_valid(msg))318 return -EINVAL;319 320 if (bpmp->suspended) {321 /* Reset BPMP IPC channels during resume based on flags passed */322 if (msg->flags & TEGRA_BPMP_MESSAGE_RESET)323 tegra_bpmp_resume(bpmp->dev);324 else325 return -EAGAIN;326 }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}352EXPORT_SYMBOL_GPL(tegra_bpmp_transfer_atomic);353 354int 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 if (bpmp->suspended) {368 /* Reset BPMP IPC channels during resume based on flags passed */369 if (msg->flags & TEGRA_BPMP_MESSAGE_RESET)370 tegra_bpmp_resume(bpmp->dev);371 else372 return -EAGAIN;373 }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}393EXPORT_SYMBOL_GPL(tegra_bpmp_transfer);394 395static 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 407void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,408 const void *data, size_t size)409{410 unsigned long flags = tegra_bpmp_mb_read_field(&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 tegra_bpmp_mb_write_field(&channel->ob, code, code);428 429 if (data && size > 0)430 tegra_bpmp_mb_write(&channel->ob, 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}442EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return);443 444static 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 465int 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}489EXPORT_SYMBOL_GPL(tegra_bpmp_request_mrq);490 491void 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 505unlock:506 spin_unlock_irqrestore(&bpmp->lock, flags);507}508EXPORT_SYMBOL_GPL(tegra_bpmp_free_mrq);509 510bool tegra_bpmp_mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)511{512 struct mrq_query_abi_request req = { .mrq = 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 err;526 527 err = tegra_bpmp_transfer(bpmp, &msg);528 if (err || msg.rx.ret)529 return false;530 531 return resp.status == 0;532}533EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_is_supported);534 535static 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 tegra_bpmp_mb_read(&request, &channel->ib, sizeof(request));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 550static 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 */587static 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 625static 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 656static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel)657{658 unsigned long flags = tegra_bpmp_mb_read_field(&channel->ob, flags);659 660 if ((flags & MSG_RING) == 0)661 return;662 663 complete(&channel->completion);664}665 666void 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 unsigned int mrq = tegra_bpmp_mb_read_field(&channel->ib, code);678 679 tegra_bpmp_handle_mrq(bpmp, mrq, channel);680 }681 682 spin_lock(&bpmp->lock);683 684 for_each_set_bit(i, busy, count) {685 struct tegra_bpmp_channel *channel;686 687 channel = &bpmp->threaded_channels[i];688 689 if (tegra_bpmp_is_response_ready(channel)) {690 tegra_bpmp_channel_signal(channel);691 clear_bit(i, busy);692 }693 }694 695 spin_unlock(&bpmp->lock);696}697 698static int tegra_bpmp_probe(struct platform_device *pdev)699{700 struct tegra_bpmp *bpmp;701 char tag[TAG_SZ];702 size_t size;703 int err;704 705 bpmp = devm_kzalloc(&pdev->dev, sizeof(*bpmp), GFP_KERNEL);706 if (!bpmp)707 return -ENOMEM;708 709 bpmp->soc = of_device_get_match_data(&pdev->dev);710 bpmp->dev = &pdev->dev;711 712 INIT_LIST_HEAD(&bpmp->mrqs);713 spin_lock_init(&bpmp->lock);714 715 bpmp->threaded.count = bpmp->soc->channels.thread.count;716 sema_init(&bpmp->threaded.lock, bpmp->threaded.count);717 718 size = BITS_TO_LONGS(bpmp->threaded.count) * sizeof(long);719 720 bpmp->threaded.allocated = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);721 if (!bpmp->threaded.allocated)722 return -ENOMEM;723 724 bpmp->threaded.busy = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);725 if (!bpmp->threaded.busy)726 return -ENOMEM;727 728 spin_lock_init(&bpmp->atomic_tx_lock);729 bpmp->tx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->tx_channel),730 GFP_KERNEL);731 if (!bpmp->tx_channel)732 return -ENOMEM;733 734 bpmp->rx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->rx_channel),735 GFP_KERNEL);736 if (!bpmp->rx_channel)737 return -ENOMEM;738 739 bpmp->threaded_channels = devm_kcalloc(&pdev->dev, bpmp->threaded.count,740 sizeof(*bpmp->threaded_channels),741 GFP_KERNEL);742 if (!bpmp->threaded_channels)743 return -ENOMEM;744 745 platform_set_drvdata(pdev, bpmp);746 747 err = bpmp->soc->ops->init(bpmp);748 if (err < 0)749 return err;750 751 err = tegra_bpmp_request_mrq(bpmp, MRQ_PING,752 tegra_bpmp_mrq_handle_ping, bpmp);753 if (err < 0)754 goto deinit;755 756 err = tegra_bpmp_ping(bpmp);757 if (err < 0) {758 dev_err(&pdev->dev, "failed to ping BPMP: %d\n", err);759 goto free_mrq;760 }761 762 err = tegra_bpmp_get_firmware_tag(bpmp, tag, sizeof(tag));763 if (err < 0) {764 dev_err(&pdev->dev, "failed to get firmware tag: %d\n", err);765 goto free_mrq;766 }767 768 dev_info(&pdev->dev, "firmware: %.*s\n", (int)sizeof(tag), tag);769 770 err = of_platform_default_populate(pdev->dev.of_node, NULL, &pdev->dev);771 if (err < 0)772 goto free_mrq;773 774 if (of_property_present(pdev->dev.of_node, "#clock-cells")) {775 err = tegra_bpmp_init_clocks(bpmp);776 if (err < 0)777 goto free_mrq;778 }779 780 if (of_property_present(pdev->dev.of_node, "#reset-cells")) {781 err = tegra_bpmp_init_resets(bpmp);782 if (err < 0)783 goto free_mrq;784 }785 786 if (of_property_present(pdev->dev.of_node, "#power-domain-cells")) {787 err = tegra_bpmp_init_powergates(bpmp);788 if (err < 0)789 goto free_mrq;790 }791 792 err = tegra_bpmp_init_debugfs(bpmp);793 if (err < 0)794 dev_err(&pdev->dev, "debugfs initialization failed: %d\n", err);795 796 return 0;797 798free_mrq:799 tegra_bpmp_free_mrq(bpmp, MRQ_PING, bpmp);800deinit:801 if (bpmp->soc->ops->deinit)802 bpmp->soc->ops->deinit(bpmp);803 804 return err;805}806 807static int __maybe_unused tegra_bpmp_suspend(struct device *dev)808{809 struct tegra_bpmp *bpmp = dev_get_drvdata(dev);810 811 bpmp->suspended = true;812 813 return 0;814}815 816static int __maybe_unused tegra_bpmp_resume(struct device *dev)817{818 struct tegra_bpmp *bpmp = dev_get_drvdata(dev);819 820 bpmp->suspended = false;821 822 if (bpmp->soc->ops->resume)823 return bpmp->soc->ops->resume(bpmp);824 else825 return 0;826}827 828static const struct dev_pm_ops tegra_bpmp_pm_ops = {829 .suspend_noirq = tegra_bpmp_suspend,830 .resume_noirq = tegra_bpmp_resume,831};832 833#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \834 IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC) || \835 IS_ENABLED(CONFIG_ARCH_TEGRA_234_SOC)836static const struct tegra_bpmp_soc tegra186_soc = {837 .channels = {838 .cpu_tx = {839 .offset = 3,840 .timeout = 60 * USEC_PER_SEC,841 },842 .thread = {843 .offset = 0,844 .count = 3,845 .timeout = 600 * USEC_PER_SEC,846 },847 .cpu_rx = {848 .offset = 13,849 .timeout = 0,850 },851 },852 .ops = &tegra186_bpmp_ops,853 .num_resets = 193,854};855#endif856 857#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)858static const struct tegra_bpmp_soc tegra210_soc = {859 .channels = {860 .cpu_tx = {861 .offset = 0,862 .count = 1,863 .timeout = 60 * USEC_PER_SEC,864 },865 .thread = {866 .offset = 4,867 .count = 1,868 .timeout = 600 * USEC_PER_SEC,869 },870 .cpu_rx = {871 .offset = 8,872 .count = 1,873 .timeout = 0,874 },875 },876 .ops = &tegra210_bpmp_ops,877};878#endif879 880static const struct of_device_id tegra_bpmp_match[] = {881#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \882 IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC) || \883 IS_ENABLED(CONFIG_ARCH_TEGRA_234_SOC)884 { .compatible = "nvidia,tegra186-bpmp", .data = &tegra186_soc },885#endif886#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)887 { .compatible = "nvidia,tegra210-bpmp", .data = &tegra210_soc },888#endif889 { }890};891 892static struct platform_driver tegra_bpmp_driver = {893 .driver = {894 .name = "tegra-bpmp",895 .of_match_table = tegra_bpmp_match,896 .pm = &tegra_bpmp_pm_ops,897 .suppress_bind_attrs = true,898 },899 .probe = tegra_bpmp_probe,900};901builtin_platform_driver(tegra_bpmp_driver);902