JP2005522859A - Manufacturing method and apparatus for avoiding prototype hold in ASIC / SOC manufacturing - Google Patents

Abstract

In the LSI manufacturing process, an event tester is used to avoid prototype hold. This LSI manufacturing method includes a step of designing an LSI in an EDA (electronic design activation) environment and generating design data for the designed LSI, and a device of the designed LSI in an EDA environment using a test bench. Perform a logic simulation of the model, and as a result, generate a test vector file with event-type test vectors, form a test-related data file using the design data and event-type test vectors, and the operation of the event tester A step of forming an event tester simulator to be simulated, a step of verifying the test-related data file and the event type test vector by the event tester simulator, and a prototype LSI by the manufacturer using the design data And a step of testing the prototype LSI by an event tester using an event type test vector, removing detected defects by event editing, and feeding back the test result to a design engineer and a manufacturer. .

Description

  The present invention relates to a method and apparatus for manufacturing a large scale integrated circuit (LSI), and particularly to directly use design simulation data generated in an electronic design automation (EDA) environment by using test data in an event format. The present invention relates to a method for manufacturing a large scale integrated circuit (LSI) that avoids prototype hold in LSI manufacturing by using an event type IC test system that enables the above.

  This application describes a modified version of the process used in the industry for LSI manufacturing. The main problem today in the manufacture of LSIs such as ASICs (Application Specific Integrated Circuits) and SOCs (System on Chip) is the stopping of the process in the manufacturing process for prototype testing. In the prototype manufacturing stage, over 50% of the ICs do not pass the test, thereby stopping the manufacturing process to the next stage (eg, application development or mass production). In this application, such a situation is called prototype hold or protohold.

  When the first silicon (prototype LSI) is manufactured, many defects are often detected in the prototype evaluation. There are various causes for these failures. It may be a vector conversion (test data conversion) error, a test program error, or even a manufacturing defect. In many cases, the cause of failure cannot be easily identified. Therefore, silicon (prototype LSI) is in a prototype hold (proto hold) state. Until the cause is confirmed and corrected, silicon cannot be used for application development, and further mass production is not possible.

  The cause of this problem is that the design environment is different from the test engineering environment, and therefore the failure factor is not easily identified. When the chip is taped out (chip design data is released by the design engineer), the test engineer must convert the design simulation vector for use in the test engineering environment. The test engineering environment is typically a cycled format with tester time sets and waveform groups. The test engineer converts the simulation vector to another format, such as STIL (standard test interface language) or the WGL (waveform generation language) specific to the test system, and is not very similar to the original simulation vector Create a test program. Therefore, when the first silicon (prototype LSI chip) shows a defect, it is difficult to specify the cause of the defect.

  The semiconductor industry is very expensive and involves large-scale manufacturing facilities, and the production volume of each LSI device is large. Therefore, such a process delay caused by the protohold becomes very expensive for an application developer, a design house (ASIC house or design center), a silicon foundry (semiconductor manufacturer), or the like. Thus, there is an urgent need in the industry for new semiconductor manufacturing processes and test systems that operate in an IC design environment and that can eliminate the complexity associated with converting test data to cycle form in current test systems.

