开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
crcmodel.h
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：9k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

crcmodel.h：源码内容
  1. /****************************************************************************/
  2. /*                             Start of crcmodel.h                          */
  3. /****************************************************************************/
  4. /*                                                                          */
  5. /* Author : Ross Williams (ross@guest.adelaide.edu.au.).                    */
  6. /* Date   : 3 June 1993.                                                    */
  7. /* Status : Public domain.                                                  */
  8. /*                                                                          */
  9. /* Description : This is the header (.h) file for the reference             */
  10. /* implementation of the Rocksoft^tm Model CRC Algorithm. For more          */
  11. /* information on the Rocksoft^tm Model CRC Algorithm, see the document     */
  12. /* titled "A Painless Guide to CRC Error Detection Algorithms" by Ross      */
  13. /* Williams (ross@guest.adelaide.edu.au.). This document is likely to be in */
  14. /* "ftp.adelaide.edu.au/pub/rocksoft".                                      */
  15. /*                                                                          */
  16. /* Note: Rocksoft is a trademark of Rocksoft Pty Ltd, Adelaide, Australia.  */
  17. /*                                                                          */
  18. /****************************************************************************/
  19. /*                                                                          */
  20. /* How to Use This Package                                                  */
  21. /* -----------------------                                                  */
  22. /* Step 1: Declare a variable of type cm_t. Declare another variable        */
  23. /*         (p_cm say) of type p_cm_t and initialize it to point to the first*/
  24. /*         variable (e.g. p_cm_t p_cm = &cm_t).                             */
  25. /*                                                                          */
  26. /* Step 2: Assign values to the parameter fields of the structure.          */
  27. /*         If you don't know what to assign, see the document cited earlier.*/
  28. /*         For example:                                                     */
  29. /*            p_cm->cm_width = 16;                                          */
  30. /*            p_cm->cm_poly  = 0x8005L;                                     */
  31. /*            p_cm->cm_init  = 0L;                                          */
  32. /*            p_cm->cm_refin = TRUE;                                        */
  33. /*            p_cm->cm_refot = TRUE;                                        */
  34. /*            p_cm->cm_xorot = 0L;                                          */
  35. /*         Note: Poly is specified without its top bit (18005 becomes 8005).*/
  36. /*         Note: Width is one bit less than the raw poly width.             */
  37. /*                                                                          */
  38. /* Step 3: Initialize the instance with a call cm_ini(p_cm);                */
  39. /*                                                                          */
  40. /* Step 4: Process zero or more message bytes by placing zero or more       */
  41. /*         successive calls to cm_nxt. Example: cm_nxt(p_cm,ch);            */
  42. /*                                                                          */
  43. /* Step 5: Extract the CRC value at any time by calling crc = cm_crc(p_cm); */
  44. /*         If the CRC is a 16-bit value, it will be in the bottom 16 bits.  */
  45. /*                                                                          */
  46. /****************************************************************************/
  47. /*                                                                          */
  48. /* Design Notes                                                             */
  49. /* ------------                                                             */
  50. /* PORTABILITY: This package has been coded very conservatively so that     */
  51. /* it will run on as many machines as possible. For example, all external   */
  52. /* identifiers have been restricted to 6 characters and all internal ones to*/
  53. /* 8 characters. The prefix cm (for Crc Model) is used as an attempt to     */
  54. /* avoid namespace collisions. This package is endian independent.          */
  55. /*                                                                          */
  56. /* EFFICIENCY: This package (and its interface) is not designed for         */
  57. /* speed. The purpose of this package is to act as a well-defined reference */
  58. /* model for the specification of CRC algorithms. If you want speed, cook up*/
  59. /* a specific table-driven implementation as described in the document cited*/
  60. /* above. This package is designed for validation only; if you have found or*/
  61. /* implemented a CRC algorithm and wish to describe it as a set of para-    */
  62. /* meters to the Rocksoft^tm Model CRC Algorithm, your CRC algorithm imple- */
  63. /* mentation should behave identically to this package under those para-    */
  64. /* meters.                                                                  */
  65. /*                                                                          */
  66. /****************************************************************************/
  68. /* The following #ifndef encloses this entire */
  69. /* header file, rendering it idempotent.     */
  71. #ifndef CM_DONE
  72. #define CM_DONE
  74. /****************************************************************************/
  75. /* The following definitions are extracted from my style header file which  */
  76. /* would be cumbersome to distribute with this package. The DONE_STYLE is   */
  77. /* the idempotence symbol used in my style header file.                     */
  79. #ifndef DONE_STYLE
  81. typedef unsigned long   ulong;
  82. typedef unsigned        bool;
  83. typedef unsigned char * p_ubyte_;
  85. #ifndef TRUE
  86. #define FALSE 0
  87. #define TRUE  1
  88. #endif
  90. /* Change to the second definition if you don't have prototypes. */
  91. #define P_(A) A
  92. /* #define P_(A) () */
  94. /* Uncomment this definition if you don't have void. */
  95. /* typedef int void; */
  97. #endif
  99. /****************************************************************************/
  100. /* CRC Model Abstract Type                                                  */
  101. /* -----------------------                                                  */
  102. /* The following type stores the context of an executing instance of the    */
  103. /* model algorithm. Most of the fields are model parameters which must be   */
  104. /* set before the first initializing call to cm_ini.                        */
  106. typedef struct
  107.   {
  108.    int   cm_width;   /* Parameter: Width in bits [8,32].       */
  109.    ulong cm_poly;    /* Parameter: The algorithm's polynomial. */
  110.    ulong cm_init;    /* Parameter: Initial register value.     */
  111.    bool  cm_refin;   /* Parameter: Reflect input bytes?        */
  112.    bool  cm_refot;   /* Parameter: Reflect output CRC?         */
  113.    ulong cm_xorot;   /* Parameter: XOR this to output CRC.     */
  115.    ulong cm_reg;     /* Context: Context during execution.     */
  116.   } cm_t;
  117. typedef cm_t *p_cm_t;
  119. /****************************************************************************/
  120. /* Functions That Implement The Model                                       */
  121. /* ----------------------------------                                       */
  122. /* The following functions animate the cm_t abstraction.                    */
  124. void cm_ini P_((p_cm_t p_cm));
  126. /* Initializes the argument CRC model instance.          */
  127. /* All parameter fields must be set before calling this. */
  129. void cm_nxt P_((p_cm_t p_cm,int ch));
  131. /* Processes a single message byte [0,255]. */
  133. void cm_blk P_((p_cm_t p_cm,p_ubyte_ blk_adr,ulong blk_len));
  135. /* Processes a block of message bytes. */
  137. ulong cm_crc P_((p_cm_t p_cm));
  139. /* Returns the CRC value for the message bytes processed so far. */
  141. /****************************************************************************/
  142. /* Functions For Table Calculation                                          */
  143. /* -------------------------------                                          */
  144. /* The following function can be used to calculate a CRC lookup table.      */
  145. /* It can also be used at run-time to create or check static tables.        */
  147. ulong cm_tab P_((p_cm_t p_cm,int index));
  149. /* Returns the i'th entry for the lookup table for the specified algorithm. */
  150. /* The function examines the fields cm_width, cm_poly, cm_refin, and the    */
  151. /* argument table index in the range [0,255] and returns the table entry in */
  152. /* the bottom cm_width bytes of the return value. */
  154. /****************************************************************************/
  155. /* End of the header file idempotence #ifndef                               */
  157. #endif
  159. /****************************************************************************/
  160. /*                             End of crcmodel.h                            */
  161. /****************************************************************************/