Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(C) 2021 Marvell.
3 : : */
4 : :
5 : : #include <errno.h>
6 : : #include <stdio.h>
7 : : #include <stdlib.h>
8 : : #include <string.h>
9 : :
10 : : #include "roc_api.h"
11 : : #include "roc_priv.h"
12 : :
13 : : /* RCLK, SCLK in MHz */
14 : : uint16_t dev_rclk_freq;
15 : : uint16_t dev_sclk_freq;
16 : :
17 : : static inline uint16_t
18 : : msgs_offset(void)
19 : : {
20 : : return PLT_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
21 : : }
22 : :
23 : : void
24 : 0 : mbox_fini(struct mbox *mbox)
25 : : {
26 : 0 : mbox->reg_base = 0;
27 : 0 : mbox->hwbase = 0;
28 : 0 : plt_free(mbox->dev);
29 : 0 : mbox->dev = NULL;
30 : 0 : }
31 : :
32 : : void
33 : 0 : mbox_reset(struct mbox *mbox, int devid)
34 : : {
35 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
36 : 0 : struct mbox_hdr *tx_hdr =
37 : 0 : (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->tx_start);
38 : 0 : struct mbox_hdr *rx_hdr =
39 : 0 : (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
40 : :
41 : 0 : mdev->msg_size = 0;
42 : 0 : mdev->rsp_size = 0;
43 : 0 : tx_hdr->msg_size = 0;
44 : 0 : tx_hdr->num_msgs = 0;
45 : 0 : rx_hdr->msg_size = 0;
46 : 0 : rx_hdr->num_msgs = 0;
47 : 0 : }
48 : :
49 : : static int
50 : 0 : cn20k_mbox_setup(struct mbox *mbox, int direction)
51 : : {
52 [ # # # # : 0 : switch (direction) {
# # # #
# ]
53 : 0 : case MBOX_DIR_AFPF:
54 : 0 : mbox->trigger = RVU_MBOX_AF_AFPFX_TRIGX(1);
55 : 0 : mbox->tr_shift = 4;
56 : 0 : break;
57 : 0 : case MBOX_DIR_AFPF_UP:
58 : 0 : mbox->trigger = RVU_MBOX_AF_AFPFX_TRIGX(0);
59 : 0 : mbox->tr_shift = 4;
60 : 0 : break;
61 : 0 : case MBOX_DIR_PFAF:
62 : 0 : mbox->trigger = RVU_MBOX_PF_PFAF_TRIGX(0);
63 : 0 : mbox->tr_shift = 0;
64 : 0 : break;
65 : 0 : case MBOX_DIR_PFAF_UP:
66 : 0 : mbox->trigger = RVU_MBOX_PF_PFAF_TRIGX(1);
67 : 0 : mbox->tr_shift = 0;
68 : 0 : break;
69 : 0 : case MBOX_DIR_PFVF:
70 : 0 : mbox->trigger = RVU_MBOX_PF_VFX_PFVF_TRIGX(1);
71 : 0 : mbox->tr_shift = 4;
72 : 0 : break;
73 : 0 : case MBOX_DIR_PFVF_UP:
74 : 0 : mbox->trigger = RVU_MBOX_PF_VFX_PFVF_TRIGX(0);
75 : 0 : mbox->tr_shift = 4;
76 : 0 : break;
77 : 0 : case MBOX_DIR_VFPF:
78 : 0 : mbox->trigger = RVU_MBOX_VF_VFPF_TRIGX(0);
79 : 0 : mbox->tr_shift = 0;
80 : 0 : break;
81 : 0 : case MBOX_DIR_VFPF_UP:
82 : 0 : mbox->trigger = RVU_MBOX_VF_VFPF_TRIGX(1);
83 : 0 : mbox->tr_shift = 0;
84 : 0 : break;
85 : : default:
86 : : return -ENODEV;
87 : : }
88 : :
89 : : return 0;
90 : : }
91 : :
92 : : static int
93 : 0 : mbox_setup(struct mbox *mbox, uintptr_t reg_base, int direction, int ndevs, uint64_t intr_offset)
94 : : {
95 [ # # # # : 0 : switch (direction) {
# ]
96 : 0 : case MBOX_DIR_AFPF:
97 : : case MBOX_DIR_PFVF:
98 : 0 : mbox->tx_start = MBOX_DOWN_TX_START;
99 : 0 : mbox->rx_start = MBOX_DOWN_RX_START;
100 : 0 : mbox->tx_size = MBOX_DOWN_TX_SIZE;
101 : 0 : mbox->rx_size = MBOX_DOWN_RX_SIZE;
102 : 0 : break;
103 : 0 : case MBOX_DIR_PFAF:
104 : : case MBOX_DIR_VFPF:
105 : 0 : mbox->tx_start = MBOX_DOWN_RX_START;
106 : 0 : mbox->rx_start = MBOX_DOWN_TX_START;
107 : 0 : mbox->tx_size = MBOX_DOWN_RX_SIZE;
108 : 0 : mbox->rx_size = MBOX_DOWN_TX_SIZE;
109 : 0 : break;
110 : 0 : case MBOX_DIR_AFPF_UP:
111 : : case MBOX_DIR_PFVF_UP:
112 : 0 : mbox->tx_start = MBOX_UP_TX_START;
113 : 0 : mbox->rx_start = MBOX_UP_RX_START;
114 : 0 : mbox->tx_size = MBOX_UP_TX_SIZE;
115 : 0 : mbox->rx_size = MBOX_UP_RX_SIZE;
116 : 0 : break;
117 : 0 : case MBOX_DIR_PFAF_UP:
118 : : case MBOX_DIR_VFPF_UP:
119 : 0 : mbox->tx_start = MBOX_UP_RX_START;
120 : 0 : mbox->rx_start = MBOX_UP_TX_START;
121 : 0 : mbox->tx_size = MBOX_UP_RX_SIZE;
122 : 0 : mbox->rx_size = MBOX_UP_TX_SIZE;
123 : 0 : break;
124 : : default:
125 : : return -ENODEV;
126 : : }
127 : :
128 : 0 : mbox->intr_offset = intr_offset;
129 : 0 : mbox->dev = plt_zmalloc(ndevs * sizeof(struct mbox_dev), ROC_ALIGN);
130 [ # # ]: 0 : if (!mbox->dev) {
131 : 0 : mbox_fini(mbox);
132 : 0 : return -ENOMEM;
133 : : }
134 : 0 : mbox->ndevs = ndevs;
135 : :
136 [ # # ]: 0 : mbox->reg_base = reg_base;
137 [ # # ]: 0 : if (roc_model_is_cn20k())
138 : 0 : return cn20k_mbox_setup(mbox, direction);
139 : :
140 [ # # # # ]: 0 : switch (direction) {
141 : 0 : case MBOX_DIR_AFPF:
142 : : case MBOX_DIR_AFPF_UP:
143 : 0 : mbox->trigger = RVU_AF_AFPF_MBOX0;
144 : 0 : mbox->tr_shift = 4;
145 : 0 : break;
146 : 0 : case MBOX_DIR_PFAF:
147 : : case MBOX_DIR_PFAF_UP:
148 : 0 : mbox->trigger = RVU_PF_PFAF_MBOX1;
149 : 0 : mbox->tr_shift = 0;
150 : 0 : break;
151 : 0 : case MBOX_DIR_PFVF:
152 : : case MBOX_DIR_PFVF_UP:
153 : 0 : mbox->trigger = RVU_PF_VFX_PFVF_MBOX0;
154 : 0 : mbox->tr_shift = 12;
155 : 0 : break;
156 : 0 : case MBOX_DIR_VFPF:
157 : : case MBOX_DIR_VFPF_UP:
158 : 0 : mbox->trigger = RVU_VF_VFPF_MBOX1;
159 : 0 : mbox->tr_shift = 0;
160 : 0 : break;
161 : : default:
162 : : return -ENODEV;
163 : : }
164 : :
165 : : return 0;
166 : : }
167 : :
168 : : int
169 : 0 : mbox_init(struct mbox *mbox, uintptr_t hwbase, uintptr_t reg_base, int direction, int ndevs,
170 : : uint64_t intr_offset)
171 : : {
172 : : struct mbox_dev *mdev;
173 : : char *var, *var_to;
174 : : int devid, rc;
175 : :
176 : 0 : rc = mbox_setup(mbox, reg_base, direction, ndevs, intr_offset);
177 [ # # ]: 0 : if (rc) {
178 : 0 : plt_err("Failed to setup the mailbox");
179 : 0 : return rc;
180 : : }
181 : :
182 : 0 : mbox->hwbase = hwbase;
183 [ # # ]: 0 : for (devid = 0; devid < ndevs; devid++) {
184 : 0 : mdev = &mbox->dev[devid];
185 : 0 : mdev->mbase = (void *)(mbox->hwbase + (devid * MBOX_SIZE));
186 : : plt_spinlock_init(&mdev->mbox_lock);
187 : : /* Init header to reset value */
188 : 0 : mbox_reset(mbox, devid);
189 : : }
190 : :
191 : 0 : var = getenv("ROC_CN10K_MBOX_TIMEOUT");
192 : 0 : var_to = getenv("ROC_MBOX_TIMEOUT");
193 : :
194 [ # # ]: 0 : if (var)
195 : 0 : mbox->rsp_tmo = atoi(var);
196 [ # # ]: 0 : else if (var_to)
197 : 0 : mbox->rsp_tmo = atoi(var_to);
198 : : else
199 : 0 : mbox->rsp_tmo = MBOX_RSP_TIMEOUT;
200 : :
201 : : return 0;
202 : : }
203 : :
204 : : /**
205 : : * @internal
206 : : * Allocate a message response
207 : : */
208 : : struct mbox_msghdr *
209 : 0 : mbox_alloc_msg_rsp(struct mbox *mbox, int devid, int size, int size_rsp)
210 : : {
211 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
212 : : struct mbox_msghdr *msghdr = NULL;
213 : :
214 : 0 : size = PLT_ALIGN(size, MBOX_MSG_ALIGN);
215 : 0 : size_rsp = PLT_ALIGN(size_rsp, MBOX_MSG_ALIGN);
216 : : /* Check if there is space in mailbox */
217 [ # # ]: 0 : if ((mdev->msg_size + size) > mbox->tx_size - msgs_offset())
218 : 0 : goto exit;
219 [ # # ]: 0 : if ((mdev->rsp_size + size_rsp) > mbox->rx_size - msgs_offset())
220 : 0 : goto exit;
221 [ # # ]: 0 : if (mdev->msg_size == 0)
222 : 0 : mdev->num_msgs = 0;
223 : 0 : mdev->num_msgs++;
224 : :
225 : 0 : msghdr = (struct mbox_msghdr *)(((uintptr_t)mdev->mbase +
226 : 0 : mbox->tx_start + msgs_offset() +
227 : 0 : mdev->msg_size));
228 : :
229 : : /* Clear the whole msg region */
230 [ # # ]: 0 : mbox_memset(msghdr, 0, sizeof(*msghdr) + size);
231 : : /* Init message header with reset values */
232 : 0 : msghdr->ver = MBOX_VERSION;
233 : 0 : mdev->msg_size += size;
234 : 0 : mdev->rsp_size += size_rsp;
235 : 0 : msghdr->next_msgoff = mdev->msg_size + msgs_offset();
236 : 0 : exit:
237 : :
238 : 0 : return msghdr;
239 : : }
240 : :
241 : : /**
242 : : * @internal
243 : : * Synchronization between UP and DOWN messages
244 : : */
245 : : bool
246 : 0 : mbox_wait_for_zero(struct mbox *mbox, int devid)
247 : : {
248 : : uint64_t data;
249 : :
250 [ # # ]: 0 : data = plt_read64((volatile void *)(mbox->reg_base +
251 : : (mbox->trigger | (devid << mbox->tr_shift))));
252 : :
253 : : /* If data is non-zero wait for ~1ms and return to caller
254 : : * whether data has changed to zero or not after the wait.
255 : : */
256 [ # # ]: 0 : if (data)
257 : 0 : usleep(1000);
258 : : else
259 : : return true;
260 : :
261 : 0 : data = plt_read64((volatile void *)(mbox->reg_base +
262 : : (mbox->trigger | (devid << mbox->tr_shift))));
263 : 0 : return data == 0;
264 : : }
265 : :
266 : : static void
267 : 0 : mbox_msg_send_data(struct mbox *mbox, int devid, uint8_t data)
268 : : {
269 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
270 : 0 : struct mbox_hdr *tx_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->tx_start);
271 : 0 : struct mbox_hdr *rx_hdr = (struct mbox_hdr *)((uintptr_t)mdev->mbase + mbox->rx_start);
272 : : uint64_t intr_val;
273 : :
274 : : /* Reset header for next messages */
275 : 0 : tx_hdr->msg_size = mdev->msg_size;
276 : 0 : mdev->msg_size = 0;
277 : 0 : mdev->rsp_size = 0;
278 : 0 : mdev->msgs_acked = 0;
279 : :
280 : : /* num_msgs != 0 signals to the peer that the buffer has a number of
281 : : * messages. So this should be written after copying txmem
282 : : */
283 : 0 : tx_hdr->num_msgs = mdev->num_msgs;
284 : 0 : rx_hdr->num_msgs = 0;
285 : :
286 : : /* Sync mbox data into memory */
287 : : plt_wmb();
288 : :
289 : : /* Check for any pending interrupt */
290 : 0 : intr_val = plt_read64(
291 : : (volatile void *)(mbox->reg_base + (mbox->trigger | (devid << mbox->tr_shift))));
292 : :
293 : 0 : intr_val |= (uint64_t)data;
294 : : /* The interrupt should be fired after num_msgs is written
295 : : * to the shared memory
296 : : */
297 : : plt_write64(intr_val, (volatile void *)(mbox->reg_base +
298 : : (mbox->trigger | (devid << mbox->tr_shift))));
299 : 0 : }
300 : :
301 : : /**
302 : : * @internal
303 : : * Send a mailbox message
304 : : */
305 : : void
306 : 0 : mbox_msg_send(struct mbox *mbox, int devid)
307 : : {
308 : 0 : mbox_msg_send_data(mbox, devid, MBOX_DOWN_MSG);
309 : 0 : }
310 : :
311 : : /**
312 : : * @internal
313 : : * Send an UP mailbox message
314 : : */
315 : : void
316 : 0 : mbox_msg_send_up(struct mbox *mbox, int devid)
317 : : {
318 : 0 : mbox_msg_send_data(mbox, devid, MBOX_UP_MSG);
319 : 0 : }
320 : :
321 : : /**
322 : : * @internal
323 : : * Wait and get mailbox response
324 : : */
325 : : int
326 : 0 : mbox_get_rsp(struct mbox *mbox, int devid, void **msg)
327 : : {
328 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
329 : : struct mbox_msghdr *msghdr;
330 : : uint64_t offset;
331 : : int rc;
332 : :
333 : 0 : rc = mbox_wait_for_rsp(mbox, devid);
334 [ # # ]: 0 : if (rc < 0)
335 : : return -EIO;
336 : :
337 : : plt_rmb();
338 : :
339 : 0 : offset = mbox->rx_start +
340 : : PLT_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
341 : 0 : msghdr = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
342 [ # # ]: 0 : if (msg != NULL)
343 : 0 : *msg = msghdr;
344 : :
345 : 0 : return msghdr->rc;
346 : : }
347 : :
348 : : /**
349 : : * Polling for given wait time to get mailbox response
350 : : */
351 : : static int
352 : 0 : mbox_poll(struct mbox *mbox, uint32_t wait)
353 : : {
354 : : uint32_t timeout = 0, sleep = 1;
355 : 0 : uint32_t wait_us = wait * 1000;
356 : : uint64_t rsp_reg = 0;
357 : : uintptr_t reg_addr;
358 : :
359 : 0 : reg_addr = mbox->reg_base + mbox->intr_offset;
360 : : do {
361 [ # # ]: 0 : rsp_reg = plt_read64(reg_addr);
362 : :
363 [ # # ]: 0 : if (timeout >= wait_us)
364 : : return -ETIMEDOUT;
365 : :
366 : 0 : plt_delay_us(sleep);
367 : 0 : timeout += sleep;
368 [ # # ]: 0 : } while (!rsp_reg);
369 : :
370 : : plt_rmb();
371 : :
372 : : /* Clear interrupt */
373 : : plt_write64(rsp_reg, reg_addr);
374 : :
375 : : /* Reset mbox */
376 : 0 : mbox_reset(mbox, 0);
377 : :
378 : 0 : return 0;
379 : : }
380 : :
381 : : /**
382 : : * @internal
383 : : * Wait and get mailbox response with timeout
384 : : */
385 : : int
386 : 0 : mbox_get_rsp_tmo(struct mbox *mbox, int devid, void **msg, uint32_t tmo)
387 : : {
388 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
389 : : struct mbox_msghdr *msghdr;
390 : : uint64_t offset;
391 : : int rc;
392 : :
393 : 0 : rc = mbox_wait_for_rsp_tmo(mbox, devid, tmo);
394 [ # # ]: 0 : if (rc != 1)
395 : : return -EIO;
396 : :
397 : : plt_rmb();
398 : :
399 : 0 : offset = mbox->rx_start +
400 : : PLT_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
401 : 0 : msghdr = (struct mbox_msghdr *)((uintptr_t)mdev->mbase + offset);
402 [ # # ]: 0 : if (msg != NULL)
403 : 0 : *msg = msghdr;
404 : :
405 : 0 : return msghdr->rc;
406 : : }
407 : :
408 : : static int
409 : 0 : mbox_wait(struct mbox *mbox, int devid, uint32_t rst_timo)
410 : : {
411 : 0 : volatile struct mbox_dev *mdev = &mbox->dev[devid];
412 : : uint32_t timeout = 0, sleep = 1;
413 : :
414 : 0 : rst_timo = rst_timo * 1000; /* Milli seconds to micro seconds */
415 : :
416 : : /* Waiting for mdev->msgs_acked tp become equal to mdev->num_msgs,
417 : : * mdev->msgs_acked are incremented at process_msgs() in interrupt
418 : : * thread context.
419 : : */
420 [ # # ]: 0 : while (mdev->num_msgs > mdev->msgs_acked) {
421 : 0 : plt_delay_us(sleep);
422 : 0 : timeout += sleep;
423 [ # # ]: 0 : if (timeout >= rst_timo) {
424 : 0 : struct mbox_hdr *tx_hdr =
425 : 0 : (struct mbox_hdr *)((uintptr_t)mdev->mbase +
426 : 0 : mbox->tx_start);
427 : 0 : struct mbox_hdr *rx_hdr =
428 : 0 : (struct mbox_hdr *)((uintptr_t)mdev->mbase +
429 : 0 : mbox->rx_start);
430 : :
431 : 0 : plt_err("MBOX[devid: %d] message wait timeout %d, "
432 : : "num_msgs: %d, msgs_acked: %d "
433 : : "(tx/rx num_msgs: %d/%d), msg_size: %d, "
434 : : "rsp_size: %d",
435 : : devid, timeout, mdev->num_msgs,
436 : : mdev->msgs_acked, tx_hdr->num_msgs,
437 : : rx_hdr->num_msgs, mdev->msg_size,
438 : : mdev->rsp_size);
439 : :
440 : 0 : return -EIO;
441 : : }
442 : : plt_rmb();
443 : : }
444 : : return 0;
445 : : }
446 : :
447 : : int
448 : 0 : mbox_wait_for_rsp_tmo(struct mbox *mbox, int devid, uint32_t tmo)
449 : : {
450 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
451 : : int rc = 0;
452 : :
453 : : /* Sync with mbox region */
454 : : plt_rmb();
455 : :
456 [ # # ]: 0 : if (mbox->trigger == RVU_PF_VFX_PFVF_MBOX1 ||
457 : : mbox->trigger == RVU_PF_VFX_PFVF_MBOX0) {
458 : : /* In case of VF, Wait a bit more to account round trip delay */
459 : 0 : tmo = tmo * 2;
460 : : }
461 : :
462 : : /* Wait message */
463 [ # # ]: 0 : if (plt_thread_is_intr())
464 : 0 : rc = mbox_poll(mbox, tmo);
465 : : else
466 : 0 : rc = mbox_wait(mbox, devid, tmo);
467 : :
468 [ # # ]: 0 : if (!rc)
469 : 0 : rc = mdev->num_msgs;
470 : :
471 : 0 : return rc;
472 : : }
473 : :
474 : : /**
475 : : * @internal
476 : : * Wait for the mailbox response
477 : : */
478 : : int
479 : 0 : mbox_wait_for_rsp(struct mbox *mbox, int devid)
480 : : {
481 : 0 : return mbox_wait_for_rsp_tmo(mbox, devid, mbox->rsp_tmo);
482 : : }
483 : :
484 : : int
485 : 0 : mbox_get_availmem(struct mbox *mbox, int devid)
486 : : {
487 : 0 : struct mbox_dev *mdev = &mbox->dev[devid];
488 : : int avail;
489 : :
490 : 0 : plt_spinlock_lock(&mdev->mbox_lock);
491 : 0 : avail = mbox->tx_size - mdev->msg_size - msgs_offset();
492 : : plt_spinlock_unlock(&mdev->mbox_lock);
493 : :
494 : 0 : return avail;
495 : : }
496 : :
497 : : int
498 : 0 : send_ready_msg(struct mbox *mbox, uint16_t *pcifunc)
499 : : {
500 : : struct ready_msg_rsp *rsp;
501 : : int rc;
502 : :
503 : 0 : mbox_alloc_msg_ready(mbox_get(mbox));
504 : :
505 : : rc = mbox_process_msg(mbox, (void *)&rsp);
506 [ # # ]: 0 : if (rc) {
507 : : mbox_put(mbox);
508 : 0 : return rc;
509 : : }
510 : : mbox_put(mbox);
511 : :
512 [ # # ]: 0 : if (rsp->hdr.ver != MBOX_VERSION) {
513 : 0 : plt_err("Incompatible MBox versions(AF: 0x%04x Client: 0x%04x)",
514 : : rsp->hdr.ver, MBOX_VERSION);
515 : 0 : return -EPIPE;
516 : : }
517 : :
518 [ # # ]: 0 : if (pcifunc)
519 : 0 : *pcifunc = rsp->hdr.pcifunc;
520 : :
521 : : /* Save rclk & sclk freq */
522 [ # # # # ]: 0 : if (!dev_rclk_freq || !dev_sclk_freq) {
523 : 0 : dev_rclk_freq = rsp->rclk_freq;
524 : 0 : dev_sclk_freq = rsp->sclk_freq;
525 : : }
526 : : return 0;
527 : : }
528 : :
529 : : int
530 : 0 : reply_invalid_msg(struct mbox *mbox, int devid, uint16_t pcifunc, uint16_t id)
531 : : {
532 : : struct msg_rsp *rsp;
533 : :
534 : : rsp = (struct msg_rsp *)mbox_alloc_msg(mbox, devid, sizeof(*rsp));
535 [ # # ]: 0 : if (!rsp)
536 : : return -ENOMEM;
537 : 0 : rsp->hdr.id = id;
538 : 0 : rsp->hdr.sig = MBOX_RSP_SIG;
539 : 0 : rsp->hdr.rc = MBOX_MSG_INVALID;
540 : 0 : rsp->hdr.pcifunc = pcifunc;
541 : :
542 : 0 : return 0;
543 : : }
544 : :
545 : : /**
546 : : * @internal
547 : : * Convert mail box ID to name
548 : : */
549 : : const char *
550 : 0 : mbox_id2name(uint16_t id)
551 : : {
552 [ # # # # : 0 : switch (id) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
553 : : default:
554 : : return "INVALID ID";
555 : : #define M(_name, _id, _1, _2, _3) \
556 : : case _id: \
557 : : return #_name;
558 : 0 : MBOX_MESSAGES
559 : 0 : MBOX_UP_CGX_MESSAGES
560 : 0 : MBOX_UP_REP_MESSAGES
561 : : #undef M
562 : : }
563 : : }
564 : :
565 : : int
566 : 0 : mbox_id2size(uint16_t id)
567 : : {
568 [ # # # # : 0 : switch (id) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
569 : : default:
570 : : return 0;
571 : : #define M(_1, _id, _2, _req_type, _3) \
572 : : case _id: \
573 : : return sizeof(struct _req_type);
574 : 0 : MBOX_MESSAGES
575 : 0 : MBOX_UP_CGX_MESSAGES
576 : 0 : MBOX_UP_REP_MESSAGES
577 : : #undef M
578 : : }
579 : : }
|