Accordingly, it is an object of the present invention to provide a new semiconductor manufacturing method incorporating a new semiconductor IC test system in which the design environment and the test engineering environment are seamlessly interrelated and a prototype hold can be avoided.
Another object of the present invention is to provide a new semiconductor manufacturing method incorporating a semiconductor IC test system (event tester) that can directly use design simulation data generated in an electronic design activation (EDA) environment. .
Another object of the present invention is that a semiconductor IC test system (event tester) is incorporated into a test engineering environment, and an event tester simulator is incorporated into an EDA environment, thereby eliminating the need for creating test vectors and test programs in the test engineering environment. It is to provide a new semiconductor manufacturing method.

  The present invention proposes a manufacturing process that does not cause proto-holding by incorporating an event type test system (event tester) in LSI manufacturing. This manufacturing method includes a step of designing an LSI in an EDA (electronic design activation) environment for generating LSI design data to form the LSI design data, and an LSI using a test bench in the EDA environment. Performing a logic simulation of the device model of the design, forming a test vector file in the event format as a result of the logic simulation, and forming the simulation data file by operating the event tester simulator using the design data and the test bench Using the design data to manufacture the prototype LSI via the manufacturing provider, and testing the prototype LSI by the event tester using the test vector file and the simulation data file It is constituted by a step of feeding back the test results to EDA environment or manufacturing provider.

  According to the test method and architecture of the test system of the present invention, it is possible to test and debug an IC without leaving the environment where the IC is designed. Traditional IC test systems require design simulation data to be converted to a cycle format such as WGL or STIL format. In the test method and architecture in the new test system, the design simulation data is used as it is without such conversion. Accordingly, the method and apparatus of the present invention allows testing in the same environment as the design simulation environment and avoids protoholds. This new semiconductor manufacturing process incorporates an event tester in a test engineering environment and an event tester simulator in an EDA environment. This eliminates the need to create test vectors and test programs in the test engineering environment, thereby saving engineering time and reducing overall costs associated with LSI production.

  The present invention will be described in detail with reference to the accompanying drawings. The present invention provides a novel LSI manufacturing process in which an event type test system (event tester) is incorporated and no protohold is generated. This method has been achieved by new technology, new equipment, and fundamental changes to existing manufacturing processes. This application describes the concept and architecture of the new device, the semiconductor manufacturing process using it, and the data format used for it.

  In the manufacturing process of the present invention, an event type test system (event tester) is used to test a prototype LSI chip such as an ASIC or an SOC instead of a cycle type test system (cycle tester) according to the prior art. In a design environment (design house), a design engineer forms various files for executing a chip test by an event tester. Such files include test pattern data, test parameter data, tester channel data, etc., and they are validated via event tester simulator based on chip design data and simulation data before prototype production. Is verified.

  At the design stage in an EDA (electronic design automation) environment, the LSI design is repeatedly simulated until the design specification is satisfied. During this process, the design engineer performs a number of simulation cycles using a hardware description language such as Verilog or VHDL to form test vectors. The design engineer examines the results of these simulations using an EDA tool that can observe the waveform and timing, such as SignalScan provided by Cadence, CA. Thus, the preferred method of checking the initial silicon should be the original Verilog / VHDL vector with no translation, and therefore LSI testing should be done in the design environment.

  The cause of the difficulty in testing in the design environment is the architecture of the tester (cycle tester) currently in use. More specifically, current testers use time sets and waveform groups that require vectors to be cycled or reformatted. Therefore, in order to use design simulation data, in a conventional IC test system, it is necessary to convert the simulation data into a cycle format such as WGL (waveform generation language) or STIL (standard test interface language).

  Thus, to achieve the desired solution, complete changes to the tester architecture, environment and process are required. The solution requires fundamental changes to make the test easier without complicating the already complex process. To eliminate the possibility of protoholding with test vectors, the problem should be solved by eliminating the vector conversion process.

  The basic requirements for operating a tester in a design simulation environment are as follows: (1) The tester architecture must support signal value changes similar to those observed in design simulations such as Verilog / VHDL, and (2) each tester pin event can be a waveform group and time. Rather than being cycled based on sets, they should be treated as independently as logic simulation in the design environment.

  The inventor of the present invention investigated the possibilities and mechanisms for supporting a test design environment and made fundamental changes to the tester architecture. FIG. 1A shows a traditional cycle tester architecture, and FIG. 1B shows an event tester architecture used in the manufacturing process of the present invention. In a general semiconductor test system, a test pattern or a vector (input stimulus, strobe, etc.) is generated based on test data described in a cycle format. As described above, the test system according to the prior art is called a cycle type test system or a cycle tester, and various types of data for generating inputs and strobes correspond to corresponding test cycles (tester rate or time set) and waveform segments. Defined relative to

  As shown in FIG. 1A, the cycle tester includes a rate generator 13 that generates a tester rate (test cycle), a pattern memory 14 that stores pattern data, a timing memory 15 that stores timing data, and a waveform (action). It comprises a waveform memory 16 for storing data, a timing generator 17 for generating a timing signal based on timing data, a waveform shaper 18 for forming a test pattern based on the timing signal, and a driver 19 for supplying a test vector to the DUT. ing.

  As shown in FIG. 1B, the event type test system (event tester) includes an event memory 20 for storing event data (time data), an event generator 21 for generating an event based on the event data, and a DUT. And a driver 22 for supplying a test vector. The architecture and concept of the event type test system is described in detail in US Pat. Nos. 6,360,343 and 6,532,561 and US Patent Application No. 10 / 150,777 owned by the assignee of the present invention and incorporated herein by reference.

  In the event tester, the rate generator 13, the timing generator 17, the pattern memory 14, the waveform memory 16, and the timing memory 15 in the cycle tester are removed, and the event memory 20 and the event generator 21 are used instead. The event memory 20 stores events detected by the Verilog / VHDL simulation. The event generator 21 turns these events into actions (to apply test vectors) using the associated timing recorded in the Verilog / VHDL simulation. These actions are applied to the DUT via the driver 22 to detect DUT defects by comparing the DUT response to IC simulation values.

  In the event tester, by removing the rate generator, timing generator, pattern memory, waveform memory, and timing memory, this architecture requires the vector to be cycled and other formats like WGL or STIL. Eliminates the need to convert to The event memory 20 in FIG. 1B stores events (data 0 or 1) in the same format as recorded in the IC simulation. Therefore, a test vector (action) is generated by driving an event at that timing. In the cycle tester of FIG. 1A, each test vector is generated by driving a waveform (action) specified based on pattern data (0 or 1) at a timing specified by a time set (test cycle). Thus, the event tester achieves the goal of eliminating cycling and vector transformations and making the test environment identical to the IC design environment.

  FIG. 2 is a diagram showing the concept of the overall LSI manufacturing process of the present invention using the event tester 30 in the test engineering environment and the event tester simulator 27 in the design (EDA) environment. At the time of tape-out, design data for prototype manufacturing formed via the EDA environment is passed to the silicon process. The test vector for the event tester can be formed directly from a VCD (value change dump) file generated by logic simulation in the EDA environment. Prior to the manufacture of prototype silicon, the test vector and various data related to the test are verified by the event tester simulator 27.

  Since the manufacturing method of the present invention has an event tester simulator similar to today's EDA environment, all of the test related data including the test vector used for the event tester is verified. Such data is specific to the LSI to be tested and the event tester incorporated into the manufacturing process. That is, the basic idea of the present invention is to check everything by an event tester simulator before silicon production. Therefore, when an actual LSI is tested by the event tester, there is no error related to the test data.

  So if there is a defect in the actual test, there can only be either a timing error or a physical defect in manufacturing. If it is a manufacturing defect, a failure analysis of the LSI can be performed to determine what type of physical defect has occurred. If it is a timing error, it can be debugged using various functions of the event tester described below. Details of the manufacturing process of FIG. 2 will be described after the problems in the conventional cycle type test system (cycle tester) and the advantages of the event type test system (event tester) are described with reference to FIGS. 3-6.

  FIG. 3 shows an LSI manufacturing process using a conventional cycle type test system (cycle tester), and the data format between the design environment and the test environment is different. In FIG. 3, since the data format (ATE format) used in the cycle tester is different from the data format generated in the design stage (EDA format), logic simulation data cannot be used without data conversion (vector conversion). Is shown. In addition, since the cycle tester has various limitations, it is difficult to convert logic simulation data into test data correctly and sufficiently and vice versa.

  More specifically, in the example of FIG. 3, in the design stage 42, the designer designs an LSI based on the intended LSI specification 41 such as ASIC or SOC. As described above, the LSI design is simulated many times until the design specification is satisfied. As a result of this logic simulation process, a test stimulus file 45 (test bench) such as a Verilog VCD (value-change dump) file is generated. The test bench 45 has an EDA format, which is the same as the event format described above.

  After the design stage 42, a design data file 46 is generated. This generally comprises RTL (register transfer level) data, netlist data and mask data. Based on the data in the design data file 46, a prototype LSI 47 is formed in the manufacturing stage 43. In the test stage 44, the prototype LSI 47 is tested by an ATE (automatic test apparatus). The ATE is generally the above-described cycle type test system (cycle tester). In order to test the prototype LSI 47 by the cycle tester, a test data file 48 for generating a test vector is formed.

  As described above, the test data used in the conventional test system is a cycle format (ATE format), and this format has no similarity to the EDA format. Therefore, it is necessary to convert the test bench (EDA format data) to an ATE format that can be accepted by the cycle tester. Because of this necessity, the following problems arise. (1) Vector conversion consumes a large amount of time and server and disk capacity. (2) Due to vector cycling, devices with multiple clocks cannot be tested. (3) Since the number of resources of the cycle tester, such as time set, waveform group, and timing generator, is limited, various limitations of the tester as exemplified in the restriction box 49 occur. Therefore, it is impossible to completely convert the test bench to the ATE format. Because of this incompatibility, it is impossible to fully test the prototype and a proto-hold problem as shown by the stop box 50 arises.

