visus
/
framework-arduinoteensy-cxx20
Tarkkaile 1
Äänestä 0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commitit
1 Haara
Puu: daa7cc5a30
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'daa7cc5a30'
${ noResults }
framework-arduinoteensy-cxx20/libraries/FastCRC/FastCRChw.cpp

566 lines
17KB
Raaka Blame Historia 

  1. /* FastCRC library code is placed under the MIT license

  2.  * Copyright (c) 2014-2019 Frank Bösing

  3.  *

  4.  * Permission is hereby granted, free of charge, to any person obtaining

  5.  * a copy of this software and associated documentation files (the

  6.  * "Software"), to deal in the Software without restriction, including

  7.  * without limitation the rights to use, copy, modify, merge, publish,

  8.  * distribute, sublicense, and/or sell copies of the Software, and to

  9.  * permit persons to whom the Software is furnished to do so, subject to

  10.  * the following conditions:

  11.  *

  12.  * The above copyright notice and this permission notice shall be

  13.  * included in all copies or substantial portions of the Software.

  14.  *

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  16.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  17.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  18.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  19.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  20.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  21.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  22.  * SOFTWARE.

  23.  */

  24. 

  25. //

  26. // HW-calculations are 32BIT

  27. //

  28. // Thanks to:

  29. // - Catalogue of parametrised CRC algorithms, CRC RevEng

  30. // http://reveng.sourceforge.net/crc-catalogue/

  31. //

  32. // - Danjel McGougan (CRC-Table-Generator)

  33. //

  34. 

  35. #include "Arduino.h"

  36. #if defined(KINETISK)

  37. 

  38. #include "mk20dx128.h"

  39. #include "FastCRC.h"

  40. 

  41. // ===============================================

  42. 

  43. typedef struct {

  44.   union {

  45. 	  uint32_t CRC; //CRC Data register

  46. 	  struct {

  47. 		  uint16_t CRC16;

  48. 		  uint16_t CRC16_1;

  49. 	  };

  50. 	  struct {

  51. 		  uint8_t CRC8;

  52. 		  uint8_t CRC8_1;

  53. 		  uint8_t CRC8_2;

  54. 		  uint8_t CRC8_3;

  55. 	  };

  56.   };

  57.   uint32_t GPOLY; //CRC Polynomial register

  58.   uint32_t CTRL;  //CRC Control register

  59. } CRC_T;

  60. 

  61. static volatile CRC_T * const rCRC = (CRC_T *)0x40032000;

  62. 

  63. #define CRC_CTRL_WAS   25 // Write CRC Data Register As Seed(1) / Data(0)

  64. #define CRC_CTRL_TCRC  24 // Width of CRC protocol (0=16 BIT, 1=32 BIT)

  65. #define CRC_CTRL_TOTR1 29 // TOTR[1]

  66. 

  67. // ================= 7-BIT CRC ===================

  68. /** Constructor

  69.  * Enables CRC-clock

  70.  */

  71. FastCRC7::FastCRC7(){

  72.   SIM_SCGC6 |= SIM_SCGC6_CRC;

  73. }

  74. 

  75. /** CRC 7

  76.  * MultiMediaCard interface

  77.  * @param data Pointer to Data

  78.  * @param datalen Length of Data

  79.  * @return CRC value

  80.  */

  81. uint8_t FastCRC7::crc7(const uint8_t *data, const uint16_t datalen)

  82. {

  83.   // poly=0x09 init=0x00 refin=false refout=false xorout=0x00 check=0x75

  84.    return (generic(0x09, 0, CRC_FLAG_NOREFLECT, data, datalen));

  85. }

  86. 

  87. /** Update

  88.  * Call for subsequent calculations with previous seed

  89.  * @param data Pointer to Data

  90.  * @param datalen Length of Data

  91.  * @return CRC value

  92.  */

  93. uint8_t FastCRC7::update(const uint8_t *data, const uint16_t datalen)

  94. {

  95. 

  96.   const uint8_t *src = data;

  97.   const uint8_t *target = src + datalen;

  98. 

  99.   while (((uintptr_t)src & 0x03) != 0 && (src < target)) {

  100.     rCRC->CRC8_3 = *src++; //Write 8 BIT

  101.   }

  102. 

  103.   while (src <= target-4) {

  104.     rCRC->CRC = *( uint32_t  *)src; //Write 32 BIT

  105.     src += 4;

  106.   }

  107. 

  108.   while (src < target) {

  109.     rCRC->CRC8_3 = *src++; //Write 8 Bit

  110.   }

  111. 

  112. //TODO: Check handling of  CRC_CTRL_TOTR1 for other CRC7s

  113. /*

  114.   if (rCRC->CTRL & (1<<CRC_CTRL_TOTR1))

  115.     return rCRC->CRC8 >> 1;

  116.   else

  117. */

  118.     return rCRC->CRC8_3 >> 1;

  119. }

  120. 

  121. /** generic function for all 7-Bit CRCs

  122.  * @param polynom Polynom

  123.  * @param seed Seed

  124.  * @param flags Flags

  125.  * @param data Pointer to Data

  126.  * @param datalen Length of Data

  127.  * @return CRC value

  128.  */

  129. uint8_t FastCRC7::generic(const uint8_t polynom, const uint8_t seed, const uint32_t flags, const uint8_t *data,const uint16_t datalen)

  130. {

  131. 

  132.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC) | (1<<CRC_CTRL_WAS);                      // 32Bit Mode, Prepare to write seed(25)

  133.   rCRC->GPOLY = ((uint32_t)polynom)<<(24 + 1);                                       // Set polynom

  134.   rCRC->CRC   = ((uint32_t)seed<<(24 + 1));                                          // Write seed

  135.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC);								  		  	 // Clear WAS Bit - prepare to write data

  136. 

  137.   return update(data, datalen);

  138. }

  139. 

  140. uint8_t FastCRC7::crc7_upd(const uint8_t *data, uint16_t datalen){return update(data, datalen);}

  141. 

  142. 

  143. 

  144. // ================= 8-BIT CRC ===================

  145. 

  146. /** Constructor

  147.  * Enables CRC-clock

  148.  */

  149. FastCRC8::FastCRC8(){

  150.   SIM_SCGC6 |= SIM_SCGC6_CRC;

  151. }

  152. 

  153. 

  154. /** SMBUS CRC

  155.  * aka CRC-8

  156.  * @param data Pointer to Data

  157.  * @param datalen Length of Data

  158.  * @return CRC value

  159.  */

  160. uint8_t FastCRC8::smbus(const uint8_t *data, const uint16_t datalen)

  161. {

  162.   // poly=0x07 init=0x00 refin=false refout=false xorout=0x00 check=0xf4

  163.   return generic(0x07, 0, CRC_FLAG_NOREFLECT, data, datalen);

  164. }

  165. 

  166. /** MAXIM 8-Bit CRC

  167.  * equivalent to _crc_ibutton_update() in crc16.h from avr_libc

  168.  * @param data Pointer to Data

  169.  * @param datalen Length of Data

  170.  * @return CRC value

  171.  */

  172. uint8_t FastCRC8::maxim(const uint8_t *data, const uint16_t datalen)

  173. {

  174.   // poly=0x31 init=0x00 refin=true refout=true xorout=0x00  check=0xa1

  175.   return generic(0x31, 0, CRC_FLAG_REFLECT, data, datalen);

  176. }

  177. 

  178. /** Update

  179.  * Call for subsequent calculations with previous seed

  180.  * @param data Pointer to Data

  181.  * @param datalen Length of Data

  182.  * @return CRC value

  183.  */

  184. uint8_t FastCRC8::update(const uint8_t *data, const uint16_t datalen)

  185. {

  186. 

  187.   const uint8_t *src = data;

  188.   const uint8_t *target = src + datalen;

  189. 

  190.   while (((uintptr_t)src & 0x03) != 0 && (src < target)) {

  191.     rCRC->CRC8_3 = *src++; //Write 8 BIT

  192.   }

  193. 

  194.   while (src <= target-4) {

  195.     rCRC->CRC = *( uint32_t  *)src; //Write 32 BIT

  196.     src += 4;

  197.   }

  198. 

  199.   while (src < target) {

  200.     rCRC->CRC8_3 = *src++; //Write 8 Bit

  201.   }

  202. 

  203.   if (rCRC->CTRL & (1<<CRC_CTRL_TOTR1))

  204.     return rCRC->CRC8;

  205.   else

  206.     return rCRC->CRC8_3;

  207. }

  208. 

  209. /** generic function for all 8-Bit CRCs

  210.  * @param polynom Polynom

  211.  * @param seed Seed

  212.  * @param flags Flags

  213.  * @param data Pointer to Data

  214.  * @param datalen Length of Data

  215.  * @return CRC value

  216.  */

  217. uint8_t FastCRC8::generic(const uint8_t polynom, const uint8_t seed, const uint32_t flags, const uint8_t *data,const uint16_t datalen)

  218. {

  219. 

  220.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC) | (1<<CRC_CTRL_WAS);                      // 32Bit Mode, Prepare to write seed(25)

  221.   rCRC->GPOLY = ((uint32_t)polynom)<<24;                                             // Set polynom

  222.   rCRC->CRC   = ((uint32_t)seed<<24);                                                // Write seed

  223.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC);								  		  	 // Clear WAS Bit - prepare to write data

  224. 

  225.   return update(data, datalen);

  226. }

  227. uint8_t FastCRC8::smbus_upd(const uint8_t *data, uint16_t datalen){return update(data, datalen);}

  228. uint8_t FastCRC8::maxim_upd(const uint8_t *data, uint16_t datalen){return update(data, datalen);}

  229. 

  230. 

  231. 

  232. // ================= 14-BIT CRC ===================

  233. 

  234. /** Constructor

  235.  * Enables CRC-clock

  236.  */

  237. FastCRC14::FastCRC14(){

  238.   SIM_SCGC6 |= SIM_SCGC6_CRC;

  239. }

  240. 

  241. /** CRC-14/DARC

  242.  * @param data Pointer to Data

  243.  * @param datalen Length of Data

  244.  * @return CRC value

  245.  */

  246. uint16_t FastCRC14::darc(const uint8_t *data,const uint16_t datalen)

  247. {

  248.  // poly=0x0805 init=0x0000 refin=true refout=true xorout=0x0000 check=0x082d residue=0x0000

  249.   return generic(0x0805, 0x0000, CRC_FLAG_REFLECT, data, datalen);

  250. }

  251. 

  252. /** CRC-14/GSM

  253.  * @param data Pointer to Data

  254.  * @param datalen Length of Data

  255.  * @return CRC value

  256.  */

  257. uint16_t FastCRC14::gsm(const uint8_t *data,const uint16_t datalen)

  258. {

  259.  //  poly=0x202d init=0x0000 refin=false refout=false xorout=0x3fff check=0x30ae residue=0x031e

  260.   return generic(0x202d, 0x0000, CRC_FLAG_NOREFLECT | CRC_FLAG_XOR, data, datalen);

  261. }

  262. 

  263. /** CRC-14/ELORAN

  264.  * @param data Pointer to Data

  265.  * @param datalen Length of Data

  266.  * @return CRC value

  267.  */

  268. uint16_t FastCRC14::eloran(const uint8_t *data,const uint16_t datalen)

  269. {

  270.  // poly=0x60b1 init=0x0000 refin=false refout=false xorout=0x0000 check=0x38d1

  271.   return generic(0x60b1, 0x0, CRC_FLAG_NOREFLECT , data, datalen);

  272. }

  273. 

  274. /** CRC-14/ft4 : TODO

  275.  * @param data Pointer to Data

  276.  * @param datalen Length of Data

  277.  * @return CRC value

  278.  */

  279. /*

  280. uint16_t FastCRC14::ft4(const uint8_t *data,const uint16_t datalen)

  281. {

  282. 

  283.   return generic(, ,  , data, datalen);

  284. }

  285. */

  286. 

  287. /** Update

  288.  * Call for subsequent calculations with previous seed

  289.  * @param data Pointer to Data

  290.  * @param datalen Length of Data

  291.  * @return CRC value

  292.  */

  293. uint16_t FastCRC14::update(const uint8_t *data, const uint16_t datalen)

  294. {

  295.   const uint8_t *src = data;

  296.   const uint8_t *target = src + datalen;

  297. 

  298.   while (((uintptr_t)src & 0x03) !=0 && (src < target))  {

  299.     rCRC->CRC8_3 = *src++; //Write 8 BIT

  300.   }

  301. 

  302.   while (src <= target-4) {

  303.     rCRC->CRC = *( uint32_t  *)src; //Write 32 BIT

  304.     src += 4;

  305.   }

  306. 

  307.   while (src < target) {

  308.     rCRC->CRC8_3 = *src++; //Write 8 Bit

  309.   }

  310. 

  311.   if (rCRC->CTRL & (1<<CRC_CTRL_TOTR1))

  312.     return rCRC->CRC16;

  313.   else

  314.     return rCRC->CRC >> (32 - 14);

  315. }

  316. 

  317. /** generic function for all 14-Bit CRCs

  318.  * @param polynom Polynom

  319.  * @param seed Seed

  320.  * @param flags Flags

  321.  * @param data Pointer to Data

  322.  * @param datalen Length of Data

  323.  * @return CRC value

  324.  */

  325. uint16_t FastCRC14::generic(const uint16_t polynom, const uint16_t seed, const uint32_t flags, const uint8_t *data, const uint16_t datalen)

  326. {

  327. 

  328.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC) | (1<<CRC_CTRL_WAS);// 32-Bit Mode, prepare to write seed(25)

  329.   rCRC->GPOLY = ((uint32_t)polynom) << (32 - 14);                       // set polynom

  330.   rCRC->CRC   = ((uint32_t)seed << (32 - 14) );                          // this is the seed

  331.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC);				  	   // Clear WAS Bit - prepare to write data

  332. 

  333.   return update(data, datalen);

  334. }

  335. 

  336. uint16_t FastCRC14::darc_upd(const uint8_t *data, uint16_t len)  {return update(data, len);}

  337. uint16_t FastCRC14::gsm_upd(const uint8_t *data, uint16_t len)  {return update(data, len);}

  338. uint16_t FastCRC14::eloran_upd(const uint8_t *data, uint16_t len)  {return update(data, len);}

  339. //uint16_t FastCRC14::ft4(const uint8_t *data, uint16_t len)  {return update(data, len);}

  340. 

  341. 

  342. // ================= 16-BIT CRC ===================

  343. 

  344. /** Constructor

  345.  * Enables CRC-clock

  346.  */

  347. FastCRC16::FastCRC16(){

  348.   SIM_SCGC6 |= SIM_SCGC6_CRC;

  349. }

  350. 

  351. /** CCITT

  352.  * Alias "false CCITT"

  353.  * @param data Pointer to Data

  354.  * @param datalen Length of Data

  355.  * @return CRC value

  356.  */

  357. uint16_t FastCRC16::ccitt(const uint8_t *data,const uint16_t datalen)

  358. {

  359.  // poly=0x1021 init=0xffff refin=false refout=false xorout=0x0000 check=0x29b1

  360.   return generic(0x1021, 0XFFFF, CRC_FLAG_NOREFLECT, data, datalen);

  361. }

  362. 

  363. /** MCRF4XX

  364.  * equivalent to _crc_ccitt_update() in crc16.h from avr_libc

  365.  * @param data Pointer to Data

  366.  * @param datalen Length of Data

  367.  * @return CRC value

  368.  */

  369. uint16_t FastCRC16::mcrf4xx(const uint8_t *data,const uint16_t datalen)

  370. {

  371.  // poly=0x1021 init=0xffff refin=true refout=true xorout=0x0000 check=0x6f91

  372.   return generic(0x1021, 0XFFFF, CRC_FLAG_REFLECT , data, datalen);

  373. }

  374. 

  375. /** MODBUS

  376.  * equivalent to _crc_16_update() in crc16.h from avr_libc

  377.  * @param data Pointer to Data

  378.  * @param datalen Length of Data

  379.  * @return CRC value

  380.  */

  381. uint16_t FastCRC16::modbus(const uint8_t *data, const uint16_t datalen)

  382. {

  383.  // poly=0x8005 init=0xffff refin=true refout=true xorout=0x0000 check=0x4b37

  384.   return generic(0x8005, 0XFFFF, CRC_FLAG_REFLECT, data, datalen);

  385. }

  386. 

  387. /** KERMIT

  388.  * Alias CRC-16/CCITT, CRC-16/CCITT-TRUE, CRC-CCITT

  389.  * @param data Pointer to Data

  390.  * @param datalen Length of Data

  391.  * @return CRC value

  392.  */

  393. uint16_t FastCRC16::kermit(const uint8_t *data, const uint16_t datalen)

  394. {

  395.  // poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 check=0x2189

  396.  // sometimes byteswapped presentation of result

  397.   return generic(0x1021, 0x00, CRC_FLAG_REFLECT, data, datalen);

  398. }

  399. 

  400. /** XMODEM

  401.  * Alias ZMODEM, CRC-16/ACORN

  402.  * @param data Pointer to Data

  403.  * @param datalen Length of Data

  404.  * @return CRC value

  405.  */

  406. uint16_t FastCRC16::xmodem(const uint8_t *data, const uint16_t datalen)

  407. {

  408.   //width=16 poly=0x1021 init=0x0000 refin=false refout=false xorout=0x0000 check=0x31c3

  409.   return generic(0x1021, 0, CRC_FLAG_NOREFLECT, data, datalen);

  410. }

  411. 

  412. /** X25

  413.  * Alias CRC-16/IBM-SDLC, CRC-16/ISO-HDLC, CRC-B

  414.  * @param data Pointer to Data

  415.  * @param datalen Length of Data

  416.  * @return CRC value

  417.  */

  418. uint16_t FastCRC16::x25(const uint8_t *data, const uint16_t datalen)

  419. {

  420.   // poly=0x1021 init=0xffff refin=true refout=true xorout=0xffff check=0x906e

  421.   return generic(0x1021, 0XFFFF, CRC_FLAG_REFLECT | CRC_FLAG_XOR, data, datalen);

  422. }

  423. 

  424. /** Update

  425.  * Call for subsequent calculations with previous seed

  426.  * @param data Pointer to Data

  427.  * @param datalen Length of Data

  428.  * @return CRC value

  429.  */

  430. uint16_t FastCRC16::update(const uint8_t *data, const uint16_t datalen)

  431. {

  432.   const uint8_t *src = data;

  433.   const uint8_t *target = src + datalen;

  434. 

  435.   while (((uintptr_t)src & 0x03) !=0 && (src < target))  {

  436.     rCRC->CRC8_3 = *src++; //Write 8 BIT

  437.   }

  438. 

  439.   while (src <= target-4) {

  440.     rCRC->CRC = *( uint32_t  *)src; //Write 32 BIT

  441.     src += 4;

  442.   }

  443. 

  444.   while (src < target) {

  445.     rCRC->CRC8_3 = *src++; //Write 8 Bit

  446.   }

  447. 

  448.   if (rCRC->CTRL & (1<<CRC_CTRL_TOTR1))

  449.     return rCRC->CRC16;

  450.   else

  451.     return rCRC->CRC16_1;

  452. }

  453. 

  454. /** generic function for all 16-Bit CRCs

  455.  * @param polynom Polynom

  456.  * @param seed Seed

  457.  * @param flags Flags

  458.  * @param data Pointer to Data

  459.  * @param datalen Length of Data

  460.  * @return CRC value

  461.  */

  462. uint16_t FastCRC16::generic(const uint16_t polynom, const uint16_t seed, const uint32_t flags, const uint8_t *data, const uint16_t datalen)

  463. {

  464. 

  465.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC) | (1<<CRC_CTRL_WAS);// 32-Bit Mode, prepare to write seed(25)

  466.   rCRC->GPOLY = ((uint32_t)polynom)<<16;                       // set polynom

  467.   rCRC->CRC   = ((uint32_t)seed<<16);                          // this is the seed

  468.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC);				  	   // Clear WAS Bit - prepare to write data

  469. 

  470.   return update(data, datalen);

  471. }

  472. 

  473. uint16_t FastCRC16::ccitt_upd(const uint8_t *data, uint16_t len)  {return update(data, len);}

  474. uint16_t FastCRC16::mcrf4xx_upd(const uint8_t *data, uint16_t len){return update(data, len);}

  475. uint16_t FastCRC16::kermit_upd(const uint8_t *data, uint16_t len) {return update(data, len);}

  476. uint16_t FastCRC16::modbus_upd(const uint8_t *data, uint16_t len) {return update(data, len);}

  477. uint16_t FastCRC16::xmodem_upd(const uint8_t *data, uint16_t len) {return update(data, len);}

  478. uint16_t FastCRC16::x25_upd(const uint8_t *data, uint16_t len)    {return update(data, len);}

  479. 

  480. 

  481. 

  482. // ================= 32-BIT CRC ===================

  483. 

  484. /** Constructor

  485.  * Enables CRC-clock

  486.  */

  487. FastCRC32::FastCRC32(){

  488.   SIM_SCGC6 |= SIM_SCGC6_CRC;

  489. }

  490. 

  491. /** CRC32

  492.  * Alias CRC-32/ADCCP, PKZIP, Ethernet, 802.3

  493.  * @param data Pointer to Data

  494.  * @param datalen Length of Data

  495.  * @return CRC value

  496.  */

  497. uint32_t FastCRC32::crc32(const uint8_t *data, const uint16_t datalen)

  498. {

  499.   // poly=0x04c11db7 init=0xffffffff refin=true refout=true xorout=0xffffffff check=0xcbf43926

  500.   return generic(0x04C11DB7L, 0XFFFFFFFFL, CRC_FLAG_REFLECT | CRC_FLAG_XOR, data, datalen);

  501. }

  502. 

  503. /** CKSUM

  504.  * Alias CRC-32/POSIX

  505.  * @param data Pointer to Data

  506.  * @param datalen Length of Data

  507.  * @return CRC value

  508.  */

  509. uint32_t FastCRC32::cksum(const uint8_t *data, const uint16_t datalen)

  510. {

  511.   // width=32 poly=0x04c11db7 init=0x00000000 refin=false refout=false xorout=0xffffffff check=0x765e7680

  512.   return generic(0x04C11DB7L, 0, CRC_FLAG_NOREFLECT | CRC_FLAG_XOR, data, datalen);

  513. }

  514. 

  515. /** Update

  516.  * Call for subsequent calculations with previous seed

  517.  * @param data Pointer to Data

  518.  * @param datalen Length of Data

  519.  * @return CRC value

  520.  */

  521. //#pragma GCC diagnostic ignored "-Wpointer-arith"

  522. uint32_t FastCRC32::update(const uint8_t *data, const uint16_t datalen)

  523. {

  524. 

  525.   const uint8_t *src = data;

  526.   const uint8_t *target = src + datalen;

  527. 

  528.   while (((uintptr_t)src & 0x03) != 0  && (src < target)) {

  529.     rCRC->CRC8_3 = *src++; //Write 8 BIT

  530.   }

  531. 

  532.   while (src <= target-4) {

  533.     rCRC->CRC = *( uint32_t  *)src; //Write 32 BIT

  534.     src += 4;

  535.   }

  536. 

  537.   while (src < target) {

  538.     rCRC->CRC8_3 = *src++; //Write 8 Bit

  539.   }

  540. 

  541.   return rCRC->CRC;

  542. }

  543. 

  544. /** generic function for all 32-Bit CRCs

  545.  * @param polynom Polynom

  546.  * @param seed Seed

  547.  * @param flags Flags

  548.  * @param data Pointer to Data

  549.  * @param datalen Length of Data

  550.  * @return CRC value

  551.  */

  552. uint32_t FastCRC32::generic(const uint32_t polynom, const uint32_t seed, const uint32_t flags, const uint8_t *data, const uint16_t datalen)

  553. {

  554. 

  555.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC) | (1<<CRC_CTRL_WAS); // 32Bit Mode, prepare to write seed(25)

  556.   rCRC->GPOLY = polynom;                                        // Set polynom

  557.   rCRC->CRC   = seed;                                           // This is the seed

  558.   rCRC->CTRL  = flags | (1<<CRC_CTRL_TCRC);                     // Clear WAS Bit - prepare to write data

  559. 

  560.   return update(data, datalen);

  561. }

  562. 

  563. uint32_t FastCRC32::crc32_upd(const uint8_t *data, uint16_t len){return update(data, len);}

  564. uint32_t FastCRC32::cksum_upd(const uint8_t *data, uint16_t len){return update(data, len);}

  565. #endif // #if defined(KINETISK)