Cyclic redundancy check
The method addresses the challenge of ensuring firmware integrity by generating and verifying a cyclic redundancy check value for updated firmware on integrated circuits, ensuring correct execution and compatibility.
Patent Information
- Application Number
- GB2022014986
- Authority / Receiving Office
- GB · GB
- Patent Type
- Patents
- Current Assignee / Owner
- Priority Date
- 2022-09-02
- Filing Date
- 2022-10-11
- Publication Date
- 2024-11-20
- Estimated Expiration
- 2042-10-11
AI Technical Summary
Existing methods for updating and verifying firmware on integrated circuits face challenges in ensuring the integrity of new parameters and functions added over time, particularly in maintaining compatibility and validating discontinuous data structures.
A computer-implemented method that generates a cyclic redundancy check (CRC) value for code, prepends it to the code as a header, and verifies the integrity of the modified code upon boot, ensuring data integrity and compatibility by storing the CRC value at the beginning or end of the data structure.
This approach ensures the integrity and compatibility of updated firmware by validating the CRC value, preventing corruption and ensuring correct algorithm execution, while maintaining backwards compatibility and efficient data access.
Smart Images

Figure 00000001_0000 
Figure 00000002_0000 
Figure 00000002_0001
Abstract
Description
Technical Field Examples described herein relate to successfully incorporating code into the memory of integrated circuits, for example code that affects or adjusts a parameter of an algorithm such as firmware. Background When implementing software patches on an integrated circuit ("IC"), for example implementing repairs and / or updates to existing firmware residing in the memory of the IC, new parameters / functions may be added overtime and / or parameters / functions of existing algorithms may be changed. In addition, new and / or additional firmware may be loaded or verified on boot, i.e., verified on start-up. In either case, there is a need to ensure the integrity of these updated parameters / functions so that associated software can be run correctly. Thus, a software patch, or as it is commonly referred to a 'patch', is a quick way to fix, repair and / or update a piece of programming to resolve functionality issues, improve security and / or add new features for example. Statements of Invention According to an example there is provided a computer-implemented method comprising: obtaining, by a processor, code of a process; generating, by a processor, a cyclic redundancy check value; and prepending, by a processor, the cyclic redundancy check value to the code to generate modified code. The modified code may have a header comprising the cyclic redundancy check value. The method may further comprise: calculating, by a processor, the length of the code; and wherein the modified code comprises the code length in the header. The modified code may comprise a reserved memory location beginning at the first memory address, the reserved memory location being reserved for the cyclic redundancy check value. The method may comprise compiling, by a processor, the code to generate compiled code having a blank header; wherein the modified code comprises the compiled code having a header comprising the cyclic redundancy check value. The method may comprise calculating, by a processor, the length of the compiled code, and wherein the header of the compiled code also comprises the header. The process may be any one or more of an algorithm of firmware, a patch to firmware, a RAM patch. The code comprises source code. The method may further comprise packaging, by a processor, the modified code to create an executable output. The method may further comprise generating, by a processor, a test script to verify the modified code. The method may comprise loading, by a processor, the modified code into a memory. The method may comprise, on boot of a system containing the code, verifying, by a processor, the integrity of the modified code. If the integrity verification fails, the method may comprise aborting the boot sequence. The compiled code may comprise a reserved memory location from a first memory address to a second memory address. Generating the cyclic redundancy check value may comprise calculating the cyclic redundancy check value from the address immediately after the second address to the end of available memory addresses. The length may be calculated in N-bit words from the address immediately after the second address to the end of available memory addresses. To generate the modified code the length may be placed at the first memory address. To generate the modified code the cyclic redundancy check value may be placed at the memory address immediately after the first memory address. The cyclic redundancy check value may be a 24-bit cyclic redundancy check with 0x65B as the polynomial and 0x555555 as initial value. The method may further comprise increasing one or more lines of the compiled code to increase its length such that the number of valid lines in the file is divisible by 4. According to an example there is provided a computer-implemented method comprising: receiving, at a processor, a request, at a processor, to generate a cyclic redundancy check value for a parameter of an algorithm; generating, by a processor executing firmware, the cyclic redundancy check value for the parameter; writing, by a processor, a file containing the parameter and cyclic redundancy check value, wherein the cyclic redundancy check value is contained in the header. The method may further comprise receiving, at a processor, a request to generate a cyclic redundancy check value per parameter of an algorithm; generating, by a processor executing firmware, the cyclic redundancy check value for each parameter; and writing, by a processor, a file containing each parameter and cyclic redundancy check value. The method may further comprising: upon initialisation of an event, verifying, by a processor, the integrity of the file and wherein the event is not executed if the verification is not successful. The event may be an audio event. The parameter may be a parameter of an audio algorithm. The audio algorithm may be a tuning algorithm, and the request may be received from an audio tuning tool. The cyclic redundancy check value may be the first word in the application programming interface. The cyclic redundancy check may be run on the entire application programming interface excluding the checksum. According to an example there is provided a data structure comprising a number of parameters and a cyclic redundancy check value, wherein the cyclic redundancy check value is prepended to the parameters. According to an example there is provided a data structure comprising a number of parameters and a cyclic redundancy check value, wherein the cyclic redundancy check value is at the beginning of the data structure, before the parameters. According to an example there is provide a data structure comprising a header wherein the header comprises a cyclic redundancy check value. The header may comprise the length of the data structure. According to an example there is provided a data structure comprising a header wherein the header comprises a cyclic redundancy check value placed at the memory address immediately after the first memory address. The header may comprise the length of the data structure placed at the first memory address. There may also be provided a system configured to perform any of the methods / processes described above. There may also be provided a system configured to generate the data structure as described above. The system may be an integrated circuit. There may also be provided a machine-readable medium comprising instructions which, when executed by a processor, cause the processor to perform any of the methods as described above. There may also be provided a computer program or computer program product comprising instructions which, when the program is executed by a computer, cause the computer to perform any of the methods described above. According to an example there is provided a semiconductor memory configured to comprise a reserved memory location at a first memory address for storing a cyclic redundancy check value. This may comprise a reserved memory region at the first memory address for storing a cyclic redundancy check value. This may comprise a reserved memory region between the first available memory address and a second memory address for storing a cyclic redundancy check value According to an example there is provided an integrated circuit comprising a memory wherein the memory is configured to comprise a reserved memory location at the a first memory address for storing a cyclic redundancy check value. According to an example there is provided a process comprising: loading code, compiling code, generating a CRC and prepending it to the compiled code. Optionally, the process may comprise calculating the length of the code (and increasing it in some examples), loading or reloading the modified code (having the CRC and, optionally, the length, for example in a header) onto a chip, and verifying on-chip the integrity of the code. Introduction of the Figures The present disclosure may be understood with reference to the accompanying drawings in which: Figures 1A-1E are schematic illustrations of example data structures; Figure 2 is a flowchart of an example method of generating code having a cyclic redundancy check (CRC) value; Figure 3 is a flowchart of an example method of packaging and loading firmware, and which may include the method of Figure 2; Figure 4 is a flowchart of an example method of verifying the integrity of code; Figure 5 is a flowchart of an example method of generating code having a CRC value; and Figure 6 is a flowchart of an example method of verifying the integrity of code and / or one or more parameters, for example to be performed at runtime. Detailed Description with Reference to the Figures Figure 1A schematically shows a data structure 100. In this example, the data structure 100 comprises three parameters (denoted A-C) and a cyclic redundancy check ("CRC") value (which may be referred to as just the CRC, or a check value, or a checksum, or a CRC address). The CRC value is appended to the end of the data structure in this example. The presence of the check value creates a redundant addition to the block of data in that it expands the data in such a way as to not change it (in the sense that the presence of the CRC will not change an algorithm running the code) but it allows the code (and / or one or more parameters, see below) to be verified. When run, if the CRC value does not match the initial CRC value then corruption and / or an error can be inferred (and subsequently investigated and / or corrected). An algorithm (such as a firmware algorithm) may contain a number of parameters (such as schematically indicated in Figure 1A) and therefore the CRC value can be used to verify parameter integrity. Some algorithms are modifiable and / or patchable and a modifiable / patchable algorithm may add new parameters over time. When a patch to the structure of Figure 1A adds new parameters, the patched structure may be as shown in Figure IB. Herein, the term "code" is meant to comprise any suitable code (for example source code, executable code, assembly code, software, firmware) and / or an algorithm and / or one or more parameters (e.g. of an algorithm) and / or any executable or set of executables. Figure IB shows a patched data structure 101, where the data structure is the structure of Figure 1A, and new parameters D and E have been added following the patch. The parameter structure (A-E) in this example is that new parameters (D and E) have been added in memory locations after the CRC (which was appended at the end of the data structure of Figure 1A) and therefore certain processors may consider this data (A-E) to be "discontinuous" (in that a CRC interrupts the parameters in terms of its respective memory location). If the patched data structure is of this type where the CRC address remains fixed in the data structure, then firmware may need to support the validation of such discontinuous data. Figure IC also shows another patched data structure 102, where the data structure is the structure of Figure 1A and where the patch is the same as in Figure IB. In this example however the CRC address has been relocated to the end of the structure as opposed to remaining fixed as illustrated in Figure IB. However, depending on the firmware, this parameter structure of Figure IC may not be backwards-compatible with earlier versions of the algorithm, and validation firmware may need updating to process the data structure of this example. Figures ID and IE respectively show a data structure 103 and patched data structure 104 utilising some of the principles of this disclosure (as before, the original data structure comprises parameters A-C and the patch introducing parameters D and E). According to this example, the CRC value is stored at the beginning of the data structure. In this way, existing parameters (including the CRC itself) retain their addresses, i.e. memory locations, and the (patched) data to be validated remains contiguous. Since validation firmware has randomword access to data memory, there is no cost associated with storing the CRC value at the beginning of this data structure. This position of the CRC (as per Figures ID and IE) may be considered "prepending" rather than "appending" (as per Figures 1A and IC) the CRC to the data structure. Figure 2 shows an example method 200, which may be a method of generating patched data, or a method of generating code (e.g. code including a CRC value). Certain steps of the method are described as being performed by a processor but it will be understood that these steps could be performed by the same processor, different processors, or any combination of suitable hardware and / or software for implementing the method. At block 201 the method comprises obtaining code of a process, which may be code of a memory patch (e.g. a RAM patch), or which may be one or more parameters of an algorithm (for example, an audio tuning algorithm). The method may be performed to generate a patch, e.g. a patch having a CRC. For example, the method 200 may comprise the compile and post-compile processes used to generate a patch that contains a CRC (and, in some examples, a length and a CRC). This generated patch having a CRC may be validated (e.g. at runtime) as will be described later. The code itself may be created during development (for example, a developer may use a tool to make a new project and author source code for the project). In one example the obtained code may be source code, or a list of source code files, to compile, e.g. in a .prx file. In one example, the source code may be related to an algorithm and / or a parameter for use with an audio device, e.g. the audio device may be an integrated circuit (IC) and the patch may be to be written to a memory space / control register / set of address ranges of the integrated circuit. In another example, method 201 may comprise fetching / loading firmware, or loading / launching a project which, in practice, may be instigated by a user clicking or opening a program and / or a development environment. Block 201 may comprise automatically obtaining the parameters of an algorithm (e.g. encoded binary), for example by a tool (e.g. using a graphical user interface or GUI). For a coded filter for example the parameters may be filter coefficients and, at block 201, either the operational instructions or the filter coefficients themselves may be loaded. Block 201 may comprise running and / or using an application programming interface which contains a number of algorithms, and firmware may be instructed to examine each parameter (for example, the parameters could be filter parameters for a tuning by means of a GUI). At block 202 the method comprises compiling the code to generate a compiled code having a blank header. The compiled code (e.g. compiled patch) may be a .PM file (e.g. an output of compiled firmware binary stored in program memory) or may take any other suitable format (e.g. a .bin file). For example, the output may include both firmware binary (or binaries) and metadata (e.g. descriptive metadata). The result, or output, of block 202 may be a file (e.g. a .PM file) with the first instruction at or starting at a set, fixed, or predetermined memory address (e.g. memory address 0xlc0008 in a specific example implementation, and with a reserved memory address location / region or "hole" from the first memory address to a second memory address, the second memory address being directly before the memory address where the first instruction is at or starts (so a hole from memory addresses OxlcOOOO - 0xlc0007 in the example, where the first instruction is at or starts at memory address 0xlc0008). The hole is reserved for storing the CRC header, to be explained below. Block 202 may comprise generating a binary. Block 202 may be instigated by running a file or script (e.g. to compile the code). At block 203 the method comprises calculating the code length (e.g. the patch length in examples where the code comprises a patch). . At block 204 the method comprises generating a cyclic redundancy check (CRC) value (or address). Both blocks may be performed by executing an appropriate file or script, such as a .py file that causes the CRC and / or the length to be generated / calculated. In other words, executing a file or running a script may cause the blocks 203 and / or 204 to be performed. Blocks 203 and 204 are therefore post-build processes. In examples where the length is adjusted (see below) calculating the CRC is performed on the adjusted-length code. At block 205 the method comprises generating modified code (e.g. a modified patch), the modified code being the compiled code having a header comprising the length and CRC value. In other words, the result of block 205 may be the compiled code (the result of block 202) including the length and CRC value which were calculated at blocks 203 and 204. This may produce an updated, or modified, .PM file (or .bin file etc. depending on the example). In other words, block 205 may comprise including the length and CRC (the results of blocks 203 and 204) into the .PM file that was the result of block 202. In this way compiled code is produced having a header comprising the CRC (and optionally a length value). In another example of the method, compiling the code and calculating it's length may comprise creating rights to a digital signal processor ("DSP"), e.g. a write to the DSP having a body and a length. A mailbox command may be sent to generate the CRC (or CRCs) and the DSP then may modify a parameter or parameters (or parameters sets) to include the CRC value(s). A host may then read back the compiled parameters with the CRC(s) and save them for future use. The parameters may have a blank header. In other words, one example of the method, parameters are converted from human-readable text to binary data, they are written to a DSP and the DSP generates the CRC(s) and then saves the parameters with the generated CRC(s) for verification. The method may comprise adding to the length of the compiled code (the output of block 202), for example by padding, or increasing, the length by one or more lines. This may be done until the number of valid lines (e.g. in the text file) is divisible by an integer N, depending on the block size requirements of the device or programming toolchain. The extent to which the compiled output needs to be padded will depend on the example and indeed the compiled output could be modified in a different way. The method may therefore comprise directly modifying the device program memory image in any suitable way. The CRC may be calculated from memory address 0xlc0008, for example, to the end of the available memory addresses. The length may be calculated in 32-bit words (e.g. of 01c0008 to the end of the available memory addresses) (for example, 4 lines of text in the .PM file may be equal to five 32-bit words). To generate the modified code, the length may be placed at memory address OxlcOOOO in the .PM file (the output of block 202) and the CRC value may be placed at memory address OxlcOOOl in the .PM file. As will be described below, some examples of the method comprise packaging the code (e.g. the patch) as firmware and so the above steps may be done prior to the firmware package. For example, the firmware may comprise a firmware file which is built with the updated .PM file (the code or patch containing the length and CRC header). For example, in a post-build process a post-processing script may read the output of block 202 to determine the size of the file and, where required, a separate step may adjust the length. Generating the CRC may comprise generating a new CRC in examples where there was already a CRC. When a build is being performed all of the above steps may be automated. They may or may not be performed by the same entity depending on the example. For instance, one or more processors on a computer may execute the steps of the method 200 and then the code, having the CRC, may be loaded into the memory of another entity (such as an integrated circuit) and that other entity may verify the code and CRC (as will be explained below). In some examples therefore block 201 may comprise loading at least one algorithm and / or parameter, e.g. firmware, which may be done by a processor of a device such as a personal computer ("PC"). Indeed, a processor of a PC may perform all of the blocks of the method 200 so the PC may generate the CRC (and length in those examples) and modify the existing code to include (or replace) the CRC. The output, the code having the CRC, may be sent to another device such as an IC and the IC may verify the CRC to verify the algorithm / parameter. The CRC may comprise a 24-bit CRC with 0x65B as the polynomial and 0x555555 as initial value. It will be appreciated by one of ordinary skill in the art that the CRC may comprise a N-bit CRC where N is an integer greater than one and typically, but not exclusively, an 8-bit, or multiples thereof, CRC. Figure 3 shows an example method 300 which includes the method 200. Blocks 301-305 of the method 300 are the same as blocks 201-205 of the method 200 as described above with respect to Figure 2. At block 307 the method comprises creating a firmware package including the code (generated at block 305), and at block 308 the method comprises loading the code (including the header and CRC value etc.), e.g. into a memory such as into a set of address ranges of an integrated circuit. Block 308 may comprise generating a firmware file having the code, length and CRC in the header and in this way generates a means for incorporating the code into hardware. Figure 4 shows an example method 400 of performing an integrity check (which may be synonymous with verifying the code / patch / CRC) and which may be used in conjunction with the method of Figures 2 and 3. At block 401 the method comprises booting firmware containing a process such as a memory patch (e.g. the output of the method 200, at block 205, containing the length and CRC in the header). At block 402 it is decided whether to check the integrity of the code (e.g. patch etc.) and, if not, then the method proceeds to block 403 at which booting is continued normally. If it is decided that the integrity of the code will be checked, then at block 404 the method comprises checking the CRC value. If the result of the integrity check is a success, block 405, then the code is verified, and the method proceeds to block 403 at which boot proceeds normally. Otherwise, if the integrity check fails, boot is aborted at block 406. The integrity check may be performed when an appropriate flag is set to set to an appropriate value. A flag set to the value '2', for example, may indicate that an integrity check is to be performed. In an example, if the CRC integrity check fails then the firmware doesn't call any memory (e.g. RAM) functions and makes the operation look like a "cold boot." Figure 5 shows an example method 500 of generating data for an algorithm. Whereas Figure 2 relates to generating data having a CRC value for a code or patch (in which case the parameters of the algorithm may not be known due to its nature as a patch, including that the size of the patch may be arbitrary), Figure 5 relates to generating a CRC value for an algorithm whose parameters are known. Method 500 may be performed by firmware to generate a CRC value per algorithm in each checksum field(s) of each algorithm. At block 501 the method comprises receiving a request to generate a CRC value. At block 502 the method comprises generating, e.g. by firmware, a CRC and may comprise generating a CRC per algorithm (as indicated by the arrows) in which case multiple requests may be received (although of course a single request could be received for multiple parameters). In some examples, the request is received from a tuning tool (e.g. of an audio device) but in these examples it is still the firmware that generates the CRC value, not the tuning tool. As indicated by the dotted box 503 in some examples a file (e.g. a .bin) file is generated containing the CRC value (for example each CRC value per algorithm). In one example, a tuning tool, sends a mailbox command (e.g. of the type "AUDIO_MBOX_CMD_RUN_CRC_GEN") that "tells" the firmware to generate a CRC per algorithm in each algorithm's checksum field(s) and the tool then writes a tuning .bin file containing the checksum. Figure 6 shows an example method 600 of performing an integrity check and may be used in conjunction with the method of Figure 5. For illustrative and exemplary purposes, in this example the algorithm is at least one tuning algorithm for audio and a CRC value is generated for at least one algorithm of a tuning tool. At block 601 the method comprises preparing to play an audio file or, put another way, the method begins with an audio initialisation event. At block 602 it is decided whether to check the integrity of the algorithm and, if not, then the method proceeds to block 603 at which tuning is applied and the algorithms are processed as normal and the audio is played. If it is decided that the integrity of the patch is to be checked, then at block 604 the method comprises checking the CRC value (e.g. per algorithm). If the result of the integrity check is a success, block 605, then the algorithm is verified, and the method proceeds to block 603 at which the audio is played as above. Otherwise, if the integrity check fails, then the audio is not played (that is the event is not performed) and / or an error message is generated. The integrity check may be performed when an appropriate flag is set to set to an appropriate value. For example, a flag may set to the value '2' may indicate that an integrity check is to be performed. In other words, on initialisation of the audio algorithm a CRC Integrity check may be performed when a flag is set (e.g. to 2). The checksum may be the first word in an application programming interface ("API"). The CRC may be run on the entire API excluding the checksum. If any algorithm has a checksum that fails, the firmware may return an error. If all checksums pass then the firmware may return a pass. If there is a failure of verification, then the initialisation of the audio algorithm may be aborted and each algorithm may remain uninitialised. Figure 7 shows a system 700 that may be configured to perform any of the methods as described above (e.g. any one or more, e.g. any combination of, of the blocks of the methods described above). The system 700 may comprise an integrated circuit. Figure 8 shows an example non-transitory machine-readable, or computer-readable, medium 800 comprising a set of instructions 802 stored thereon. The medium 802 is shown in Figure 8 associated with a processor 804. The instructions 802, when executed by the processor, 804 are to cause the processor 804 to perform a series of tasks. The instructions 802, when executed by the processor 804, may be to cause the processor to perform any of the methods described above (e.g. any one or more, e.g. any combination of, of the blocks thereof). Figure 9 shows a method 900 comprising, at 902, obtaining code, at 904, generating a CRC value and, at 906, prepending the CRC value to the code to generate modified code. Therefore, the method 900 may be a method of generating a data structure such as that depicted in Figures ID and IE. The modified code may have a header and the header may comprise the cyclic redundancy check value. The method 900 may additionally comprise calculating the length of the code, wherein the modified code comprises the code length in the header. The invention also provides a computer program or a computer program product comprising instructions which, when executed by a computer, cause the computer to carryout any of the methods / method steps described herein, and a non-transitory computer- readable medium comprising instructions which, when executed by a computer, cause the computer to carry out any of the methods / method steps described herein. A computer program embodying the invention may be stored on a non-transitory computer-readable medium, or it could, for example, be in the form of a signal such as a downloadable data signal provided from an Internet website, or it could be in any other form. Any of the methods described thereof, e.g. any one or more of the blocks / steps thereof may be performed by digital, analog or mixed signal circuitry, which may be embodied or implemented as integrated circuitry (e.g. one or more integrated circuits) or discrete circuitry, and / or by one or more processing resources (e.g. one or more microprocessors, microcontrollers, state machines, FPGAs, ASICs, DSPs or similar, or any combination thereof) executing suitable instructions. Features of any given aspect or example may be combined with the features of any other aspect or example and the various features described herein may be implemented in any combination in a given example. The skilled person will recognise that where applicable the above-described apparatus and methods may be embodied as processor control code, for example on a carrier medium such as a disk, CD- or DVD-ROM, programmed memory such as read only memory (Firmware), or on a data carrier such as an optical or electrical signal carrier. For many applications, embodiments of the invention will be implemented on a DSP (Digital Signal Processor), ASIC (Application Specific Integrated Circuit) or FPGA (Field Programmable Gate Array). Thus, the code may comprise conventional program code or microcode or, for example code for setting up or controlling an ASIC or FPGA. The code may also comprise code for dynamically configuring re-configurable apparatus such as re-programmable logic gate arrays. Similarly, the code may comprise code for a hardware description language such as VerilogTM or VHDL (Very high speed integrated circuit Hardware Description Language). As the skilled person will appreciate, the code may be distributed between a plurality of coupled components in communication with one another. Where appropriate, the embodiments may also be implemented using code running on a field-(re-)programmable analogue array or similar device in order to configure analogue hardware. It should be noted that the above-mentioned examples illustrate rather than limit the invention, and that those skilled in the art will be able to design many alternative embodiments without departing from the scope of the appended claims. The word "comprising" does not exclude the presence of elements or steps other than those listed in a claim, "a" or "an" does not exclude a plurality, and a single feature or other unit may fulfil the functions of several units recited in the claims. Any reference signs in the claims shall not be construed so as to limit their scope.
Claims
5 1. An audio integrated circuit comprising:a processor configured to generate modified code for at least one parameter of an audio algorithm by generating a cyclic redundancy check value for code relating to each parameter and prepending the CRC value to the code at a reserved memory location beginning at the first memory address; and10 a memory configured to store the modified code,wherein the processor is configured to, upon initialization of an event, verify the integrity of the code based on the CRC value and, if the code is verified, initialise the audio algorithm and, otherwise, abort the initialisation of the audio algorithm.15 2. The audio integrated circuit of claim 1, wherein the event is the boot of asystem containing the code.
3. The audio integrated circuit of claim 2, wherein, if the code is verified, the integrated circuit is to include the audio algorithm in the system.
204. The audio integrated circuit of claim 1, wherein the event is an audio event and wherein initialisation of the audio event comprises initialisation of the audio algorithm.
5. The audio integrated circuit of claim 4, wherein the audio algorithm is a tuning 25 algorithm or an audio filter algorithm, and wherein the processor is configured togenerate the modified code on request from an audio tool.
6. The audio integrated circuit of any preceding claim wherein the processor is configured to automatically obtain a plurality of parameters of the audio algorithm 30 and configured to generate modified code for each parameter.
7. The audio integrated circuit of any preceding claim wherein, to generate themodified code, the processor is configured to, for each parameter, increase one or more lines of the code to increase its length such that the number of lines is divisible by an integer.
58. The audio integrated circuit of any preceding claim wherein the cyclic redundancy check value is a 24-bit cyclic redundancy check value with 0x65B as the polynomial and 0x555555 as initial value.10 9. The audio integrated circuit of any preceding claim wherein the code relatesto a patch for an algorithm.22 09 23
Citation Information
Patent Citations
Method and system for firmware updates
US20100241838A1