FIG. 4 shows data conversion (vector conversion) from a data structure in the design environment to a data structure in the test engineering environment. As described above, stimulus data generated in an EDA environment needs to be converted into a cycle format in order to form a cycle type test pattern by a conventional test system. Therefore, in the process of FIG. 4, the test stimulus file 45 is converted into the test vector file 48 of FIG.
In the example of FIG. 4, LSI design verification data (test bench) designed in an EDA environment is stored in a stimulus data (VCD) file 56 and a pin data file 57. Data relating to input / output values from the stimulus data file 56 and data relating to the LSI pin arrangement from the pin data file 57 are supplied to the conversion software 55 and converted into cycle type data. Data describing the test system specifications such as test parameters and test pin arrangement is supplied from the data files 58, 59 and 60 to the conversion software 55 and converted into cycle type data.

  Through this process, a main (test plan) file 61 and a test pattern file 62 are formed. Here, the main file 61 has timing data describing the test cycle of the test pattern waveform and the timing of the waveform. The pattern file 62 has a test vector. The converted data is further converted into object code by each compiler. Thereby, object code files 64 and 66 are formed. The data of the object code files 64 and 66 is transferred to the corresponding memory (waveform, timing, and pattern memory) of the pattern / timing generator 68 provided in the tester hardware via the loader.

  In the cycle tester, the waveform, timing, and data stored in the pattern memory have a cycle type data structure as described above. When testing a prototype LSI, data is read from these memories to generate a test pattern. The test pattern is applied to the LSI via pin electronics (not shown). The test result data is reorganized in a data file 67 such as a defective data store. Data from the data file 67 is used in failure analysis by the analysis tool 54. The result of the failure analysis can be added to the result of the EDA tool 53 in the EDA environment, but since the data structure is different, the result of the failure analysis cannot be used directly.

  As described above, since the data obtained from the EDA design environment and the data used in the semiconductor test system have different structures, various conversion processes must be used for data conversion. In particular, various conversion software (tester software) indicated by dotted lines is required for data conversion for a cycle type test system. The event tester according to the present invention eliminates all these conversion software.

  As described above, the production method of the present invention is implemented by using an event tester for the test environment and an event tester simulator for the EDA environment. As mentioned above, U.S. Patent Nos. 6,360,343 and 6,532,561 and U.S. Patent Application No. 10 / 150,777 held by the same assignee of the present invention describe the concept of an event type test system, which is hereby incorporated by reference. . Before explaining the LSI production method of the present invention, an event type test system will be outlined with reference to FIGS.

  FIG. 5 is a block diagram showing a basic configuration example in an event type test system (event tester) for carrying out the manufacturing / testing method of the present invention. The event tester has a host computer 72 and a bus interface 73 respectively connected to the system bus 74. The event tester further includes an internal bus 75, an address control logic 78, a defective memory 77, an event memory 79, an event summing / scaling logic 82, an event generator 84, and pin electronics 86. The event tester evaluates the device under test (DUT) connected to the pin electronics 86.

  An example of the host computer 72 is a workstation having an operating system such as UNIX (registered trademark), Windows, or Linux. The host computer 72 functions as a user interface such as the graphic user interface (GUI) shown in FIG. 7, and starts and stops a test by a user, loads a test program and other conditions, monitors events, Enables editing and test result analysis. The host computer 72 interfaces with test system hardware via a system bus 74 and a bus interface 73. Although not shown in the figure, the host computer 72 is preferably connected to a communication network in order to send and receive test information to and from other test systems and computer networks.

  The internal bus 75 is a bus in the test system hardware and is commonly connected to most of the functional blocks. The address control logic 78 gives instructions to other functional blocks of the test system based on the test program and test conditions from the host computer 72. The defective memory 77 stores a test result such as defective information of the DUT 88 at an address designated by the address control logic 78. Information stored in the defective memory 77 is used at the stage of failure analysis of the device under test. The address control logic 78 supplies address data to the event memory 79. As shown in FIG. 5, the event memory 79 is typically composed of an event count memory 80 and an event vernier memory 81. In an actual test system, a large number of event memories are provided, each of which corresponds to a test pin of the test system. In the event memory 79, the event count memory 80 and the event vernier memory 81 store timing data and event type data of each event. The event count memory 80 stores timing data that is an integer multiple of the reference clock (integer part data), and the event vernier memory stores the fractional part (fraction part data) of the reference clock. For example, the timing data of each event is expressed as a time difference (delta time) between two adjacent events.

  The event summing and scaling logic 82 is for generating data indicating the overall timing of each event based on the delta timing data from the event count memory 80 and the event vernier memory 81. Basically, such comprehensive timing data is formed by accumulating a plurality of integer multiple data and fraction data. In the process of accumulating timing data, the event summing / scaling logic 82 also performs a carry-over operation (offset to integer data) of fractional data. The event summing and scaling logic 82 further performs a timing shift function and a clock scaling function for editing an event.

  The event generator 84 is for actually generating an event based on the comprehensive timing data from the event summing and scaling logic 82. Events generated in this way (for example, test signals and expected values) are supplied to the DUT 88 via the pin electronics 86. Basically, the pin electronics 86 is formed of a number of components, each of which is configured with a driver, a comparator, and a switch so as to establish an input / output relationship with the DUT 88.

  FIG. 6 compares the data structure of the cycle tester, which is a conventional technique, with the data structure of the event tester used in the present invention when the same test signal (pattern) is generated. In this example, the case where the test pattern waveform 91 is generated by the test data in the cycle format is compared with the case where the test pattern waveform 91 is generated by the test data in the event format. A waveform 91 is a signal applied to the two pins Sa and Sb of the IC device, which is typically formed by logic simulation in the design of the IC device, and its VCD (Verilog Value Change Dump) description. 99 is shown.

  In order to form the waveform 91, as shown in the event base description 98, the event data used in the event tester describes a waveform by a combination of set / reset edges San, Sbn, Ran, Rbn and their timing. In this description, the timing of each event can be expressed by a relative time length from the previous event or an absolute time length from a predetermined reference point. As shown in FIG. 6, the event base description 98 is basically the same as the VCD description 99.

  In order to form the test pattern waveform 91 in a conventional test system based on the cycle-based concept, the test data consists of a test cycle (time set), a waveform group (waveform type and their edge timing), and a vector (pattern ) Must be divided into data. That is, regarding the cycle type data structure, vector (pattern) data 95 and test cycle (time set) data 93 are shown on the left side of FIG. As shown in FIG. 6, the test pattern is divided for each test cycle. That is, the test pattern is divided by one or more time sets (TS1, TS2, and TS3), a combination of waveforms, and timing for each test cycle.

  An example data description for such a waveform, timing, and test cycle is shown as waveform data 96. Waveform logic 1, 0, Z is shown as pattern data 95. For example, in the waveform data 96, a test cycle is described by “rate” in order to define a time interval between the test cycles, and the waveform is RZ (return zero), NRZ (non return zero), XOR (exclusive OR). ). Further, the timing of each waveform is defined as a delay time from a predetermined edge of the corresponding test cycle.

  As described above, the event type description 98 is the same as the design simulation result (VCD) 99. On the other hand, the cycle-based description requires a time set, each waveform type, and a timing description that are separated from the original design simulation result. The conventional test system cannot sufficiently convert the test data formed in the design environment into the cycle type format due to the complexity of the data structure. Furthermore, data conversion from the event format to the cycle format is very time consuming, complicated and error-prone, and data accuracy is a problem.

  Therefore, in the present invention, an event tester is used for the test environment. The event tester uses the time and signal values recorded in the VCD file generated in the design (EDA) environment as they are. Therefore, the data from the VCD file can be used directly in the event tester as a test vector for the LSI device under test. To determine the pass fail, the user is allowed to specify strobe low, strobe high, and strobe Z offsets so that the device can be enabled to respond to expected output conditions.

  Referring back to FIG. 2, the overall LSI manufacturing process of the present invention will be described in more detail. In the actual test, in addition to the test vector that can be formed from the VCD file, other data (test parameters, pin configuration, tester pin assignment, etc.) are also required. Such data can be formed by using design data and simulation data that exist when the initial design is completed. In the present invention, the validity of such a data file is checked using the event tester simulator 27.

  2 includes a design process in an EDA (design) environment, which is typically a design center (design house), a test process by an event tester 30, and a silicon manufacturing process in a silicon foundry. The design environment includes an event tester simulator 27 that simulates the operation of the event tester 30. The event tester simulator 27 is software for verifying the accuracy of data. The device pinout (pin arrangement) in the pin file 321, the tester channel mapping in the socket (soc) file 323, and the LSI device part in the parameter (par) file 322 The operation to be performed, the I / O parameter value, the order of tests applied to the LSI device in the test plan (tpl) file 324 are verified. The test vector is an event in the VCD file 36 and is verified by the event tester simulator 27. Therefore, it is not necessary to develop a new test program.

  While designing an LSI, in this case, an SOC 26 (system on chip) having a core A-C in an EDA environment, formation of design data 281-282 and test stove 31 and use of a logic simulation 29 (Verilog / VHDL simulator, etc.) )Repeated. At the end of the design, design data files 331-334 containing RTL data, pin data, netlist data, and mask data are formed and sent to the silicon manufacturing process. The VCD file 36 is formed as a result of logic simulation. The event tester simulator 27 verifies the data in the test data files 321-324 (pin, par, soc, tpl), and corrects them if there is an error. The event tester simulator 27 also verifies the test vector from the VCD file 36 via the compiler 35. Therefore, the event tester simulator 27 verifies all the correctness of the above-mentioned data, and there is no problem in loading these data files and test vectors into the tester. Make sure you can run the test vector.

  After the event tester simulator 27 verifies all of the data files and test vectors associated with the test, a prototype silicon DUT 26 is formed in the silicon process 24. Data from the files 321 -324 (verified) is installed in the event tester 30 as event tester software 37. The verified test vector is installed in the event memory 38 in the event tester 30. The event tester 30 evaluates the DUT 26 by applying a test pattern from the event memory 38 via the tester hardware 39. Therefore, it is possible to quickly determine whether the prototype silicon has manufacturing defects or whether it is as good as the simulation vector. In any case, the designed SOC does not face a proto-hold, and the transition between failure analysis or silicon release (for application development and mass production) is affirmed.

  The assignee of the present invention has also developed a new user interface (GUI) that allows the user to observe the signal values and timing of test vectors and device response outputs. Thus, if the actual test detects a failure, the event tester can determine if this is a timing error, and if so, the event tester can perform event editing (timing offset, scaling, etc.) via the GUI 40. To analyze the details of timing errors. Based on the results of such event editing, a new test bench 34 is fed back to the EDA environment for further simulation.

  FIG. 7 shows a display example of an event tester GUI that can be advantageously applied to the manufacturing method of the present invention. When performing a test, the user specifies various test parameters via this GUI. For example, parameters such as power supply voltage level and current value, input and output voltage and current, voltage clamp and power supply conditions (slope value or standby time) similar to those performed by design engineers when establishing a test bench . The display example of FIG. 7 shows a time scale 101, a signal event 102 corresponding to the time scale 101, a checker board 103 corresponding to the time scale 101, and a signal name 106 having a one-to-one relationship with the signal event 102. , Test plan 105, pin selection 107, and other parameter windows. The test response of the device can be observed for each pin or as a collection of pin arrangements in the desired order. Since all operations are performed in an event format, the user can modify the event and its timing with a simple drag operation with the mouse.

  The assignee of the present invention has developed a scaling function to scale (change) timing for selected regions, selected pins, or all tests. When this function is used, for example, when the test result indicates a failure, in order to execute the entire test at different event timings, the user may simply input the scale factor. Such a test is very useful for identifying defects in the initial silicon timing as well as for knowing speed and frequency characteristics. Details of this scaling are described in US patent application Ser. No. 09 / 286,226 owned by the assignee of the present invention. In addition, examples of event editing and time shift offsets are described in US patent application Ser. Nos. 09 / 340,371 and 10 / 039,720 owned by the assignee of the present invention.

  In addition to the signal event display, event editing and scaling functions, the assignee has developed a checkerboard map 103 as shown in FIG. The checkerboard map 103 displays the pass / fail information for the entire test quickly and compressed. This also serves as a navigation tool. Clicking the mouse on any part of the checkerboard synchronizes the time period with the signal event window 102. When a failure is clicked on the checkerboard, the signal event corresponding to the signal event window 102 is enlarged and displayed.

  The assignee of the present invention further developed the ability to create a new test bench for simulation under a test environment. This test bench can be used as an input to the EDA simulator to re-simulate the design results. After a prototype silicon defect is detected by the event tester in the test response signal, the user can remove the defect using the event editing and event manipulation functions. Once the cause of the defect is understood, it is preferable to rebuild the simulation test bench so that the cause of failure in the design can be repaired. Since all operations of this tester are performed in an event format, the user can capture these events and timings and translate them into a Verilog / VHDL test bench as shown in FIG. .

  As described above, since the event tester directly uses the simulation data, it can be verified as soon as the prototype silicon arrives. Running and passing an event tester test, you can determine that (1) the prototype silicon is healthy and (2) the prototype silicon is as good as the simulation vector. Thus, silicon can be released for application development and mass production.

  If defects are detected in the test run, they mean either timing violations (which can be removed using event scaling or event editing as described above) or manufacturing defects. Yes. Note that timing violations are also caused by manufacturing defects or process variations. Thus, when a defect is detected in a test run, the prototype silicon is sent to failure analysis to determine the defect type (bridge, open, short, gate oxidation defect). Either way, protoholds can be avoided. If the test passes, the silicon is released. If the test fails, it is fed back to the manufacturing process to repair manufacturing defects. Note that such a deterministic decision can only be made without vector conversion. That is, such a decision can be derived by an event tester and an event tester simulator. Because today's manufacturing processes use vector transformations, no such conclusion can be drawn.

  Many differences can be found by comparing the event tester type test with today's cycle type test. The main difference is due to the complete removal of the vector conversion step in the event tester. In order to clarify this difference, an event type test flow is shown in FIG. 8 for comparison with the cycle type test flow of FIG. As described above with reference to FIGS. 3 and 4, due to various limitations (timing sets, waveforms, etc.), today's EDA and ATE formats are quite different. Therefore, today, EDA vectors cannot be used as is for the tester, and therefore, when the test indicates a failure, no conclusion can be drawn about the cause of the failure.

