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;
181 /*
182 * Check whether remote proc ID has been set and isn't the same as the
183 * local proc ID
184 */
185 Assert_isTrue ((params->remoteProcId < MultiProc_getNumProcessors()) &&
186 (params->remoteProcId != MultiProc_INVALIDID) &&
187 (params->remoteProcId != MultiProc_self()),
188 ti_sdo_ipc_Notify_A_internal);
190 if (params->remoteProcId >= MultiProc_getNumProcessors() ||
191 params->remoteProcId == MultiProc_INVALIDID) {
192 return; /* keep Coverity happy */
193 }
195 obj->remoteProcId = params->remoteProcId;
196 obj->evtRegMask = 0;
197 obj->notifyHandle = NULL;
199 /* Disable global interrupts */
200 key = Hwi_disable();
202 /* Store the driver handle so it can be retreived in the isr */
203 NotifyDriverMbx_module->drvHandles[obj->remoteProcId] = obj;
205 /* Enable the mailbox interrupt from the remote core */
206 NotifyDriverMbx_enable(obj);
208 /* Restore global interrupts */
209 Hwi_restore(key);
210 }
212 /*
213 * ======== NotifyDriverMbx_Instance_finalize ========
214 */
215 Void NotifyDriverMbx_Instance_finalize(NotifyDriverMbx_Object *obj)
216 {
217 /* Disable the mailbox interrupt source */
218 NotifyDriverMbx_disable(obj);
220 NotifyDriverMbx_module->drvHandles[obj->remoteProcId] = NULL;
221 }
223 /*
224 * ======== NotifyDriverMbx_registerEvent ========
225 */
226 Void NotifyDriverMbx_registerEvent(NotifyDriverMbx_Object *obj,
227 UInt32 eventId)
228 {
229 UInt hwiKey;
231 /*
232 * Disable interrupt line to ensure that isr doesn't
233 * preempt registerEvent and encounter corrupt state
234 */
235 hwiKey = Hwi_disable();
237 /* Set the 'registered' bit */
238 SET_BIT(obj->evtRegMask, eventId);
240 /* Restore the interrupt line */
241 Hwi_restore(hwiKey);
242 }
244 /*
245 * ======== NotifyDriverMbx_unregisterEvent ========
246 */
247 Void NotifyDriverMbx_unregisterEvent(NotifyDriverMbx_Object *obj,
248 UInt32 eventId)
249 {
250 UInt hwiKey;
252 /*
253 * Disable interrupt line to ensure that isr doesn't
254 * preempt registerEvent and encounter corrupt state
255 */
256 hwiKey = Hwi_disable();
258 /* Clear the registered bit */
259 CLEAR_BIT(obj->evtRegMask, eventId);
261 /* Restore the interrupt line */
262 Hwi_restore(hwiKey);
263 }
265 /*
266 * ======== NotifyDriverMbx_sendEvent ========
267 */
268 /*
269 * PUT_NOTIFICATION will spin waiting for enough room in the mailbox FIFO
270 * to store the number of messages needed for the notification ('numMsgs').
271 * If spinning is necesssary (i.e. if waitClear is TRUE and there isn't enough
272 * room in the FIFO) then PUT_NOTIFICATION will allow pre-emption while
273 * spinning.
274 *
275 * PUT_NOTIFICATION needs to prevent another local thread from writing to the
276 * same mailbox after the current thread has
277 * 1) determined that there is enough room to write the notification and
278 * 2) written the first of two messages to the mailbox.
279 * This is needed to respectively prevent
280 * 1) both threads from incorrectly assuming there is enough space in the FIFO
281 * for their own notifications
282 * 2) the interrupting thread from writing a notification between two
283 * two messages that need to be successivly written by the preempted thread.
284 * Therefore, the check for enough FIFO room and one/both mailbox write(s)
285 * should all occur atomically (i.e. with interrupts disabled)
286 */
287 #define PUT_NOTIFICATION(m) \
288 key = Hwi_disable(); \
289 while(MAILBOX_FIFOLENGTH - REG32(MAILBOX_STATUS(m)) < numMsgs) { \
290 Hwi_restore(key); \
291 if (!waitClear) { \
292 return (Notify_E_FAIL); \
293 } \
294 key = Hwi_disable(); \
295 }; \
296 REG32(MAILBOX_MESSAGE(m)) = eventId + smallPayload; \
297 if (smallPayload == 0xFFFFFFE0) { \
298 REG32(MAILBOX_MESSAGE(m)) = payload; \
299 } \
300 Hwi_restore(key);
302 Int NotifyDriverMbx_sendEvent(NotifyDriverMbx_Object *obj,
303 UInt32 eventId,
304 UInt32 payload,
305 Bool waitClear)
306 {
307 UInt16 remoteProcId = obj->remoteProcId;
308 UInt key, numMsgs;
309 UInt32 smallPayload;
311 /* Decide if the payload is small enough to fit in the first mbx msg */
312 if (payload < 0x7FFFFFF) {
313 smallPayload = (payload << 5);
314 numMsgs = 1;
315 }
316 else {
317 smallPayload = 0xFFFFFFE0;
318 numMsgs = 2;
319 }
321 #if defined(xdc_target__isaCompatible_64)
322 if (remoteProcId == NotifyDriverMbx_hostProcId) {
323 PUT_NOTIFICATION(DSP_TO_HOST)
324 }
325 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
326 PUT_NOTIFICATION(DSP_TO_VIDEO)
327 }
328 else {
329 PUT_NOTIFICATION(DSP_TO_VPSS)
330 }
331 #elif defined(xdc_target__isaCompatible_v7M)
332 if (!(BIOS_smpEnabled) && (Core_getId())) {
333 if (remoteProcId == NotifyDriverMbx_dspProcId) {
334 PUT_NOTIFICATION(VPSS_TO_DSP)
335 }
336 else if (remoteProcId == NotifyDriverMbx_hostProcId) {
337 PUT_NOTIFICATION(VPSS_TO_HOST)
338 }
339 else {
340 PUT_NOTIFICATION(VPSS_TO_VIDEO)
341 }
342 }
343 else {
344 if (remoteProcId == NotifyDriverMbx_dspProcId) {
345 PUT_NOTIFICATION(VIDEO_TO_DSP)
346 }
347 else if (remoteProcId == NotifyDriverMbx_hostProcId) {
348 PUT_NOTIFICATION(VIDEO_TO_HOST)
349 }
350 else {
351 PUT_NOTIFICATION(VIDEO_TO_VPSS)
352 }
353 }
354 #else
355 if (remoteProcId == NotifyDriverMbx_dspProcId) {
356 PUT_NOTIFICATION(HOST_TO_DSP)
357 }
358 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
359 PUT_NOTIFICATION(HOST_TO_VIDEO)
360 }
361 else {
362 PUT_NOTIFICATION(HOST_TO_VPSS)
363 }
364 #endif
366 return (Notify_S_SUCCESS);
367 }
369 /*
370 * ======== NotifyDriverMbx_disable ========
371 */
372 Void NotifyDriverMbx_disable(NotifyDriverMbx_Object *obj)
373 {
374 UInt16 remoteProcId = obj->remoteProcId;
376 #if defined(xdc_target__isaCompatible_64)
377 if (remoteProcId == NotifyDriverMbx_hostProcId) {
378 REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(HOST_TO_DSP);
379 }
380 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
381 REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(VIDEO_TO_DSP);
382 }
383 else {
384 REG32(MAILBOX_IRQENABLE_CLR_DSP) = MAILBOX_REG_VAL(VPSS_TO_DSP);
385 }
386 #elif defined(xdc_target__isaCompatible_v7M)
387 if (!(BIOS_smpEnabled) && (Core_getId())) {
388 if (remoteProcId == NotifyDriverMbx_hostProcId) {
389 REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
390 }
391 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
392 REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
393 }
394 else {
395 REG32(MAILBOX_IRQENABLE_CLR_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
396 }
397 }
398 else {
399 if (remoteProcId == NotifyDriverMbx_hostProcId) {
400 REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
401 }
402 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
403 REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
404 }
405 else {
406 REG32(MAILBOX_IRQENABLE_CLR_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
407 }
408 }
409 #else
410 if (remoteProcId == NotifyDriverMbx_dspProcId) {
411 REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
412 }
413 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
414 REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
415 }
416 else {
417 REG32(MAILBOX_IRQENABLE_CLR_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
418 }
419 #endif
420 }
422 /*
423 * ======== NotifyDriverMbx_enable ========
424 */
425 Void NotifyDriverMbx_enable(NotifyDriverMbx_Object *obj)
426 {
427 UInt16 remoteProcId = obj->remoteProcId;
429 #if defined(xdc_target__isaCompatible_64)
430 if (remoteProcId == NotifyDriverMbx_hostProcId) {
431 REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(HOST_TO_DSP);
432 }
433 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
434 REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(VIDEO_TO_DSP);
435 }
436 else {
437 REG32(MAILBOX_IRQENABLE_SET_DSP) = MAILBOX_REG_VAL(VPSS_TO_DSP);
438 }
439 #elif defined(xdc_target__isaCompatible_v7M)
440 if (!(BIOS_smpEnabled) && (Core_getId())) {
441 if (remoteProcId == NotifyDriverMbx_hostProcId) {
442 REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(HOST_TO_VPSS);
443 }
444 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
445 REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(DSP_TO_VPSS);
446 }
447 else {
448 REG32(MAILBOX_IRQENABLE_SET_VPSS) = MAILBOX_REG_VAL(VIDEO_TO_VPSS);
449 }
450 }
451 else {
452 if (remoteProcId == NotifyDriverMbx_hostProcId) {
453 REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(HOST_TO_VIDEO);
454 }
455 else if (remoteProcId == NotifyDriverMbx_dspProcId) {
456 REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(DSP_TO_VIDEO);
457 }
458 else {
459 REG32(MAILBOX_IRQENABLE_SET_VIDEO) = MAILBOX_REG_VAL(VPSS_TO_VIDEO);
460 }
461 }
462 #else
463 if (remoteProcId == NotifyDriverMbx_dspProcId) {
464 REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(DSP_TO_HOST);
465 }
466 else if (remoteProcId == NotifyDriverMbx_videoProcId) {
467 REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VIDEO_TO_HOST);
468 }
469 else {
470 REG32(MAILBOX_IRQENABLE_SET_HOST) = MAILBOX_REG_VAL(VPSS_TO_HOST);
471 }
472 #endif
473 }
475 /*
476 * ======== NotifyDriverMbx_disableEvent ========
477 */
478 Void NotifyDriverMbx_disableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
479 {
480 /* NotifyDriverMbx_disableEvent not supported by this driver */
481 Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
482 }
484 /*
485 * ======== NotifyDriverMbx_enableEvent ========
486 */
487 Void NotifyDriverMbx_enableEvent(NotifyDriverMbx_Object *obj, UInt32 eventId)
488 {
489 /* NotifyDriverMbx_enableEvent not supported by this driver */
490 Assert_isTrue(FALSE, NotifyDriverMbx_A_notSupported);
491 }
493 /*
494 *************************************************************************
495 * Internal functions
496 *************************************************************************
497 */
499 /*
500 * ======== NotifyDriverMbx_isr ========
501 */
503 /*
504 * Get a message from the mailbox. The bottom 5 bits of the message
505 * contains the eventId. The top 27 bits of the message contains either
506 * 1) The payload if the payload is less than 0x7FFFFFF
507 * 2) 0x7FFFFFF otherwise
508 * If the top 27 bits of the first message is 0x7FFFFFF, then the payload
509 * is in the next mailbox message.
510 */
511 #define GET_NOTIFICATION(dst, src) \
512 if (REG32(MAILBOX_STATUS(MBX(src, dst)))) { \
513 numProcessed++; \
514 msg = REG32(MAILBOX_MESSAGE(MBX(src, dst))); \
515 eventId = (UInt16)(msg & 0x1F); \
516 payload = msg >> 5; \
517 if (payload == 0x7FFFFFF) { \
518 while(REG32(MAILBOX_STATUS(MBX(src, dst))) == 0); \
519 payload = REG32(MAILBOX_MESSAGE(MBX(src, dst))); \
520 } \
521 REG32(MAILBOX_IRQSTATUS_CLR_##dst) = \
522 MAILBOX_REG_VAL(MBX(src, dst)); \
523 obj = NotifyDriverMbx_module->drvHandles[PROCID_##src]; \
524 Assert_isTrue(obj != NULL, ti_sdo_ipc_Notify_A_internal); \
525 if (TEST_BIT(obj->evtRegMask, eventId)) { \
526 ti_sdo_ipc_Notify_exec(obj->notifyHandle, \
527 eventId, \
528 payload); \
529 } \
530 }
532 Void NotifyDriverMbx_isr(UArg arg)
533 {
534 NotifyDriverMbx_Object *obj;
535 UInt32 msg, payload;
536 UInt16 eventId;
537 Int numProcessed;
539 #if defined(xdc_target__isaCompatible_64)
540 do {
541 numProcessed = 0;
542 GET_NOTIFICATION(DSP, HOST)
543 GET_NOTIFICATION(DSP, VPSS)
544 GET_NOTIFICATION(DSP, VIDEO)
545 }
546 while (numProcessed != 0);
548 /* Write to EOI (End Of Interrupt) register */
549 REG32(MAILBOX_EOI_REG) = 0x1;
551 #elif defined(xdc_target__isaCompatible_v7M)
552 do {
553 numProcessed = 0;
554 if (!(BIOS_smpEnabled) && (Core_getId())) {
555 GET_NOTIFICATION(VPSS, HOST)
556 GET_NOTIFICATION(VPSS, DSP)
557 GET_NOTIFICATION(VPSS, VIDEO)
558 }
559 else {
560 GET_NOTIFICATION(VIDEO, HOST)
561 GET_NOTIFICATION(VIDEO, DSP)
562 GET_NOTIFICATION(VIDEO, VPSS)
563 }
564 }
565 while (numProcessed != 0);
567 #else
568 do {
569 numProcessed = 0;
570 GET_NOTIFICATION(HOST, DSP)
571 GET_NOTIFICATION(HOST, VPSS)
572 GET_NOTIFICATION(HOST, VIDEO)
573 }
574 while (numProcessed != 0);
576 #endif
577 }
579 /*
580 * ======== NotifyDriverMbx_setNotifyHandle ========
581 */
582 Void NotifyDriverMbx_setNotifyHandle(NotifyDriverMbx_Object *obj,
583 Ptr notifyHandle)
584 {
585 /* Internally used, so no Assert needed */
586 obj->notifyHandle = (ti_sdo_ipc_Notify_Handle)notifyHandle;
587 }