Architecture and method of managing an interface based on a finite states machine

Abstract: An interface comprising a finite states machine and logic circuits for adapting it to a given specification, for managing asynchronous and independent interactions between external circuits, by way of user commands, and a plurality of internal circuits each functioning with a clock generally different from the clock of other internal circuits, of an integrated digital system, is defined to work with a unique clock and unique reset and further comprises an arbitration structure of the input signal provided to the finite states machine, comprising a memory buffer in which any user command or any command or datum, generated by any one of said internal circuits issued during a phase in which said finite states machine is carrying out an evaluation is stored. The interface is particularly suited to constitute a command interpreter of a FLASH-EEPROM device.

Description: FIELD OF THE INVENTION The present invention relates to finite states machines and in particular to a method of managing and an interface based on a finite states machine. BACKGROUND OF THE INVENTION Often in digital and digital-analog integrated circuits it is necessary to include a finite states machine that works as an interface between the external circuitry (user) and one or more internal functional circuits such as counters, microcontrollers, converters, and the like. Such a structure must on one side update its internal state in order to give a precise indication of the working condition of the device at every instant and, on the other side it receives user commands, communicates the information (if so required) to certain functional circuits, waits for their response, runs embedded algorithms, signals the end of these algorithms, etc. Often, the interface performs a true handshake among the external circuits and one or more internal circuits. The interface assumes a basic role and any misfunctioning, even in just one of the tasks that it carries out, may in some cases cause an interruption of communications and consequently require a hardware reset of the whole integrated circuit a new start from the initial conditions. The article "Synthesis of asynchronous state machine using a local clock" XP010025205, discloses a state machine having a structure that provides a local clock. The possibility of determing the outputs of the future state in function of a control combinatory logic relationship between the inputs and the current state of the outputs is described. If, at a certain instant, is present at the input a combination such to determine a changing state through the logic combination of the current state and of the input combination, then a clock signal that suitably acts on a master-slave flip flop structure is generated. The document US-A-5,333,300, discloses an interface between a command interface and a microcontroller of a flash memory. The structure does not contemplate the ability of managing asynchronous requests of valuation coming from different sources. The specifications to be satisfied by this type of structure may be subdivided in two categories: 1) The interface may modify its own state only upon an user clock pulse (CLK) and in this phase it will carry out its own evaluation based on the values present at the external inputs as well as on signals coming from the internal circuits with which it interfaces. In this case, the interface acts only upon reception of an user command taking into account all information provided to it. Its functioning is akin to the work of an employee who acts on command of a single boss (external circuits), taking into account what his colleagues (internal circuits) have communicated to him. 2) The interface may modify its state upon "commands" coming from one or several internal circuits (from "peer" circuits). In this case, its functioning is akin to that of an employee that carries out tasks assigned to him from time to time by two or more bosses, without any allowance of missing to perform any of the received commands, unless recognizably useless. Typically, in such circuits the requests of operations coming from external circuits are of various kinds and rather complex and are issued in the form of a bit sequence, the combinations of which must be suitably encoded and correspond, in general, to tenths of possible commands. On the contrary, the handshake with any of the relevant internal circuits takes place through the communication of just few bits (often a single bit or flag) that signals an "acknowledge" or an "end operation". The considerations that will be made in the following description and the invention relate to interface structures belonging to the second category, the specifications of which are relatively more burdening and complex than those of an interface structure belonging to the first category. The relative complexity of the design of these interfaces of second category derives from the fact that the specification of these structure does not allow for a straightforward identification of an appropriate design of a suitable state machine according to classic design rules established in the literature. In fact, in the literature may be found various methods for the implementation of synchronous machines, but they are all based on the assumption that they work with a single clock and a with single reset. Conventionally, the variety of commands is peculiar of and attributed to commands coming from the external world, while by contrast the internal circuits communicate among them through simple "acknowledge" signals, and according to the design solutions so far practiced, the state machine (briefly SM) is considered as a synchronous machine that receives its clock from the external world circuits and manages the interaction with the internal circuits in an asynchronous mode by resetting the bistable state circuits (FF) according to conditions based on information coming from the internal circuits. Assuming that, upon recognizing a proper sequence of user commands, the SM reaches a state univocally determined by the setting of the FFprog, which causes the start of a certain embedded operation by the device. When such an operation has been completed, in order to resume the initial condition it is possible to use an ENDOP signal (End Operation) generated by the internal circuit that perform the operation to reset the FFprog and eventually other synchronous circuits that had changed their state upon the recognition of the input sequence. In certain applications, the reset is done by means of a very short pulse (of minimum duration) as it will be better highlighted later. In other applications, certain state FFs receive the user clock, other FFs have their own clock pin coupled to handshake signals with the internal circuits; such that upon an internal communication, a FF sets, instantaneously changing the global state of the machine but the same FF must be reset after propagation of the event through a circuit chain. There are also applications in which both reset mechanism are used, in combination. In practice, by considering the interface as a single large finite states machine, it may be observed that in the first type of applications it uses a single (user) clock but a multiple reset, while in the second type of applications it uses a multiple clock (in the sense that different FF have different signals on their respective CLK pins) and finally, in the case of applications implementing a hybrid mechanism, there may be state variables with multiple clocks and multiple reset signals. Drawbacks of all these approaches may be summarized as follows: Wide windows of insensibility to commands: in particular, it must be observed that, where a pulse deriving from an internal communication is used to reset the state variables, the pulse must last enough to ensure reset in all temperature and supply voltage "corners" (limit conditions). This implies that, during such a reset pulse, eventual user commands will not be accepted, irrespectively of their "importance". Complex design: design complexity increases because in order to cover all possible situations it is not easy to resolve such a complexity in few homogeneous circuits. On the contrary it is necessary to use a large number of different combinatory and sequential sub-circuits (sparse logic), whereby each of them must store reset conditions for other sequential circuits that eventually must close the loop by resetting the first ones. Difficult reproducibility : these structures are so specifically designed for solving a particular problem that when a new device compliant to a different specification is needed, the design must be completely overhauled. Area occupation : the impossibility of solving the circuital complexity with a "standard" structure using with a single clock and a single reset, severely hinder optimization during the phase of automatic synthesis. Basically, while in a standard structure it could be possible to obtain a four flip-flops synthesis by describing the circuitry according to the above mentioned known approaches the synthesis may produce a circuit requiring about ten memory elements. The greater the number of the states to be managed, the greater is this proliferation effect. Difficult testability : if the whole interface could summarize its current state on a bus of state variables of a few bits concentrated in an homogeneous area, it would be easy, in test mode, to force a state, let the structure evolve and finally read the state in which the structure evolves after an evaluation. The above discussed approaches because of their inherent complexity clearly imply a difficult testability. Any didactical document pertaining to digital design invariably stresses that for synchronous structures the design approach to be followed is that leading to the maximum uniformity of clock and reset of all FFs. On the other hand, the above mentioned specification are satisfied with great difficulty by following such a canonical design approach as the circuit structures of known commercial devices amply demonstrate it. SUMMARY OF THE INVENTION A different approach followed by the present inventors that has been found outstandingly effective in overcoming the above discussed difficulties and drawbacks of the known approach is that of designing the interface circuit such to be, substantially definable as a SM working with a single CLK command and with a single reset command (the latter common to all the logic circuits of the device) solicitable to act, respecting the set up and hold times on the inputs, at a rate such that each new command does not arrive before the current evaluation has been correctly concluded. Indeed, a state machine having these features would fall into "standard" categories and would be suitable for a VHDL description referred to a MOORE or to a MEALY machine, or the like, depending on needs. Furthermore, a so defined SM, upon being designed by an automatic synthesizer, would lead to an "optimized" synthesis even from the point of view of the area requisite. The problem of adapting a specification that impose the possibility of independent and close asynchronous interactions (because of the absence of a protocol that coordinates the actions of the external circuits in respect to the actions of the internal circuits), with a single clock command (CLK) structure that exclude the possibility of multiple commands, has been brilliantly solved by defining an arbitration structure that adapts certain requirements of the specification to a certain SM of standard characteristics. The tasks of such an arbitration structure are: detecting all the requests coming from external worlds; detecting the condition (free or in the course of carrying out an evaluation) of the single clock SM and, depending on it, sorting and cueing the requests, while respecting two main aims: passing commands to the SM only when it is able to carry them out (that is when there is not any other evaluation in progress) and eventually providing the data (on respective inputs of the SM) necessary to produce a correct evaluation; detecting all the requests and deciding which to store for carrying it out as soon as possible and which to filter (eliminate) if recognized as influent or useless. Basically, the method of managing a finite states machine commanded, according to the invention, through an "interface" or input arbitration circuit having a memory buffer in which any command to be carried out may be stored, by issuing a command through data inputs of the finite states machine and applying a clock signal to a single clock input of the finite states machine, comprises the following steps: a) for each new command verifying whether it is received while the state machine is carrying out a previously received command or not; b) if the test a) is negative, conveying the command to the finite states machine either as a simple clock pulse if it is an user command or as an input datum and a clock pulse if it comes from internal circuitry, and restarting a new cycle from point a); c) if the test of point a) is positive, verifying whether the new command can be ignored or not; d) if the test of point c) is negative, storing the command in the buffer, waiting for the state machine to end execution of the previous command, conveying the stored command to the state machine in the form of an input datum and of a clock pulse, then erasing the command from the buffer and restarting a new cycle from point a). By analogy, the arbitration structure is like an efficient secretary capable of accepting the tasks and of communicating them to the employee only if necessary and if this person is not at the moment busy with other tasks. In this manner it is possible to reduce the stress and to improve the quality of the work of the employee. Comparably, the error probability of the device of the invention is drastically reduced by realizing an accurate SM (employee) and an efficient arbitration structure (secretary). Such a difference between a prior art interface and an interface of the invention may be pictorially highlighted as fancifully done in Figure 1, suggestive of the relative complexity of the situation of a traditional design and of the relative simplicity of design according to the scheme of this invention, based on the implementation of an arbitration circuit of the input signals. The invention is more precisely defined in the annexed claims. BRIEF DESCRIPTION OF THE DRAWINGS Figure 1 is a fanciful representation that compares the functioning of a finite states machine interface according to the known techniques and according to the present invention. Figure 2 is a high level block diagram of the architecture of the interface of the present invention. Figure 3 is a basic circuit diagram according to a possible embodiment of the input arbitration structure. Figure 4 is a timing diagram of the structure of Figure 3 relating to a case of a first group or category. Figure 5 is a timing diagram relating to a case of a second group or kind. Figure 6 is a timing diagram relating to a third group or category. Figure 7 is a timing diagram relating to a case of a fourth group or category. Figure 8 is a classification table of commands relating to a specific application of the architecture of the invention to a FLASH AMD-compatible memory. Figure 9 depicts a possible embodiment of an arbitration structure for a command interpreter of a FLASH AMD-compatible memory. Figure 10 illustrates the path of commands coming from the user in the case of a FLASH AMD-compatible memory. Figure 11 illustrates the path of the command TIMEOUT coming from the counter of the FLASH AMD-compatible memory. Figure 12 illustrates the path of the user command SUSPEND during the execution of a TIMEOUT command. Figure 13 illustrates the path of an ENDOP command coming from the microcontroller of the FLASH AMD-compatible memory. Figure 14 depicts a significant portion of the circuit of generation of the clock to be fed to the SM. Figure 15 depicts the functional diagram of a priority-set, set-reset flip-flop for managing the additional data to be sent to the SM. Figure 16 is a timing diagram relating to real-time user commands of group A1. Figure 17 is a timing diagram relating to internal commands (from micro, counter, etc.) or to commands delayed by superposition. Figure 18 is a high level block diagram of a commercially available FLASH-EEPROM device. DESCRIPTION OF SEVERAL EMBODIMENT OF THE INVENTION Having established the architectural approach of the invention, it is possible to describe in more details how to go about designing a proper input arbitration structure (ARBITRO). Being the invention applicable and effective in many different cases, the following description will not refer to a particular specification, rather an effective design approach of the different arbitration circuits, specific for the different possible commands, will be identified and illustrated hereinbelow. Basically, according to the present invention, the input arbitration structure manages the following situations that may be classified into groups: GROUP 1 - External (user) command while no evaluation is in progress; GROUP 2 - Internal command while no evaluation is in progress; GROUP 3 - Internal or external command, while an evaluation that cannot be neglected for respecting the specification, is in progress; GROUP 4 - Internal or external command, while an evaluation that can be neglected because it would not change the state of the SM is in progress. In the above situations, the arbitration structure must perform as follows: GROUP 1 masking eventual further commands to the SM for a time Teval sufficient to carry out the evaluation; transmitting the clock edge in the form of a monostable signal to the SM. GROUP 2 masking eventual further commands to the SM for a time Teval sufficient to carry out the evaluation; providing the information in input to the SM in a real time fashion; issuing a clock pulse to the SM after a certain time interval Tsu. GROUP 3 storing the request in a real time fashion; waiting for the end of the operation in progress; providing the stored information (that can be defined as INTDATA) to the SM; issuing a clock pulse to the SM after a certain time interval Tsu; resetting the buffer storing the already used information. GROUP 4 ignoring the request and doing nothing. Figure 2 is a scheme of an interface architecture of the invention, characterized by the presence of an arbitration structure ARBITRO. The inputs and the outputs toward the finite states machine SM are provided with appropriate labels identifying the distinct input signals paths. Among various ways of embodying this architectural approach depending on the specifications and the preferences of the designer, a possible configuration that may be easily adapted to any specific case will be presented hereinbelow. Figure 3 depicts a possible circuit that realizes the structure ARBITRO of the interface of the invention of Figure 2. The different conditioned paths of commands may be recognized by looking at the respective zones contoured by a dotted and dashed perimeter in the general circuit diagram of Figure 3. The zone of Figure 3 labeled GROUP 1 relates to the signal path stimulated by user commands arriving while the state machine is not carrying out any evaluation; by contrast when an evaluation is still in progress, such a path is disabled by the gate input with the signal Teval (see the block CLOCK GENERATOR). The zone of Figure 3 labeled GROUP 3 relates to the signal path stimulated by commands coming from the internal circuitry while the SM is not carrying out any evaluation. The zone of Figure 3 labeled GROUP 2 relates to the signal path through which commands (user and other commands) arriving during evaluation of a previous command are stored. The signals Cond_i represent the conditions (determined by the internal state of the SM) that determine the temporary storage and the eventual successive delayed evaluation only if necessary. The zone of Figure 3 labeled GROUP 4 relates to the signal path stimulated when suitable input signals must be provided to the SM because "internal" or delayed commands have been received. The zone of Figure 3 labeled GROUP 5 relates to the circuit that generates the clock and the signal Teval to be sent to the SM. Referring to the timing diagram depicted in Figure 4, in case of a GROUP 1 command, a start pulse is provided to the monostable A that generates the signal Sig_eval having a duration equal to Teval, that is long enough to carry out the evaluation (where evaluation means the propagation time through the registers of the SM plus the time needed by the input combinatory logic network to stabilize itself following a change of the state variables. In fact it must be considered that just after the time Teval has elapsed, a new evaluation may take place. The monostable signal shown in the lowest part of Figure 4 cannot be set for the whole Teval interval because all the paths that could set it are disabled during this time interval. The CLK_SM is nothing else than Sig_eval, thus the timing of the SM is similar to that illustrated in the diagrams of Figure 4. As it may be easily noticed, nothing changes and the set up times of data, ensured by the user in respect to USRCLK, are guaranteed even in respect to CLK_SM. As long as MON_A does not return in stand-by, any new clock pulse will be transmitted in real time. In case of a GROUP 2 command an internal command arrives while no operation in progress and in this case the timing will be that depicted in Figure 5, wherein the signal CLKAINT represents a generic internally generated evaluation request reaching the SM. As it is possible to note, the two monostable pulses are generated in real time (as a matter of fact MON_B switches MON_A in order to avoid any glitches on the clock). The monostable pulse MON_A blocks any eventual interfering command towards the SM. The monostable pulse MON_B times the provision to the SM input datum in respect to the clock beat. The signal INTDATA, which represents the information, is instantaneously set. After a time Tsu, determined by the monostable pulse MON_B, a clock pulse may be issued. In this case, the timing of the signal CLK_SM is determined by the difference (Teval - Tsu), therefore this difference must be greater than the evaluation time plus the stabilization time of the input combinatory logic network of the SM following variations of state variables. In the case of a GROUP 3 command, an user command or an internal command that cannot be neglected is received while an evaluation is still in progress. The information (command) is stored in memory elements (Flip-Flop) and only when the interval Teval of the operation in progress expires, the new evaluation may be started with the same execution characteristics of a GROUP 2 command. Figure 6 depicts the timing diagram relative to this third group. Figure 7 depicts a possible timing diagram of an external (user) command or request of evaluation or a GROUP 4 internal command. As highlighted by the diagram of Figure 7, any request that is not to be stored in a memory element and that arrives while an evaluation is still in progress, is masked by SIG_EVAL and is never executed. The circuit depicted in Figure 3 is just a sample embodiment, in reality an arbitration structure ARBITRO with the above illustrated functions may be realized using circuits that may be adapted or optimized depending on specifications and preferences of the designer. The architecture of the invention has many advantages. An interface made according to this invention does not have windows of insensibility to commands as wide as a classic structure normally has because of the fact that a local reset pulse of finite duration masks eventual user commands. According to the novel approach of this invention the reset signal of the SM is the same global reset signal of the whole logic circuit and does not switches during normal functioning. The window of indetermination of a structure realized according to the present invention is smaller than the crossing time of just a couple of fast logic gates (i.e. a fraction of nanosecond). The complexity of the design is markedly reduced because it is possible to design a SM through a standard description with single clock and single reset such to make any transition easily predictable. Moreover, the arbitration structure ARBITRO may have in general a modular structure whereby it is always possible to make a new situation fit one of the four groups described above so that the circuit module for managing remains standardizable. A consequence of these peculiarities and advantages is that the structure may be reproduced in different technologies and may be quickly adapted to changes in the specifications (it is thus possible to save a lot of time in designing and in re-designing). Another advantage that may be underlined is the reduced silicon area requirement for realizing the SM. In fact, as stated before, the possibility of describing the SM in a "standard" fashion allows for an optimized codification of all the states and thus it is possible to reduce the number of FF required. A consequence of this is simplification of testability. In fact, the variables that describe completely the state of the machine are less numerous, therefore more readily encoded and localizable on a single bus. It is thus easier to bring out (access) the variables to test the SM. It is even possible to force the starting state, issue a clock beat and read the final state. USE OF THE INTERFACE AS CLOCK ARBITRATION STRUCTURE FOR THE COMMAND INTERPRETER OF A FLASH MEMORY According to the most recent developments, so called FLASH-EEPROM non volatile memory devices can manage, by means of their own internal logic circuitry, complex updating algorithms and generate autonomously the relatively high voltages that are needed for erasing and writing data. In order to make it possible, specific digital structures are needed, among which: a microcontroller that, depending on the task to be performed, carries out an appropriate sequence of operations or steps (algorithm); a counter for managing, among other things, the timing of application of high voltages to specific circuit nodes. In certain FLASH memories there are specific logic circuitries for managing the protection and other functions. Among said digital structures there is also an interface structure, commonly known as "command interpreter" (CI) that, depending on more or less complex specifications, recognizes (by way of codes) the operations that the user requires, and establishes a handshake with pertinent digital circuits. For example, according to certain specifications, once the sequence of commands corresponding to an erasing operation has been detected, the CI starts a counter, waits for a signal TIMEOUT and communicates to the microcontroller a state of readiness to run the relative code. The communication ends with the end of the operation, signaled by the microcontroller to the command interpreter. Obviously, among different specifications there are differences in the codes used for a certain operation as well as in the type of operations that are contemplated (for example certain specifications contemplate a suspension of the programming, in other specifications such a command is not accepted). Generally, these differences do not imply any substantial difference in the design of the command interpreter, rather a decoder is realized to recognize certain codes instead of other and a state machine (SM) wherein certain states and certain transitions are contemplated as needed. There is though a crucial difference that distinguishes specifications in two categories, each imposing implementation of a state machine conceptually different from the other, with the associate risk of introducing criticalities and errors in designing a memory device compatible to both categories of specifications. For sake of simplicity, a first category may be represented by INTEL specifications and the other category by AMD specifications. The substantial difference between the two types of specification may be highlighted with an example: in memory devices of the first kind (INTEL), when an operation ends, for example a program operation, the CI must not "react" by changing its state immediately but it will do so only after an user command is received that makes the SM return to its initial state; in memory devices of the second kind (AMD), in the same situation, the CI must change its state by returning to a IDLE state without any user command; indeed, when the operation ends, may start immediately a new sequence of commands that must be accepted. In order to understand why this difference is rather "substantial", it must be observed that in the first case there is only a source of commands, other circuits may condition the successive evaluation but cannot determine it. In the second case, on the contrary, more than one source may start the evaluation or change directly the state of the SM. What complicated the situation is that there is not and could hardly exist any synchronism among user commands and commands coming from internal circuits. This implies that, while a certain evaluation is being carried out, a successive command may arrive that should not change the evaluation in progress but not be omitted. There is a certain number of operations that are managed by the user without any handshake with a microcontroller or with a counter: such operations are CFI, AUTOSELECT, UNLOCK_BYPASS, that are not analyzed in detail because they do not require any adaptation of the arbitration structure according to the present invention. A command PROGRAM relates to a programming operation of a word at a certain memory address. In this case the beginning of the operation is determined by the user. During the programming, before the microcontroller signals the end of the operation by the signal ENDOP, no user command may cause a change of state; nor software reset (reset sw) and suspension commands are admitted. When ENDOP is received, there are two possibilities: if the algorithm was successfully concluded, the SM must return in IDLE condition, ready to start another operation; on the contrary, if the algorithm failed, the SM remains locked in modification state as long as the user, having detected the "fail", gives the F0 (reset sw) command to unlock it. Therefore, in one case is the microcontroller that unlocks it, in the other case is the user who does it. Another possible operation is CHIPERASE that consists in canceling all memory sectors of the FLASH_EEPROM device; the managing, from the point of view of the command interpreter, is the same as for the command PROGRAM. Another allowed operation is BLOCKERASE that consists in canceling one or more memory sectors chosen by the user. It is surely more complex because of the various possibilities that are contemplated by the specification. After a pre-defined number of user commands, the user signals the address of a sector to be erased; if there is not any further intervention by the user, after a certain pre-established time (50 µs), the algorithm erases the selected sector. On the contrary, if the user indicates a different sector to be erased before 50 µs are elapsed, the counter restarts counting 50 µs, and so on for as many sectors the user wants to select. After 50 µs are elapsed from the last indication of a sector, the algorithm carries out the erasing. When the algorithm ends there are the two possibilities already described for the other operations of data modification. A substantial difference in respect to the other operations of modification consists in the fact that a suspension, ordered by the user, is acceptable while waiting for a TIMEOUT (thus the algorithm has not been started yet), as well as while the algorithm is in progress. This spectrum of possibilities highlights the different interleaving that may occur among different asynchronous commands. For example, if a SUSPEND is received immediately after a TIMEOUT, it must be ensured that the first command is not lost because the user expects a suspension after that command. There are various known circuits that implement a command interpreter referred to AMD type specifications. To illustrate in detail these techniques may be burdensome, but in these known circuits the managing of the multiple asynchronous commands is implemented in a structure having a "core" SM (finite states machine) with around a plurality of sparse memory devices (each of which may work with its own clock and with a different reset condition) that condition the clock and the reset of the SM core. Moreover, many of these synchronous elements determine a chain of reactions such that the setting of a flip-flop may cause the generation of a reset pulse that resets another flip-flop which in turn resets the first flip-flop. For instance, given a sequence of user commands that, when detected, implies an operation of data modification (program or erase), let us suppose that at the time T0 an evaluation of an user command be in progress; if at the time T0 an ENDOP coming from the microcontroller is received this command could be lost or change the state of the CI while it is already evolving. In certain known solutions, ENDOP acts on the reset of the SM core and thus it is able to bring the SM to an IDLE state irrespectively of the evaluation that was in progress. This effect must be masked though if ENDOP arrives when a failure of the algorithm has already occurred and thus an appropriate conditioning must be implemented. Even more articulated is the managing of a possible proximity between TIMEOUT of the counter and a suspension required by the user. Depending on the adopted solutions, there is the risk of losing the suspension and this is not allowed by the specifications. Beyond practical examples, it is easy to recognize the risk that hides in any design approach that cannot rely on a rigorous structuration of the specifications but on establishing an appropriate control for each situation and that implies recourse to a variety of actions sometimes to the masking of the clock, sometimes to the conditioning of the reset and other times to a mix of actions. The most evident consequent drawbacks are: WIDE WINDOWS OF INSENSIBILITY TO COMMANDS . If in certain situations an operation is carried out changing the state by means of a reset pulse of non null duration while in other situations by means of a clock edge, it easy to understand that there may be wide windows of insensibility. In fact, in a FF as long as a reset pulse, is active an eventual clock pulse that may arrive will not change its state. Moreover if a clock pulse is very close to the reset the state assumed by the memory element could be random. POSSIBILITY OF HALT . The considerations made above imply that an ENDOP type command could be lost. This command arrives only once and if lost, the system could halt in the modification state or even in an unforeseeable state. The problem is aggravated by the fact that in certain conditions a software reset command contemplated by the FLASH memory must be ignored. AREA OCCUPATION. The designer has a limited possibility of optimizing area occupation because he must consider all possible conditions using an approach that hardly leads to a standard SM definition. There are several memory elements with control pins conditioned in the most various manners and therefore they are difficult to be simplified even by an automatic optimization tool. DIFFICULT TESTABILITY . The state in which the IC is at a given instant is determined by all the FF that have been used, which are numerous and not homogeneously disposed. Therefore, it is difficult to couple them to few output pins, as it happens in testmode. Moreover it is excessively laborious to make tests in which it is possible to force any initial condition and detect the future state in order to ascertain the correct functioning of the system. DIFFICULT REPRODUCIBILITY . Having the design followed the approach of satisfying each point of the specification, it is hard to quickly adapt the same circuit to a different specification, even if only slightly different from the original one. It is useful to remark that, in applications that use flash memory devices, the probability of superposition of demands to the SM coming from different sources is rather small; this because the user provides commands that are properly spaced according to specification; the microcontroller intervenes with a single signal ENDOP to signal the end of an operation but does it only once per operation and executes operations that last relatively long (several µs for programming and seconds for erasing); the counter generates a single TIMEOUT for each sector cancellation operation and provides it after 50 µs from the provision of the address of the last sector to be canceled. This explains why even approaches that are not so rigorous from the point of view of the design approach, seldom show malfunctionings. Besides, once the circuit has been realized on silicon, if a malfunctioning occurs it may be difficult to attribute it to the CI because a situation of superposition cannot be reproduced. Being little probable does not mean that it cannot happen. Therefore it is very important to minimize the risk of possible "failures" by defining a CI structure that does not have by the above mentioned criticalities and drawbacks of the known CI structures that are used in these types of memory device. The interface architecture of the present invention eliminates or reduces in an extremely effective manner the above mentioned problems. In fact the above discussed problems pertain to a digital structure with multiple clock and multiple reset, while, according to the approach of the present invention, the design of the CI structure is split in design of a distinct command arbitration structure (clock and data arbitration structure, in the case considered) and of a state machine functioning with a single clock and a single reset. The objective is thus to design an input arbitration structure that receives multiple clocks and multiple resets and communicates with a conventional SM using a single clock and a single reset. The input arbitration circuit (ARBITRO) performs the following functions: providing a single clock (CLK); providing supplementary input data to the SM with appropriate set up and hold; separating the evaluation operations in order to carry them out one at the time. For the particular application being considered, the possibilities are the following: user commands while SM is not evaluating; end count command from the counter (TIMEOUT) while SM is not evaluating; command from the microcontroller (e.g. ENDOP) while SM is not evaluating; command from the microcontroller while SM is evaluating; user suspension command (SUSPEND) while a previous counter command is being executed; any user command, except a SUSPEND, while an evaluation is in progress; command from the counter while an evaluation is in progress. The arbitration circuit (ARBITRO) must behave in one of the three following ways: 1) accepting the command and passing it to the SM because not engaged in any task; 2) accepting commands but passing them to the SM later if the SM is engaged in an evaluation; 3) ignoring the commands because the specification allows it. Moreover, there are user commands that may be issued while the SM is free but that may not be carried out though respecting the specification. For instance, if the SM is in a state BLOCKERASE (cancellation of one or more sectors) the only user command that may cause a change of state (before the end of the operation decided by the microcontroller) is that corresponding to the suspension code; any other user command must not change the state of the machine. It is then possible to decide in this case of not producing a useless evaluation. In the case of this important application of the invention, the operations to be carried out are: GROUP A1 masking other possible commands for a time Teval; providing a clock pulse to the SM in a real time mode; GROUP A2 masking other possible commands for a time Teval; providing the input datum to the SM in a real time mode; providing a clock pulse to the SM after a time Tsu. GROUP B storing the request in real time mode; waiting for the end of the operation in progress; providing the input datum to the SM in real time mode; providing a clock pulse to the SM after a time Tsu. GROUP C ignoring the command and doing nothing. The above classification if referred to the sources may be schematized as shown in Figure 8. A possible embodiment of an arbitration circuit for the type of application of the interface of the invention as an arbitration structure of input clock signals is depicted in Figure 9. The labeled portions of the circuit are separately analyzed in detail. The path of user commands relating to the situations of GROUPS A1 and C is that of Figure 10. CWE_N is the user clock that, when a command is produced, switches high. PULSE_GEN transforms a rising transition in a pulse having a short duration that varies with temperature and the supply voltage. The duration of such a pulse does not have to be particularly precise. If the signal MASK_N is high, that is the command is not masked, the result is a simple pulse on the signal USRTRANS. The portion of the circuit bordered by a dashed line that produces the signal MASK_N may even be omitted depending on what is contemplated in the design of the SM. Preferably this portion of the circuit is present because it is safer to filter the request than making an evaluation that leaves the state of the SM unchanged (as any other command while a programming is in progress). Therefore, the mask does not leave user commands pass in all modification states while an algorithm is in progress except in case of a suspension during the BLOCKERASE operation. If the algorithm has terminated and a FAIL has been generated, user commands must pass because a F0 is necessary to unlock the SM. CUIFAIL is the output signal of the SM that is set only when the algorithm ends in an unsuccessfully manner. The signal SUSPEND_X is generated by a decoder that recognizes the code of the suspension command on the data bus. Given that the user must provide codes with an advance time Tsu before the clock pulse, the mask is surely in steady conditions when the front edge of CWE_N is received. The path for the command TIMEOUT generated by the counter that signals the end of the waiting to start the BLOCKERASE algorithm is highlighted in Figure 11. If any evaluation is in progress, there is a pulse on TIMEOUT_TRANS. If an evaluation has been started or if an evaluation is still in progress, such a pulse does not pass on TIMEOUT_TRANS. This is allowed by the specifications, because having an evaluation in progress when TIMEOUT is received means that the user has given a command (in fact the microcontroller cannot be the cause of the evaluation because in this phase any modification has not been started yet). From the specifications, a command may be a suspension, and in this case the TIMEOUT must not be waited anylonger; or a new sector to be canceled, and in this case the counting must be reset and thus it is correct to lose the TIMEOUT that could be received in this phase; or any other command must return the SM in IDLE state, therefore even in this case the TIMEOUT is ignored. The path that ensures that the user command SUSPEND is not lost during the execution of TIMEOUT is highlighted in Figure 12. The specification does not allow to lose such information that must be stored and carried out later (GROUP B); therefore a memory device is necessary. If a leading edge of USRTRANS is received and the combinatory function on the datum present at the input D of the flip-flop confirms that an evaluation, caused by the counter because of the end of the counting, is going to be started (TIMEOUT) or is already in progress, and the user has imposed the code SUSPEND on the data, the FLAG_SUSPEND is set. This information cannot pass as long as the evaluation in progress (Teval has not yet elapsed). At this point FALSE_TIMEOUT_TRANS switches high and this, as it is better described hereinbelow, will eventually start the new evaluation. As soon as such an evaluation starts, the switching of Teval quickly switches S 1 low. In cascade to the output FALSE-TIMEOUT-TRANS may be present a stretcher circuit that stretches the pulse, in the sense that it leaves unchanged the leading edge and delays the trailing edge; this better ensures the propagation of information. The path for end operation commands coming from the microcontroller, when the SM is not evaluating and when SM is evaluating, is highlighted in Figure 13. When there is a command coming from the microcontroller, there cannot be situations belonging to GROUP C and thus the command cannot be ignored. When a trailing edge of ENDOP_N is detected, if USRTRANS has not been started yet or an evaluation Teval is in progress, a pulse will pass through the lower path on G_ENDOPTRANS. On the contrary, when ENDOP_N arrives, the lower path is blocked by the setting of the flip-flop. The information carried by ENDOP cannot be evaluated immediately and for this reason it is blocked by Teval. Only at the end of the evaluation in progress the stored evaluation will be started. Even in this case a pulse stretcher stage, may be present. The information of the flip-flop is reset (RES2) only when the deferred evaluation has brought the SM in the correct state. The circuit structures described so far represent the possible paths leading to the generation of pulses on one of the four intermediate signal paths that, in some way, must determine the generation of output signals from the arbitration structure ARBITRO. The remaining portions of the arbitration structure, respectively establish the clock and the supplementary input signals, to be provided to the SM to enable it carry out the required evaluation. By referring to Figure 14, the function that determines the clock CLOCK_TO_SM that is sent to the timing input of the SM is the logic difference between the outputs of two monostables: the monostable MON_A, that has a time duration Toper that represents the time needed to carry out completely an operation; the monostable MON_B, that has a time duration defined by the fact that when it is necessary to provide inputs to the SM, they must be provided in advance of a set up time. By defining Tsu the maximum set up time required by the fake inputs that are those established by the circuit of zone 5 of Figure 9 and shown in Figure 15, that is: OLD_SUSPEND (for an evaluation of deferred suspension); ENDOPDATA (for an evaluation due to a command of the microcontroller); CUI_TIMEOUT (for an evaluation determined by the counter). If the pulse is generated directly by the user (and not deferred), no further fake pulse must be provided by the arbitration structure. In this case the MON_B remains idle and the CLK_TO_SM will coincide with the pulse of MON_A. Because the output CLOCK has a minimum delay in respect to the user clock (CWE_N), the set up and hold times of the data provided by the user are practically unchanged in respect to the user clock. Figure 16 illustrates the timing in case of real time user commands (GROUP A1). In each of the other three possibilities, the pulse shall determine the almost simultaneous switching of the two monostables and the CLK_TO_SM will be that depicted in the time diagram of Figure 17, delayed by T_MON_B, that is by Tsu in respect to the leading edge of MON_A. By considering the fact that, together with MON_A, the fake input relative to the pulsed signal that starts the chain is set, it may be stated that Tsu is the time between the fake datum and the leading edge of the clock. The small delay of Figures 9 and 14 ensures that MON_B starts just ahead of MON_A, in order to prevent the generation of glitches on the clock. This situation is illustrated in the time diagram of Figure 17, wherein INTDATA must be associated, depending on the cause, to either ENDOPDATA, CUITIMEOUT or OLD_SUSPEND. Referring to the circuit of Figure 13, there are set-reset FF with priority set wherein the signals are set with the same pulse that generates the clock, and reset by MASKSIG_N that signals the end of the timing. Another observation relates to the resets of the two flip-flops for the cases belonging to GROUP B. Such resets are obtained by signals determined by the SM that are set only when the evaluation that has been stored is started. For example, the signal RES_FLAG_ENDOP_N resets FLAG_ENDOP only when RES_CUIFLAG is set that is a signal active in the IDLE or ERASESUSPEND state, or when CUIFAIL is set. When this last signal switches high, it means that a fail has occurred but also that a command coming from the microcontroller has been evaluated. In the same way, the signal RES_SUSP_FLAG_N is determined by a signal SUSP_REQ that the SM sets at the moment of the occurred suspension. Furthermore, certain output signals of the SM are used in the arbitration circuit. These signals reset the FF when an evaluation has been finished, if they were set for the reasons explained in describing the circuit portions of Figure 12 and Figure 13. For the FF relating to the microcontroller commands, it may be reset if the system goes to the IDLE state (whereby the SM sets RES_CUIFLAG) or if a CUIFAIL is produced. In the first case, the ENDOP is processed and, no fail having been generated, the system returns to the IDLE state. In the second case, the command has been processed but, having a fail been produced, ENDOP is set. The reset of the other FF takes place either in the case the suspension is immediate because the BLOCKERASE algorithm has not yet been started (the SM sets RES_CUIFLAG) or in the case being the algorithm in progress, the signal SUSP_REQ, that corresponds to an acknowledge of the micro that will suspend the algorithm as soon as possible is produced. The main advantage of the illustrated solution is that of allowing the realization of a SM with a single clock and a single reset from which all the positive effects derive. The conventional character of the structure implies an improved controllability of all the situations and thus lesser of design errors and bugs. It allows to use a standard SM structure depending on needs instead of a hybrid structure; moreover, it brings about a reduction of the occupied area because any design synthesizer tool will be able to optimize a conventional SM. A further advantage is the nullification, or at least a strong reduction, of situations in which indispensable commands may be lost and in which it is possible to be halted in a state from which it is possible to exit only with a hardware reset. As far as the test modes are concerned, if the complexity of the specifications implies a 2^N number of states, in order to know exactly the instantaneous working condition of the command interpreter, it is sufficient to output N signals that are those on which are encoded all possible states. It is also possible to force, in testmode, the state variables through N inputs and successively to provide a clock pulse to switch to the future state. It is possible to verify the correctness of the evaluation by inputting through the dedicated pads the new state variable. In other words, the designer has the possibility of implementing, with a low cost, a good controllability and inspectability of the command interpreter. Any flip-flop, except those of the SM and of the arbitration structure, will be present in the hierarchy of the command interpreter and will undergo controls or conditionings depending on particular situations. Despite the arbitration structure is realized for a particular specification, its organization is absolutely general. Therefore it is always possible, mutatis mutandis , to re-adapt it to other situations in which multiple command sources are involved. Figure 18 depicts a high level functional block diagram of a FLASH_EEPROM non volatile memory device of the family of commercial devices 28F400B3, 28F800B3, called "SMART 3 ADVANCED BOOT BLOCK", produced by INTEL CORP. In the block diagram of the depicted device illustrating a typical, under many aspects, internal organization of a non volatile memory device. It is possible to recognize the functional block called COMMAND USER INTERFACE that is typically present in such non volatile memory devices, even of others manufacturers. A functional description of the whole non volatile memory device may be found on the data sheet of the above-identified commercial devices and its reiteration does not seem necessary to understand the object of the present invention that, as above discussed, relates exclusively to an improved architecture of the functional block COMMAND USER INTERFACE, or more briefly CI, as it is called in the present document. According to the present invention, the block COMMAND USER INTERFACE of a non volatile memory device of FLASH_EEPROM type, has advantageously an architecture as that described herein and illustrated in Figures 9-17.