As shown in FIG. 8, these restrictions are removed in the event tester, and the EDA vector can be used "as is". In the design stage 112, the designer designs the LSI based on the intended LSI specification 111 such as ASIC or SOC. After the design stage 112, a design data file 116 is created and sent to the manufacturing stage 113 for creating the prototype LSI 117. These processes are basically the same as those shown in FIG. 3, with the main difference being the test phase 114 performed by the event tester.
As a result of the logic simulation performed in the design stage 112, a test stimulus (VCD) file 115 is formed in an event format. As described with respect to FIG. 2, other test data files verified by the event tester simulator at the design stage 112 are also used. The event tester uses an event format. Therefore, the test stimulus file 115 having the above event format can be directly used. Therefore, vector conversion as shown in FIG. 4 is not necessary.

  FIG. 9 is a diagram similar to FIG. 4 and shows the comparison and difference between the two testers. As shown in FIG. 9, the event tester does not perform vector conversion, but uses an EDA simulator vector in the VCD format. More specifically, the specification 122 is created based on the necessary conditions 121 of the LSI. In an EDA environment, designers typically describe the intended LSI using Verilog / VHDL via text entry 123 and behavior (behavior) entry 124. Based on such an entry, an LSI device model 125 intended for LSI is generally formed at the RTL level or the gate level.

  In the logic simulation 126, the device model 125 is repeatedly verified using a test bench. As a result of the logic simulation 126, an event vector file, typically a Verilog VCD (Value Change Dump) file 129, is created. The VCD file 129 stores data indicating changes in input / output values of the LSI and their times. The prototype LSI 130 is tested by an event tester 131 that uses a vector of the VCD file 129. When the event tester 131 detects a failure, it uses the above-described GUI, scaling, event offset, and event edit functions in step 128 to change the test vector and form a new test bench 127. Feed back to the EDA environment for further simulation.

  In the process of FIG. 9, it should be noted that a complete loop (design-test-design) can be formed in the test using the event tester, which is not possible with the prior art. In FIG. 9, this complete loop is possible because of the new test bench described above and because all tasks (design and test) are performed in a single environment. .

  A phase diagram of today's manufacturing process is shown in FIG. Starting from the specification state 141, the process proceeds to the IC design state 142, the simulation state 143, and the design completion state 144. In the tape-out state 145, the design data is sent to the manufacturing state 146. The prototype LSI is tested in the ATE test state 147. In today's semiconductor manufacturing process, if a defect is detected in the test state 147, the LSI faces a proto-hold 148. This is because the failure includes a plurality of failure factors such as a vector conversion error, a test program error, and a manufacturing defect.

  As shown in FIG. 10, this is an open-ended process, where the protohold is open. Because of this open state, the entire process is not assertive. During the proto-hold 148, engineers have to struggle to identify the cause of failure and rely on various trial and error operations. Until the cause of the failure is confirmed, the silicon cannot be released and sent to failure analysis. This is because the cause of the failure may be a vector conversion error or a test program error, not a design or manufacturing defect.

