0af963d6a5f36eb165d6a6838e6ee6bb8019ffd6
[processor-sdk/open-amp.git] / lib / system / generic / machine / zynq7 / machine_system.c
1 /*
2  * Copyright (c) 2014, Mentor Graphics Corporation
3  * All rights reserved.
4  *
5  * Copyright (c) 2015 Xilinx, Inc. All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright notice,
11  *    this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright notice,
13  *    this list of conditions and the following disclaimer in the documentation
14  *    and/or other materials provided with the distribution.
15  * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 #include <stdio.h>
32 #include <string.h>
33 #include "baremetal.h"
34 #include "machine_system.h"
35 #include "openamp/env.h"
37 static inline unsigned int get_cpu_id_arm(void)
38 {
39         unsigned long cpu_id = 0;
41         asm volatile ("MRC p15 ,"
42                       "0," "%0," "c0," "c0," "5":[cpu_id] "=&r"(cpu_id)
43                       : /* No inputs */ );
45         /*
46          * Return cpu id to caller, extract last two bits from Multiprocessor
47          * Affinity Register */
48         return (cpu_id & 0x03);
49 }
51 int platform_interrupt_enable(unsigned int vector_id, unsigned int polarity,
52                               unsigned int priority)
53 {
54         unsigned long reg_offset;
55         unsigned long bit_shift;
56         unsigned long temp32 = 0;
57         unsigned long targ_cpu;
59         temp32 = get_cpu_id_arm();
61         /* Determine the necessary bit shift in this target / priority register
62            for this interrupt vector ID */
63         bit_shift = ((vector_id) % 4) * 8;
65         /* Build a target value based on the bit shift calculated above and the CPU core
66            that this code is executing on */
67         targ_cpu = (1 << temp32) << bit_shift;
69         /* Determine the Global interrupt controller target / priority register
70            offset for this interrupt vector ID
71            NOTE:  Each target / priority register supports 4 interrupts */
72         reg_offset = ((vector_id) / 4) * 4;
74         /* Read-modify-write the priority register for this interrupt */
75         temp32 = MEM_READ32(INT_GIC_DIST_BASE + INT_GIC_DIST_PRI + reg_offset);
77         /* Set new priority. */
78         temp32 |= (priority << (bit_shift + 4));
79         MEM_WRITE32(INT_GIC_DIST_BASE + INT_GIC_DIST_PRI + reg_offset, temp32);
81         /* Read-modify-write the target register for this interrupt to allow this
82            cpu to accept this interrupt */
83         temp32 =
84             MEM_READ32(INT_GIC_DIST_BASE + INT_GIC_DIST_TARGET + reg_offset);
85         temp32 |= targ_cpu;
86         MEM_WRITE32(INT_GIC_DIST_BASE + INT_GIC_DIST_TARGET + reg_offset,
87                     temp32);
89         /* Determine the Global interrupt controller enable set register offset
90            for this vector ID
91            NOTE:  There are 32 interrupts in each enable set register */
92         reg_offset = (vector_id / 32) * 4;
94         /* Write to the appropriate bit in the enable set register for this
95            vector ID to enable the interrupt */
97         temp32 = (1UL << (vector_id - (reg_offset * 0x08)));
98         MEM_WRITE32(INT_GIC_DIST_BASE + INT_GIC_DIST_ENABLE_SET + reg_offset,
99                     temp32);
101         /* Return the vector ID */
102         return (vector_id);
105 int platform_interrupt_disable(unsigned int vector_id)
107         unsigned long reg_offset;
108         unsigned long bit_shift;
109         unsigned long temp32 = 0;
110         unsigned long targ_cpu;
112         temp32 = get_cpu_id_arm();
114         /* Determine the Global interrupt controller enable set register offset
115            for this vector ID
116            NOTE:  There are 32 interrupts in each enable set register */
117         reg_offset = (vector_id / 32) * 4;
119         /* Write to the appropriate bit in the enable clear register for this
120            vector ID to disable the interrupt */
122         MEM_WRITE32(INT_GIC_DIST_BASE + INT_GIC_DIST_ENABLE_CLEAR + reg_offset,
123                     (1UL << (vector_id - (reg_offset * 0x08))));
125         /* Determine the Global interrupt controller target register offset for
126            this interrupt vector ID
127            NOTE:  Each target register supports 4 interrupts */
128         reg_offset = (vector_id / 4) * 4;
130         /* Determine the necessary bit shift in this target register for this
131            vector ID */
132         bit_shift = (vector_id % 4) * 8;
134         /* Build a value based on the bit shift calculated above and the CPU core
135            that this code is executing on */
136         targ_cpu = (1 << temp32) << bit_shift;
138         /* Read-modify-write the target register for this interrupt and remove this cpu from
139            accepting this interrupt */
140         temp32 =
141             MEM_READ32(INT_GIC_DIST_BASE + INT_GIC_DIST_TARGET + reg_offset);
142         temp32 &= ~targ_cpu;
144         MEM_WRITE32(INT_GIC_DIST_BASE + INT_GIC_DIST_TARGET + reg_offset,
145                     temp32);
147         /* Return the vector ID */
148         return (vector_id);
151 int old_value = 0;
153 void restore_global_interrupts()
155         ARM_AR_INT_BITS_SET(old_value);
158 void disable_global_interrupts()
160         int value = 0;
161         ARM_AR_INT_BITS_GET(&value);
162         if (value != old_value) {
163                 ARM_AR_INT_BITS_SET(ARM_AR_INTERRUPTS_DISABLE_BITS);
164                 old_value = value;
165         }
168 void platform_map_mem_region(unsigned int vrt_addr, unsigned int phy_addr,
169                              unsigned int size, unsigned int flags)
171         int is_mem_mapped = 0;
172         int cache_type = 0;
174         if ((flags & (0x0f << 4)) == MEM_MAPPED) {
175                 is_mem_mapped = 1;
176         }
178         if ((flags & 0x0f) == WB_CACHE) {
179                 cache_type = WRITEBACK;
180         } else if ((flags & 0x0f) == WT_CACHE) {
181                 cache_type = WRITETHROUGH;
182         } else {
183                 cache_type = NOCACHE;
184         }
186         arm_ar_map_mem_region(vrt_addr, phy_addr, size, is_mem_mapped,
187                               cache_type);
190 void platform_cache_all_flush_invalidate()
192         ARM_AR_MEM_DCACHE_ALL_OP(1);
195 void platform_cache_disable()
197         ARM_AR_MEM_CACHE_DISABLE();
200 unsigned long platform_vatopa(void *addr)
202         return (((unsigned long)addr & (~(0x0fff << 20))) | (0x08 << 24));
205 void *platform_patova(unsigned long addr)
207         return ((void *)addr);