1 /******************************************************************************
2  *
3  * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by
4  * Analog Devices, Inc.),
5  * Copyright (C) 2023-2024 Analog Devices, Inc.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *     http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  ******************************************************************************/
20 
21 #ifndef LIBRARIES_PERIPHDRIVERS_SOURCE_CTB_CTB_REVA_H_
22 #define LIBRARIES_PERIPHDRIVERS_SOURCE_CTB_CTB_REVA_H_
23 
24 #include "ctb_reva_regs.h"
25 #include "trng_reva_regs.h"
26 
27 /* ************************************************************************* */
28 /* Definitions                                                           */
29 /* ************************************************************************* */
30 
31 typedef void (*mxc_ctb_reva_complete_cb_t)(void *req, int result);
32 
33 typedef enum {
34     MXC_CTB_REVA_FEATURE_DMA = 1 << 0,
35     MXC_CTB_REVA_FEATURE_ECC = 1 << 1,
36     MXC_CTB_REVA_FEATURE_CRC = 1 << 2,
37     MXC_CTB_REVA_FEATURE_HASH = 1 << 4,
38     MXC_CTB_REVA_FEATURE_CIPHER = 1 << 5,
39     MXC_CTB_REVA_FEATURE_TRNG = 1 << 6
40 } mxc_ctb_reva_features_t;
41 
42 /* ************************************************************************* */
43 /* DMA Definitions                                                           */
44 /* ************************************************************************* */
45 
46 struct _mxc_ctb_reva_dma_req_t {
47     uint8_t *sourceBuffer; ///< pointer to source data
48     uint8_t *destBuffer; ///< pointer to destination buffer
49     uint32_t length; ///< length of source data
50     mxc_ctb_reva_complete_cb_t callback; ///< Null callback indicates a blocking operation
51 } typedef mxc_ctb_reva_dma_req_t;
52 
53 typedef enum {
54     MXC_CTB_REVA_DMA_READ_FIFO_DMA = MXC_V_CTB_REVA_CTRL_RDSRC_DMAORAPB,
55     MXC_CTB_REVA_DMA_READ_FIFO_RNG = MXC_V_CTB_REVA_CTRL_RDSRC_RNG
56 } mxc_ctb_reva_dma_read_source_t;
57 
58 typedef enum {
59     MXC_CTB_REVA_DMA_WRITE_FIFO_CIPHER = MXC_V_CTB_REVA_CTRL_WRSRC_CIPHEROUTPUT,
60     MXC_CTB_REVA_DMA_WRITE_FIFO_READ_FIFO = MXC_V_CTB_REVA_CTRL_WRSRC_READFIFO,
61     MXC_CTB_REVA_DMA_WRITE_FIFO_NONE = MXC_V_CTB_REVA_CTRL_WRSRC_NONE
62 } mxc_ctb_reva_dma_write_source_t;
63 
64 /* ************************************************************************* */
65 /* ECC Definitions                                                           */
66 /* ************************************************************************* */
67 
68 struct _mxc_ctb_reva_ecc_req_t {
69     uint8_t *dataBuffer;
70     uint32_t dataLen;
71     uint32_t checksum;
72     mxc_ctb_reva_complete_cb_t callback;
73 } typedef mxc_ctb_reva_ecc_req_t;
74 
75 struct _mxc_ctb_reva_crc_req_t {
76     uint8_t *dataBuffer;
77     uint32_t dataLen;
78     uint32_t resultCRC;
79     mxc_ctb_reva_complete_cb_t callback;
80 } typedef mxc_ctb_reva_crc_req_t;
81 
82 typedef enum { MXC_CTB_REVA_CRC_LSB_FIRST, MXC_CTB_REVA_CRC_MSB_FIRST } mxc_ctb_reva_crc_bitorder_t;
83 
84 struct _mxc_ctb_reva_hash_req_t {
85     uint8_t *msg;
86     uint32_t len;
87     uint8_t *hash;
88     mxc_ctb_reva_complete_cb_t callback;
89 } typedef mxc_ctb_reva_hash_req_t;
90 
91 typedef enum {
92     MXC_CTB_REVA_HASH_DIS = MXC_V_CTB_REVA_HASH_CTRL_HASH_DIS, // Disable
93     MXC_CTB_REVA_HASH_SHA1 = MXC_V_CTB_REVA_HASH_CTRL_HASH_SHA1, // Select SHA1
94     MXC_CTB_REVA_HASH_SHA224 = MXC_V_CTB_REVA_HASH_CTRL_HASH_SHA224, // Select SHA224
95     MXC_CTB_REVA_HASH_SHA256 = MXC_V_CTB_REVA_HASH_CTRL_HASH_SHA256, // Select SHA256
96     MXC_CTB_REVA_HASH_SHA384 = MXC_V_CTB_REVA_HASH_CTRL_HASH_SHA384, // Select SHA384
97     MXC_CTB_REVA_HASH_SHA512 = MXC_V_CTB_REVA_HASH_CTRL_HASH_SHA512 // Select SHA384
98 } mxc_ctb_reva_hash_func_t;
99 
100 typedef enum {
101     MXC_CTB_REVA_HASH_SOURCE_INFIFO = 0,
102     MXC_CTB_REVA_HASH_SOURCE_OUTFIFO = 1
103 } mxc_ctb_reva_hash_source_t;
104 
105 /* ************************************************************************* */
106 /* Cipher Definitions                                                           */
107 /* ************************************************************************* */
108 
109 struct _mxc_ctb_reva_cipher_req_t {
110     uint8_t *plaintext;
111     uint32_t ptLen;
112     uint8_t *iv;
113     uint8_t *ciphertext;
114     mxc_ctb_reva_complete_cb_t callback;
115 } typedef mxc_ctb_reva_cipher_req_t;
116 
117 typedef enum {
118     MXC_CTB_REVA_MODE_ECB = MXC_V_CTB_REVA_CIPHER_CTRL_MODE_ECB, ///< Electronic Code Book
119     MXC_CTB_REVA_MODE_CBC = MXC_V_CTB_REVA_CIPHER_CTRL_MODE_CBC, ///< Cipher Block Chaining
120     MXC_CTB_REVA_MODE_CFB = MXC_V_CTB_REVA_CIPHER_CTRL_MODE_CFB, ///< Cipher Feedback
121     MXC_CTB_REVA_MODE_CTR = MXC_V_CTB_REVA_CIPHER_CTRL_MODE_CTR, ///< Counter
122 } mxc_ctb_reva_cipher_mode_t;
123 
124 typedef enum {
125     MXC_CTB_REVA_CIPHER_DIS = MXC_V_CTB_REVA_CIPHER_CTRL_CIPHER_DIS, ///< Disable
126     MXC_CTB_REVA_CIPHER_AES128 = MXC_V_CTB_REVA_CIPHER_CTRL_CIPHER_AES128, ///< Select AES-128
127     MXC_CTB_REVA_CIPHER_AES192 = MXC_V_CTB_REVA_CIPHER_CTRL_CIPHER_AES192, ///< Select AES-192
128     MXC_CTB_REVA_CIPHER_AES256 = MXC_V_CTB_REVA_CIPHER_CTRL_CIPHER_AES256, ///< Select AES-256
129     MXC_CTB_REVA_CIPHER_DES = MXC_V_CTB_REVA_CIPHER_CTRL_CIPHER_DES, ///< Select DES
130     MXC_CTB_REVA_CIPHER_TDES = MXC_V_CTB_REVA_CIPHER_CTRL_CIPHER_TDES ///< Select TDES
131 } mxc_ctb_reva_cipher_t;
132 
133 typedef enum {
134     MXC_CTB_REVA_CIPHER_KEY_SOFTWARE = 0,
135     MXC_CTB_REVA_CIPHER_KEY_AES_KEY2 = 2,
136     MXC_CTB_REVA_CIPHER_KEY_AES_KEY3 = 3
137 } mxc_ctb_reva_cipher_key_t;
138 
139 typedef enum {
140     MXC_CTB_REVA_CIPHER_ENCRYPTION,
141     MXC_CTB_REVA_CIPHER_DECRYPTION
142 } mxc_ctb_reva_cipher_operation_t;
143 
144 /* ************************************************************************* */
145 /* Global Control/Configuration functions                                    */
146 /* ************************************************************************* */
147 
148 int MXC_CTB_RevA_Init(mxc_ctb_reva_regs_t *ctb_regs, uint32_t features);
149 void MXC_CTB_RevA_EnableInt(mxc_ctb_reva_regs_t *ctb_regs);
150 void MXC_CTB_RevA_DisableInt(mxc_ctb_reva_regs_t *ctb_regs);
151 int MXC_CTB_RevA_Ready(mxc_ctb_reva_regs_t *ctb_regs);
152 void MXC_CTB_RevA_DoneClear(mxc_ctb_reva_regs_t *ctb_regs, uint32_t features);
153 uint32_t MXC_CTB_RevA_Done(mxc_ctb_reva_regs_t *ctb_regs);
154 void MXC_CTB_RevA_Reset(uint32_t features);
155 void MXC_CTB_RevA_CacheInvalidate(void);
156 int MXC_CTB_RevA_Shutdown(uint32_t features);
157 uint32_t MXC_CTB_RevA_GetEnabledFeatures(void);
158 void MXC_CTB_RevA_Handler(mxc_trng_reva_regs_t *trng);
159 
160 /************************************/
161 /* CTB DMA - Used for all features  */
162 /************************************/
163 
164 void MXC_CTB_RevA_DMA_SetReadSource(mxc_ctb_reva_regs_t *ctb_regs,
165                                     mxc_ctb_reva_dma_read_source_t source);
166 mxc_ctb_reva_dma_read_source_t MXC_CTB_RevA_DMA_GetReadSource(mxc_ctb_reva_regs_t *ctb_regs);
167 void MXC_CTB_RevA_DMA_SetWriteSource(mxc_ctb_reva_regs_t *ctb_regs,
168                                      mxc_ctb_reva_dma_write_source_t source);
169 mxc_ctb_reva_dma_write_source_t MXC_CTB_RevA_DMA_GetWriteSource(mxc_ctb_reva_regs_t *ctb_regs);
170 void MXC_CTB_RevA_DMA_SetSource(mxc_ctb_reva_regs_t *ctb_regs, uint8_t *source);
171 void MXC_CTB_RevA_DMA_SetDestination(mxc_ctb_reva_regs_t *ctb_regs, uint8_t *dest);
172 int MXC_CTB_RevA_DMA_SetupOperation(mxc_ctb_reva_dma_req_t *req);
173 int MXC_CTB_RevA_DMA_DoOperation(mxc_ctb_reva_dma_req_t *req);
174 void MXC_CTB_RevA_DMA_StartTransfer(mxc_ctb_reva_regs_t *ctb_regs, uint32_t length);
175 
176 /* ************************************************************************* */
177 /* True Random Number Generator (TRNG) functions                             */
178 /* ************************************************************************* */
179 
180 int MXC_CTB_RevA_TRNG_RandomInt(mxc_trng_reva_regs_t *trng);
181 int MXC_CTB_RevA_TRNG_Random(uint8_t *data, uint32_t len);
182 void MXC_CTB_RevA_TRNG_RandomAsync(mxc_trng_reva_regs_t *trng, uint8_t *data, uint32_t len,
183                                    mxc_ctb_reva_complete_cb_t callback);
184 
185 /* ************************************************************************* */
186 /* Error Correction Code (ECC) functions                                     */
187 /* ************************************************************************* */
188 
189 /*******************************/
190 /* Low Level Functions         */
191 /*******************************/
192 
193 void MXC_CTB_RevA_ECC_Enable(mxc_ctb_reva_regs_t *ctb_regs);
194 void MXC_CTB_RevA_ECC_Disable(mxc_ctb_reva_regs_t *ctb_regs);
195 uint32_t MXC_CTB_RevA_ECC_GetResult(mxc_ctb_reva_regs_t *ctb_regs);
196 
197 /*******************************/
198 /* High Level Functions        */
199 /*******************************/
200 
201 int MXC_CTB_RevA_ECC_Compute(mxc_ctb_reva_ecc_req_t *req);
202 int MXC_CTB_RevA_ECC_ErrorCheck(mxc_ctb_reva_ecc_req_t *req);
203 void MXC_CTB_RevA_ECC_ComputeAsync(mxc_ctb_reva_ecc_req_t *req);
204 void MXC_CTB_RevA_ECC_ErrorCheckAsync(mxc_ctb_reva_ecc_req_t *req);
205 
206 /* ************************************************************************* */
207 /* Cyclic Redundancy Check (CRC) functions                                   */
208 /* ************************************************************************* */
209 
210 /*******************************/
211 /* Low Level Functions         */
212 /*******************************/
213 
214 void MXC_CTB_RevA_CRC_SetDirection(mxc_ctb_reva_regs_t *ctb_regs,
215                                    mxc_ctb_reva_crc_bitorder_t bitOrder);
216 mxc_ctb_reva_crc_bitorder_t MXC_CTB_RevA_CRC_GetDirection(mxc_ctb_reva_regs_t *ctb_regs);
217 void MXC_CTB_RevA_CRC_SetPoly(mxc_ctb_reva_regs_t *ctb_regs, uint32_t poly);
218 uint32_t MXC_CTB_RevA_CRC_GetPoly(mxc_ctb_reva_regs_t *ctb_regs);
219 uint32_t MXC_CTB_RevA_CRC_GetResult(mxc_ctb_reva_regs_t *ctb_regs);
220 void MXC_CTB_RevA_CRC_SetInitialValue(uint32_t seed);
221 void MXC_CTB_RevA_CRC_SetFinalXORValue(uint32_t xor);
222 
223 /*******************************/
224 /* High Level Functions        */
225 /*******************************/
226 
227 int MXC_CTB_RevA_CRC_Compute(mxc_ctb_reva_regs_t *ctb_regs, mxc_ctb_reva_crc_req_t *req);
228 void MXC_CTB_RevA_CRC_ComputeAsync(mxc_ctb_reva_regs_t *ctb_regs, mxc_ctb_reva_crc_req_t *req);
229 
230 /* ************************************************************************* */
231 /* Hash functions                                                            */
232 /* ************************************************************************* */
233 
234 /***********************/
235 /* Low Level Functions */
236 /***********************/
237 
238 void MXC_CTB_RevA_Hash_SetFunction(mxc_ctb_reva_regs_t *ctb_regs,
239                                    mxc_ctb_reva_hash_func_t function);
240 mxc_ctb_reva_hash_func_t MXC_CTB_RevA_Hash_GetFunction(mxc_ctb_reva_regs_t *ctb_regs);
241 void MXC_CTB_RevA_Hash_SetAutoPad(mxc_ctb_reva_regs_t *ctb_regs, int pad);
242 int MXC_CTB_RevA_Hash_GetAutoPad(mxc_ctb_reva_regs_t *ctb_regs);
243 void MXC_CTB_RevA_Hash_GetResult(mxc_ctb_reva_regs_t *ctb_regs, uint8_t *digest, int *len);
244 void MXC_CTB_RevA_Hash_SetMessageSize(mxc_ctb_reva_regs_t *ctb_regs, uint32_t size);
245 void MXC_CTB_RevA_Hash_SetSource(mxc_ctb_reva_regs_t *ctb_regs, mxc_ctb_reva_hash_source_t source);
246 mxc_ctb_reva_hash_source_t MXC_CTB_RevA_Hash_GetSource(mxc_ctb_reva_regs_t *ctb_regs);
247 void MXC_CTB_RevA_Hash_InitializeHash(mxc_ctb_reva_regs_t *ctb_regs);
248 
249 /************************/
250 /* High Level Functions */
251 /************************/
252 
253 int MXC_CTB_RevA_Hash_Compute(mxc_ctb_reva_hash_req_t *req);
254 void MXC_CTB_RevA_Hash_ComputeAsync(mxc_ctb_reva_hash_req_t *req);
255 
256 /* ************************************************************************* */
257 /* Cipher functions                                                          */
258 /* ************************************************************************* */
259 
260 /************************/
261 /* Low Level Functions  */
262 /************************/
263 
264 void MXC_CTB_RevA_Cipher_SetMode(mxc_ctb_reva_regs_t *ctb_regs, mxc_ctb_reva_cipher_mode_t mode);
265 mxc_ctb_reva_cipher_mode_t MXC_CTB_RevA_Cipher_GetMode(mxc_ctb_reva_regs_t *ctb_regs);
266 void MXC_CTB_RevA_Cipher_SetCipher(mxc_ctb_reva_regs_t *ctb_regs, mxc_ctb_reva_cipher_t cipher);
267 mxc_ctb_reva_cipher_t MXC_CTB_RevA_Cipher_GetCipher(mxc_ctb_reva_regs_t *ctb_regs);
268 void MXC_CTB_RevA_Cipher_SetKeySource(mxc_ctb_reva_regs_t *ctb_regs,
269                                       mxc_ctb_reva_cipher_key_t source);
270 mxc_ctb_reva_cipher_key_t MXC_CTB_RevA_Cipher_GetKeySource(mxc_ctb_reva_regs_t *ctb_regs);
271 void MXC_CTB_RevA_Cipher_LoadKey(mxc_ctb_reva_regs_t *ctb_regs);
272 void MXC_CTB_RevA_Cipher_SetOperation(mxc_ctb_reva_regs_t *ctb_regs,
273                                       mxc_ctb_reva_cipher_operation_t operation);
274 void MXC_CTB_RevA_Cipher_SetKey(mxc_ctb_reva_regs_t *ctb_regs, uint8_t *key, uint32_t len);
275 void MXC_CTB_RevA_Cipher_SetIV(mxc_ctb_reva_regs_t *ctb_regs, uint8_t *iv, uint32_t len);
276 void MXC_CTB_RevA_Cipher_GetIV(mxc_ctb_reva_regs_t *ctb_regs, uint8_t *ivOut, uint32_t len);
277 
278 /************************/
279 /* High Level Functions */
280 /************************/
281 
282 int MXC_CTB_RevA_Cipher_Encrypt(mxc_ctb_reva_cipher_req_t *req);
283 int MXC_CTB_RevA_Cipher_Decrypt(mxc_ctb_reva_cipher_req_t *req);
284 void MXC_CTB_RevA_Cipher_EncryptAsync(mxc_ctb_reva_cipher_req_t *req);
285 void MXC_CTB_RevA_Cipher_DecryptAsync(mxc_ctb_reva_cipher_req_t *req);
286 
287 #endif // LIBRARIES_PERIPHDRIVERS_SOURCE_CTB_CTB_REVA_H_
288