In the manufacturing process of the present invention, by using an event tester, it is not necessary to use vector conversion at all, and a test program is not developed. A state diagram of this new manufacturing process is shown in FIG. In state 151, the necessary files are generated and verified. As described above, the event tester simulator uses the design state 142 and the simulation state 143 to verify such files (pin, par, soc, tpl, vcd).
Therefore, in the tape-out 15, design data (RTL, netlist, mask) is sent to the manufacturing state 153, and files (pin, par, soc, tpl, vcd) having various simulation data are stored in the prototype LSI by the event tester. Sent to test state 154 for testing. If a defect is detected, the cause of the defect is fed back to the manufacturing stage 155. If the test results do not indicate a problem, the prototype silicon is released for application development and mass production.

  As shown in FIG. 11, the process of the present invention is a closed-end process without protoholding and trial and error. In this process, silicon can be released decisively. In order to achieve such an assertive end state, fundamental changes with the prior art are required everywhere. For example, as shown in FIG. 11, the tape-out 152 includes not only a GDSII (graphic design standard II) layout database but also data files of pin, par, soc, tpl, and vcd. Another basic requirement is to integrate an event tester in the manufacturing process and not to perform vector conversion or test program formation.

  FIG. 12 is a flowchart showing the overall flow of the process of the present invention. In FIG. 12, in step 161, LSI design is typically performed by a design house (design center). As mentioned above, in addition to the usual EDA tools, an event tester simulator is incorporated into this process. In step 162, it is determined whether the tape is ready. In this process, not only manufacturing data but also various files (pin, par, soc, tpl, vcd) used for the event tester are checked.

  In step 163, prototype silicon is produced by a manufacturing provider (silicon foundry) based on the design data. Although Design House and Silicon Foundry are shown separately, they may be two separate groups or departments within the same company, or two different companies. The prototype silicon is tested by the event tester at step 164 using the various files (vcd, pin, par, etc.) provided via step 165. As described above, such a file is formed using an event tester simulator and a Verilog / VHDL simulator under an EDA environment.

