Abstract:
A peripheral device control system includes a single flash memory having a changeable portion for storing firmware for controlling the peripheral device and a preprogrammed portion containing control code. When it is desired to modify the changeable firmware, the control code is read from the flash memory to a storage area in the using system and is used to control the loading of the modified firmware in the flash memory.

Description:
This application is a continuation, of application Ser. No. 07/829,129, filed Jan. 31, 1992, now abandoned. 
    
    
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     This invention relates in general to peripheral device control systems, and relates more particularly to such systems having improved capabilities for modifying the firmware or microcode therein. 
     2. Prior Art 
     In many systems for the control of peripheral devices associated with computer systems there is a need to periodically modify or update the firmware in the control systems. Such need may arise during the development stage or during the commercial use stage, or both. Examples of computer peripheral device control systems which require such firmware modification are those associated with disk drives, tape drives, printers and modems. For instance, most current hard disk drive systems incorporate a single microcontroller and electrically programmable read only memory (EPROM) chips to provide the overall control hardware/firmware. This approach has been utilized from the early days of the hard disk drive and it has provided the lowest cost and most flexibility at the beginning of the design cycle. Firmware changes in hard disk drive systems are very common as a result of many factors. These factors include the fact that the hard disk drive is an electromechanical device; interface specifications change; more selftest functions are needed, and finally, human error occurs in the design process. 
     In that early period, when printed circuit board (PCB) space was not at a premium, the microcontroller chip and the EPROM were provided in what was known as Dual In-Line (DIP) packages. This approach not only provided the lowest cost, but also allowed the designer to use sockets on the PCB so that modifications to the firmware could be accomplished by replacing the EPROM without requiring any unsoldering or soldering. 
     The continuing evolution of hard disk drives has provided increasing memory capacities and an overall reduction in physical size. This has forced the designer to use Surface Mount Device (SMD) technology to provide the added functionality required to produce higher capacities with less PCB space. Most designers maintained the microcontroller/EPROM design architecture, but paid a high price for this architecture when firmware changes were required in the field. The cost difference between the two design approaches was on the average of 200% more for the SMD technology. This forced many disk drive system developers to commit to Read Only Memory (ROM) devices early in the design cycle to reduce costs. However, when a subsequent firmware change was required, greater costs were incurred. In the worst case, with the ROM soldered to the PCB, the ROM first had to be unsoldered from the PCB, the old ROM scrapped, and a new one soldered in its place. 
     Another problem encountered with some disk drive system designs is the location of the code memory chip itself. The memory chip may be buried inside the PCB, so that the PCB itself has to be removed before the memory chip can be accessed and changed, adding more cost to the firmware change process. 
     One approach to reduce the cost of firmware changes is to employ a single microcontroller, but add a small set of &#34;BOOT&#34; firmware which is mask fabricated into the microcontroller, and substitute a random access memory (RAM) chip in place of the EPROM. The masked BOOT code from the microcontroller is used to &#34;spin up&#34; the disk drive device and position the read/write heads over a special track on the disk that contains the remaining firmware which is then downloaded from the disk to the RAM. The BOOT firmware then turns control over to the RAM-based code. 
     When introduced, this technique was a breakthrough for cost vs firmware updates compared to the early EPROM technique. However, this approach still has disadvantages. For one, the designer needed to complete the BOOT code quickly in order to enable the microcontroller fabricator to complete the BOOT code masking process. Secondly, most of the disk drive hardware needed to be functioning in order to update the code on the disk. Thirdly, there is a long time delay involved in spinning up the disk and downloading the code, sometimes causing problem on fast systems at power on. 
     With the introduction of the flash memory chip in 1988, a solution for changeable firmware in disk drive systems was possible. Current flash memory chips fall into different types, 12 volt vs 5 volt reprogrammable, and bulk erase vs byte or page erasable. This type of memory device appeared to provide a good design approach to allow changeable firmware throughout the life of the disk drive. It would provide changeable firmware without the need to replace the chip, and no masked microcontroller BOOT firmware was needed. Other advantages over the RAM-based design was that very little hardware was needed in order to reprogram and no time delay was incurred on power up. 
     The use of flash memory in this environment did present two significant problems. The first was the cost of flash memory technology itself, and the second was the need to be able to reprogram the flash memory without any masked BOOT code. The cost issue involves consideration of the cost savings which can be obtained with the use of flash memory if firmware changes are needed. One approach would be to utilize two flash memory chips, one containing the BOOT code and the other containing the changeable firmware. However, this is not totally attractive because of the added space requirement for the second chip on an already crowded PCB. The present invention solves the second problem of changing firmware with only a single microcontroller and a single flash memory chip, without the use of any masked BOOT code. 
     SUMMARY OF THE PRESENT INVENTION 
     In accordance with the present invention, desired changes in system firmware in a peripheral device control system are accomplished without the need for any masked BOOT code through a novel interconnection of a single flash memory chip and a digital signal processor having an amount of RAM therein sufficient to store firmware BOOT code for controlling the updating of the changeable firmware in the flash memory. 
     At the time of assembly of the PCB containing the flash memory, this BOOT firmware is preprogrammed into the flash memory chip at specified locations. In operation, when it is desired to modify the changeable firmware in the flash memory, this preprogrammed BOOT code is read out of the flash memory into a RAM area of the digital signal processor. This BOOT code in the RAM can then be executed to control the writing of the modified functional firmware into the flash memory. This approach solves the problem that when code is being written into a flash memory, it is not possible to read from the flash memory; thus, it would not be possible to read any BOOT code from the flash memory itself while writing into it. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a block diagram of a peripheral device control system embodying the present invention; 
     FIG. 2 is a representation of a typical distribution of the preprogrammed firmware and the changeable firmware in a flash memory chip in accordance with this invention; and 
     FIGS. 3-10 are flow charts illustrating various phases of the operation of the invention. 
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     FIG. 1 shows a block diagram of elements for one implementation of the present invention in connection with a disk drive system. Although the invention will be described in connection with a disk drive system, it will be understood that the invention is useful in control systems for other peripheral devices such as printers, tape drives and modems. 
     FIG. 1 shows a microprocessor 8 such as a Zilog type Z86C94. This unit contains a number of elements including a digital signal processor (DSP) 11 having associated therewith a RAM memory area 22. Microprocessor 8 also includes a central processing unit (CPU) 9 having associated therewith a RAM memory area 25. In a representative embodiment, memory 22 may have a capacity of 160 bytes and memory 25 has a capacity of 256 bytes. Information is transmitted to and from microprocessor 8 on a serial port by means of a transmit data (TXD) line and a receive data (RXD) line forming part of the well known standard RS232 interface. Microprocessor 8 operates to control one or more peripheral devices (not shown) such as a disk drive system in the present example. 
     The system of FIG. 1 also includes a flash memory 21 which interacts with microprocessor 8 as described above to store firmware code for operation of the disk drive system and provide for updating of that firmware as required by the user. As is known in the art, a flash memory is a type of non-volatile RAM. 
     Flash memory 21 may be an ATMEL type 29C256 flash memory device, a 5 volt, page programmable, 32k by 8 bit device. In the present embodiment, each page in flash memory 21 has 64 bytes, which results in 512 pages/device, and has a page programming time of 10 msec. The microprocessor runs at 20Mhz and the access time of flash memory 21 is 150 nSec. The timing for reading of the flash memory can be obtained without any wait state, but writing to the flash memory requires the microprocessor switch to a slower timing mode. Microprocessor 8 communicates with flash memory 21 over an address bus 10 and a data bus 12. 
     As mentioned above, when the microprocessor starts writing a page of data to the flash memory, the flash memory locks out all access to any other part of the memory. This can cause a problem with most microprocessors in that they must continue to execute code out of the same memory chip. The solution for this problem in the present invention is to allow the microcontroller to execute code from its own internal RAM 22. 
     When the user wants to change the firmware in memory 21, the microprocessor loads internal data RAM 22 with the flash memory BOOT code by moving preprogrammed control code from the flash memory preprogrammed BOOT area to RAM 22 on data bus 12 between memory 21 and microprocessor 8. The new firmware data to be loaded into memory 21 is then moved from the data port of the microprocessor (serial input or interface buffer) from memory 25 to the changeable portion of the flash memory, and the system waits for the flash memory to complete the 10m sec. programming time. 
     As discussed above, the flash memory is preprogrammed with the BOOT code offline on a flash memory programmer and the programmed flash memory is then secured to a PCB along with microprocessor 8. 
     FIG. 2 illustrates one typical organization of flash memory 21 including the preprogrammed portions or modules of firmware code. The first portion of memory 21 in FIG. 2 includes 12 bytes labeled &#34;Vectors&#34; and 65 bytes labeled &#34;Startup.&#34; These 77 bytes are preprogrammed into memory 21 as described above and their function is shown in the flow chart of FIG. 3. At power on/reset, the microcontroller ports are initialized (block 101), the registers are cleared (block 102), the timers are initialized (block 103), and the serial input/output (SIO) baud rate clock is started (block 104). This clock is a serial baud generator which will recognize any input from the user and enable the SIO interrupt (block 105), followed by a predetermined time delay (block 106). The code for this power on/reset sequence is shown in pages 1 and 2 of the attached Appendix A. 
     The next portion of memory 21 in FIG. 2 is labeled &#34;Changeable Code&#34; and represents 31,664 bytes which store the changeable firmware which can be addressed and modified by the user. 
     The next preprogrammed portion of memory 21 that is utilized in the present invention is located at the high end of memory. Referring to FIG. 2, the flash memory resides starting at address 000 and extending to address 7FFF, which is 32,000 bytes if it is converted from hex to decimal. The flash memory portion beginning at address 7C00 is firmware that is preprogrammed into the memory in addition to the preprogrammed Vectors and Startup portions discussed above. 
     Referring to the flow chart of FIG. 4, the first part of this portion is 17 bytes of code labeled &#34;SIOINT&#34; in FIG. 2 (block 111 in FIG. 4) that determines whether an interrupt that was generated from the serial port was a Control A character (block 112) which will place the system in this programming mode. The code for this routine is shown on page 3 of Appendix A. 
     If the character was a Control A character, the system will go to the operation shown in the flow chart of FIG. 5, which is identified as the &#34;Flash Utilities&#34; (block 113) of 1024 bytes in FIG. 2 and which contains a number of routines. The system first displays a flash control message (block 121) for the user, these messages being &#34;Verify Flash To SIO&#34; (block 122), &#34;SIO to Flash&#34; (block 123) and &#34;Reset&#34; (block 124). The code for this display phase is shown on page 4 of Appendix A. 
     When it is desired to change any portion of the firmware in flash memory 21, it is necessary to read out the entire page of memory 21 in which the change is to be made, store it in a writable store such as RAM 25, download from the serial port the change or changes to be made on that page, including the address within the page, make the desired changes in the firmware in RAM 25 and then write the entire page (including the modified portion) back to flash memory 21. This procedure is required because it is not possible to make changes to less than single page of memory 21 by writing directly to that memory. 
     In the first routine, &#34;Verify Flash To SIO&#34; code can, be downloaded from the serial port and checked to see if the code to be put into the changeable area of the flash memory is the same as the code already in the memory. This is useful because at times a user is not certain what revision level of code is in the memory. This utility compares every byte to be sent with each byte residing in the memory, based on the memory address, before it rewrites anything in the changeable code area. Referring to FIG. 6A, the flash memory is READ at the downloaded flash memory address (block 127) and a comparison made (block 128). If any of the compared bytes do not match, the system will notify the user that there is a verified error at a specified address, that the byte it read and the byte that was to be sent to that address do not match. This is shown in FIG. 6A where the system sends a message &#34;Verify Bad&#34; (block 125) at the specified address if the compared bytes do not match. 
     If the comparison in block 128 is good, the system increments the address (block 129) and proceeds to obtain the next byte by way of routine C shown in FIG. 6B. When the byte counter (Register 4) reaches zero, indicating there are no bytes remaining on that line in the flash memory, the check sum for that line is obtained (block 130, FIG. 6A) and the system proceeds to routine B shown in FIG. 6B. If all compared bytes are good, the system displays a &#34;verify good&#34; message (block 126, FIG. 6B). The code for this routine is listed on page 5 of Appendix A. 
     Utility number 3, &#34;Reset&#34; vectors the user back to, the start as a way to restart without turning power on and off again. This code for this procedure is shown at the top of page 6 of Appendix A. 
     Utility number 2, &#34;SIO to Flash&#34;, operates to move data from the serial port and write it into the free changeable code space in memory 21 based on the address provided by the user. This routine moves the data and handles all the re-programming of the flash memory. FIGS. 7, 8 and 9 show the steps executed when the user selects utility number 2. In FIG. 7, a message is displayed (block 131) telling the user he is waiting for a SYNC signal from the system. This is to insure synchronism with the system to enter the &#34;Set Up DSP&#34; phase (block 132). 
     The system is instructed EXECUTE FROM INTERNAL DATA MEMORY; this means do not execute code from the external flash memory, but execute code from DSP RAM memory 22. After clearing the system user flags (block 133); the system waits for a line of data from the serial input (block 134). This allows the moving of a specified amount of data from RAM 25 of the microcontroller, preferably one line at a time, and writing it out to the changeable code portion of flash memory 21. If the transmitted line completes the requested loading (block 135), the system ends the flash loading (block 136). If there are more lines to be loaded, the system sets the user flag to show &#34;one line present&#34; (block 137) and proceeds to routine D in FIG. 8. The code for this phase of the operation is shown on page 7 of Appendix A. 
     The flow chart of FIG. 8 of this routine includes obtaining the page address from registers R8 and R9 and the byte address within the addressed page from register R13 (block 141). After the first line is written, the system obtains the next line of code to be written and writes it to flash memory, repeating this until all writing is completed. 
     As stated earlier, there are two different flash memory architectures available commercially; one is referred to as bulk erase, which means that to reprogram the flash memory, the command &#34;Erase&#34; is given. A difficulty with that architecture is that if the power goes off after such an erase, the entire flash memory contents are gone. The present invention uses a flash memory technology which allows erasing on a page basis as in the above-identified Atmel memory. In that flash memory, each page is 64 bytes, so that the present system is never sensitive to power outages. 
     In the operation of loading code from RAM 25 to flash memory, two variables are provided by the system on the serial port. One variable is the byte address at which writing is to start and the length of the writing, and the other variable is the address of the page in which the user wants to write. Still referring to FIG. 8, the system checks (block 142) to determine if the byte address and line length is greater than the size of a page of data that has already been loaded into RAM 25. If the new data involves a memory area which is larger than that loaded in RAM 25, it is desirable to load that portion which is already in RAM 25 into flash memory 21 before supplying the new data to RAM 25. 
     This is shown in FIG. 8 where the size of the code to be loaded is compared with a page size. If the comparison indicates an &#34;equal to or greater than&#34; condition (block 143), the page length is saved in register 4 (block 144) and the system proceeds with routine G shown in FIG. 9. The system determines (block 151) the number of bytes remaining on the present page and the number of bytes on the next page. The next step is to obtain a line of data from the serial port (SIO) (block 152) and load it into RAM 25 to complete a page of data in that RAM. This page of data is then programmed from RAM 25 to flash memory 21 (block 153) and the system then checks (block 154) to determine if there are additional bytes of code on the next page for that load. If so, the byte address in RAM 25 is set back to zero and the page address is advanced by one (block 155). The system then reads the next code into the newly designated page address and continues in this manner until all data has been written to memory 21. 
     The system then proceeds to obtain the line check sum (block 156) which involves a known error detection technique in which a check sum of the bytes on each line of code downloaded from RAM 25 to memory 21 is obtained and compared with the number of bytes intended to be loaded. If the check sum indicates a proper byte count, the system returns by routine F to block 134 of FIG. 7 to wait for the next line of data from the serial port. 
     In FIG. 8, if the comparison in block 143 indicates a &#34;less than&#34; condition, the system proceeds to routine E in FIG. 9 to obtain a new line of data (block 157) from the said input. 
     When an address is downloaded, the address might not be an address that is on a page boundary. Thus, the system needs two parameters from the downloaded program; the page address, which one of the 512-pages, and which byte in that page is the writing to start on. If the system is downloading and it is not on a page boundary, the downloading could begin in the middle of a page and extend through another page. The present system detects an attempt to cross page boundaries and holds up further downloading, as shown in FIG. 10. When the system determines that it is over a page boundary, it must be prevented from sending additional data because the serial download is an asynchronous operation which is not clocked. 
     To stop data from the system, after clearing the page loaded flag (block 161), an X-off character is sent to the system (block 162). This sets an internal code bit (block 163) telling the system to execute code out of the internal memory (blocks 164 and 165), dump the flash page, and switch back to non-extended timing (block 166). Then the internal code is disabled (block 171) and an X-on character is sent to the serial input (block 172), which tells the system to send additional code to the flash memory. This portion of the code is shown at the top of page 9 of Appendix A. ##SPC1##