SDOCM00106584 Notify mailbox driver support on DRA7xx (IPU, HOST) - Part 1
[ipc/ipcdev.git] / packages / ti / sdo / ipc / family / vayu / TableInit.xs
1 /*
2  * Copyright (c) 2012-2014 Texas Instruments Incorporated - http://www.ti.com
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  */
32 /*
33  *  ======== TableInit.xs ========
34  *
35  */
37 /*
38  * When assigning virtual indexes to each core make sure
39  * to assign even virtual indexes to DSP/M4 cores with
40  * even Core Ids, and assign odd virtual indexes to DSP/M4
41  * cores with odd Core Ids.
42  *
43  * Example:
44  *     DSP physical Core Id = 0 -> Virtual Index = 4;
45  *     DSP physical Core Id = 1 -> Virtual Index = 5;
46  *
47  * Virtual Index Assignment:
48  *
49  * | EVE1 -> 0 | EVE2 -> 1   | EVE3 -> 2   | EVE4 -> 3   |
50  * | DSP1 -> 4 | DSP2 -> 5   | IPU1-0 -> 6 | IPU2-0 -> 7 |
51  * | HOST -> 8 | IPU1-1 -> 9 | IPU2-1 -> 10
52  *
53  */
54 var eve1VirtId    = 0;
55 var eve2VirtId    = 1;
56 var eve3VirtId    = 2;
57 var eve4VirtId    = 3;
58 var dsp1VirtId    = 4;
59 var dsp2VirtId    = 5;
60 var ipu1_0VirtId  = 6;
61 var ipu2_0VirtId  = 7;
62 var hostVirtId    = 8;
63 var ipu1_1VirtId  = 9;
64 var ipu2_1VirtId  = 10;
67 /*
68  *  ======== initProcId ========
69  *  Assign MultiProc ids and virtual processor ids.
70  */
71 function initProcId(mod)
72 {
73     var MultiProc = xdc.useModule("ti.sdo.utils.MultiProc");
75     for (var i = 0; i < mod.procIdTable.length; i++) {
76         mod.procIdTable[i] = -1;
77     }
79     mod.eve1ProcId   = MultiProc.getIdMeta("EVE1");
80     mod.eve2ProcId   = MultiProc.getIdMeta("EVE2");
81     mod.eve3ProcId   = MultiProc.getIdMeta("EVE3");
82     mod.eve4ProcId   = MultiProc.getIdMeta("EVE4");
83     mod.dsp1ProcId   = MultiProc.getIdMeta("DSP1");
84     mod.dsp2ProcId   = MultiProc.getIdMeta("DSP2");
85     mod.ipu1_0ProcId = MultiProc.getIdMeta("IPU1");  /* assume smp */
86     mod.ipu1_1ProcId = MultiProc.getIdMeta("IPU1-1");
87     mod.ipu2_0ProcId = MultiProc.getIdMeta("IPU2");  /* assume smp */
88     mod.ipu2_1ProcId = MultiProc.getIdMeta("IPU2-1");
89     mod.hostProcId   = MultiProc.getIdMeta("HOST");
91     if (mod.eve1ProcId != MultiProc.INVALIDID) {
92         mod.procIdTable[mod.eve1ProcId] = eve1VirtId;
93     }
94     if (mod.eve2ProcId != MultiProc.INVALIDID) {
95         mod.procIdTable[mod.eve2ProcId] = eve2VirtId;
96     }
97     if (mod.eve3ProcId != MultiProc.INVALIDID) {
98         mod.procIdTable[mod.eve3ProcId] = eve3VirtId;
99     }
100     if (mod.eve4ProcId != MultiProc.INVALIDID) {
101         mod.procIdTable[mod.eve4ProcId] = eve4VirtId;
102     }
103     if (mod.dsp1ProcId != MultiProc.INVALIDID) {
104         mod.procIdTable[mod.dsp1ProcId] = dsp1VirtId;
105     }
106     if (mod.dsp2ProcId != MultiProc.INVALIDID) {
107         mod.procIdTable[mod.dsp2ProcId] = dsp2VirtId;
108     }
110     if (mod.ipu1_0ProcId != MultiProc.INVALIDID) {
111         mod.procIdTable[mod.ipu1_0ProcId] = ipu1_0VirtId;
112     }
113     else {
114         /* IPU1 not smp */
115         mod.ipu1_0ProcId = MultiProc.getIdMeta("IPU1-0");
117         if (mod.ipu1_0ProcId != MultiProc.INVALIDID) {
118             mod.procIdTable[mod.ipu1_0ProcId] = ipu1_0VirtId;
119         }
120     }
122     if (mod.ipu1_1ProcId != MultiProc.INVALIDID) {
123         mod.procIdTable[mod.ipu1_1ProcId] = ipu1_1VirtId;
124     }
126     if (mod.ipu2_0ProcId != MultiProc.INVALIDID) {
127         mod.procIdTable[mod.ipu2_0ProcId] = ipu2_0VirtId;
128     }
129     else {
130         /* IPU2 not smp */
131         mod.ipu2_0ProcId = MultiProc.getIdMeta("IPU2-0");
133         if (mod.ipu2_0ProcId != MultiProc.INVALIDID) {
134             mod.procIdTable[mod.ipu2_0ProcId] = ipu2_0VirtId;
135         }
136     }
138     if (mod.ipu2_1ProcId != MultiProc.INVALIDID) {
139         mod.procIdTable[mod.ipu2_1ProcId] = ipu2_1VirtId;
140     }
142     if (mod.hostProcId != MultiProc.INVALIDID) {
143         mod.procIdTable[mod.hostProcId] = hostVirtId;
144     }
147 /*
148  * Function to generate mailbox table
149  */
150 function generateTable(InterruptCore)
152     var SYS_MBX5_OFFSET = 0;
153     var SYS_MBX6_OFFSET = 1;
154     var SYS_MBX7_OFFSET = 2;
155     var SYS_MBX8_OFFSET = 3;
156     var eveMbx2BaseIdx = 2;
158     var index;
159     var subMbxIdx;
160     var tableEntry;
161     var mbxUserIdx;
162     var mbxBaseAddrIdx;
164     /*
165      * Each entry in the mailbox table stores 3 indexes.
166      * The breakup of each entry is shown below:
167      * Entry format : 0xAAAABBCC
168      *         AAAA : Mailbox base address table index
169      *           BB : Mailbox User Id
170      *           CC : Sub-mailbox index
171      *
172      * In order to lookup the User Id, Sub-mailbox Index and mailbox base
173      * address for a given src and dst core from the mailboxTable, the
174      * procedure shown below is followed:
175      *     1. Find the right entry for the given src and dst core.
176      *        mailboxTable index is given by:
177      *            Index = (src * NumCores) + dst
178      *     2. Mbx BaseAddr Index = mailboxTable[Index] >> 16
179      *     2. dst Mailbox UserId = (mailboxTable[Index] >> 8) & 0xFF
180      *     3. Sub-Mailbox Index  = mailboxTable[Index] & 0xFF
181      */
183     /*
184      * 'i' is src core index, and
185      * 'j' is dst core index
186      */
187     for (var i = 0; i < InterruptCore.NUM_CORES; i++) {
188         for (var j = 0; j < InterruptCore.NUM_CORES; j++) {
190             /* init mailboxTable */
191             index = (i * InterruptCore.NUM_CORES) + j;
192             InterruptCore.mailboxTable[index] = -1;
194             /* EVE Internal Mailbox 2 */
195             if ((i < InterruptCore.NUM_EVES) && (j < InterruptCore.NUM_EVES)) {
197                 /* Generate 3 masks forming a single table entry */
198                 mbxBaseAddrIdx = ((j * 3) + eveMbx2BaseIdx) << 16;
200                 /* Determined based on the send remote receive local
201                  * methodology being followed for EVE-to-EVE communication.
202                  */
203                 mbxUserIdx = 0 << 8;
204                 subMbxIdx = i;
206                 tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
207                 InterruptCore.mailboxTable[index] = tableEntry;
208                 continue;
209             }
211             /* EVE Internal Mailbox 0/1 */
212             if ((i < InterruptCore.NUM_EVES) || (j < InterruptCore.NUM_EVES)) {
213                 if (i < InterruptCore.NUM_EVES) {
214                     mbxBaseAddrIdx = ((i * 3) + (j % 2)) << 16;
216                     if ((j == dsp1VirtId) || (j == dsp2VirtId)) {
217                         /* Destination is DSP1 or DSP2 */
218                         mbxUserIdx = 1 << 8;
219                         subMbxIdx = 0;
220                     }
221                     else if ((j == ipu1_0VirtId) || (j == ipu2_0VirtId)) {
222                         /* Destination is IPU1-0 or IPU2-0 */
223                         mbxUserIdx = 2 << 8;
224                         subMbxIdx = 2;
225                     }
226                     else if ((j == ipu1_1VirtId) || (j == hostVirtId) ||
227                         (j == ipu2_1VirtId)) {
228                         /* Destination is Host or IPU1-1 */
229                         mbxUserIdx = 3 << 8;
230                         subMbxIdx = 4;
232                         if (j == ipu2_1VirtId) {
233                             mbxBaseAddrIdx = ((i * 3) + ((j - 1) % 2)) << 16;
234                         }
235                     }
237                     tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
238                     InterruptCore.mailboxTable[index] = tableEntry;
239                     continue;
240                 }
241                 else if (j < InterruptCore.NUM_EVES) {
242                     mbxBaseAddrIdx = ((j * 3) + (i % 2)) << 16;
243                     mbxUserIdx = 0 << 8; /* destination is always EVE */
245                     if ((i == dsp1VirtId) || (i == dsp2VirtId)) {
246                         /* Source is DSP1 or DSP2 */
247                         subMbxIdx = 1;
248                     }
249                     else if ((i == ipu1_0VirtId) || (i == ipu2_0VirtId)) {
250                         /* Source is IPU1-0 or IPU2-0 */
251                         subMbxIdx = 3;
252                     }
253                     else if ((i == ipu1_1VirtId) || (i == hostVirtId) ||
254                         (i == ipu2_1VirtId)) {
255                         /* Source is Host or IPU1-1*/
256                         subMbxIdx = 5;
258                         if (i == ipu2_1VirtId) {
259                             mbxBaseAddrIdx = ((j * 3) + ((i - 1) % 2)) << 16;
260                         }
261                     }
263                     tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
264                     InterruptCore.mailboxTable[index] = tableEntry;
265                     continue;
266                 }
267             }
269             /* System Mailbox 5 */
270             /* For communication between HOST<->DSP1/IPU1 */
271             if (((i == dsp1VirtId) || (i == ipu1_0VirtId) ||
272                 (i == hostVirtId) || (i == ipu1_1VirtId)) &&
273                 ((j == dsp1VirtId) || (j == ipu1_0VirtId) ||
274                 (j == hostVirtId) || (j == ipu1_1VirtId))) {
276                 mbxBaseAddrIdx = ((InterruptCore.NUM_EVES * 3) +
277                                   SYS_MBX5_OFFSET) << 16;
279                 /* These combinations do not need mailbox */
280                 if ((i == j) ||
281                     (i == ipu1_0VirtId && j == ipu1_1VirtId) ||
282                     (i == ipu1_1VirtId && j == ipu1_0VirtId)) {
283                     continue;
284                 }
286                 if (j == dsp1VirtId) {
287                     mbxUserIdx = 0;
288                     if (i == ipu1_0VirtId) {
289                         subMbxIdx = 3;
290                     }
291                     else if (i == hostVirtId) {
292                         subMbxIdx = 5;
293                     }
294                     else if (i == ipu1_1VirtId) {
295                         subMbxIdx = 8;
296                     }
297                 }
298                 else if (j == ipu1_0VirtId) {
299                     mbxUserIdx = 1 << 8;
300                     if (i == dsp1VirtId) {
301                         subMbxIdx = 0;
302                     }
303                     else if (i == hostVirtId) {
304                         subMbxIdx = 6;
305                     }
306                 }
307                 else if (j == hostVirtId) {
308                     mbxUserIdx = 2 << 8;
309                     if (i == dsp1VirtId) {
310                         subMbxIdx = 1;
311                     }
312                     else if (i == ipu1_0VirtId) {
313                         subMbxIdx = 4;
314                     }
315                     else if (i == ipu1_1VirtId) {
316                         subMbxIdx = 9;
317                     }
318                 }
319                 else if (j == ipu1_1VirtId) {
320                     mbxUserIdx = 3 << 8;
321                     if (i == dsp1VirtId) {
322                         subMbxIdx = 2;
323                     }
324                     else if (i == hostVirtId) {
325                         subMbxIdx = 7;
326                     }
327                 }
329                 tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
330                 InterruptCore.mailboxTable[index] = tableEntry;
331                 continue;
332             }
334             /* System Mailbox 6 */
335             /* For communication between HOST<->DSP2/IPU2 */
336             if (((i == dsp2VirtId) || (i == ipu2_0VirtId) ||
337                 (i == hostVirtId) || (i == ipu2_1VirtId)) &&
338                 ((j == dsp2VirtId) || (j == ipu2_0VirtId) ||
339                 (j == hostVirtId) || (j ==ipu2_1VirtId))) {
341                 mbxBaseAddrIdx = ((InterruptCore.NUM_EVES * 3) +
342                                    SYS_MBX6_OFFSET) << 16;
344                 /* These combinations do not need mailbox */
345                 if ((i == j) ||
346                     (i == ipu2_0VirtId && j == ipu2_1VirtId) ||
347                     (i == ipu2_1VirtId && j == ipu2_0VirtId)) {
348                     continue;
349                 }
351                 if (j == dsp2VirtId) {
352                     mbxUserIdx = 0;
353                     if (i == ipu2_0VirtId) {
354                         subMbxIdx = 3;
355                     }
356                     else if (i == hostVirtId) {
357                         subMbxIdx = 5;
358                     }
359                     else if (i == ipu2_1VirtId) {
360                         subMbxIdx = 8;
361                     }
362                 }
363                 else if (j == ipu2_0VirtId) {
364                     mbxUserIdx = 1 << 8;
365                     if (i == dsp2VirtId) {
366                         subMbxIdx = 0;
367                     }
368                     else if (i == hostVirtId) {
369                         subMbxIdx = 6;
370                     }
371                 }
372                 else if (j == hostVirtId) {
373                     mbxUserIdx = 2 << 8;
374                     if (i == dsp2VirtId) {
375                         subMbxIdx = 1;
376                     }
377                     else if (i == ipu2_0VirtId) {
378                         subMbxIdx = 4;
379                     }
380                     else if (i == ipu2_1VirtId) {
381                         subMbxIdx = 9;
382                     }
383                 }
384                 else if (j == ipu2_1VirtId) {
385                     mbxUserIdx = 3 << 8;
386                     if (i == dsp2VirtId) {
387                         subMbxIdx = 2;
388                     }
389                     else if (i == hostVirtId) {
390                         subMbxIdx = 7;
391                     }
392                 }
394                 tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
395                 InterruptCore.mailboxTable[index] = tableEntry;
396                 continue;
397             }
399             /*  System Mailbox 7
400              *  This is for communication between DSP1/IPU1_0<->DSP2/IPU2-0
401              *  but not DSP1<->IPU1-0 or DSP<->IPU2-0. Those communication
402              *  lines have already been established above.
403              */
404             if (((i == dsp1VirtId) || (i == dsp2VirtId)     ||
405                 (i == ipu1_0VirtId) || (i == ipu2_0VirtId)) &&
406                 ((j == dsp1VirtId) || (j == dsp2VirtId)     ||
407                 (j == ipu1_0VirtId) || (j == ipu2_0VirtId))) {
409                 mbxBaseAddrIdx = ((InterruptCore.NUM_EVES * 3) +
410                                   SYS_MBX7_OFFSET) << 16;
412                 /* DSP1/IPU1 and DSP2/IPU2 already established previously */
413                 if (i == j) {
414                     continue;
415                 }
416                 if ((i == dsp1VirtId && j == ipu1_0VirtId) ||
417                     (i == dsp2VirtId && j == ipu2_0VirtId)) {
418                     continue;
419                 }
421                 if (j == dsp1VirtId) {
422                     mbxUserIdx = 0;
423                     if (i == dsp2VirtId) {
424                         subMbxIdx = 2;
425                     }
426                     else if (i == ipu2_0VirtId) {
427                         subMbxIdx = 6;
428                     }
429                 }
430                 else if (j == dsp2VirtId) {
431                     mbxUserIdx = 1 << 8;
432                     if (i == dsp1VirtId) {
433                         subMbxIdx = 0;
434                     }
435                     else if (i == ipu1_0VirtId) {
436                         subMbxIdx = 4;
437                     }
438                 }
439                 else if (j == ipu1_0VirtId) {
440                     mbxUserIdx = 2 << 8;
441                     if (i == dsp2VirtId) {
442                         subMbxIdx = 3;
443                     }
444                     else if (i == ipu2_0VirtId) {
445                         subMbxIdx = 7;
446                     }
447                 }
448                 else if (j == ipu2_0VirtId) {
449                     mbxUserIdx = 3 << 8;
450                     if (i == dsp1VirtId) {
451                         subMbxIdx = 1;
452                     }
453                     else if (i == ipu1_0VirtId) {
454                         subMbxIdx = 5;
455                     }
456                 }
458                 tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
459                 InterruptCore.mailboxTable[index] = tableEntry;
460             }
462             /*  System Mailbox 8
463              *  This is required only if one of the IPU is running
464              *  NON-SMP BIOS. This is for the second core of
465              *  IPU1-1<->DSP2/IPU2 or second core of IPU2-1<->DSP1/IPU1.
466              */
467             if (((i == dsp1VirtId) || (i == dsp2VirtId) ||
468                 (i == ipu1_0VirtId) || (i == ipu1_1VirtId) ||
469                 (i == ipu2_0VirtId) || (i == ipu2_1VirtId)) &&
470                 ((j == dsp1VirtId) || (j == dsp2VirtId) ||
471                 (j == ipu1_0VirtId) || (j == ipu1_1VirtId) ||
472                 (j == ipu2_0VirtId) || (j == ipu2_1VirtId))) {
474                 mbxBaseAddrIdx = ((InterruptCore.NUM_EVES * 3) +
475                                   SYS_MBX8_OFFSET) << 16;
477                 /* Don't set any previously established lines */
478                 if (i == j) {
479                     continue;
480                 }
482                 if ((i == dsp1VirtId) && (j != ipu2_1VirtId)) {
483                     continue;
484                 }
486                 if ((i == dsp2VirtId) && (j != ipu1_1VirtId)) {
487                     continue;
488                 }
490                 if ((i == ipu1_0VirtId) && (j != ipu2_1VirtId)) {
491                     continue;
492                 }
494                 if ((i == ipu1_1VirtId) &&
495                     ((j != dsp2VirtId) && (j != ipu2_0VirtId))) {
496                     continue;
497                 }
499                 if ((i == ipu2_0VirtId) && (j != ipu1_1VirtId)) {
500                     continue;
501                 }
503                 if ((i == ipu2_1VirtId) &&
504                     ((j != dsp1VirtId) && (j != ipu1_0VirtId))) {
505                     continue;
506                 }
508                 /* Set new communication lines */
509                 if (j == dsp1VirtId) {
510                     /* only required when IPU2 is NON-SMP BIOS */
511                     mbxUserIdx = 0;
512                     if (i == ipu2_1VirtId) {
513                         subMbxIdx = 2;
514                     }
515                 }
516                 else if (j == dsp2VirtId) {
517                     /* only required when IPU1 is NON-SMP BIOS */
518                     mbxUserIdx = 1 << 8;
519                     if (i == ipu1_1VirtId) {
520                         subMbxIdx = 1;
521                     }
522                 }
523                 else if (j == ipu1_0VirtId) {
524                     /* only required when IPU2 is NON-SMP BIOS */
525                     mbxUserIdx = 2 << 8;
526                     if (i == ipu2_1VirtId) {
527                         subMbxIdx = 3;
528                     }
529                 }
530                 else if (j == ipu1_1VirtId) {
531                     /* only required when IPU1 is NON-SMP BIOS */
532                     mbxUserIdx = 2 << 8;
533                     if (i == dsp2VirtId) {
534                         subMbxIdx = 0;
535                     }
536                     else if (i == ipu2_0VirtId) {
537                         subMbxIdx = 3;
538                     }
539                 }
540                 else if (j == ipu2_0VirtId) {
541                     /* only required when IPU1 is NON-SMP BIOS */
542                     mbxUserIdx = 3 << 8;
543                     if (i == ipu1_1VirtId) {
544                         subMbxIdx = 2;
545                     }
546                 }
547                 else if (j == ipu2_1VirtId) {
548                     /* only required when IPU2 is NON-SMP BIOS */
549                     mbxUserIdx = 3 << 8;
550                     if (i == dsp1VirtId) {
551                         subMbxIdx = 0;
552                     }
553                     else if (i == ipu1_0VirtId) {
554                         subMbxIdx = 1;
555                     }
556                 }
558                 tableEntry = mbxBaseAddrIdx | mbxUserIdx | subMbxIdx;
559                 InterruptCore.mailboxTable[index] = tableEntry;
560             }
561         }
562     }
564     /* added mailbox for NotifyDriverMbx support */
565     index = (ipu1_0VirtId * InterruptCore.NUM_CORES) + ipu1_1VirtId;
566     InterruptCore.mailboxTable[index] = 15 << 16 | 2 << 8 | 4;
568     index = (ipu1_1VirtId * InterruptCore.NUM_CORES) + ipu1_0VirtId;
569     InterruptCore.mailboxTable[index] = 14 << 16 | 2 << 8 | 8;