Wafer map management, explained.

A wafer holds hundreds to tens of thousands of identical dies. After wafer sort, the electrical test done at the prober, every die has a result: the bin it was sorted into. A wafer map is that result laid out as a grid, one cell per die position and one bin per cell, together with what is needed to read it: lot and wafer ID, die size, grid dimensions, orientation and reference points.

The map is not a report that someone reads and files away. Equipment acts on it. A die bonder picks only the dies the map calls good, so a wrong map means good dies left on the tape, or bad dies shipped.

Die

One copy of the chip on the wafer, at one row and column of the grid.

Bin

The category a die was sorted into: pass, a lower grade, or a reason for failing.

Reference die

A known position used to line the map up with the physical wafer.

Notch or flat

The cut in the wafer's edge that fixes which way up it is.

A map is written once and then handed from system to system. Each hand-off is a file, and each file is a chance to lose or distort data.

1. Wafer sort

   The prober steps across the wafer die by die while the tester runs the test program. The tester writes a datalog, often STDF; the prober or a host system writes the map.

2. Review and inking

   Rules or engineers mark more dies as bad: clusters of failures, edge dies, statistical outliers. The change now lives in the map instead of in a physical ink dot.

3. Merge

   Results from several steps, such as first pass, retest and optical inspection, are combined into one final map, with a rule for which result wins.

4. Assembly

   The map is converted to the format the die bonder or sorter expects, often SINF or SEMI E142, and aligned to the wafer with reference dies.

5. Traceability

   The final map, and the history of how it got there, is kept for customer returns and yield analysis.

There is no single wafer map format. Each class of tool writes its own, and most fabs handle several at once. These are the ones engineers run into most.

Two rules hold for all of them. Keep the original file exactly as it arrived. And treat every conversion as a place where something can be dropped: a soft bin, a test-step ID, a comment the next system needed.

This is where most map errors start. Every format has to say which die is (0, 0), which way X and Y count, and which way up the wafer is. They do not agree.

• Origin. Some systems count from the top-left die, some from the wafer center, some from a reference die. Coordinates can be negative.
• Axis direction. X may grow to the right or to the left; Y may grow up or down. A map read with Y the wrong way round is upside down, and still looks plausible.
• Notch or flat. A notch on 300 mm and most 200 mm wafers, a flat on 150 mm and smaller, marks the orientation. Formats record it as an angle or as a letter (STDF uses U, D, L and R), and they do not all measure from the same side.
• Die or reticle. One reticle shot prints several dies at once. Shot coordinates and die coordinates are different grids.

The reliable check is simple. Before trusting a converted map, compare one known die, such as a reference die or a failure cluster, against the original. If a cluster near the notch has moved to the opposite edge, the orientation is wrong.

A bin is the category a die was sorted into. Bin 1 is conventionally the first-quality pass, but nothing enforces it: each product's bin table says what every number means.

• Hard bin and soft bin. The hard bin is the coarse result the prober or handler acts on. The soft bin is the finer reason from the test program, usually which test failed. STDF carries both; many map formats carry only one.
• Numbers and codes. Some formats store a bin as a number, others as a character such as 1, A or X. The same die can be bin 12 in one file and C in another. Turning codes into numbers needs the product's bin table, not a guess.
• Neither pass nor fail. Maps also mark dies that were never tested: partial dies at the edge, dies inside the edge exclusion, reference dies, skipped sites. Counting them as passes or fails skews yield.

Merging

When a wafer is tested more than once, or tested and also inspected, the results become one map. Common rules: the retest replaces the first pass, the worst bin wins, an inspection defect overrides an electrical pass. Write the rule down. Two engineers merging the same files by hand will not always produce the same map.

Maps must share a grid before they can be merged: the same size, origin and orientation. Merging before aligning is the classic way to produce a map that looks right and is not.

Inking

Inking marks more dies as bad than the test did, because their neighbors suggest they will fail later.

Cluster inking

Passing dies around a spot of failures, likely damaged by the same cause.

GDBN

Good die in bad neighborhood: a passing die surrounded by failures.

PAT

Part average testing: dies that pass but sit far from the population, standard in automotive flows (AEC-Q001).

Edge and zone

Fixed rings or regions with a known reliability risk.

Every inking rule trades yield for quality. Its settings, such as the margin, the minimum spot size and the maximum yield loss, belong in a versioned recipe, and every inked die should be traceable to the rule that inked it.

1. A rotated map

   The orientation is lost in a conversion, and the bonder picks dies from the wrong side of the wafer.

2. A grid shifted by one

   One system counts from 0, the other from 1. Every die moves, and the map still looks fine at a glance.

3. Colliding bin codes

   Two products use the same code for different things, and their maps are merged under one table.

4. The wrong version

   Several "final" maps sit on a shared drive, and the bonder gets the one from before the retest.

5. Edits nobody can trace

   A manual change fixes today's problem and becomes next month's customer return, with no record of who changed which dies.

6. Silent data loss

   A converter drops the soft bins or test-step IDs that the analysis needs later.

• One place where every map lives, with the original file kept as received.
• Orientation and coordinates checked on import, against a reference die.
• Conversions that round-trip: read a file, write it back, and get the same file.
• Merge and inking rules stored as named, versioned recipes, not in someone's head.
• Every change recorded: who, when, which dies and why.
• Yield and spatial analysis run on the same data the bonder will use.