summaryrefslogtreecommitdiffstats
path: root/src/sbefw/core/sbeSecureMemRegionManager.H
blob: 1d5fc4bda540bc5d5fcf541a992deca56159f862 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/sbefw/core/sbeSecureMemRegionManager.H $                  */
/*                                                                        */
/* OpenPOWER sbe Project                                                  */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2017                             */
/*                                                                        */
/*                                                                        */
/* Licensed under the Apache License, Version 2.0 (the "License");        */
/* you may not use this file except in compliance with the License.       */
/* You may obtain a copy of the License at                                */
/*                                                                        */
/*     http://www.apache.org/licenses/LICENSE-2.0                         */
/*                                                                        */
/* Unless required by applicable law or agreed to in writing, software    */
/* distributed under the License is distributed on an "AS IS" BASIS,      */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
/* implied. See the License for the specific language governing           */
/* permissions and limitations under the License.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
#pragma once

#include <stdint.h>
#include <stddef.h>
#include "sbe_sp_intf.H"

enum class memRegionMode:uint8_t
{
    READ = 0x01,
    WRITE = 0x02,
};

// Structure to define a mem region
typedef struct
{
    uint64_t startAddress;
    uint32_t size;
    uint32_t mode;
} secureMemRegion_t;

// OCC SRAM Command buffer
constexpr uint64_t OCC_CMD_ADDR = 0xFFFBE000ull;
constexpr uint32_t OCC_CMD_SIZE = 0xFFFBEFFF - 0xFFFBE000;
// OCC SRAM Response buffer
constexpr uint64_t OCC_RESP_ADDR = 0xFFFBF000ull;
constexpr uint32_t OCC_RESP_SIZE = 0xFFFBFFFF- 0xFFFBF000;

class SBESecureMemRegionManager
{
    protected:
    secureMemRegion_t *iv_memRegions;
    const size_t iv_maxRegions;
    size_t iv_regionsOpenCnt;

    /*
     * @brief getPartialRegionSize - get the overlapping region
     *                               if it exists.
     *                               Also if the overlap is from the beginning,
     *                               first region is returned
     *
     *
     * @param[in] i_region           region to check for overlap
     *
     * @return overlapping region
     */
    secureMemRegion_t getPartialRegionSize(const secureMemRegion_t i_region);

    public:
    SBESecureMemRegionManager(secureMemRegion_t *i_regions,
                              size_t i_maxRegions):
                              iv_memRegions(i_regions),
                              iv_maxRegions(i_maxRegions)
    {
    }

    // Disable copy constructors
    SBESecureMemRegionManager(const SBESecureMemRegionManager&) = delete;
    SBESecureMemRegionManager& operator=(const SBESecureMemRegionManager&) = delete;

    /*
     * @brief add - Open a new memory region
     *
     * @param[in] i_startAddr  Start address of the memory region
     * @param[in] i_size       Size of the memory region
     * @param[in] i_mode       Bit mapped access mode of the memory region
     *
     * @return SBE secondary RC
     */
    sbeSecondaryResponse add(const uint64_t i_startAddr,
                             const uint32_t i_size,
                             const uint8_t i_mode);
    /*
     * @brief remove - Close a memory region
     *
     * @param[in] i_startAddr  Start address of the memory region
     *
     * @return SBE secondary RC
     */
    sbeSecondaryResponse remove(const uint64_t i_startAddr);
    /*
     * @brief isAccessAllowed - Check if the access is allowed
     *
     * @param[in] i_region     region to check the access for
     *
     * @return SBE secondary RC
     */
    sbeSecondaryResponse isAccessAllowed(secureMemRegion_t i_region);

    /*
     * @brief closeAllRegions - close all non-secure regions
     */
    void closeAllRegions()
    {
        iv_regionsOpenCnt = 0;
    }
};

class SBEOccSramSecMemRegionManager : public SBESecureMemRegionManager
{
    public:
        SBEOccSramSecMemRegionManager(secureMemRegion_t *i_regions,
                                  size_t i_maxRegions):
        SBESecureMemRegionManager(i_regions,
                                  i_maxRegions)
        {
            add(OCC_CMD_ADDR,
                OCC_CMD_SIZE,
                static_cast<uint8_t>( memRegionMode::WRITE) |
                static_cast<uint8_t>(memRegionMode::READ));
            add(OCC_RESP_ADDR,
                OCC_RESP_SIZE,
                static_cast<uint8_t>(memRegionMode::READ));
        }

        // Disable copy constructors
        SBEOccSramSecMemRegionManager(const SBEOccSramSecMemRegionManager&) = delete;
        SBEOccSramSecMemRegionManager& operator=(const SBEOccSramSecMemRegionManager&) = delete;
        // Disable delete functions
        sbeSecondaryResponse remove(const uint64_t i_startAddr) = delete;
        void closeAllRegions() = delete;

};

extern SBESecureMemRegionManager mainStoreSecMemRegionManager;
extern SBEOccSramSecMemRegionManager occSramSecRegionManager;
OpenPOWER on IntegriCloud