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/module.h> |
10 | #include <linux/of.h> |
11 | #include <linux/of_platform.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(np: dev->of_node, phandle_name: "nvidia,bpmp" , index: 0); |
48 | if (!np) |
49 | return ERR_PTR(error: -ENOENT); |
50 | |
51 | pdev = of_find_device_by_node(np); |
52 | if (!pdev) { |
53 | bpmp = ERR_PTR(error: -ENODEV); |
54 | goto put; |
55 | } |
56 | |
57 | bpmp = platform_get_drvdata(pdev); |
58 | if (!bpmp) { |
59 | bpmp = ERR_PTR(error: -EPROBE_DEFER); |
60 | put_device(dev: &pdev->dev); |
61 | goto put; |
62 | } |
63 | |
64 | put: |
65 | of_node_put(node: 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(dev: 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(kt: ktime_get(), usec: timeout); |
121 | |
122 | do { |
123 | if (tegra_bpmp_is_response_ready(channel)) |
124 | return 0; |
125 | } while (ktime_before(cmp1: ktime_get(), cmp2: 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(ns: local_clock()); |
167 | |
168 | do { |
169 | if (tegra_bpmp_is_request_channel_free(channel)) |
170 | return 0; |
171 | |
172 | now = ns_to_ktime(ns: local_clock()); |
173 | } while (ktime_us_delta(later: now, earlier: 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 | tegra_bpmp_mb_read(data, &channel->ib, size); |
204 | |
205 | err = tegra_bpmp_ack_response(channel); |
206 | if (err < 0) |
207 | return err; |
208 | |
209 | *ret = tegra_bpmp_mb_read_field(&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(nr: index, addr: bpmp->threaded.allocated); |
231 | spin_unlock_irqrestore(lock: &bpmp->lock, flags); |
232 | |
233 | unlock: |
234 | up(sem: &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 | tegra_bpmp_mb_write_field(&channel->ob, code, mrq); |
244 | tegra_bpmp_mb_write_field(&channel->ob, flags, flags); |
245 | |
246 | if (data && size > 0) |
247 | tegra_bpmp_mb_write(&channel->ob, 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(sem: &bpmp->threaded.lock, jiffies: usecs_to_jiffies(u: timeout)); |
264 | if (err < 0) |
265 | return ERR_PTR(error: err); |
266 | |
267 | spin_lock_irqsave(&bpmp->lock, flags); |
268 | |
269 | index = find_first_zero_bit(addr: bpmp->threaded.allocated, size: 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(nr: index, addr: 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(nr: index, addr: bpmp->threaded.busy); |
290 | |
291 | spin_unlock_irqrestore(lock: &bpmp->lock, flags); |
292 | return channel; |
293 | |
294 | clear_allocated: |
295 | clear_bit(nr: index, addr: bpmp->threaded.allocated); |
296 | unlock: |
297 | spin_unlock_irqrestore(lock: &bpmp->lock, flags); |
298 | up(sem: &bpmp->threaded.lock); |
299 | |
300 | return ERR_PTR(error: 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 | static int __maybe_unused tegra_bpmp_resume(struct device *dev); |
317 | |
318 | int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp, |
319 | struct tegra_bpmp_message *msg) |
320 | { |
321 | struct tegra_bpmp_channel *channel; |
322 | int err; |
323 | |
324 | if (WARN_ON(!irqs_disabled())) |
325 | return -EPERM; |
326 | |
327 | if (!tegra_bpmp_message_valid(msg)) |
328 | return -EINVAL; |
329 | |
330 | if (bpmp->suspended) { |
331 | /* Reset BPMP IPC channels during resume based on flags passed */ |
332 | if (msg->flags & TEGRA_BPMP_MESSAGE_RESET) |
333 | tegra_bpmp_resume(dev: bpmp->dev); |
334 | else |
335 | return -EAGAIN; |
336 | } |
337 | |
338 | channel = bpmp->tx_channel; |
339 | |
340 | spin_lock(lock: &bpmp->atomic_tx_lock); |
341 | |
342 | err = tegra_bpmp_channel_write(channel, mrq: msg->mrq, MSG_ACK, |
343 | data: msg->tx.data, size: msg->tx.size); |
344 | if (err < 0) { |
345 | spin_unlock(lock: &bpmp->atomic_tx_lock); |
346 | return err; |
347 | } |
348 | |
349 | spin_unlock(lock: &bpmp->atomic_tx_lock); |
350 | |
351 | err = tegra_bpmp_ring_doorbell(bpmp); |
352 | if (err < 0) |
353 | return err; |
354 | |
355 | err = tegra_bpmp_wait_response(channel); |
356 | if (err < 0) |
357 | return err; |
358 | |
359 | return __tegra_bpmp_channel_read(channel, data: msg->rx.data, size: msg->rx.size, |
360 | ret: &msg->rx.ret); |
361 | } |
362 | EXPORT_SYMBOL_GPL(tegra_bpmp_transfer_atomic); |
363 | |
364 | int tegra_bpmp_transfer(struct tegra_bpmp *bpmp, |
365 | struct tegra_bpmp_message *msg) |
366 | { |
367 | struct tegra_bpmp_channel *channel; |
368 | unsigned long timeout; |
369 | int err; |
370 | |
371 | if (WARN_ON(irqs_disabled())) |
372 | return -EPERM; |
373 | |
374 | if (!tegra_bpmp_message_valid(msg)) |
375 | return -EINVAL; |
376 | |
377 | if (bpmp->suspended) { |
378 | /* Reset BPMP IPC channels during resume based on flags passed */ |
379 | if (msg->flags & TEGRA_BPMP_MESSAGE_RESET) |
380 | tegra_bpmp_resume(dev: bpmp->dev); |
381 | else |
382 | return -EAGAIN; |
383 | } |
384 | |
385 | channel = tegra_bpmp_write_threaded(bpmp, mrq: msg->mrq, data: msg->tx.data, |
386 | size: msg->tx.size); |
387 | if (IS_ERR(ptr: channel)) |
388 | return PTR_ERR(ptr: channel); |
389 | |
390 | err = tegra_bpmp_ring_doorbell(bpmp); |
391 | if (err < 0) |
392 | return err; |
393 | |
394 | timeout = usecs_to_jiffies(u: bpmp->soc->channels.thread.timeout); |
395 | |
396 | err = wait_for_completion_timeout(x: &channel->completion, timeout); |
397 | if (err == 0) |
398 | return -ETIMEDOUT; |
399 | |
400 | return tegra_bpmp_channel_read(channel, data: msg->rx.data, size: msg->rx.size, |
401 | ret: &msg->rx.ret); |
402 | } |
403 | EXPORT_SYMBOL_GPL(tegra_bpmp_transfer); |
404 | |
405 | static struct tegra_bpmp_mrq *tegra_bpmp_find_mrq(struct tegra_bpmp *bpmp, |
406 | unsigned int mrq) |
407 | { |
408 | struct tegra_bpmp_mrq *entry; |
409 | |
410 | list_for_each_entry(entry, &bpmp->mrqs, list) |
411 | if (entry->mrq == mrq) |
412 | return entry; |
413 | |
414 | return NULL; |
415 | } |
416 | |
417 | void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code, |
418 | const void *data, size_t size) |
419 | { |
420 | unsigned long flags = tegra_bpmp_mb_read_field(&channel->ib, flags); |
421 | struct tegra_bpmp *bpmp = channel->bpmp; |
422 | int err; |
423 | |
424 | if (WARN_ON(size > MSG_DATA_MIN_SZ)) |
425 | return; |
426 | |
427 | err = tegra_bpmp_ack_request(channel); |
428 | if (WARN_ON(err < 0)) |
429 | return; |
430 | |
431 | if ((flags & MSG_ACK) == 0) |
432 | return; |
433 | |
434 | if (WARN_ON(!tegra_bpmp_is_response_channel_free(channel))) |
435 | return; |
436 | |
437 | tegra_bpmp_mb_write_field(&channel->ob, code, code); |
438 | |
439 | if (data && size > 0) |
440 | tegra_bpmp_mb_write(&channel->ob, data, size); |
441 | |
442 | err = tegra_bpmp_post_response(channel); |
443 | if (WARN_ON(err < 0)) |
444 | return; |
445 | |
446 | if (flags & MSG_RING) { |
447 | err = tegra_bpmp_ring_doorbell(bpmp); |
448 | if (WARN_ON(err < 0)) |
449 | return; |
450 | } |
451 | } |
452 | EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return); |
453 | |
454 | static void tegra_bpmp_handle_mrq(struct tegra_bpmp *bpmp, |
455 | unsigned int mrq, |
456 | struct tegra_bpmp_channel *channel) |
457 | { |
458 | struct tegra_bpmp_mrq *entry; |
459 | u32 zero = 0; |
460 | |
461 | spin_lock(lock: &bpmp->lock); |
462 | |
463 | entry = tegra_bpmp_find_mrq(bpmp, mrq); |
464 | if (!entry) { |
465 | spin_unlock(lock: &bpmp->lock); |
466 | tegra_bpmp_mrq_return(channel, -EINVAL, &zero, sizeof(zero)); |
467 | return; |
468 | } |
469 | |
470 | entry->handler(mrq, channel, entry->data); |
471 | |
472 | spin_unlock(lock: &bpmp->lock); |
473 | } |
474 | |
475 | int tegra_bpmp_request_mrq(struct tegra_bpmp *bpmp, unsigned int mrq, |
476 | tegra_bpmp_mrq_handler_t handler, void *data) |
477 | { |
478 | struct tegra_bpmp_mrq *entry; |
479 | unsigned long flags; |
480 | |
481 | if (!handler) |
482 | return -EINVAL; |
483 | |
484 | entry = devm_kzalloc(dev: bpmp->dev, size: sizeof(*entry), GFP_KERNEL); |
485 | if (!entry) |
486 | return -ENOMEM; |
487 | |
488 | spin_lock_irqsave(&bpmp->lock, flags); |
489 | |
490 | entry->mrq = mrq; |
491 | entry->handler = handler; |
492 | entry->data = data; |
493 | list_add(new: &entry->list, head: &bpmp->mrqs); |
494 | |
495 | spin_unlock_irqrestore(lock: &bpmp->lock, flags); |
496 | |
497 | return 0; |
498 | } |
499 | EXPORT_SYMBOL_GPL(tegra_bpmp_request_mrq); |
500 | |
501 | void tegra_bpmp_free_mrq(struct tegra_bpmp *bpmp, unsigned int mrq, void *data) |
502 | { |
503 | struct tegra_bpmp_mrq *entry; |
504 | unsigned long flags; |
505 | |
506 | spin_lock_irqsave(&bpmp->lock, flags); |
507 | |
508 | entry = tegra_bpmp_find_mrq(bpmp, mrq); |
509 | if (!entry) |
510 | goto unlock; |
511 | |
512 | list_del(entry: &entry->list); |
513 | devm_kfree(dev: bpmp->dev, p: entry); |
514 | |
515 | unlock: |
516 | spin_unlock_irqrestore(lock: &bpmp->lock, flags); |
517 | } |
518 | EXPORT_SYMBOL_GPL(tegra_bpmp_free_mrq); |
519 | |
520 | bool tegra_bpmp_mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq) |
521 | { |
522 | struct mrq_query_abi_request req = { .mrq = mrq }; |
523 | struct mrq_query_abi_response resp; |
524 | struct tegra_bpmp_message msg = { |
525 | .mrq = MRQ_QUERY_ABI, |
526 | .tx = { |
527 | .data = &req, |
528 | .size = sizeof(req), |
529 | }, |
530 | .rx = { |
531 | .data = &resp, |
532 | .size = sizeof(resp), |
533 | }, |
534 | }; |
535 | int err; |
536 | |
537 | err = tegra_bpmp_transfer(bpmp, &msg); |
538 | if (err || msg.rx.ret) |
539 | return false; |
540 | |
541 | return resp.status == 0; |
542 | } |
543 | EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_is_supported); |
544 | |
545 | static void tegra_bpmp_mrq_handle_ping(unsigned int mrq, |
546 | struct tegra_bpmp_channel *channel, |
547 | void *data) |
548 | { |
549 | struct mrq_ping_request request; |
550 | struct mrq_ping_response response; |
551 | |
552 | tegra_bpmp_mb_read(&request, &channel->ib, sizeof(request)); |
553 | |
554 | memset(&response, 0, sizeof(response)); |
555 | response.reply = request.challenge << 1; |
556 | |
557 | tegra_bpmp_mrq_return(channel, 0, &response, sizeof(response)); |
558 | } |
559 | |
560 | static int tegra_bpmp_ping(struct tegra_bpmp *bpmp) |
561 | { |
562 | struct mrq_ping_response response; |
563 | struct mrq_ping_request request; |
564 | struct tegra_bpmp_message msg; |
565 | unsigned long flags; |
566 | ktime_t start, end; |
567 | int err; |
568 | |
569 | memset(&request, 0, sizeof(request)); |
570 | request.challenge = 1; |
571 | |
572 | memset(&response, 0, sizeof(response)); |
573 | |
574 | memset(&msg, 0, sizeof(msg)); |
575 | msg.mrq = MRQ_PING; |
576 | msg.tx.data = &request; |
577 | msg.tx.size = sizeof(request); |
578 | msg.rx.data = &response; |
579 | msg.rx.size = sizeof(response); |
580 | |
581 | local_irq_save(flags); |
582 | start = ktime_get(); |
583 | err = tegra_bpmp_transfer_atomic(bpmp, &msg); |
584 | end = ktime_get(); |
585 | local_irq_restore(flags); |
586 | |
587 | if (!err) |
588 | dev_dbg(bpmp->dev, |
589 | "ping ok: challenge: %u, response: %u, time: %lld\n" , |
590 | request.challenge, response.reply, |
591 | ktime_to_us(ktime_sub(end, start))); |
592 | |
593 | return err; |
594 | } |
595 | |
596 | /* deprecated version of tag query */ |
597 | static int tegra_bpmp_get_firmware_tag_old(struct tegra_bpmp *bpmp, char *tag, |
598 | size_t size) |
599 | { |
600 | struct mrq_query_tag_request request; |
601 | struct tegra_bpmp_message msg; |
602 | unsigned long flags; |
603 | dma_addr_t phys; |
604 | void *virt; |
605 | int err; |
606 | |
607 | if (size != TAG_SZ) |
608 | return -EINVAL; |
609 | |
610 | virt = dma_alloc_coherent(dev: bpmp->dev, TAG_SZ, dma_handle: &phys, |
611 | GFP_KERNEL | GFP_DMA32); |
612 | if (!virt) |
613 | return -ENOMEM; |
614 | |
615 | memset(&request, 0, sizeof(request)); |
616 | request.addr = phys; |
617 | |
618 | memset(&msg, 0, sizeof(msg)); |
619 | msg.mrq = MRQ_QUERY_TAG; |
620 | msg.tx.data = &request; |
621 | msg.tx.size = sizeof(request); |
622 | |
623 | local_irq_save(flags); |
624 | err = tegra_bpmp_transfer_atomic(bpmp, &msg); |
625 | local_irq_restore(flags); |
626 | |
627 | if (err == 0) |
628 | memcpy(tag, virt, TAG_SZ); |
629 | |
630 | dma_free_coherent(dev: bpmp->dev, TAG_SZ, cpu_addr: virt, dma_handle: phys); |
631 | |
632 | return err; |
633 | } |
634 | |
635 | static int tegra_bpmp_get_firmware_tag(struct tegra_bpmp *bpmp, char *tag, |
636 | size_t size) |
637 | { |
638 | if (tegra_bpmp_mrq_is_supported(bpmp, MRQ_QUERY_FW_TAG)) { |
639 | struct mrq_query_fw_tag_response resp; |
640 | struct tegra_bpmp_message msg = { |
641 | .mrq = MRQ_QUERY_FW_TAG, |
642 | .rx = { |
643 | .data = &resp, |
644 | .size = sizeof(resp), |
645 | }, |
646 | }; |
647 | int err; |
648 | |
649 | if (size != sizeof(resp.tag)) |
650 | return -EINVAL; |
651 | |
652 | err = tegra_bpmp_transfer(bpmp, &msg); |
653 | |
654 | if (err) |
655 | return err; |
656 | if (msg.rx.ret < 0) |
657 | return -EINVAL; |
658 | |
659 | memcpy(tag, resp.tag, sizeof(resp.tag)); |
660 | return 0; |
661 | } |
662 | |
663 | return tegra_bpmp_get_firmware_tag_old(bpmp, tag, size); |
664 | } |
665 | |
666 | static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel) |
667 | { |
668 | unsigned long flags = tegra_bpmp_mb_read_field(&channel->ob, flags); |
669 | |
670 | if ((flags & MSG_RING) == 0) |
671 | return; |
672 | |
673 | complete(&channel->completion); |
674 | } |
675 | |
676 | void tegra_bpmp_handle_rx(struct tegra_bpmp *bpmp) |
677 | { |
678 | struct tegra_bpmp_channel *channel; |
679 | unsigned int i, count; |
680 | unsigned long *busy; |
681 | |
682 | channel = bpmp->rx_channel; |
683 | count = bpmp->soc->channels.thread.count; |
684 | busy = bpmp->threaded.busy; |
685 | |
686 | if (tegra_bpmp_is_request_ready(channel)) { |
687 | unsigned int mrq = tegra_bpmp_mb_read_field(&channel->ib, code); |
688 | |
689 | tegra_bpmp_handle_mrq(bpmp, mrq, channel); |
690 | } |
691 | |
692 | spin_lock(lock: &bpmp->lock); |
693 | |
694 | for_each_set_bit(i, busy, count) { |
695 | struct tegra_bpmp_channel *channel; |
696 | |
697 | channel = &bpmp->threaded_channels[i]; |
698 | |
699 | if (tegra_bpmp_is_response_ready(channel)) { |
700 | tegra_bpmp_channel_signal(channel); |
701 | clear_bit(nr: i, addr: busy); |
702 | } |
703 | } |
704 | |
705 | spin_unlock(lock: &bpmp->lock); |
706 | } |
707 | |
708 | static int tegra_bpmp_probe(struct platform_device *pdev) |
709 | { |
710 | struct tegra_bpmp *bpmp; |
711 | char tag[TAG_SZ]; |
712 | size_t size; |
713 | int err; |
714 | |
715 | bpmp = devm_kzalloc(dev: &pdev->dev, size: sizeof(*bpmp), GFP_KERNEL); |
716 | if (!bpmp) |
717 | return -ENOMEM; |
718 | |
719 | bpmp->soc = of_device_get_match_data(dev: &pdev->dev); |
720 | bpmp->dev = &pdev->dev; |
721 | |
722 | INIT_LIST_HEAD(list: &bpmp->mrqs); |
723 | spin_lock_init(&bpmp->lock); |
724 | |
725 | bpmp->threaded.count = bpmp->soc->channels.thread.count; |
726 | sema_init(sem: &bpmp->threaded.lock, val: bpmp->threaded.count); |
727 | |
728 | size = BITS_TO_LONGS(bpmp->threaded.count) * sizeof(long); |
729 | |
730 | bpmp->threaded.allocated = devm_kzalloc(dev: &pdev->dev, size, GFP_KERNEL); |
731 | if (!bpmp->threaded.allocated) |
732 | return -ENOMEM; |
733 | |
734 | bpmp->threaded.busy = devm_kzalloc(dev: &pdev->dev, size, GFP_KERNEL); |
735 | if (!bpmp->threaded.busy) |
736 | return -ENOMEM; |
737 | |
738 | spin_lock_init(&bpmp->atomic_tx_lock); |
739 | bpmp->tx_channel = devm_kzalloc(dev: &pdev->dev, size: sizeof(*bpmp->tx_channel), |
740 | GFP_KERNEL); |
741 | if (!bpmp->tx_channel) |
742 | return -ENOMEM; |
743 | |
744 | bpmp->rx_channel = devm_kzalloc(dev: &pdev->dev, size: sizeof(*bpmp->rx_channel), |
745 | GFP_KERNEL); |
746 | if (!bpmp->rx_channel) |
747 | return -ENOMEM; |
748 | |
749 | bpmp->threaded_channels = devm_kcalloc(dev: &pdev->dev, n: bpmp->threaded.count, |
750 | size: sizeof(*bpmp->threaded_channels), |
751 | GFP_KERNEL); |
752 | if (!bpmp->threaded_channels) |
753 | return -ENOMEM; |
754 | |
755 | platform_set_drvdata(pdev, data: bpmp); |
756 | |
757 | err = bpmp->soc->ops->init(bpmp); |
758 | if (err < 0) |
759 | return err; |
760 | |
761 | err = tegra_bpmp_request_mrq(bpmp, MRQ_PING, |
762 | tegra_bpmp_mrq_handle_ping, bpmp); |
763 | if (err < 0) |
764 | goto deinit; |
765 | |
766 | err = tegra_bpmp_ping(bpmp); |
767 | if (err < 0) { |
768 | dev_err(&pdev->dev, "failed to ping BPMP: %d\n" , err); |
769 | goto free_mrq; |
770 | } |
771 | |
772 | err = tegra_bpmp_get_firmware_tag(bpmp, tag, size: sizeof(tag)); |
773 | if (err < 0) { |
774 | dev_err(&pdev->dev, "failed to get firmware tag: %d\n" , err); |
775 | goto free_mrq; |
776 | } |
777 | |
778 | dev_info(&pdev->dev, "firmware: %.*s\n" , (int)sizeof(tag), tag); |
779 | |
780 | err = of_platform_default_populate(root: pdev->dev.of_node, NULL, parent: &pdev->dev); |
781 | if (err < 0) |
782 | goto free_mrq; |
783 | |
784 | if (of_property_present(np: pdev->dev.of_node, propname: "#clock-cells" )) { |
785 | err = tegra_bpmp_init_clocks(bpmp); |
786 | if (err < 0) |
787 | goto free_mrq; |
788 | } |
789 | |
790 | if (of_property_present(np: pdev->dev.of_node, propname: "#reset-cells" )) { |
791 | err = tegra_bpmp_init_resets(bpmp); |
792 | if (err < 0) |
793 | goto free_mrq; |
794 | } |
795 | |
796 | if (of_property_present(np: pdev->dev.of_node, propname: "#power-domain-cells" )) { |
797 | err = tegra_bpmp_init_powergates(bpmp); |
798 | if (err < 0) |
799 | goto free_mrq; |
800 | } |
801 | |
802 | err = tegra_bpmp_init_debugfs(bpmp); |
803 | if (err < 0) |
804 | dev_err(&pdev->dev, "debugfs initialization failed: %d\n" , err); |
805 | |
806 | return 0; |
807 | |
808 | free_mrq: |
809 | tegra_bpmp_free_mrq(bpmp, MRQ_PING, bpmp); |
810 | deinit: |
811 | if (bpmp->soc->ops->deinit) |
812 | bpmp->soc->ops->deinit(bpmp); |
813 | |
814 | return err; |
815 | } |
816 | |
817 | static int __maybe_unused tegra_bpmp_suspend(struct device *dev) |
818 | { |
819 | struct tegra_bpmp *bpmp = dev_get_drvdata(dev); |
820 | |
821 | bpmp->suspended = true; |
822 | |
823 | return 0; |
824 | } |
825 | |
826 | static int __maybe_unused tegra_bpmp_resume(struct device *dev) |
827 | { |
828 | struct tegra_bpmp *bpmp = dev_get_drvdata(dev); |
829 | |
830 | bpmp->suspended = false; |
831 | |
832 | if (bpmp->soc->ops->resume) |
833 | return bpmp->soc->ops->resume(bpmp); |
834 | else |
835 | return 0; |
836 | } |
837 | |
838 | static const struct dev_pm_ops tegra_bpmp_pm_ops = { |
839 | .suspend_noirq = tegra_bpmp_suspend, |
840 | .resume_noirq = tegra_bpmp_resume, |
841 | }; |
842 | |
843 | #if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \ |
844 | IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC) || \ |
845 | IS_ENABLED(CONFIG_ARCH_TEGRA_234_SOC) |
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 | .ops = &tegra186_bpmp_ops, |
863 | .num_resets = 193, |
864 | }; |
865 | #endif |
866 | |
867 | #if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC) |
868 | static const struct tegra_bpmp_soc tegra210_soc = { |
869 | .channels = { |
870 | .cpu_tx = { |
871 | .offset = 0, |
872 | .count = 1, |
873 | .timeout = 60 * USEC_PER_SEC, |
874 | }, |
875 | .thread = { |
876 | .offset = 4, |
877 | .count = 1, |
878 | .timeout = 600 * USEC_PER_SEC, |
879 | }, |
880 | .cpu_rx = { |
881 | .offset = 8, |
882 | .count = 1, |
883 | .timeout = 0, |
884 | }, |
885 | }, |
886 | .ops = &tegra210_bpmp_ops, |
887 | }; |
888 | #endif |
889 | |
890 | static const struct of_device_id tegra_bpmp_match[] = { |
891 | #if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \ |
892 | IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC) || \ |
893 | IS_ENABLED(CONFIG_ARCH_TEGRA_234_SOC) |
894 | { .compatible = "nvidia,tegra186-bpmp" , .data = &tegra186_soc }, |
895 | #endif |
896 | #if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC) |
897 | { .compatible = "nvidia,tegra210-bpmp" , .data = &tegra210_soc }, |
898 | #endif |
899 | { } |
900 | }; |
901 | |
902 | static struct platform_driver tegra_bpmp_driver = { |
903 | .driver = { |
904 | .name = "tegra-bpmp" , |
905 | .of_match_table = tegra_bpmp_match, |
906 | .pm = &tegra_bpmp_pm_ops, |
907 | .suppress_bind_attrs = true, |
908 | }, |
909 | .probe = tegra_bpmp_probe, |
910 | }; |
911 | builtin_platform_driver(tegra_bpmp_driver); |
912 | |