1 /*
2 * Copyright (c) 2013, Texas Instruments Incorporated
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
33 /*
34 * ======== NotifyDriverMbx.c ========
35 */
37 #include <xdc/std.h>
38 #include <xdc/runtime/Assert.h>
39 #include <xdc/runtime/Startup.h>
41 #include <ti/sysbios/BIOS.h>
42 #include <ti/sysbios/hal/Hwi.h>
43 #ifdef xdc_target__isaCompatible_v7M
44 #include <ti/sysbios/family/arm/ducati/Core.h>
45 #endif
47 #include <ti/sdo/ipc/interfaces/INotifyDriver.h>
48 #include <ti/sdo/ipc/_Notify.h>
49 #include <ti/sdo/utils/_MultiProc.h>
51 #include "package/internal/NotifyDriverMbx.xdc.h"
53 /* Bit mask operations */
54 #define SET_BIT(num,pos) ((num) |= (1u << (pos)))
55 #define CLEAR_BIT(num,pos) ((num) &= ~(1u << (pos)))
56 #define TEST_BIT(num,pos) ((num) & (1u << (pos)))
58 /* Assigned mailboxes */
59 #define DSP_TO_HOST 0
60 #define DSP_TO_VIDEO 1
61 #define DSP_TO_VPSS 2
62 #define HOST_TO_DSP 3
63 #define HOST_TO_VIDEO 4
64 #define HOST_TO_VPSS 5
65 #define VIDEO_TO_HOST 6
66 #define VIDEO_TO_DSP 7
67 #define VPSS_TO_HOST 8
68 #define VPSS_TO_DSP 9
69 #define VIDEO_TO_VPSS 10
70 #define VPSS_TO_VIDEO 11
72 #define MAILBOX_REG_VAL(M) (0x1 << (2 * M))
74 /* Register access method. */
75 #define REG16(A) (*(volatile UInt16 *) (A))
76 #define REG32(A) (*(volatile UInt32 *) (A))
78 #define MAILBOX_FIFOLENGTH 4
80 #define MAILBOX_MESSAGE(M) \
81 (NotifyDriverMbx_mailboxBaseAddr + 0x40 + (0x4 * M))
82 #define MAILBOX_FIFOSTATUS(M) \
83 (NotifyDriverMbx_mailboxBaseAddr + 0x80 + (0x4 * M))
84 #define MAILBOX_STATUS(M) \
85 (NotifyDriverMbx_mailboxBaseAddr + 0xC0 + (0x4 * M))
87 /* HOST registers */
88 #define MAILBOX_IRQSTATUS_CLR_HOST (NotifyDriverMbx_mailboxBaseAddr + 0x104)
89 #define MAILBOX_IRQENABLE_SET_HOST (NotifyDriverMbx_mailboxBaseAddr + 0x108)
90 #define MAILBOX_IRQENABLE_CLR_HOST (NotifyDriverMbx_mailboxBaseAddr + 0x10C)
92 /* DSP registers */
93 #define MAILBOX_IRQSTATUS_CLR_DSP (NotifyDriverMbx_mailboxBaseAddr + 0x114)
94 #define MAILBOX_IRQENABLE_SET_DSP (NotifyDriverMbx_mailboxBaseAddr + 0x118)
95 #define MAILBOX_IRQENABLE_CLR_DSP (NotifyDriverMbx_mailboxBaseAddr + 0x11C)
97 /* VIDEO registers */
98 #define MAILBOX_IRQSTATUS_CLR_VIDEO (NotifyDriverMbx_mailboxBaseAddr + 0x124)
99 #define MAILBOX_IRQENABLE_SET_VIDEO (NotifyDriverMbx_mailboxBaseAddr + 0x128)
100 #define MAILBOX_IRQENABLE_CLR_VIDEO (NotifyDriverMbx_mailboxBaseAddr + 0x12C)
102 /* VPSS registers */
103 #define MAILBOX_IRQSTATUS_CLR_VPSS (NotifyDriverMbx_mailboxBaseAddr + 0x134)
104 #define MAILBOX_IRQENABLE_SET_VPSS (NotifyDriverMbx_mailboxBaseAddr + 0x138)
105 #define MAILBOX_IRQENABLE_CLR_VPSS (NotifyDriverMbx_mailboxBaseAddr + 0x13C)
107 #define MAILBOX_EOI_REG (NotifyDriverMbx_mailboxBaseAddr + 0x140)
109 #define MBX(src, dst) (src##_TO_##dst)
111 #define PROCID_HOST NotifyDriverMbx_hostProcId
112 #define PROCID_VPSS NotifyDriverMbx_vpssProcId
113 #define PROCID_VIDEO NotifyDriverMbx_videoProcId
114 #define PROCID_DSP NotifyDriverMbx_dspProcId
116 /*
117 *************************************************************************
118 * Module functions
119 *************************************************************************
120 */
122 /*
123 * ======== NotifyDriverMbx_Module_startup ========
124 */
126 /* The INIT macro empties the mailbox that corresponds to 'src'-to-'dst' */
127 #define INIT(src, dst) \
128 while (REG32(MAILBOX_STATUS(MBX(src, dst)))) { \
129 REG32(MAILBOX_MESSAGE(MBX(src, dst))); \
130 } \
131 REG32(MAILBOX_IRQSTATUS_CLR_##dst) \
132 = MAILBOX_REG_VAL(MBX(src, dst));
134 Int NotifyDriverMbx_Module_startup(Int phase)
135 {
136 #if defined(xdc_target__isaCompatible_64)
138 INIT(HOST, DSP)
139 INIT(VIDEO, DSP)
140 INIT(VPSS, DSP)
141 REG32(MAILBOX_EOI_REG) = 0x1;
143 #elif defined(xdc_target__isaCompatible_v7M)
144 if (!(BIOS_smpEnabled) && (Core_getId())) {
145 INIT(DSP, VPSS)
146 INIT(HOST, VPSS)
147 INIT(VIDEO, VPSS)
148 }
149 else {
150 INIT(DSP, VIDEO)
151 INIT(HOST, VIDEO)
152 INIT(VPSS, VIDEO)
153 }
155 #else
156 INIT(DSP, HOST)
157 INIT(VIDEO, HOST)
158 INIT(VPSS, HOST)
160 #endif
162 return (Startup_DONE);
163 }
166 /*
167 **************************************************************
168 * Instance functions
169 **************************************************************
170 */
172 /*
173 * ======== NotifyDriverMbx_Instance_init ========
174 */
175 Void NotifyDriverMbx_Instance_init(NotifyDriverMbx_Object *obj,
176 const NotifyDriverMbx_Params *params)
177 {
178 UInt key;
180 /*
181 * Check whether remote proc ID has been set and isn't the same as the
182 * local proc ID
183 */
184 Assert_isTrue ((params->remoteProcId != MultiProc_INVALIDID) &&
185 (params->remoteProcId != MultiProc_self()),
186 ti_sdo_ipc_Notify_A_internal);
188 if (params->remoteProcId >= MultiProc_getNumProcessors() ||
189 params->remoteProcId == MultiProc_INVALIDID) {
190 return; /* keep Coverity happy */
191 }
193 obj->remoteProcId = params->remoteProcId;
194 obj->evtRegMask = 0;
195 obj->notifyHandle = NULL;
197 /* Disable global interrupts */
198 key = Hwi_disable();
200 /* Store the driver handle so it can be retreived in the isr */
201 NotifyDriverMbx_module->drvHandles[obj->remoteProcId] = obj;
203 /* Enable the mailbox interrupt from the remote core */
204 NotifyDriverMbx_enable(obj);
206 /* Restore global interrupts */
207 Hwi_restore(key);
208 }
210 /*
211 * ======== NotifyDriverMbx_Instance_finalize ========
212 */
213 Void NotifyDriverMbx_Instance_finalize(NotifyDriverMbx_Object *obj)
214 {
215 /* Disable the mailbox interrupt source */
216 NotifyDriverMbx_disable(obj);
218 NotifyDriverMbx_module->drvHandles[obj->remoteProcId] = NULL;
219 }
221 /*
222 * ======== NotifyDriverMbx_registerEvent ========
223 */
224 Void NotifyDriverMbx_registerEvent(NotifyDriverMbx_Object *obj,
225 UInt32 eventId)
226 {
227 UInt hwiKey;
229 /*
230 * Disable interrupt line to ensure that isr doesn't
231 * preempt registerEvent and encounter corrupt state
232 */
233 hwiKey = Hwi_disable();
235 /* Set the 'registered' bit */
236 SET_BIT(obj->evtRegMask, eventId);
238 /* Restore the interrupt line */
239 Hwi_restore(hwiKey);
240 }
242 /*
243 * ======== NotifyDriverMbx_unregisterEvent ========
244 */
245 Void NotifyDriverMbx_unregisterEvent(NotifyDriverMbx_Object *obj,
246 UInt32 eventId)
247 {
248 UInt hwiKey;
250 /*
251 * Disable interrupt line to ensure that isr doesn't
252 * preempt registerEvent and encounter corrupt state
253 */
254 hwiKey = Hwi_disable();
256 /* Clear the registered bit */
257 CLEAR_BIT(obj->evtRegMask, eventId);
259 /* Restore the interrupt line */
260 Hwi_restore(hwiKey);
261 }
263 /*
264 * ======== NotifyDriverMbx_sendEvent ========
265 */
266 /*
267 * PUT_NOTIFICATION will spin waiting for enough room in the mailbox FIFO
268 * to store the number of messages needed for the notification ('numMsgs').
269 * If spinning is necesssary (i.e. if waitClear is TRUE and there isn't enough
270 * room in the FIFO) then PUT_NOTIFICATION will allow pre-emption while
271 * spinning.
272 *
273 * PUT_NOTIFICATION needs to prevent another local thread from writing to the
274 * same mailbox after the current thread has
275 * 1) determined that there is enough room to write the notification and
276 * 2) written the first of two messages to the mailbox.
277 * This is needed to respectively prevent
278 * 1) both threads from incorrectly assuming there is enough space in the FIFO
279 * for their own notifications
280 * 2) the interrupting thread from writing a notification between two
281 * two messages that need to be successivly written by the preempted thread.
282 * Therefore, the check for enough FIFO room and one/both mailbox write(s)
283 * should all occur atomically (i.e. with interrupts disabled)
284 */
285 #define PUT_NOTIFICATION(m) \
286 key = Hwi_disable(); \
287 while(MAILBOX_FIFOLENGTH - REG32(MAILBOX_STATUS(m)) < numMsgs) { \
288 Hwi_restore(key); \
289 if (!waitClear) { \
290 return (Notify_E_FAIL); \
291 } \
292 key = Hwi_disable(); \
293 }; \
294 REG32(MAILBOX_MESSAGE(m)) = eventId + smallPayload; \
295 if (smallPayload == 0xFFFFFFE0) { \
296 REG32(MAILBOX_MESSAGE(m)) = payload; \
297 } \
298 Hwi_restore(key);
300 Int NotifyDriverMbx_sendEvent(NotifyDriverMbx_Object *obj,
301 UInt32 eventId,
302 UInt32 payload,
303 Bool waitClear)
304 {
305 UInt16 remoteProcId = obj->remoteProcId;
306 UInt key, numMsgs;
307 UInt32 smallPayload;
309 /* Decide if the payload is small enough to fit in the first mbx msg */
310 if (payload < 0x7FFFFFF) {
311 smallPayload = (payload << 5);
312 numMsgs = 1;
313 }
314 else {
315 smallPayload = 0xFFFFFFE0;
316 numMsgs = 2;
317 }
319 #if defined(xdc_target__isaCompatible_64)
320 if (remoteProcId == NotifyDriverMbx_hostProcId) {
321 PUT_NOTIFICATION(DSP_TO_HOST)
322 }
323 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
324 PUT_NOTIFICATION(DSP_TO_VIDEO)
325 }
326 else {
327 PUT_NOTIFICATION(DSP_TO_VPSS)
328 }
329 #elif defined(xdc_target__isaCompatible_v7M)
330 if (!(BIOS_smpEnabled) && (Core_getId())) {
331 if (remoteProcId == NotifyDriverMbx_dspProcId) {
332 PUT_NOTIFICATION(VPSS_TO_DSP)
333 }
334 else if (remoteProcId == NotifyDriverMbx_hostProcId) {
335 PUT_NOTIFICATION(VPSS_TO_HOST)
336 }
337 else {
338 PUT_NOTIFICATION(VPSS_TO_VIDEO)
339 }
340 }
341 else {
342 if (remoteProcId == NotifyDriverMbx_dspProcId) {
343 PUT_NOTIFICATION(VIDEO_TO_DSP)
344 }
345 else if (remoteProcId == NotifyDriverMbx_hostProcId) {
346 PUT_NOTIFICATION(VIDEO_TO_HOST)
347 }
348 else {
349 PUT_NOTIFICATION(VIDEO_TO_VPSS)
350 }
351 }
352 #else
353 if (remoteProcId == NotifyDriverMbx_dspProcId) {
354 PUT_NOTIFICATION(HOST_TO_DSP)
355 }
356 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
357 PUT_NOTIFICATION(HOST_TO_VIDEO)
358 }
359 else {
360 PUT_NOTIFICATION(HOST_TO_VPSS)
361 }
362 #endif
364 return (Notify_S_SUCCESS);
365 }
367 /*
368 * ======== NotifyDriverMbx_disable ========
369 */
370 Void NotifyDriverMbx_disable(NotifyDriverMbx_Object *obj)
371 {
372 UInt16 remoteProcId = obj->remoteProcId;
374 #if defined(xdc_target__isaCompatible_64)
375 if (remoteProcId == NotifyDriverMbx_hostProcId) {
376 REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(HOST_TO_DSP);
377 }
378 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
379 REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(VIDEO_TO_DSP);
380 }
381 else {
382 REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(VPSS_TO_DSP);
383 }
384 #elif defined(xdc_target__isaCompatible_v7M)
385 if (!(BIOS_smpEnabled) && (Core_getId())) {
386 if (remoteProcId == NotifyDriverMbx_hostProcId) {
387 REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
388 }
389 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
390 REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
391 }
392 else {
393 REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
394 }
395 }
396 else {
397 if (remoteProcId == NotifyDriverMbx_hostProcId) {
398 REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
399 }
400 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
401 REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
402 }
403 else {
404 REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
405 }
406 }
407 #else
408 if (remoteProcId == NotifyDriverMbx_dspProcId) {
409 REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
410 }
411 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
412 REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
413 }
414 else {
415 REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
416 }
417 #endif
418 }
420 /*
421 * ======== NotifyDriverMbx_enable ========
422 */
423 Void NotifyDriverMbx_enable(NotifyDriverMbx_Object *obj)
424 {
425 UInt16 remoteProcId = obj->remoteProcId;
427 #if defined(xdc_target__isaCompatible_64)
428 if (remoteProcId == NotifyDriverMbx_hostProcId) {
429 REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(HOST_TO_DSP);
430 }
431 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
432 REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(VIDEO_TO_DSP);
433 }
434 else {
435 REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(VPSS_TO_DSP);
436 }
437 #elif defined(xdc_target__isaCompatible_v7M)
438 if (!(BIOS_smpEnabled) && (Core_getId())) {
439 if (remoteProcId == NotifyDriverMbx_hostProcId) {
440 REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
441 }
442 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
443 REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
444 }
445 else {
446 REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
447 }
448 }
449 else {
450 if (remoteProcId == NotifyDriverMbx_hostProcId) {
451 REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
452 }
453 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
454 REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
455 }
456 else {
457 REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
458 }
459 }
460 #else
461 if (remoteProcId == NotifyDriverMbx_dspProcId) {
462 REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
463 }
464 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
465 REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
466 }
467 else {
468 REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
469 }
470 #endif
471 }
473 /*
474 * ======== NotifyDriverMbx_disableEvent ========
475 */
476 Void NotifyDriverMbx_disableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
477 {
478 /* NotifyDriverMbx_disableEvent not supported by this driver */
479 Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
480 }
482 /*
483 * ======== NotifyDriverMbx_enableEvent ========
484 */
485 Void NotifyDriverMbx_enableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
486 {
487 /* NotifyDriverMbx_enableEvent not supported by this driver */
488 Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
489 }
491 /*
492 *************************************************************************
493 * Internal functions
494 *************************************************************************
495 */
497 /*
498 * ======== NotifyDriverMbx_isr ========
499 */
501 /*
502 * Get a message from the mailbox. The bottom 5 bits of the message
503 * contains the eventId. The top 27 bits of the message contains either
504 * 1) The payload if the payload is less than 0x7FFFFFF
505 * 2) 0x7FFFFFF otherwise
506 * If the top 27 bits of the first message is 0x7FFFFFF, then the payload
507 * is in the next mailbox message.
508 */
509 #define GET_NOTIFICATION(dst, src) \
510 if (REG32(MAILBOX_STATUS(MBX(src, dst)))) { \
511 numProcessed++; \
512 msg = REG32(MAILBOX_MESSAGE(MBX(src, dst))); \
513 eventId = (UInt16)(msg & 0x1F); \
514 payload = msg >> 5; \
515 if (payload == 0x7FFFFFF) { \
516 while(REG32(MAILBOX_STATUS(MBX(src, dst))) == 0); \
517 payload = REG32(MAILBOX_MESSAGE(MBX(src, dst))); \
518 } \
519 REG32(MAILBOX_IRQSTATUS_CLR_##dst) = \
520 MAILBOX_REG_VAL(MBX(src, dst)); \
521 obj = NotifyDriverMbx_module->drvHandles[PROCID_##src]; \
522 Assert_isTrue(obj != NULL, ti_sdo_ipc_Notify_A_internal); \
523 if (TEST_BIT(obj->evtRegMask, eventId)) { \
524 ti_sdo_ipc_Notify_exec(obj->notifyHandle, \
525 eventId, \
526 payload); \
527 } \
528 }
530 Void NotifyDriverMbx_isr(UArg arg)
531 {
532 NotifyDriverMbx_Object *obj;
533 UInt32 msg, payload;
534 UInt16 eventId;
535 Int numProcessed;
537 #if defined(xdc_target__isaCompatible_64)
538 do {
539 numProcessed = 0;
540 GET_NOTIFICATION(DSP, HOST)
541 GET_NOTIFICATION(DSP, VPSS)
542 GET_NOTIFICATION(DSP, VIDEO)
543 }
544 while (numProcessed != 0);
546 /* Write to EOI (End Of Interrupt) register */
547 REG32(MAILBOX_EOI_REG) = 0x1;
549 #elif defined(xdc_target__isaCompatible_v7M)
550 do {
551 numProcessed = 0;
552 if (!(BIOS_smpEnabled) && (Core_getId())) {
553 GET_NOTIFICATION(VPSS, HOST)
554 GET_NOTIFICATION(VPSS, DSP)
555 GET_NOTIFICATION(VPSS, VIDEO)
556 }
557 else {
558 GET_NOTIFICATION(VIDEO, HOST)
559 GET_NOTIFICATION(VIDEO, DSP)
560 GET_NOTIFICATION(VIDEO, VPSS)
561 }
562 }
563 while (numProcessed != 0);
565 #else
566 do {
567 numProcessed = 0;
568 GET_NOTIFICATION(HOST, DSP)
569 GET_NOTIFICATION(HOST, VPSS)
570 GET_NOTIFICATION(HOST, VIDEO)
571 }
572 while (numProcessed != 0);
574 #endif
575 }
577 /*
578 * ======== NotifyDriverMbx_setNotifyHandle ========
579 */
580 Void NotifyDriverMbx_setNotifyHandle(NotifyDriverMbx_Object *obj,
581 Ptr notifyHandle)
582 {
583 /* Internally used, so no Assert needed */
584 obj->notifyHandle = (ti_sdo_ipc_Notify_Handle)notifyHandle;
585 }