Cleaned up system stream.
[processor-sdk/performance-audio-sr.git] / pasdk / test_dsp / framework / systemStream.c
2 /*
3 Copyright (c) 2017, Texas Instruments Incorporated - http://www.ti.com/
4 All rights reserved.
6 * Redistribution and use in source and binary forms, with or without 
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the
16 * distribution.
17 *
18 * Neither the name of Texas Instruments Incorporated nor the names of
19 * its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 */
36 //
37 //
38 // Framework -- System Stream Function Definitions
39 //
40 //     System Stream Functions Main and 1-5.
41 //
42 //
44 //
45 // See: pa/f/s3/ss0.c
46 //
48 // Specific ASP usage requires inter-file symbol definitions ...
49 #include "noasp.h"
50 // ... end of specific usage definitions.
52 #include <xdc/std.h>
53 #include <xdc/cfg/global.h>
54 #include <xdc/runtime/Log.h>
55 #include <ti/sysbios/knl/Clock.h>
56 #include <ti/sysbios/knl/Task.h>
57 #include <ti/sysbios/utils/Load.h>
59 #include <paftyp.h>
60 #include <pafsys_a.h>
61 #include <pafcc.h>
62 //#include "alg.h"
63 #include "logp.h"
65 #include "identify.h"
66 #include "system.h"
67 #include "systemStream.h"
69 #include <acp.h>
70 #include <acp_mds.h>
71 #include <acptype.h>
72 #include <acpbeta.h>
73 #include <acperr.h>
75 //#include "pafhjt.h"
76 //
77 //#ifdef RAM_REPORT
78 //#include <paf_alg_print.h>
79 //extern int IRAM;
80 //extern int SDRAM;
81 //extern int L3RAM;
82 //#endif /* RAM_REPORT */
84 #ifndef FULL_SPEAKER
85 #define FULL_SPEAKER
86 #endif
88 #include "pfp/pfp.h"
89 #include "pfp_app.h"        /* contains all PFP ID's */
91 // Minimum time between invocation of system stream processing
92 #define SYSTEM_STREAM_PROC_INTERVAL ( 1000 )    // in msec.
94 // Indicates whether system stream initialized.
95 // 0: uninitialized
96 // 1: initialized
97 Int gSysStreamInit=0;
99 //
100 // systemStream : audio stream control function (main)
101 //
103 LINNO_DEFN (systemStreamMain);
104 ERRNO_DEFN (systemStreamMain);
106 Void
107 systemStreamMain(
108     const PAF_SST_Params *pP, 
109     PAF_SST_Config *pC
112     Int32 ss = pP->ss;
113     const PAF_SST_Fxns *fxns= pP->fxns;
114     PAF_SystemStatus *pStatus = pC->pStatus;
116     LINNO_RPRT (systemStreamMain, -1);
118     // Initialize on first invocation
119     if (pC->firstTimeInit == 0)
120     {
121         UInt32 pfpEnabledBf;
122         UInt8 i;
124         // Apply PFP enable bitfield
125         if (pStatus->pfpEnabledBf != 0)
126         {
127             pfpEnabledBf = pStatus->pfpEnabledBf;
128             i = 0;
129             while ((pfpEnabledBf != 0) && (i < PFP_PPCNT_MAX))
130             {
131                 if (pfpEnabledBf & 1)
132                 {
133                     pfpEnable(i);
134                 }
135                 pfpEnabledBf >>= 1;
136                 i++;
137             }
138         }
139         
140         if (pC->acp == NULL) 
141         {
142             ALG_Handle acpAlg;
143             ACP_Handle acp;
144             Int32 betaPrimeValue = ss - 1;
145             Int32 betaPrimeOffset;
146             Int32 betaPrime;
148             // Initialize algorithms
150             // Create an ACP algorithm instance with trace enabled
151             ACP_MDS_init();
153             // Create ACP instance for System Stream
154             if ( !(acpAlg = (ALG_Handle )ACP_MDS_create (NULL)) )
155             {
156                 //LOG_printf(&trace, "SS%d: ACP algorithm instance creation failed",
157                 //    ss);
158                 Log_error1("SS%d: ACP algorithm instance creation failed", (IArg)ss);
159                 LINNO_RPRT (systemStreamMain, __LINE__);
160                 return;
161             }
163             acpAlg->fxns->algControl(acpAlg, ACP_GETBETAPRIMEOFFSET,
164                 (IALG_Status *) &betaPrimeOffset);
165             betaPrime = betaPrimeOffset * betaPrimeValue;
167             // Attach System Stream status (update Beta Table entry)
168             acp = (ACP_Handle )acpAlg;
169             acp->fxns->attach(acp, ACP_SERIES_STD, STD_BETA_SYSIDL+betaPrime, (IALG_Status *)pStatus);
171             acpAlg->fxns->algControl(acpAlg, ACP_SETBETAPRIMEVALUE,
172                 (IALG_Status *) &betaPrimeValue);
174             // Update System Stream configuration ACP handle
175             pC->acp = acp;
177             //LOG_printf(&trace, "SS%d: ACP processing initialized", ss);
178             Log_info1("SS%d: ACP processing initialized", (IArg)ss);
179             LINNO_RPRT(systemStreamMain, -2);
181             // Attach PAF IDENTITY
182             acp->fxns->attach(acp, ACP_SERIES_STD, STD_BETA_IDENTITY, (IALG_Status *) &pafIdentification);
183         }
184         
185         pC->firstTimeInit = 1;
186     }       
188 #ifdef RAM_REPORT
189     {
190         static int count=0;
191         if (count < 10)
192         {
193             count++;            
194         }
195         else if (count == 10)
196         {
197             PAF_ALG_memStatusPrint(IRAM,SDRAM,L3RAM);
198             count++;
199         }
200     }
201 #endif /* RAM_REPORT */
203     // Invoke sub-functions as per mode
204     if (fxns != NULL) 
205     {
206         Int32 i;
207         Int64 x[PAF_SYSTEMSTREAMFXNS_XN];
209         for (i=0; i < fxns->count; i++) 
210         {
211             if ((pStatus->mode & (1 << i)) == 0)
212                 continue;
213             if (! fxns->sub[i].compute)
214                 continue;
215             if (fxns->sub[i].compute (pP, pC, x))
216                 continue;
217             if (! fxns->sub[i].transmit)
218                 continue;
219             if (fxns->sub[i].transmit (pP, pC, x))
220                 continue;
221         }
222     }
225 //
226 // systemStream1 : audio stream control functions (sub)
227 //
228 //   Process listening mode, recreation mode, and speaker configuration
229 //   to set Decode Channel Configuration Request and Override Select
230 //   Registers.
231 //
233 #ifndef NODEC
235 Int32
236 systemStream1Compute(
237     const PAF_SST_Params *pP, 
238     PAF_SST_Config *pC, 
239     Int64 x[]
242     PAF_SystemStatus *pStatus = pC->pStatus;
243     static const PAF_ChannelConfiguration cs[PAF_SYS_RECREATIONMODE_N] = {
244         // PAF_SYS_RECREATIONMODE_NONE
245         { PAF_CC_SAT_NONE, PAF_CC_SUB_ZERO, 0, 0, 0, 0, 0, 0, },
246         // PAF_SYS_RECREATIONMODE_MONO (unused below)
247         { PAF_CC_SAT_MONO, PAF_CC_SUB_ZERO, 0, 0, 0, 0, 0, 0, },
248         // PAF_SYS_RECREATIONMODE_STEREO
249         { PAF_CC_SAT_STEREO, PAF_CC_SUB_ZERO, 0, 0, 0, 0, 0, 0, },
250         // PAF_SYS_RECREATIONMODE_PHANTOM0_1
251         { PAF_CC_SAT_STEREO, PAF_CC_SUB_ONE, 0, 0, 0, 0, 0, 0, },
252         // PAF_SYS_RECREATIONMODE_SURROUND0_1
253         { PAF_CC_SAT_3STEREO, PAF_CC_SUB_ONE, 0, 0, 0, 0, 0, 0, },
254         // PAF_SYS_RECREATIONMODE_PHANTOM2_1
255         { PAF_CC_SAT_PHANTOM2, PAF_CC_SUB_ONE, 0, 0, 0, 0, 0, 0, },
256         // PAF_SYS_RECREATIONMODE_SURROUND2_1
257         { PAF_CC_SAT_SURROUND2, PAF_CC_SUB_ONE, 0, 0, 0, 0, 0, 0, },
258     };
259     XDAS_UInt8 n;
260     PAF_ChannelConfiguration ccr; /* Channel Configuration Request */
261     PAF_ChannelConfiguration cco; /* Channel Configuration Override */
263     // Listening mode: ignored.
265     // Recreation mode: direct, select, or auto.
267     switch (n = pStatus->recreationMode) 
268     {
269         case PAF_SYS_RECREATIONMODE_DONT:
270             ccr.full = -1;
271             cco.full = -1;
272             break;
274         case PAF_SYS_RECREATIONMODE_DIRECT:
275             ccr = pStatus->channelConfigurationRequest;
276             cco.full = PAF_CC_UNKNOWN;
277             break;
279         case PAF_SYS_RECREATIONMODE_AUTO:
280             ccr.full = 0;
281             ccr.part.sat = PAF_CC_SAT_STEREO
282                 + (pStatus->speakerCntr & PAF_SYS_SPEAKERNUMB) * 5
283                 + (pStatus->speakerSurr & PAF_SYS_SPEAKERNUMB)
284                 + (pStatus->speakerBack & PAF_SYS_SPEAKERNUMB);
285             ccr.part.sub = (pStatus->speakerSubw & PAF_SYS_SPEAKERNUMB);
286             ccr.part.extMask =
287                   ((pStatus->speakerWide & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LwRw : 0)
288 #ifdef FULL_SPEAKER
289                 | ((pStatus->speakerLRCntr & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LcRc : 0)
290 #endif
291                 | ((pStatus->speakerHead & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LhRh : 0) ;
292 #ifdef FULL_SPEAKER
293             ccr.part.extMask2 =
294                     ((pStatus->speakerCntrSurr & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_Cs : 0)
295                   | ((pStatus->speakerLRCntrSurr & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LcsRcs : 0)
296                   | ((pStatus->speakerRearSurr2 & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_Lrs2Rrs2 : 0)
297                   | ((pStatus->speakerRearSurr1 & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_Lrs1Rrs1 : 0)
298                   | ((pStatus->speakerSurr2 & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_Ls2Rs2 : 0)
299                   | ((pStatus->speakerSurr1 & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_Ls1Rs1 : 0)
300                   | ((pStatus->speakerScreen & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LscRsc : 0);
301 #endif
302             ccr.part.extMask3 =
303                   ((pStatus->speakerTopfront & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LtfRtf : 0)
304                 | ((pStatus->speakerToprear & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LtrRtr : 0)
305                 | ((pStatus->speakerTopmiddle & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LtmRtm : 0)
306                 | ((pStatus->speakerFrontheight & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LfhRfh : 0)
307                 | ((pStatus->speakerRearheight & PAF_SYS_SPEAKERNUMB) ? PAF_CC_EXTMASK_LrhRrh : 0);
309             pStatus->channelConfigurationRequest = ccr;
310             cco.full = PAF_CC_UNKNOWN;
311             break;
313         case PAF_SYS_RECREATIONMODE_MONO:
314             ccr.full = (pStatus->speakerCntr & PAF_SYS_SPEAKERNUMB)
315                 ? PAF_CC_MONO : PAF_CC_STEREO_MONO;
316             pStatus->channelConfigurationRequest = ccr;
317             cco.full = PAF_CC_UNKNOWN;
318             break;
320         default:
321             ccr = cs[n < lengthof (cs) ? n : 0];
322             pStatus->channelConfigurationRequest = ccr;
323             cco.full = PAF_CC_UNKNOWN;
324             break;
325     }
327     if (pStatus->channelConfigurationRequestType
328         != PAF_SYS_CCRTYPE_STANDARD) 
329     {
330         PAF_ChannelConfiguration ccs;
332         ccs = cco;
334         // CCO is computed CCR.
335         cco = ccr;
337         // CCR is as per request type:
338         // DecodeBypass - PAF_CC_UNKNOWN (see above)
339         // DecodeDirect - don't write, allow use as control register
340         ccr.full = pStatus->channelConfigurationRequestType
341             == PAF_SYS_CCRTYPE_DECODEDIRECT ? -1 : ccs.full;
342     }
344     x[0] = ccr.full; /* Channel Configuration Request */
345     x[1] = cco.full; /* Channel Configuration Override */
347     return 0;
350 Int32
351 systemStream1Transmit(
352     const PAF_SST_Params *pP, 
353     PAF_SST_Config *pC, 
354     Int64 x[]
357     Int32 ss = pP->ss;
358     ACP_Handle acp = pC->acp;
359     PAF_ChannelConfiguration ccr; /* Channel Configuration Request */
360     PAF_ChannelConfiguration cco; /* Channel Configuration Override */
362     ccr.full = x[0]; /* Channel Configuration Request */
363     cco.full = x[1]; /* Channel Configuration Override */
365     // Send Request to Audio Stream 1 Decode Status.
367     if (ccr.full != -1) 
368     {
369         ACP_Unit from[7];
370         Int32 errno;
372         // writeDECChannelConfigurationRequest 0xce24,0x3808
373         from[0] = 0xc906;
374         from[1] = 0xce00 | STD_BETA_DECODE;
375         from[2] = 0x3808;
376         from[3] = ccr.full;
377         from[4] = ccr.full >> 16;
378         from[5] = ccr.full >> 32;
379         from[6] = ccr.full >> 48;
381         if (errno = acp->fxns->sequence(acp, from, NULL)) 
382         {
383             //LOG_printf(&trace, "SS%d: DEC sequence processing error (0x%04x)",
384             //    ss, errno);
385             Log_error2("SS%d: DEC sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
386             ERRNO_RPRT (systemStreamMain, errno);
387         }
389         // writeENCChannelConfigurationCompact(sat,sub,aux,ext0,ext2,ext3,rsvd1,rsvd2) 0xce25,0x9808
390         from[0] = 0xc906;
391         from[1] = 0xce00 | STD_BETA_ENCODE;
392         from[2] = 0x9808;
393         from[3] = ccr.full;
394         from[4] = ccr.full >> 16;
395         from[5] = ccr.full >> 32;
396         from[6] = ccr.full >> 48;
398         if (errno = acp->fxns->sequence(acp, from, NULL)) 
399         {
400             //LOG_printf(&trace, "SS%d: ENC sequence processing error (0x%04x)",
401             //    ss, errno);
402             Log_error2("SS%d: ENC sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
403             ERRNO_RPRT (systemStreamMain, errno);
404         }
405     }
407     // Send Override to Audio Stream 1 Decode Status.
409     if (cco.full != -1)
410     {
411         ACP_Unit from[7];
412         Int32 errno;
414         // writeDECChannelConfigurationOverride 0xce24,0x5808
415         from[0] = 0xc906;
416         from[1] = 0xce00 | STD_BETA_DECODE;
417         from[2] = 0x5808; 
418         from[3] = cco.full;
419         from[4] = cco.full >> 16;
420         from[5] = cco.full >> 32;
421         from[6] = cco.full >> 48;
422     
423         if (errno = acp->fxns->sequence(acp, from, NULL)) 
424         {
425             //LOG_printf(&trace, "SS%d: DEC sequence processing error (0x%04x)",
426             //    ss, errno);
427             Log_error2("SS%d: DEC sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
428             ERRNO_RPRT (systemStreamMain, errno);
429         }
430     }
432     return 0;
435 #else /* NODEC */
437 asm(" .global _systemStream1Compute");
438 asm("_systemStream1Compute .set 0");
440 asm(" .global _systemStream1Transmit");
441 asm("_systemStream1Transmit .set 0");
443 #endif /* NODEC */
445 //
446 // systemStream2 : audio stream control functions (sub)
447 //
448 //   Process listening mode, recreation mode, and speaker configuration
449 //   to set Bass Management Output Configuration Select Register.
450 //
452 #ifndef NOBM
454 #define DOC_AUTO  0x0f  // 15, to leave some room
456 Int32
457 systemStream2Compute(
458     const PAF_SST_Params *pP, 
459     PAF_SST_Config *pC, 
460     Int64 x[]
463     PAF_SystemStatus *pStatus = pC->pStatus;
464     Int32 oc; /* Output Configuration */
466     // Determine BM Output Configuration Select (if auto mode):
468     if ( pStatus->recreationMode == PAF_SYS_RECREATIONMODE_DONT
469       || pStatus->recreationMode == PAF_SYS_RECREATIONMODE_DIRECT )
470     {
471         return 1;
472     }
473     // Set channel flags, including channels beyond Dolby spec:
475     oc = (DOC_AUTO << 24) +
476         ((pStatus->speakerSubw & PAF_SYS_SPEAKERFREQ_HI ? 1 : 0) << 0) +
477         ((pStatus->speakerMain & PAF_SYS_SPEAKERFREQ_LO ? 1 : 0) << 1) +
478         ((pStatus->speakerCntr & PAF_SYS_SPEAKERFREQ_LO ? 1 : 0) << 2) +
479         ((pStatus->speakerSurr & PAF_SYS_SPEAKERFREQ_LO ? 1 : 0) << 3) +
480         ((pStatus->speakerBack & PAF_SYS_SPEAKERFREQ_LO ? 1 : 0) << 4) +
481         ((pStatus->speakerWide & PAF_SYS_SPEAKERFREQ_LO ? 1 : 0) << 5) +
482         ((pStatus->speakerHead & PAF_SYS_SPEAKERFREQ_LO ? 1 : 0) << 6) ;
484     x[0] = oc; /* Output Configuration */
486     return 0;
489 Int32
490 systemStream2Transmit(
491     const PAF_SST_Params *pP, 
492     PAF_SST_Config *pC, 
493     Int64 x[]
496     Int32 ss = pP->ss;
497     ACP_Handle acp = pC->acp;
498     Int32 oc;
500     oc = x[0]; /* Output Configuration */
502     // Send Select to Audio Stream 1 Bass Management Status if valid:
504     {
505         Int32 errno;
506         ACP_Unit from[6];
508         from[0] = 0xc905;
510         // writeBMOCSelectOCAuto(OCNO,AUTO) 0xcb40,0x000a,
511         //     ((OCNO) << 8)&0xff00+(AUTO)&0x00ff
513         from[1] = 0xcb00 | STD_BETA_BM;
514         from[2] = 0x000a;
515         from[3] = (oc>>16) & 0xffff;
517         // writeBMOCSelectChannels(CHANS) 0xca40,
518         //     0x0800+((CHANS) & 0x00ff)
520         from[4] = 0xca00 | STD_BETA_BM;
521         from[5] = 0x0800 + (oc & 0xff);
523         if (errno = acp->fxns->sequence(acp, from, NULL)) 
524         {
525             if (errno == ACPERR_APPLY_NOBETA) 
526             {
527                 // Return without reporting to trace Log if BM is not
528                 // part of the stream.
529                 return 1;
530             }
531             else 
532             {
533                 //LOG_printf(&trace, "SS%d: BM sequence processing error (0x%04x)",
534                 //    ss, errno);
535                 Log_error2("SS%d: BM sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
536                 ERRNO_RPRT (systemStreamMain, errno);
537             }
538         }
539     }
541     return 0;
544 #else /* NOBM */
546 asm(" .global _systemStream2Compute");
547 asm("_systemStream2Compute .set 0");
549 asm(" .global _systemStream2Transmit");
550 asm("_systemStream2Transmit .set 0");
552 #endif /* NOBM */
554 //
555 // systemStream3 : audio stream control functions (sub)
556 //
557 //   Process S/PDIF pre-emphasis flag information and Deemphasis Filter
558 //   Mode Control information to set Deemphasis Filter Active Select
559 //   Register if needed.
560 //
561 //   Note that this implementation is quite arbitrary and could be done
562 //   another way, including completely via a shortcut! --Kurt
563 //
565 #ifndef NODEM
567 Int32
568 systemStream3Compute(
569     const PAF_SST_Params *pP, 
570     PAF_SST_Config *pC, 
571     Int64 x[]
574     Int32 ss = pP->ss;
575     ACP_Handle acp = pC->acp;
576     Int32 errno;
577     ACP_Unit from[3], to[3];
579     // readDEMFilterMode 0xc250,0x0500
580     from[0] = 0xc902;
581     from[1] = 0xc200 | STD_BETA_DEM;
582     from[2] = 0x0500;
583     
584     if (errno = acp->fxns->sequence(acp, from, to)) 
585     {
586         if (errno == ACPERR_APPLY_NOBETA) 
587         {
588             // Return without reporting to trace Log if DEM is not
589             // part of the stream.
590             return 1;
591         }
592         else 
593         {
594             //LOG_printf(&trace, "SS%d: DEM sequence processing error (0x%04x)",
595             //    ss, errno);
596             Log_error2("SS%d: DEM sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
597             ERRNO_RPRT (systemStreamMain, errno);
598         }
599     }
601     // If Deemphasis Filter Mode Control is not "Auto", no further action.
602     if ((to[2] & 0xff) != 1)
603         return 1;
605     // readDECEmphasis  0xc224,0x33
606     from[0] = 0xc902;
607     from[1] = 0xc200 | STD_BETA_DECODE;
608     from[2] = 0x3300;
610     if (errno = acp->fxns->sequence(acp, from, to)) 
611     {
612         //LOG_printf(&trace, "SS%d: DEC sequence processing error (0x%04x)",
613         //    ss, errno);
614         Log_error2("SS%d: DEC sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
615         ERRNO_RPRT (systemStreamMain, errno);
616     }
618     x[0] = (to[2] & 0xff) == 2 ? 1 : 0;
620     return 0;
623 Int32
624 systemStream3Transmit(
625     const PAF_SST_Params *pP, 
626     PAF_SST_Config *pC, 
627     Int64 x[]
630     Int32 ss = pP->ss;
631     ACP_Handle acp = pC->acp;
632     ACP_Unit from[3];
633     Int32 errno;
635     from[0] = 0xc902;
636     from[1] = 0xca00 | STD_BETA_DEM;
637     from[2] = 0x0600 + x[0];
639     if (errno = acp->fxns->sequence(acp, from, NULL)) 
640     {
641         if (errno == ACPERR_APPLY_NOBETA) 
642         {
643             // Return without reporting to trace Log if DEM is not
644             // part of the stream.
645             return 1;
646         }
647         else 
648         {
649             //LOG_printf(&trace, "SS%d: DEM sequence processing error (0x%04x)",
650             //    ss, errno);
651             Log_error2("SS%d: DEM sequence processing error (0x%04x)", (IArg)ss, (IArg)errno);
652             ERRNO_RPRT (systemStreamMain, errno);
653         }
654     }
656     return 0;
659 #else /* NODEM */
661 asm(" .global _systemStream3Compute");
662 asm("_systemStream3Compute .set 0");
664 asm(" .global _systemStream3Transmit");
665 asm("_systemStream3Transmit .set 0");
667 #endif /* NODEM */
670 //
671 // systemStream5 : CPU Load Graph
672 //
674 //#include <xdc/runtime/LoggerBuf.h>
675 //#include <xdc/runtime/System.h>
676 //#include <ti/bios/include/log.h>
677 //#include <ti/sysbios/knl/Task.h>
679 #if 1 // FL: debug
680 UInt16 gCpuLoad;
681 UInt8 gPeakCpuLoad;
682 UInt8 gAsipLoad;
683 UInt8 gPeakAsipLoad;
684 UInt8 gAsopLoad;
685 UInt8 gPeakAsopLoad;
686 UInt8 gAipLoad;
687 UInt8 gPeakAipLoad;
688 UInt8 gAfpLoad;
689 UInt8 gPeakAfpLoad;
690 UInt8 gSsLoad;
691 UInt8 gPeakSsLoad;
692 //UInt32 gHwiLoad;
693 //UInt32 gSwiLoad;
694 #endif
697 Int32
698 systemStream5Compute(
699     const PAF_SST_Params *pP, 
700     PAF_SST_Config *pC, 
701     Int64 x[]
704     PAF_SystemStatus *pStatus = pC->pStatus;
705     Load_Stat stat;
706     UInt32 pfpDisableMask, pfpEnableMask;
707     UInt32 pfpResetStatsMask;
708     UInt8 i;
710     Load_getTaskLoad(Task_getIdleTask(), &stat);
711     pStatus->cpuLoad = (100 - Load_calculateLoad(&stat)) * 256;
712     if (pStatus->peakCpuLoad < pStatus->cpuLoad)
713     {
714         pStatus->peakCpuLoad = pStatus->cpuLoad;
715     }
716   
717     // Compute ASIT load
718     Load_getTaskLoad(TaskAsip, &stat);
719     pStatus->asitLoad = Load_calculateLoad(&stat);
720     if (pStatus->peakAsitLoad < pStatus->asitLoad)
721     {
722         pStatus->peakAsitLoad = pStatus->asitLoad;
723     }
724     
725     // Compute ASOT load
726     Load_getTaskLoad(TaskAsop, &stat);
727     pStatus->asotLoad = Load_calculateLoad(&stat);
728     if (pStatus->peakAsotLoad < pStatus->asotLoad)
729     {
730         pStatus->peakAsotLoad = Load_calculateLoad(&stat);
731     }
733     // Compute AIP Task load
734     Load_getTaskLoad(TaskAip, &stat);
735     pStatus->aipLoad = Load_calculateLoad(&stat);
736     if (pStatus->peakAipLoad < pStatus->aipLoad)
737     {
738         pStatus->peakAipLoad = Load_calculateLoad(&stat);        
739     }
741     // Compute AFP Task load
742     Load_getTaskLoad(TaskAfp, &stat);
743     pStatus->afpLoad = Load_calculateLoad(&stat);
744     if (pStatus->peakAfpLoad < pStatus->afpLoad)
745     {
746         pStatus->peakAfpLoad = Load_calculateLoad(&stat);        
747     }
748     
749     // Compute System Stream Task load
750     Load_getTaskLoad(TaskSystemStream, &stat);
751     pStatus->ssLoad = Load_calculateLoad(&stat);
752     if (pStatus->peakSsLoad < pStatus->ssLoad)
753     {
754         pStatus->peakSsLoad = Load_calculateLoad(&stat);        
755     }
757     // Apply PFP disable mask
758     if (pStatus->pfpDisableMask != 0)
759     {
760         pfpDisableMask = pStatus->pfpDisableMask;
761         i = 0;
762         while ((pfpDisableMask != 0) && (i < PFP_PPCNT_MAX))
763         {
764             if (pfpDisableMask & 1)
765             {
766                 pfpDisable(i);
767             }
768             pfpDisableMask >>= 1;
769             i++;
770         }
771         pStatus->pfpEnabledBf &= ~pStatus->pfpDisableMask;
772         pStatus->pfpDisableMask = 0;
773     }
774     
775     // Apply PFP enable mask
776     if (pStatus->pfpEnableMask != 0)
777     {
778         pfpEnableMask = pStatus->pfpEnableMask;
779         i = 0;
780         while ((pfpEnableMask != 0) && (i < PFP_PPCNT_MAX))
781         {
782             if (pfpEnableMask & 1)
783             {
784                 pfpEnable(i);
785             }
786             pfpEnableMask >>= 1;
787             i++;
788         }
789         pStatus->pfpEnabledBf |= pStatus->pfpEnableMask;
790         pStatus->pfpEnableMask = 0;
791     }
793     // Apply PFP reset mask
794     if (pStatus->pfpResetStatsMask != 0)
795     {
796         pfpResetStatsMask = pStatus->pfpResetStatsMask;
797         i = 0;
798         while ((pfpResetStatsMask != 0) && (i < PFP_PPCNT_MAX))
799         {
800             if (pfpResetStatsMask & 1)
801             {
802                 pfpResetStats(i);
803             }
804             pfpResetStatsMask >>= 1;
805             i++;
806         }
807         pStatus->pfpResetStatsMask = 0;
808     }    
809     
810     // FL: debug
811     gCpuLoad = pStatus->cpuLoad>>8;
812     gAsipLoad = pStatus->asitLoad;
813     gAsopLoad = pStatus->asotLoad;
814     gAipLoad = pStatus->aipLoad;
815     gAfpLoad = pStatus->afpLoad;
816     gSsLoad = pStatus->ssLoad;
817     gPeakCpuLoad = pStatus->peakCpuLoad>>8;
818     gPeakAsipLoad = pStatus->peakAsitLoad;
819     gPeakAsopLoad = pStatus->peakAsotLoad;
820     gPeakAipLoad = pStatus->peakAipLoad;
821     gPeakAfpLoad = pStatus->peakAfpLoad;
822     gPeakSsLoad = pStatus->peakSsLoad;
823     
824     return 0;
827 Int32
828 systemStream5Transmit(
829     const PAF_SST_Params *pP, 
830     PAF_SST_Config *pC, 
831     Int64 x[]
834     return 0;
837 // FL: debug
838 //#define MAX_CAP_CUR_TIME ( 100 )
839 //UInt32 gCurTime[MAX_CAP_CUR_TIME];
840 //Uint32 gCurTimeIdx=0;
842 /*
843  *  ======== taskSystemStreamFxn ========
844  *  IDLE function for audio stream
845  */
846 Void taskSystemStreamFxn()
848     Int32 i;
849     UInt32 elapsed, now, then=0;
850     UInt32 time, interval;
852     //System_printf("Enter idleAudioStream()\n");    
853     //Log_info0("Enter idleAudioStream()");
855     time = SYSTEM_STREAM_PROC_INTERVAL; // in msec.
857     while (1)
858     {
859         // Compute interval in system clock ticks, interval time expressed in msec.
860         // Performing calculation inside while loop allows changes in system clock tick period.
861         interval = time * USEC_PER_MSEC / Clock_tickPeriod;
863         // Compute elapsed time
864         // Note in case of wrap of 32-bit return value for now,
865         // (now-then) calculation is correct despite (now<then)
866         // due to 2s complement arithmetic.
867         now = Clock_getTicks();
868         elapsed = now - then;
869         then = now; // latch "now" as "then" for next iteration
871         // If elapsed time since last iteration is less than desired System Stream period,
872         // then sleep until interval has passed.
873         // Otherwise execute functions in System Stream.
874         if (interval > elapsed)
875         {
876             Task_sleep(interval - elapsed);
877         }
879         // FL: debug
880         //gCurTime[gCurTimeIdx] = Clock_getTicks();
881         //gCurTimeIdx++;
882         //if (gCurTimeIdx >= MAX_CAP_CUR_TIME)
883         //{
884         //    gCurTimeIdx = 0;
885         //}
887         for (i=0; i < lengthof(systemStreamConfig); i++)
888         {
889             systemStreamParams[i].fxns->main
890                 (&systemStreamParams[i], &systemStreamConfig[i]);            
891         }
893         if (gSysStreamInit == 0)
894         {
895             gSysStreamInit = 1;  // Indicate system stream initialized
896         }
897     }