1 2 /****************************************************************************** 3 ******************************************************************************/ 4 5 #ifndef __BME_H 6 #define __BME_H 7 #ifdef __cplusplus 8 extern "C" { 9 #endif 10 /****************************************************************************** 11 * BME operation code 12 * 13 *//*! @addtogroup BME_OPCode 14 * @{ 15 *******************************************************************************/ 16 17 #define BME_OPCODE_AND 1 /*!< AND opcode */ 18 #define BME_OPCODE_OR 2 /*!< OR opcode */ 19 #define BME_OPCODE_XOR 3 /*!< XOR opcode */ 20 #define BME_OPCODE_BITFIELD 4 /*!< Bit field opcode */ 21 22 #define BME_OPCODE_BIT_CLEAR 2 /*!< Bit clear opcode */ 23 #define BME_OPCODE_BIT_SET 3 /*!< Bit set opcode */ 24 /*! @} End of BME_OPCode */ 25 26 /****************************************************************************** 27 * BME macro used to generate hardcoded BME addresses 28 * 29 *//*! @addtogroup BME_Utilities 30 * @{ 31 *******************************************************************************/ 32 33 /****************************************************************************** 34 * macro used to generate hardcoded AND address. 35 * 36 *******************************************************************************/ 37 38 /*****************************************************************************//*! 39 * 40 * @brief generates BME AND operation addresss (hardcoded 32-bit address). 41 * 42 * @param[in] ADDR 32-bit address. 43 * 44 * @return hardcoded 32-bit address. 45 * 46 * @ Pass/ Fail criteria: none. 47 * 48 *****************************************************************************/ 49 #define BME_AND(ADDR) (*(volatile uint32_t *)(((uint32_t)ADDR) | (BME_OPCODE_AND<<26))) 50 51 /****************************************************************************** 52 * macro used to generate hardcoded OR address. 53 * 54 *******************************************************************************/ 55 56 /*****************************************************************************//*! 57 * 58 * @brief generates BME OR operation addresss (hardcoded 32-bit address). 59 * 60 * @param[in] ADDR 32-bit address. 61 * 62 * @return hardcoded 32-bit address. 63 * 64 * @ Pass/ Fail criteria: none. 65 * 66 *****************************************************************************/ 67 68 #define BME_OR(ADDR) (*(volatile uint32_t *)(((uint32_t)ADDR) | (BME_OPCODE_OR<<26))) 69 70 71 /****************************************************************************** 72 * macro used to generate hardcoded XOR address. 73 * 74 *******************************************************************************/ 75 76 /*****************************************************************************//*! 77 * 78 * @brief generates BME XOR operation addresss (hardcoded 32-bit address). 79 * 80 * @param[in] ADDR 32-bit address. 81 * 82 * @return hardcoded 32-bit address. 83 * 84 * @ Pass/ Fail criteria: none. 85 * 86 *****************************************************************************/ 87 88 #define BME_XOR(ADDR) (*(volatile uint32_t *)(((uint32_t)ADDR) | (BME_OPCODE_XOR<<26))) 89 90 #if !defined(BME_SANITY_CHECK) 91 /*! 92 * @brief This is fastest way for BME without sanity check. 93 */ 94 /****************************************************************************** 95 * macro used to generate hardcoded load 1 bit clear address (LAC1). 96 * 97 *******************************************************************************/ 98 /*****************************************************************************//*! 99 * 100 * @brief generates BME bit clear operation addresss (hardcoded 32-bit address). 101 * 102 * @param[in] ADDR 32-bit address. 103 * @param[in] bit bit number, 0-based. 104 * 105 * @return hardcoded 32-bit address. 106 * 107 * @ Pass/ Fail criteria: none. 108 * 109 *****************************************************************************/ 110 111 #define BME_BIT_CLEAR(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 112 | (BME_OPCODE_BIT_CLEAR <<26) \ 113 | ((bit)<<21))) 114 115 /****************************************************************************** 116 * macro used to generate hardcoded load 1 bit set address (LAS1). 117 * 118 *******************************************************************************/ 119 /*****************************************************************************//*! 120 * 121 * @brief generates BME bit set operation addresss (hardcoded 32-bit address). 122 * 123 * @param[in] ADDR 32-bit address. 124 * @param[in] bit bit number, 0-based. 125 * 126 * @return hardcoded 32-bit address. 127 * 128 * @ Pass/ Fail criteria: none. 129 * 130 *****************************************************************************/ 131 132 #define BME_BIT_SET(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 133 | (BME_OPCODE_BIT_SET <<26) \ 134 | ((bit)<<21))) 135 136 /****************************************************************************** 137 * macro used to generate hardcoded bit field insert address (BFI). 138 * 139 *******************************************************************************/ 140 /*****************************************************************************//*! 141 * 142 * @brief generates BME bitfield insert operation addresss (hardcoded 32-bit address). 143 * 144 * @param[in] ADDR 32-bit address. 145 * @param[in] bit bit number, 0-based. 146 * @param[in] width bitfield width, 1-based. 147 * 148 * @return hardcoded 32-bit address. 149 * 150 * @ Pass/ Fail criteria: none. 151 * 152 *****************************************************************************/ 153 #define BME_BITFIELD_INSERT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 154 | (BME_OPCODE_BITFIELD <<26) \ 155 | ((bit)<<23) | ((width-1))<<19)) 156 157 158 /****************************************************************************** 159 * macro used to generate hardcoded bit field extract address (UBFX). 160 * 161 *******************************************************************************/ 162 /*****************************************************************************//*! 163 * 164 * @brief generates BME bitfield extract operation addresss (hardcoded 32-bit address). 165 * 166 * @param[in] ADDR 32-bit address. 167 * @param[in] bit bit number, 0-based. 168 * @param[in] width bitfield width, 1-based. 169 * 170 * @return hardcoded 32-bit address. 171 * 172 * @ Pass/ Fail criteria: none. 173 * 174 *****************************************************************************/ 175 176 #define BME_BITFIELD_EXTRACT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 177 | (BME_OPCODE_BITFIELD <<26) \ 178 | ((bit)<<23) | ((width-1))<<19)) 179 #else 180 /*! 181 * @brief This is slow way for BME as it has sanity check. 182 */ 183 /****************************************************************************** 184 * macro used to generate hardcoded load 1 bit clear address (LAC1). 185 * 186 *******************************************************************************/ 187 #define BME_BIT_CLEAR(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 188 | (BME_OPCODE_BIT_CLEAR <<26) \ 189 | ((bit & 0x1F)<<21))) /*!< Bit clear operation */ 190 191 /****************************************************************************** 192 * macro used to generate hardcoded load 1 bit set address (LAS1). 193 * 194 *******************************************************************************/ 195 #define BME_BIT_SET(ADDR,bit) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 196 | (BME_OPCODE_BIT_SET <<26) \ 197 | ((bit & 0x1F)<<21))) /*!< Bit set operation */ 198 199 /****************************************************************************** 200 * macro used to generate hardcoded bit field insert address (BFI). 201 * 202 *******************************************************************************/ 203 #define BME_BITFIELD_INSERT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 204 | (BME_OPCODE_BITFIELD <<26) \ 205 | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield insert operation */ 206 207 208 /****************************************************************************** 209 * macro used to generate hardcoded bit field extract address (UBFX). 210 * 211 *******************************************************************************/ 212 #define BME_BITFIELD_EXTRACT(ADDR,bit,width) (*(volatile uint32_t *)(((uint32_t)ADDR) \ 213 | (BME_OPCODE_BITFIELD <<26) \ 214 | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield extract operation */ 215 216 #endif 217 218 /****************************************************************************** 219 * The following macros are used to generate hardcoded address for 8-bit operation. 220 * 221 *******************************************************************************/ 222 223 /****************************************************************************** 224 * macro used to generate hardcoded AND address for 8-bit operation. 225 * 226 *******************************************************************************/ 227 /*****************************************************************************//*! 228 * 229 * @brief generates BME AND operation addresss (hardcoded 32-bit address) for 8-bit data. 230 * 231 * @param[in] ADDR 32-bit address. 232 * 233 * @return hardcoded 32-bit address. 234 * 235 * @ Pass/ Fail criteria: none. 236 * 237 *****************************************************************************/ 238 239 #define BME_AND_8b(ADDR) (*(volatile uint8_t *)(((uint32_t)ADDR) | (BME_OPCODE_AND<<26))) 240 241 /****************************************************************************** 242 * macro used to generate hardcoded OR address. 243 * 244 *******************************************************************************/ 245 /*****************************************************************************//*! 246 * 247 * @brief generates BME OR operation addresss (hardcoded 32-bit address) for 8-bit data. 248 * 249 * @param[in] ADDR 32-bit address. 250 * 251 * @return hardcoded 32-bit address. 252 * 253 * @ Pass/ Fail criteria: none. 254 * 255 *****************************************************************************/ 256 257 #define BME_OR_8b(ADDR) (*(volatile uint8_t *)(((uint32_t)ADDR) | (BME_OPCODE_OR<<26))) 258 259 260 /****************************************************************************** 261 * macro used to generate hardcoded XOR address. 262 * 263 *******************************************************************************/ 264 265 /*****************************************************************************//*! 266 * 267 * @brief generates BME XOR operation addresss (hardcoded 32-bit address) for 8-bit data. 268 * 269 * @param[in] ADDR 32-bit address. 270 * 271 * @return hardcoded 32-bit address. 272 * 273 * @ Pass/ Fail criteria: none. 274 * 275 *****************************************************************************/ 276 277 #define BME_XOR_8b(ADDR) (*(volatile uint8_t *)(((uint32_t)ADDR) | (BME_OPCODE_XOR<<26))) 278 279 #if !defined(BME_SANITY_CHECK) 280 /*! 281 * @brief This is fastest way for BME without sanity check. 282 */ 283 /****************************************************************************** 284 * macro used to generate hardcoded load 1 bit clear address (LAC1). 285 * 286 *******************************************************************************/ 287 288 /*****************************************************************************//*! 289 * 290 * @brief generates BME bit clear operation addresss (hardcoded 32-bit address) for 8-bit data. 291 * 292 * @param[in] ADDR 32-bit address. 293 * @param[in] bit bit number, 0-based. 294 * 295 * @return hardcoded 32-bit address. 296 * 297 * @ Pass/ Fail criteria: none. 298 * 299 *****************************************************************************/ 300 301 #define BME_BIT_CLEAR_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 302 | (BME_OPCODE_BIT_CLEAR <<26) \ 303 | ((bit)<<21))) 304 305 /****************************************************************************** 306 * macro used to generate hardcoded load 1 bit set address (LAS1). 307 * 308 *******************************************************************************/ 309 /*****************************************************************************//*! 310 * 311 * @brief generates BME bit set operation addresss (hardcoded 32-bit address) for 8-bit data. 312 * 313 * @param[in] ADDR 32-bit address. 314 * @param[in] bit bit number, 0-based. 315 * 316 * @return hardcoded 32-bit address. 317 * 318 * @ Pass/ Fail criteria: none. 319 * 320 *****************************************************************************/ 321 322 #define BME_BIT_SET_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 323 | (BME_OPCODE_BIT_SET <<26) \ 324 | ((bit)<<21))) 325 326 /****************************************************************************** 327 * macro used to generate hardcoded bit field insert address (BFI). 328 * 329 *******************************************************************************/ 330 331 /*****************************************************************************//*! 332 * 333 * @brief generates BME bitfield insert operation addresss (hardcoded 32-bit address) for 8-bit data. 334 * 335 * @param[in] ADDR 32-bit address. 336 * @param[in] bit bit number, 0-based. 337 * @param[in] width bitfield width, 1-based. 338 * 339 * @return hardcoded 32-bit address. 340 * 341 * @ Pass/ Fail criteria: none. 342 * 343 *****************************************************************************/ 344 345 #define BME_BITFIELD_INSERT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 346 | (BME_OPCODE_BITFIELD <<26) \ 347 | ((bit)<<23) | ((width-1))<<19)) 348 /****************************************************************************** 349 * macro used to generate hardcoded bit field extract address (UBFX). 350 * 351 *******************************************************************************/ 352 /*****************************************************************************//*! 353 * 354 * @brief generates BME bitfield extract operation addresss (hardcoded 32-bit address) for 8-bit data. 355 * 356 * @param[in] ADDR 32-bit address. 357 * @param[in] bit bit number, 0-based. 358 * @param[in] width bitfield width, 1-based. 359 * 360 * @return hardcoded 32-bit address. 361 * 362 * @ Pass/ Fail criteria: none. 363 * 364 *****************************************************************************/ 365 #define BME_BITFIELD_EXTRACT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 366 | (BME_OPCODE_BITFIELD <<26) \ 367 | ((bit<<23) | ((width-1))<<19)) 368 #else 369 /*! 370 * @brief This is slow way for BME as it has sanity check. 371 */ 372 /****************************************************************************** 373 * macro used to generate hardcoded load 1 bit clear address (LAC1). 374 * 375 *******************************************************************************/ 376 #define BME_BIT_CLEAR_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 377 | (BME_OPCODE_BIT_CLEAR <<26) \ 378 | ((bit & 0x1F)<<21))) /*!< Bit clear operation on 8-bit*/ 379 380 /****************************************************************************** 381 * macro used to generate hardcoded load 1 bit set address (LAS1). 382 * 383 *******************************************************************************/ 384 #define BME_BIT_SET_8b(ADDR,bit) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 385 | (BME_OPCODE_BIT_SET <<26) \ 386 | ((bit & 0x1F)<<21))) /*!< Bit set operation on 8-bit */ 387 388 /****************************************************************************** 389 * macro used to generate hardcoded bit field insert address (BFI). 390 * 391 *******************************************************************************/ 392 #define BME_BITFIELD_INSERT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 393 | (BME_OPCODE_BITFIELD <<26) \ 394 | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield insert operation on 8-bit */ 395 396 /****************************************************************************** 397 * macro used to generate hardcoded bit field extract address (UBFX). 398 * 399 *******************************************************************************/ 400 401 #define BME_BITFIELD_EXTRACT_8b(ADDR,bit,width) (*(volatile uint8_t *)(((uint32_t)ADDR) \ 402 | (BME_OPCODE_BITFIELD <<26) \ 403 | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield extract operation on 8-bit*/ 404 #endif 405 406 407 /****************************************************************************** 408 * The following macros are used to generate hardcoded address for 16-bit operation. 409 * 410 *******************************************************************************/ 411 412 /****************************************************************************** 413 * macro used to generate hardcoded AND address for 16-bit operation. 414 * 415 *******************************************************************************/ 416 /*****************************************************************************//*! 417 * 418 * @brief generates BME AND operation addresss (hardcoded 32-bit address) for 16-bit data. 419 * 420 * @param[in] ADDR 32-bit address. 421 * 422 * @return hardcoded 32-bit address. 423 * 424 * @ Pass/ Fail criteria: none. 425 * 426 *****************************************************************************/ 427 428 #define BME_AND_16b(ADDR) (*(volatile uint16_t *)(((uint32_t)ADDR) | (BME_OPCODE_AND<<26))) 429 430 /****************************************************************************** 431 * macro used to generate hardcoded OR address. 432 * 433 *******************************************************************************/ 434 435 /*****************************************************************************//*! 436 * 437 * @brief generates BME OR operation addresss (hardcoded 32-bit address) for 16-bit data. 438 * 439 * @param[in] ADDR 32-bit address. 440 * 441 * @return hardcoded 32-bit address. 442 * 443 * @ Pass/ Fail criteria: none. 444 * 445 *****************************************************************************/ 446 447 #define BME_OR_16b(ADDR) (*(volatile uint16_t *)(((uint32_t)ADDR) | (BME_OPCODE_OR<<26))) 448 449 450 /****************************************************************************** 451 * macro used to generate hardcoded XOR address. 452 * 453 *******************************************************************************/ 454 455 /*****************************************************************************//*! 456 * 457 * @brief generates BME XOR operation addresss (hardcoded 32-bit address) for 16-bit data. 458 * 459 * @param[in] ADDR 32-bit address. 460 * 461 * @return hardcoded 32-bit address. 462 * 463 * @ Pass/ Fail criteria: none. 464 * 465 *****************************************************************************/ 466 467 #define BME_XOR_16b(ADDR) (*(volatile uint16_t *)(((uint32_t)ADDR) | (BME_OPCODE_XOR<<26))) 468 469 470 #if !defined(BME_SANITY_CHECK) 471 /*! 472 * @brief This is fastest way for BME without sanity check. 473 */ 474 475 /****************************************************************************** 476 * macro used to generate hardcoded load 1 bit clear address (LAC1). 477 * 478 *******************************************************************************/ 479 /*****************************************************************************//*! 480 * 481 * @brief generates BME bit clear operation addresss (hardcoded 32-bit address) for 16-bit data. 482 * 483 * @param[in] ADDR 32-bit address. 484 * @param[in] bit bit number, 0-based. 485 * 486 * @return hardcoded 32-bit address. 487 * 488 * @ Pass/ Fail criteria: none. 489 * 490 *****************************************************************************/ 491 492 #define BME_BIT_CLEAR_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 493 | (BME_OPCODE_BIT_CLEAR <<26) \ 494 | ((bit)<<21))) 495 496 /****************************************************************************** 497 * macro used to generate hardcoded load 1 bit set address (LAS1). 498 * 499 *******************************************************************************/ 500 /*****************************************************************************//*! 501 * 502 * @brief generates BME bit set operation addresss (hardcoded 32-bit address) for 16-bit data. 503 * 504 * @param[in] ADDR 32-bit address. 505 * @param[in] bit bit number, 0-based. 506 * 507 * @return hardcoded 32-bit address. 508 * 509 * @ Pass/ Fail criteria: none. 510 * 511 *****************************************************************************/ 512 513 #define BME_BIT_SET_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 514 | (BME_OPCODE_BIT_SET <<26) \ 515 | ((bit)<<21))) 516 517 /****************************************************************************** 518 * macro used to generate hardcoded bit field insert address (BFI). 519 * 520 *******************************************************************************/ 521 /*****************************************************************************//*! 522 * 523 * @brief generates BME bitfield insert operation addresss (hardcoded 32-bit address) for 16-bit data. 524 * 525 * @param[in] ADDR 32-bit address. 526 * @param[in] bit bit number, 0-based. 527 * @param[in] width bitfield width, 1-based. 528 * 529 * @return hardcoded 32-bit address. 530 * 531 * @ Pass/ Fail criteria: none. 532 * 533 *****************************************************************************/ 534 535 #define BME_BITFIELD_INSERT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 536 | (BME_OPCODE_BITFIELD <<26) \ 537 | ((bit)<<23) | ((width-1))<<19)) 538 539 540 /****************************************************************************** 541 * macro used to generate hardcoded bit field extract address (UBFX). 542 * 543 *******************************************************************************/ 544 /*****************************************************************************//*! 545 * 546 * @brief generates BME bitfield extract operation addresss (hardcoded 32-bit address) for 16-bit data. 547 * 548 * @param[in] ADDR 32-bit address. 549 * @param[in] bit bit number, 0-based. 550 * @param[in] width bitfield width, 1-based. 551 * 552 * @return hardcoded 32-bit address. 553 * 554 * @ Pass/ Fail criteria: none. 555 * 556 *****************************************************************************/ 557 558 #define BME_BITFIELD_EXTRACT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 559 | (BME_OPCODE_BITFIELD <<26) \ 560 | ((bit)<<23) | ((width-1))<<19)) 561 562 #else 563 /*! 564 * @brief This is slow way for BME as it has sanity check. 565 */ 566 /****************************************************************************** 567 * macro used to generate hardcoded load 1 bit clear address (LAC1). 568 * 569 *******************************************************************************/ 570 #define BME_BIT_CLEAR_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 571 | (BME_OPCODE_BIT_CLEAR <<26) \ 572 | ((bit & 0x1F)<<21))) /*!< Bit clear operation on 16-bit*/ 573 574 /****************************************************************************** 575 * macro used to generate hardcoded load 1 bit set address (LAS1). 576 * 577 *******************************************************************************/ 578 #define BME_BIT_SET_16b(ADDR,bit) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 579 | (BME_OPCODE_BIT_SET <<26) \ 580 | ((bit & 0x1F)<<21))) /*!< Bit set operation on 16-bit */ 581 582 /****************************************************************************** 583 * macro used to generate hardcoded bit field insert address (BFI). 584 * 585 *******************************************************************************/ 586 #define BME_BITFIELD_INSERT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 587 | (BME_OPCODE_BITFIELD <<26) \ 588 | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield insert operation on 16-bit */ 589 590 591 /****************************************************************************** 592 * macro used to generate hardcoded bit field extract address (UBFX). 593 * 594 *******************************************************************************/ 595 #define BME_BITFIELD_EXTRACT_16b(ADDR,bit,width) (*(volatile uint16_t *)(((uint32_t)ADDR) \ 596 | (BME_OPCODE_BITFIELD <<26) \ 597 | ((bit & 0x1F)<<23) | ((width-1) & 0xF)<<19)) /*!< Bitfield extract operation on 16-bit*/ 598 #endif 599 600 /*! @} End of BME_Utilities */ 601 #ifdef __cplusplus 602 } 603 #endif 604 #endif /* __BME_H */ 605 606 607