In the practice of the present invention, the assignee of the present invention used ASCII text files for these files (pin, par, tpl, etc.), but any other format may be used. Also, instead of using separate files, they may be combined or reconfigured in different ways to make one or two files. Similarly, some changes can be made to the process and flow. For example, instead of the design house or design center in step 161, a third party may form a pin, par, soc, or tpl file.
In step 166, if the test indicates a failure, the cause of the failure can be detected. Since the test vector has been verified at the design stage, if a defect is detected in step 166 by using the same test vector in the event tester, the defect is considered a manufacturing defect. Thus, in step 168, failure analysis is performed to find manufacturing process problems. If the test result indicates a pass result, in step 167, the prototype silicon is released for application development and mass production.

  In the flow of FIG. 12, the design engineer sends various files (pin, par, tpl, soc) and a simulation vector (VCD from the simulator) to the manufacturing process in addition to the layout database (GDSII). With existing technologies and conventions, the design engineer simply sends the layout database to the silicon foundry (pin, par, soc and tpl files do not exist in existing technologies). When the prototype production is completed during the manufacturing process, ie when the prototype silicon arrives, the manufacturing engineer places the silicon in the event tester and runs the simulation vector to determine whether the prototype silicon has a manufacturing defect or the simulation vector. It is possible to promptly determine whether it is equally good. In either case, silicon does not face protoholds and can make a definitive transition between failure analysis and silicon release.

  In the above, we have described a new IC manufacturing process that is assertive and avoids protoholding. This solution includes a new device (new tester and tester simulator) and a new flow based on this tester and tester simulator. The tester operates in an event environment, i.e., the environment in which the device was designed and simulated. This event tester extends the design environment for testing. In addition to resolving the protohold problem, another advantage of this tester and test method is that it simplifies the entire test process and allows a direct link from design simulation to test. This is a great advantage in the initial silicon debugging and characterization because the designer can check the device response of the simulation with multiple simulation test vectors.

  Although only preferred embodiments have been described, various forms and modifications of the present invention can be made without departing from the spirit and scope of the present invention within the scope of the appended claims based on the above disclosure. Such forms and modifications are also within the scope of the claims of the present invention and equivalents.

