1 /* 2 * Copyright 2017-2021 NXP 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 * 6 */ 7 8 #ifndef _SEC_HW_SPECIFIC_H_ 9 #define _SEC_HW_SPECIFIC_H_ 10 11 #include "caam.h" 12 #include "sec_jr_driver.h" 13 14 /* DEFINES AND MACROS */ 15 16 /* Used to retry resetting a job ring in SEC hardware. */ 17 #define SEC_TIMEOUT 100000 18 19 /* 20 * Offset to the registers of a job ring. 21 *Is different for each job ring. 22 */ 23 #define CHAN_BASE(jr) ((phys_addr_t)(jr)->register_base_addr) 24 25 #define unlikely(x) __builtin_expect(!!(x), 0) 26 27 #define SEC_JOB_RING_IS_FULL(pi, ci, ring_max_size, ring_threshold) \ 28 ((((pi) + 1 + ((ring_max_size) - (ring_threshold))) & \ 29 (ring_max_size - 1)) == ((ci))) 30 31 #define SEC_CIRCULAR_COUNTER(x, max) (((x) + 1) & (max - 1)) 32 33 /* Struct representing various job ring registers */ 34 struct jobring_regs { 35 #ifdef NXP_SEC_BE 36 unsigned int irba_h; 37 unsigned int irba_l; 38 #else 39 unsigned int irba_l; 40 unsigned int irba_h; 41 #endif 42 unsigned int rsvd1; 43 unsigned int irs; 44 unsigned int rsvd2; 45 unsigned int irsa; 46 unsigned int rsvd3; 47 unsigned int irja; 48 #ifdef NXP_SEC_BE 49 unsigned int orba_h; 50 unsigned int orba_l; 51 #else 52 unsigned int orba_l; 53 unsigned int orba_h; 54 #endif 55 unsigned int rsvd4; 56 unsigned int ors; 57 unsigned int rsvd5; 58 unsigned int orjr; 59 unsigned int rsvd6; 60 unsigned int orsf; 61 unsigned int rsvd7; 62 unsigned int jrsta; 63 unsigned int rsvd8; 64 unsigned int jrint; 65 unsigned int jrcfg0; 66 unsigned int jrcfg1; 67 unsigned int rsvd9; 68 unsigned int irri; 69 unsigned int rsvd10; 70 unsigned int orwi; 71 unsigned int rsvd11; 72 unsigned int jrcr; 73 }; 74 75 /* Offsets representing common SEC Registers */ 76 #define SEC_REG_MCFGR_OFFSET 0x0004 77 #define SEC_REG_SCFGR_OFFSET 0x000C 78 #define SEC_REG_JR0ICIDR_MS_OFFSET 0x0010 79 #define SEC_REG_JR0ICIDR_LS_OFFSET 0x0014 80 #define SEC_REG_JR1ICIDR_MS_OFFSET 0x0018 81 #define SEC_REG_JR1ICIDR_LS_OFFSET 0x001C 82 #define SEC_REG_JR2ICIDR_MS_OFFSET 0x0020 83 #define SEC_REG_JR2ICIDR_LS_OFFSET 0x0024 84 #define SEC_REG_JR3ICIDR_MS_OFFSET 0x0028 85 #define SEC_REG_JR3ICIDR_LS_OFFSET 0x002C 86 #define SEC_REG_JRSTARTR_OFFSET 0x005C 87 #define SEC_REG_CTPR_MS_OFFSET 0x0FA8 88 89 /* Offsets representing various RNG registers */ 90 #define RNG_REG_RTMCTL_OFFSET 0x0600 91 #define RNG_REG_RTSDCTL_OFFSET 0x0610 92 #define RNG_REG_RTFRQMIN_OFFSET 0x0618 93 #define RNG_REG_RTFRQMAX_OFFSET 0x061C 94 #define RNG_REG_RDSTA_OFFSET 0x06C0 95 #define ALG_AAI_SH_SHIFT 4 96 97 /* SEC Registers Bitmasks */ 98 #define MCFGR_PS_SHIFT 16 99 #define MCFGR_AWCACHE_SHIFT 8 100 #define MCFGR_AWCACHE_MASK (0xF << MCFGR_AWCACHE_SHIFT) 101 #define MCFGR_ARCACHE_SHIFT 12 102 #define MCFGR_ARCACHE_MASK (0xF << MCFGR_ARCACHE_SHIFT) 103 104 #define SCFGR_RNGSH0 0x00000200 105 #define SCFGR_VIRT_EN 0x00008000 106 107 #define JRICID_MS_LICID 0x80000000 108 #define JRICID_MS_LAMTD 0x00020000 109 #define JRICID_MS_AMTDT 0x00010000 110 #define JRICID_MS_TZ 0x00008000 111 #define JRICID_LS_SDID_MASK 0x00000FFF 112 #define JRICID_LS_NSEQID_MASK 0x0FFF0000 113 #define JRICID_LS_NSEQID_SHIFT 16 114 #define JRICID_LS_SEQID_MASK 0x00000FFF 115 116 #define JRSTARTR_STARTJR0 0x00000001 117 #define JRSTARTR_STARTJR1 0x00000002 118 #define JRSTARTR_STARTJR2 0x00000004 119 #define JRSTARTR_STARTJR3 0x00000008 120 121 #define CTPR_VIRT_EN_POR 0x00000002 122 #define CTPR_VIRT_EN_INC 0x00000001 123 124 /* RNG RDSTA bitmask */ 125 #define RNG_STATE0_HANDLE_INSTANTIATED 0x00000001 126 #define RTMCTL_PRGM 0x00010000 /* 1 -> program mode, 0 -> run mode */ 127 /* use von Neumann data in both entropy shifter and statistical checker */ 128 #define RTMCTL_SAMP_MODE_VON_NEUMANN_ES_SC 0 129 /* use raw data in both entropy shifter and statistical checker */ 130 #define RTMCTL_SAMP_MODE_RAW_ES_SC 1 131 /* use von Neumann data in entropy shifter, raw data in statistical checker */ 132 #define RTMCTL_SAMP_MODE_VON_NEUMANN_ES_RAW_SC 2 133 /* invalid combination */ 134 #define RTMCTL_SAMP_MODE_INVALID 3 135 #define RTSDCTL_ENT_DLY_MIN 3200 136 #define RTSDCTL_ENT_DLY_MAX 12800 137 #define RTSDCTL_ENT_DLY_SHIFT 16 138 #define RTSDCTL_ENT_DLY_MASK (U(0xffff) << RTSDCTL_ENT_DLY_SHIFT) 139 #define RTFRQMAX_DISABLE (1 << 20) 140 141 /* Constants for error handling on job ring */ 142 #define JR_REG_JRINT_ERR_TYPE_SHIFT 8 143 #define JR_REG_JRINT_ERR_ORWI_SHIFT 16 144 #define JR_REG_JRINIT_JRE_SHIFT 1 145 146 #define JRINT_JRE (1 << JR_REG_JRINIT_JRE_SHIFT) 147 #define JRINT_ERR_WRITE_STATUS (1 << JR_REG_JRINT_ERR_TYPE_SHIFT) 148 #define JRINT_ERR_BAD_INPUT_BASE (3 << JR_REG_JRINT_ERR_TYPE_SHIFT) 149 #define JRINT_ERR_BAD_OUTPUT_BASE (4 << JR_REG_JRINT_ERR_TYPE_SHIFT) 150 #define JRINT_ERR_WRITE_2_IRBA (5 << JR_REG_JRINT_ERR_TYPE_SHIFT) 151 #define JRINT_ERR_WRITE_2_ORBA (6 << JR_REG_JRINT_ERR_TYPE_SHIFT) 152 #define JRINT_ERR_RES_B4_HALT (7 << JR_REG_JRINT_ERR_TYPE_SHIFT) 153 #define JRINT_ERR_REM_TOO_MANY (8 << JR_REG_JRINT_ERR_TYPE_SHIFT) 154 #define JRINT_ERR_ADD_TOO_MANY (9 << JR_REG_JRINT_ERR_TYPE_SHIFT) 155 #define JRINT_ERR_HALT_MASK 0x0C 156 #define JRINT_ERR_HALT_INPROGRESS 0x04 157 #define JRINT_ERR_HALT_COMPLETE 0x08 158 159 #define JR_REG_JRCR_VAL_RESET 0x00000001 160 161 #define JR_REG_JRCFG_LO_ICTT_SHIFT 0x10 162 #define JR_REG_JRCFG_LO_ICDCT_SHIFT 0x08 163 #define JR_REG_JRCFG_LO_ICEN_EN 0x02 164 #define JR_REG_JRCFG_LO_IMSK_EN 0x01 165 166 /* Constants for Descriptor Processing errors */ 167 #define SEC_HW_ERR_SSRC_NO_SRC 0x00 168 #define SEC_HW_ERR_SSRC_CCB_ERR 0x02 169 #define SEC_HW_ERR_SSRC_JMP_HALT_U 0x03 170 #define SEC_HW_ERR_SSRC_DECO 0x04 171 #define SEC_HW_ERR_SSRC_JR 0x06 172 #define SEC_HW_ERR_SSRC_JMP_HALT_COND 0x07 173 174 #define SEC_HW_ERR_DECO_HFN_THRESHOLD 0xF1 175 #define SEC_HW_ERR_CCB_ICV_CHECK_FAIL 0x0A 176 177 /* Macros for extracting error codes for the job ring */ 178 179 #define JR_REG_JRINT_ERR_TYPE_EXTRACT(value) \ 180 ((value) & 0x00000F00) 181 182 #define JR_REG_JRINT_ERR_ORWI_EXTRACT(value) \ 183 (((value) & 0x3FFF0000) >> \ 184 JR_REG_JRINT_ERR_ORWI_SHIFT) 185 186 #define JR_REG_JRINT_JRE_EXTRACT(value) \ 187 ((value) & JRINT_JRE) 188 189 /* Macros for manipulating JR registers */ 190 typedef union { 191 uint64_t m_whole; 192 struct { 193 #ifdef NXP_SEC_BE 194 uint32_t high; 195 uint32_t low; 196 #else 197 uint32_t low; 198 uint32_t high; 199 #endif 200 } m_halves; 201 } ptr_addr_t; 202 203 #if defined(CONFIG_PHYS_64BIT) 204 #define sec_read_addr(a) sec_in64((a)) 205 #define sec_write_addr(a, v) sec_out64((a), (v)) 206 #else 207 #define sec_read_addr(a) sec_in32((a)) 208 #define sec_write_addr(a, v) sec_out32((a), (v)) 209 #endif 210 211 #define JR_REG(name, jr) (CHAN_BASE(jr) + JR_REG_##name##_OFFSET) 212 #define JR_REG_LO(name, jr) (CHAN_BASE(jr) + JR_REG_##name##_OFFSET_LO) 213 214 #define GET_JR_REG(name, jr) (sec_in32(JR_REG(name, (jr)))) 215 #define GET_JR_REG_LO(name, jr) (sec_in32(JR_REG_LO(name, (jr)))) 216 217 #define SET_JR_REG(name, jr, val) \ 218 (sec_out32(JR_REG(name, (jr)), (val))) 219 220 #define SET_JR_REG_LO(name, jr, val) \ 221 (sec_out32(JR_REG_LO(name, (jr)), (val))) 222 223 /* STRUCTURES AND OTHER TYPEDEFS */ 224 /* Lists the possible states for a job ring. */ 225 typedef enum sec_job_ring_state_e { 226 SEC_JOB_RING_STATE_STARTED, /* Job ring is initialized */ 227 SEC_JOB_RING_STATE_RESET, /* Job ring reset is in progres */ 228 } sec_job_ring_state_t; 229 230 struct sec_job_ring_t { 231 /* 232 * Consumer index for job ring (jobs array). 233 * @note: cidx and pidx are accessed from 234 * different threads. 235 * Place the cidx and pidx inside the structure 236 * so that they lay on different cachelines, to 237 * avoid false sharing between threads when the 238 * threads run on different cores! 239 */ 240 uint32_t cidx; 241 242 /* Producer index for job ring (jobs array) */ 243 uint32_t pidx; 244 245 /* Ring of input descriptors. Size of array is power of 2 to allow 246 * fast update of producer/consumer indexes with bitwise operations. 247 */ 248 phys_addr_t *input_ring; 249 250 /* Ring of output descriptors. */ 251 struct sec_outring_entry *output_ring; 252 253 /* The file descriptor used for polling for interrupts notifications */ 254 uint32_t irq_fd; 255 256 /* Model used by SEC Driver to receive notifications from SEC. 257 * Can be either of the three: 258 * #SEC_NOTIFICATION_TYPE_IRQ or 259 * #SEC_NOTIFICATION_TYPE_POLL 260 */ 261 uint32_t jr_mode; 262 /* Base address for SEC's register memory for this job ring. */ 263 void *register_base_addr; 264 /* notifies if coelescing is enabled for the job ring */ 265 uint8_t coalescing_en; 266 /* The state of this job ring */ 267 sec_job_ring_state_t jr_state; 268 }; 269 270 /* Forward structure declaration */ 271 typedef struct sec_job_ring_t sec_job_ring_t; 272 273 struct sec_outring_entry { 274 phys_addr_t desc; /* Pointer to completed descriptor */ 275 uint32_t status; /* Status for completed descriptor */ 276 } __packed; 277 278 /* Lists the states possible for the SEC user space driver. */ 279 typedef enum sec_driver_state_e { 280 SEC_DRIVER_STATE_IDLE, /*< Driver not initialized */ 281 SEC_DRIVER_STATE_STARTED, /*< Driver initialized and */ 282 SEC_DRIVER_STATE_RELEASE, /*< Driver release is in progress */ 283 } sec_driver_state_t; 284 285 /* Union describing the possible error codes that */ 286 /* can be set in the descriptor status word */ 287 288 union hw_error_code { 289 uint32_t error; 290 union { 291 struct { 292 uint32_t ssrc:4; 293 uint32_t ssed_val:28; 294 } __packed value; 295 struct { 296 uint32_t ssrc:4; 297 uint32_t res:28; 298 } __packed no_status_src; 299 struct { 300 uint32_t ssrc:4; 301 uint32_t jmp:1; 302 uint32_t res:11; 303 uint32_t desc_idx:8; 304 uint32_t cha_id:4; 305 uint32_t err_id:4; 306 } __packed ccb_status_src; 307 struct { 308 uint32_t ssrc:4; 309 uint32_t jmp:1; 310 uint32_t res:11; 311 uint32_t desc_idx:8; 312 uint32_t offset:8; 313 } __packed jmp_halt_user_src; 314 struct { 315 uint32_t ssrc:4; 316 uint32_t jmp:1; 317 uint32_t res:11; 318 uint32_t desc_idx:8; 319 uint32_t desc_err:8; 320 } __packed deco_src; 321 struct { 322 uint32_t ssrc:4; 323 uint32_t res:17; 324 uint32_t naddr:3; 325 uint32_t desc_err:8; 326 } __packed jr_src; 327 struct { 328 uint32_t ssrc:4; 329 uint32_t jmp:1; 330 uint32_t res:11; 331 uint32_t desc_idx:8; 332 uint32_t cond:8; 333 } __packed jmp_halt_cond_src; 334 } __packed error_desc; 335 } __packed; 336 337 /* FUNCTION PROTOTYPES */ 338 339 /* 340 * @brief Initialize a job ring/channel in SEC device. 341 * Write configuration register/s to properly initialize a job ring. 342 * 343 * @param [in] job_ring The job ring 344 * 345 * @retval 0 for success 346 * @retval other for error 347 */ 348 int hw_reset_job_ring(sec_job_ring_t *job_ring); 349 350 /* 351 * @brief Reset a job ring/channel in SEC device. 352 * Write configuration register/s to reset a job ring. 353 * 354 * @param [in] job_ring The job ring 355 * 356 * @retval 0 for success 357 * @retval -1 in case job ring reset failed 358 */ 359 int hw_shutdown_job_ring(sec_job_ring_t *job_ring); 360 361 /* 362 * @brief Handle a job ring/channel error in SEC device. 363 * Identify the error type and clear error bits if required. 364 * 365 * @param [in] job_ring The job ring 366 * @param [in] sec_error_code error code as first read from SEC engine 367 */ 368 369 void hw_handle_job_ring_error(sec_job_ring_t *job_ring, 370 uint32_t sec_error_code); 371 /* 372 * @brief Handle a job ring error in the device. 373 * Identify the error type and printout a explanatory 374 * messages. 375 * 376 * @param [in] job_ring The job ring 377 * 378 */ 379 380 int hw_job_ring_error(sec_job_ring_t *job_ring); 381 382 /* @brief Set interrupt coalescing parameters on the Job Ring. 383 * @param [in] job_ring The job ring 384 * @param [in] irq_coalesing_timer 385 * Interrupt coalescing timer threshold. 386 * This value determines the maximum 387 * amount of time after processing a descriptor 388 * before raising an interrupt. 389 * @param [in] irq_coalescing_count 390 * Interrupt coalescing count threshold. 391 * This value determines how many descriptors 392 * are completed before raising an interrupt. 393 */ 394 395 int hw_job_ring_set_coalescing_param(sec_job_ring_t *job_ring, 396 uint16_t irq_coalescing_timer, 397 uint8_t irq_coalescing_count); 398 399 /* @brief Enable interrupt coalescing on a job ring 400 * @param [in] job_ring The job ring 401 */ 402 403 int hw_job_ring_enable_coalescing(sec_job_ring_t *job_ring); 404 405 /* 406 * @brief Disable interrupt coalescing on a job ring 407 * @param [in] job_ring The job ring 408 */ 409 410 int hw_job_ring_disable_coalescing(sec_job_ring_t *job_ring); 411 412 /* 413 * @brief Poll the HW for already processed jobs in the JR 414 * and notify the available jobs to UA. 415 * 416 * @param [in] job_ring The job ring to poll. 417 * @param [in] limit The maximum number of jobs to notify. 418 * If set to negative value, all available 419 * jobs are notified. 420 * 421 * @retval >=0 for No of jobs notified to UA. 422 * @retval -1 for error 423 */ 424 425 int hw_poll_job_ring(struct sec_job_ring_t *job_ring, int32_t limit); 426 427 /* @brief Poll the HW for already processed jobs in the JR 428 * and silently discard the available jobs or notify them to UA 429 * with indicated error code. 430 431 * @param [in,out] job_ring The job ring to poll. 432 * @param [in] do_notify Can be #TRUE or #FALSE. 433 * Indicates if descriptors to be discarded 434 * or notified to UA with given error_code. 435 * @param [in] error_code The detailed SEC error code. 436 * @param [out] notified_descs Number of notified descriptors. 437 * Can be NULL if do_notify is #FALSE 438 */ 439 void hw_flush_job_ring(struct sec_job_ring_t *job_ring, 440 uint32_t do_notify, 441 uint32_t error_code, uint32_t *notified_descs); 442 443 /* 444 * @brief Flush job rings of any processed descs. 445 * The processed descs are silently dropped, 446 * WITHOUT being notified to UA. 447 */ 448 void flush_job_rings(void); 449 450 /* 451 * @brief Handle desc that generated error in SEC engine. 452 * Identify the exact type of error and handle the error. 453 * Depending on the error type, the job ring could be reset. 454 * All descs that are submitted for processing on this job ring 455 * are notified to User Application with error status and detailed error code. 456 457 * @param [in] job_ring Job ring 458 * @param [in] sec_error_code Error code read from job ring's Channel 459 * Status Register 460 * @param [out] notified_descs Number of notified descs. Can be NULL if 461 * do_notify is #FALSE 462 * @param [out] do_driver_shutdown If set to #TRUE, then UA is returned code 463 * #SEC_PROCESSING_ERROR 464 * which is indication that UA must call 465 * sec_release() after this. 466 */ 467 void sec_handle_desc_error(struct sec_job_ring_t *job_ring, 468 uint32_t sec_error_code, 469 uint32_t *notified_descs, 470 uint32_t *do_driver_shutdown); 471 472 /* 473 * @brief Release the software and hardware resources tied to a job ring. 474 * @param [in] job_ring The job ring 475 * @retval 0 for success 476 * @retval -1 for error 477 */ 478 int shutdown_job_ring(struct sec_job_ring_t *job_ring); 479 480 /* 481 * @brief Enable irqs on associated job ring. 482 * @param [in] job_ring The job ring 483 * @retval 0 for success 484 * @retval -1 for error 485 */ 486 int jr_enable_irqs(struct sec_job_ring_t *job_ring); 487 488 /* 489 * @brief Disable irqs on associated job ring. 490 * @param [in] job_ring The job ring 491 * @retval 0 for success 492 * @retval -1 for error 493 */ 494 int jr_disable_irqs(struct sec_job_ring_t *job_ring); 495 496 /* 497 * IRJA - Input Ring Jobs Added Register shows 498 * how many new jobs were added to the Input Ring. 499 */ 500 static inline void hw_enqueue_desc_on_job_ring(struct jobring_regs *regs, 501 int num) 502 { 503 sec_out32(®s->irja, num); 504 } 505 506 #endif /* _SEC_HW_SPECIFIC_H_ */ 507