Claims: An interface for a plurality of internal circuits and external circuits, the interface comprising: a finite state machine (SM) for managing asynchronous and independent interactions between the plurality of internal circuits and external circuits, said finite state machine functioning based upon a unique clock (CLK_SM) and a unique reset; and an arbitration circuit (ARBITRO) connected to said finite state machine for receiving input signals (INPUT DATA) for said finite state machine from different sources, and for storing the input signals generated by the plurality of internal circuits when said finite state machine is performing an evaluation. An interface according to claim 1, wherein said arbitration circuit (ARBITRO) provides the unique clock (CLK_SM) and the unique reset to said finite state machine (SM). An interface according to claim 1, wherein a clock for each internal circuit is different from the clocks of the other internal circuits (CLK1INT,.....CLKiINT). An interface according to claim 1, wherein said arbitration circuit (ARBITRO) comprises a memory buffer for storing the input signals generated by the plurality of internal circuits. An interface according to claim 1, wherein the input signals generated by the plurality of internal circuits (GROUP3) comprise at least one of a command signal and data. An interface according to claim 1, wherein said arbitration circuit (ARBITRO) comprises at least one of a plurality of logic and memory bistable circuits (GROUP2) connected together for forming a plurality of distinct signal paths with the external circuits, and with the plurality of internal circuits. A non-volatile memory device comprising: a plurality of digital circuits; and a command interpreter circuit for recognizing operations required from the non-volatile memory device through command codes and for implementing a handshake with said plurality of digital circuits, said command interpreter circuit comprising a finite state machine (SM) for managing asynchronous and independent interactions between said plurality of digital circuits and external circuits, said finite state machine functioning based upon a unique clock and a unique reset, and an arbitration circuit (ARBITRO) connected to said finite state machine (SM) for receiving the command codes for said finite state machine, and for storing the command codes generated by said plurality of digital circuits when said finite state machine is performing an evaluation. A non-volatile memory device according to claim 7, wherein said arbitration circuit provides the unique clock and the unique reset to said finite state machine. A non-volatile memory device according to claim 7, wherein a clock for each digital circuit is different from the clocks of the other digital circuits. A non-volatile memory device according to claim 7, wherein said arbitration circuit comprises a memory buffer for storing the command codes generated by said plurality of digital circuits. A non-volatile memory device according to claim 7, wherein the command codes generated by said plurality of digital circuits comprise at least one of a command signal and data. A non-volatile memory device according to claim 7, wherein said arbitration circuit comprises at least one of a plurality of logic and memory bistable circuits connected together for forming a plurality of distinct signal paths with the external circuits, and with said plurality of digital circuits. A non-volatile memory device according to claim 7, wherein the said plurality of digital circuits and said command interpreter circuit are configured so that the nonvolatile memory device is a FLASH EEPROM. A method for managing a finite state machine (SM) through an input arbitration circuit (ARBITRO) that stores commands issued by different sources to be executed, and provides a clock to the finite state machine, the method comprising: a) for each new command, verifying whether it is received while the finite state machine is carrying out a previous command; b) if step a) is negative, then issuing the new command to the finite state machine in real time, and restarting a new cycle from step a); c) if step a) is positive, then verifying whether the new command can be ignored; and d) if step c) is negative, then storing the new command in the input arbitration circuit, waiting for the finite state machine to end execution of the previous command, issuing a deferred command to the finite state machine, and erasing the new command from the input arbitration circuit. A method according to claim 14, wherein in step b), the new command comprises the clock if the command is provided by external circuitry, and comprises input data and the clock if the command is provided by internal circuitry. A method according to claim 14, wherein in step d), the deferred command comprises input data and the clock. A method according to claim 14, wherein the input arbitration circuit also provides a reset to the finite state machine. A method according to claim 14, wherein the input arbitration circuit comprises a memory buffer for storing the commands to be executed.

Inventors: SURICO STEFANO, SURICO, STEFANO
Applicants: ST MICROELECTRONICS SRL, STMICROELECTRONICS S.R.L.
Application year: 2001
Main classification: G05B19
IPC codes: G05B19, G11C16