FIG. 1A is a schematic diagram illustrating a test system architecture according to the prior art, and FIG. 1B is a schematic diagram illustrating a new test system architecture for use in the manufacturing process of the present invention. FIG. 2 is a diagram showing the concept of the overall LSI manufacturing process of the present invention using an event tester in a test engineering environment and an event tester simulator in a design environment. FIG. 3 is a diagram showing an LSI manufacturing process using a test system in the prior art in which the data format between the design environment and the test is liberated. FIG. 4 is a diagram illustrating a process for converting between test data used in a conventional test system and a data structure in a design environment. FIG. 5 is a block diagram showing a configuration example of an event type test system (event tester) used in the manufacturing process of the present invention. FIG. 6 is a diagram for comparing the data structure used in the cycle type test system (cycle tester) and the data structure used in the event type test system (event tester). FIG. 7 shows an example of an image on a monitor screen by the graphic user interface of the event type test system of the present invention. FIG. 8 shows an example of the LSI manufacturing process of the present invention using the event type test system in which the data formats between the design environment and the test environment completely match each other. FIG. 9 is a diagram showing another example of the LSI manufacturing process of the present invention using an event type test system that does not require data conversion in the process. FIG. 10 is a state diagram showing an example in which a prototype is used in the semiconductor manufacturing process in the prior art. FIG. 11 is a state diagram showing an example of a semiconductor manufacturing process of the present invention that avoids protoholding. FIG. 12 is a flowchart illustrating an example of a semiconductor manufacturing process of the present invention in which an event tester is incorporated in a test environment and an event tester simulator is incorporated in a design environment.

Claims (20)

In LSI manufacturing methods to avoid prototype hold:
Designing an LSI under an EDA (electronic design activation) environment and generating design data for the designed LSI;
Performing a logic simulation of the LSI device model designed above in an EDA environment using a test bench, and as a result, generating a test vector file with an event type test vector;
Forming a test-related data file using the design data and the event type test vector;
Forming an event tester simulator that simulates the operation of the event tester;
Verifying the test-related data file and event type test vector via the event tester simulator;
Manufacturing a prototype LSI using a manufacturing supplier using the design data;
Testing the prototype LSI with an event tester using an event type test vector, removing detected defects by event editing, and feeding back the test results to a design engineer and a manufacturing supplier;
The LSI manufacturing method comprised by these.   2. The LSI manufacturing method according to claim 1, wherein the simulation test vector in the test vector file is directly used by an event tester without data conversion or translation when applied to the prototype LSI.   The simulation test vector in the test vector file is directly used by the event tester without applying data conversion or translation when applied to the prototype LSI, and the data in the test-related data file is a test pattern for testing the prototype LSI. The LSI manufacturing method according to claim 1, wherein the LSI manufacturing method is used directly by an event tester in order to specify a test condition including the parameters.   The LSI manufacturing method according to claim 1, wherein the step of performing the logic simulation includes a step of generating a VCD (Value Change Dump) file as a test vector file.   The step of verifying the test-related data file by the event tester simulator includes the correctness of the LSI pin arrangement of the pin file, the mapping of the tester channel of the socket file, the I / O parameter value for the prototype LSI of the parameter file, and the test plan file The LSI manufacturing method according to claim 1, further comprising a step of checking the correctness of the test order.   The LSI manufacturing method according to claim 1, wherein the event tester simulator verifies the event type test vector generated through the logic simulation to be loaded into the event tester.   The LSI manufacturing method according to claim 1, wherein the event tester simulator corrects errors before they are used in the event tester by verifying the test-related data file and the event type test vector through a logic simulation. Method.   The event tester operates using the data of the event type test vector and the test related data file, and all of the event type test vector and the test related data file are verified by the event tester simulator. The LSI manufacturing method according to claim 1, wherein the LSI is tested without making an error.   The step of testing the prototype LSI by the event tester includes the step of storing the event type test vector of the test vector file directly formed by the LSI design logic simulation in the EDA environment in an event memory provided in the event tester; 2. The LSI manufacturing method according to claim 1, comprising: generating an event type test vector from the event memory and applying the event type test vector to the prototype LSI; and evaluating the response output of the prototype LSI at a predetermined timing.   The step of testing the prototype LSI by the event tester includes the steps of forming a new test bench based on the test result and further sending the new test bench to the design environment for logic simulation. An LSI manufacturing method as described in 1. In an LSI manufacturing apparatus for avoiding prototype hold: means for designing an LSI in an EDA (electronic design activation) environment and generating design data for the designed LSI;
Means for performing a logic simulation of the LSI device model designed above in an EDA environment using a test bench, and as a result, generating a test vector file with an event type test vector;
Means for forming a test-related data file using the design data and the event type test vector;
An event tester simulator that simulates the operation of the event tester;
Via the event tester simulator, means for verifying the test-related data file and the event type test vector,
Means for manufacturing a prototype LSI via a manufacturing supplier using the design data;
An event tester for testing the prototype LSI using an event type test vector, removing detected defects by event editing, and feeding back test results to a design engineer and a manufacturing supplier;
The LSI manufacturing apparatus comprised by this.   12. The LSI manufacturing apparatus according to claim 11, wherein the simulation test vector in the test vector file is directly used by the event tester without data conversion or translation when applied to the prototype LSI.   The simulation test vector in the test vector file is directly used by the event tester without data conversion or translation when applied to the prototype LSI, and the data in the test-related data file is a test for testing the prototype LSI. 12. The LSI manufacturing apparatus according to claim 11, which is directly used by an event tester to specify a test condition including a pattern parameter.   12. The LSI manufacturing apparatus according to claim 11, wherein the logic simulation means includes means for generating a VCD (Value Change Dump) file as a test vector file.   The means for verifying the test-related data file by the event tester simulator includes correctness of the LSI pin arrangement of the pin file, mapping of the tester channel of the socket file, I / O parameter value for the prototype LSI of the parameter file, and a test plan file 12. The LSI manufacturing apparatus according to claim 11, further comprising means for checking the correctness of the test order.   The LSI manufacturing apparatus according to claim 11, wherein the event tester simulator verifies the event type test vector generated through the logic simulation to be loaded into the event tester.   12. The LSI according to claim 11, wherein the event tester simulator corrects errors before they are used in the event tester by verifying the test-related data file and the event type test vector via a logic simulation. manufacturing device.   The event tester operates using the data of the event type test vector and the test-related data file, and all of the event type test vector and the test-related data file are verified by the event tester simulator. The LSI manufacturing apparatus according to claim 11, wherein the LSI is tested without creating a program.   The event tester for testing the prototype LSI is means for storing the event type test vector of the test vector file directly formed by logic simulation of LSI design in the EDA environment in an event memory provided in the event tester. 12. The LSI manufacturing apparatus according to claim 11, further comprising: means for generating an event type test vector from the event memory and applying it to the prototype LSI; and means for evaluating a response output of the prototype LSI at a predetermined timing.   12. The event tester for testing the prototype LSI includes means for forming a new test bench based on a test result and sending the new test bench to a design environment for further logic simulation. LSI manufacturing equipment.

Images