
Summary: Packaging, testing and IC programming are three separate process steps, handled by different factories with different equipment. Yet on a device's journey from wafer to circuit board, they sit right next to each other. Knowing which devices need data written, and at which stage, is more useful than asking in general terms whether packaging and test "needs programming."
Let's start by clearing up a common confusion.
The "test" performed at an OSAT (outsourced semiconductor assembly and test provider) confirms whether a device works. Programming writes the code or data the device will use. One answers "Is it good?" The other determines "What will it do?"
So not every OSAT needs a programmer, and not every device needs programming. But for writable devices such as MCUs, flash memory, EEPROMs and CPLDs, there is often a programming step between passing test and going onto the board. This article looks at where that step takes place and how it connects to the steps around it.
After wafer fabrication, devices move into back-end processing. For a typical wire-bonded package, the main steps are:
Wafer sort (CP): A tester contacts the pads of each die on the wafer through a probe card to perform functional and parametric tests. The result is a wafer map that separates good dies from bad ones.
Backgrinding and dicing: The back of the wafer is ground down, and the wafer is cut into individual dies.
Die attach and interconnect: Each die is mounted on a lead frame or substrate. Electrical connections are then made by wire bonding or flip-chip bonding.
Molding and forming: Mold compound protects the die, followed by plating, trim and form, or ball attach.
Marking: The part number, lot number and other information are marked on the package surface.
Final test (FT): Packaged devices are tested through test sockets for functionality, electrical parameters and performance. Some products also go through temperature testing or burn-in screening.
Packing and shipping: Devices are packed in trays, tubes or tape and reel. Moisture-sensitive devices are also dry-packed in vacuum-sealed bags.
Samsung Semiconductor's description of Electrical Die Sorting (EDS) notes that defective dies are marked with ink at this stage, so they don't proceed to packaging and inspection. This saves materials and labor. Wafer sort and final test are both, at heart, ways of separating good devices from bad ones at different stages.
Steps vary by package type and device category. Advanced packaging adds bumping, redistribution layers (RDL), multi-die stacking and other steps.
This part of the flow is growing more complex. Yole Group forecasts that the advanced packaging market will grow at a CAGR of 9.4% and approach US$80 billion by 2030. More package types mean more adaptation work for any downstream process that has to contact device leads or balls, including programming.
Whether a device needs programming depends first on its function and internal memory structure, not on its package. The devices that need data written are mainly MCUs; memory devices such as NOR/NAND Flash, EEPROMs, eMMC and UFS; and logic devices such as FPGAs and CPLDs. Most analog ICs, power semiconductors and discrete components don't involve downstream programming.
Even for writable devices, the write can happen at different points in the supply chain:
| Stage | Performed By | What Is Written | Role of Programming Equipment |
|---|---|---|---|
| Semiconductor vendor test | Semiconductor vendor / OSAT | Trim values, fuses, factory configuration | Usually done by the tester within the test flow; part of the semiconductor vendor's process |
| Distribution or programming services | Distributors, programming service providers | Customer code, serial numbers | Offline programming equipment, often combined with marking and taping |
| Before SMT placement | Electronics manufacturers | Customer code, configuration data | Offline or automated programming |
| Board level after placement | Electronics manufacturers | Code, per-board data | In-system programming (ISP) |
Some devices have one-time programmable (OTP) or eFuse data written by the semiconductor vendor during wafer sort or final test. This data may be used for trimming, unique identifiers, security settings or feature options. Memory devices may also undergo fuse-based redundancy repair during test, in which spare cells replace defective ones.
These writes are usually irreversible, or can only be modified to a limited extent. The semiconductor vendor performs them through the test program according to the product design, with strictly controlled permissions and processes. This is not the same as downstream customer programming. Do not assume that a universal programmer can handle the OTP or eFuse areas of every device.
For NAND Flash, production testing, bad block handling, factory configuration and downstream data writing are separate processes. Some NAND devices are initialized or have bad blocks marked during manufacturing test. Downstream programming must then account for the bad block management method and ECC, in line with the customer's software solution. "Supports flash" does not mean a programmer can perform every production operation NAND requires.
Take Arrow, a major distributor, as an example. Services publicly listed by its programming centers include device programming, EIA-481 tape and reel, custom marking, barcode labeling, input/output conversion between tray, tube and tape, 3D lead inspection, moisture bake-out and serial number programming. Here, programming isn't an isolated step. It is combined with marking, packing and inspection.
Earlier articles in this series covered the last two stages. This article focuses on the stretch from the OSAT to the board: in what package and packing format devices arrive at the programming station, and in what form they must be handed to the next step after programming.
| Item | Device Test (CP / FT) | Device Programming |
|---|---|---|
| Purpose | Determine whether a device meets functional and electrical requirements, and bin it | Write specified code, firmware or configuration data |
| Main operations | Apply test signals, measure responses, screen | Erase, program, verify |
| Typical equipment | Testers, probers, handlers | Universal programmers, ISP equipment, automated programming systems |
| Content source | Semiconductor vendor's test program | Downstream customer's program files |
| Output | Pass/fail, test parameters, bins | Program/Verify results and job records |
| Typically performed by | Semiconductor vendors, OSATs | Distributors, programming service providers, electronics manufacturers |
Put simply, test answers "Is this device good?" and programming answers "What is on this device?" A programmer's Verify step only confirms that the written data is correct. It cannot replace the semiconductor vendor's electrical and functional testing.
That said, the two aren't completely separate. The OTP, eFuse and trim writes mentioned earlier are write operations within the test flow. In practice, two scenarios are common.
Scenario 1: Test and configuration at the semiconductor vendor
Wafer sort: electrical parameters, functionality and die screening
Packaging and final test: functional and performance screening
Configuration writes defined by the product process, such as OTP, eFuse and trimming
Result confirmation and shipment
Scenario 2: Downstream device programming
Purchase packaged MCUs, NOR Flash, EEPROMs and other devices
Program offline, or in-system after placement
Placement and assembly
Board-level testing and system validation
The semiconductor vendor arranges Scenario 1 according to its product process. Scenario 2 takes place downstream, and that is where a universal programmer delivers most of its value.
In Scenario 2, several handoff points between the OSAT and the programming station deserve attention:
Incoming condition: Devices entering the programming station should come from lots that have passed test and are within their shelf life. When programming fails, it must be possible to tell whether the device or the contact is at fault, rather than simply writing the device off as defective.
Identification: Blank and programmed devices look identical. Many factories mark or label devices after programming to distinguish blank from programmed parts, and one software version from another.
Packing format: After programming, devices must be delivered in the format the next step requires, such as tape and reel for the placement machine, or back into trays.
Lot traceability: The semiconductor vendor's lot number, the programming file version and the programming lot should ideally be linked, so that issues can be traced back.
Devices of the same type don't necessarily share the same socket or configuration. If the part number, package, pinout, electrical conditions or algorithm differs in any way, compatibility must be reconfirmed.
DIP: Dual in-line package, using a matching DIP socket.
SOP / SOIC: Small-outline packages; the socket must match the lead pitch and body size.
QFN: A leadless package that makes contact through pads on its underside.
BGA: Ball grid array, requiring a matching BGA socket or a dedicated contact solution.
WLCSP: A wafer-level package that places higher demands on contact structure and positioning accuracy.
Even packages that share the QFN or BGA label may differ in size, pitch and ball count, so sockets aren't necessarily interchangeable. Support can't be judged from the software device list alone. Confirm that a socket or adapter solution is available for the target package.
In volume programming, unstable socket contact causes device ID failures, interrupted programming or verification errors. For heavily used sockets, pay attention to:
Contact materials and structure
Insertion count, maintenance and replacement intervals
Device orientation and positioning accuracy
The effect of repeated handling on leads or solder balls
Changeover efficiency between packages
In automated programming systems, also check how the socket works with the pick-and-place mechanism, so that devices are seated reliably and make stable contact.
Whether devices ship in trays, tubes or tape and reel determines how the programming station picks them. Automated programming systems need matching feeders. After programming, devices may also need to ship in a different format, for example tray in, tape out.
This point is often overlooked. Many surface-mount devices are moisture-sensitive and are vacuum-sealed in moisture barrier bags at the factory. Under IPC/JEDEC J-STD-033, a device's floor life, its allowable exposure to the factory environment, starts the moment the bag is opened. If that time is exceeded, the devices must be baked according to the standard before reflow.
Offline programming requires opening the bag, so the programming station must account for this exposure time. Will devices be dry-packed again after programming? Is baking needed? How will records be kept? This is why programming service providers list baking as a supporting service.
| Device Type | Typical Content | Key Conditions |
|---|---|---|
| MCU | Bootloader, application code, configuration words | Interface, operating voltage, algorithm, security or protection state |
| NOR Flash | Boot code, firmware image | Capacity, interface, erase method, program and verify |
| NAND Flash | Data and specific configuration | Bad block management, ECC, vendor-specified operating flow |
| EEPROM | Parameters, identification data, calibration data | Address, capacity, page write, data verification |
| eMMC / UFS | Data images, partition configuration | Capacity, partition settings, verification method |
| FPGA / CPLD | Logic configuration files | Configuration mode, interface, file format, security settings |
Some writes are irreversible, such as certain MCU security bits or option settings, so parameters must be confirmed item by item. Support for an interface doesn't automatically mean support for every device that uses it. Always refer to the device datasheet and the programmer's device support list.
When a line handles many packages and device types, a universal programming platform reduces equipment sprawl and job management overhead. But "universal" doesn't mean it can program everything. Evaluate it against five dimensions:
| Dimension | Questions to Ask | How to Verify |
|---|---|---|
| Device support list | Do the full part number and suffix, capacity, package, operating voltage, interface and algorithm version all match? | Check the full part number against the list. For unlisted devices, confirm whether an algorithm can be developed or adapted. |
| Package and socket | Is a socket available for the target package? What about its contact structure, positioning accuracy, service life and replacement method? | Trial-fit and trial-program with actual devices. |
| Programming algorithm | Do the erase, program, verify and configuration flows cover the required operations, such as security bits, partitions and bad block handling? | Test with production program files. |
| Program / Verify | Does the verification method meet process requirements? Are failures detected? Can jobs and results be saved? | Record the time for each phase separately and run continuous operation tests. |
| Scalability | Can sockets run in parallel, channels be added and jobs be configured independently? Can the platform connect to automation equipment and data systems? What changes are needed for new devices? | Confirm the adaptation path and interfaces with the vendor. |
Of these, the device support list is the one most easily reduced to a single number. However long the list, it doesn't tell you whether your target devices will program reliably. The most reliable method is always to test with the target devices and production program files. For volume production projects, run continuous operation tests rather than programming just a few samples.
Scalability determines the equipment's life cycle. Part numbers, packages and volumes on the line will all change. Manual loading may be enough today, but tomorrow you may need to connect automation equipment and upload data. Asking these questions during selection is far easier than replacing equipment later.
According to current product documentation, the HILOMAX ALL-1000G Series is designed to program a wide range of device types. It uses a dual-system architecture with independent MCU and Flash systems. The MCU system focuses on stability and compatibility, while the Flash system focuses on high-speed programming and interface evolution. The platform adapts to different devices and packages through Pin Cards. For eligible Flash devices, some adaptation needs can be met simply by swapping the Pin Card.
The ALL-1000G suits scenarios with many device types, mixed packages and frequent changeovers, such as programming services, high-mix electronics manufacturing and new device qualification. Swappable Pin Cards don't mean every new device needs only a card change. Each new part number still requires confirmation of the adaptation hardware, software version and validation requirements.
When a single part number runs in high volume and needs automated loading, unloading and packing conversion, the AT3 Series automated programming systems are worth evaluating. The series includes the AT3-150C, AT3-350C and AT3-350M4, which differ in socket count, pick-and-place structure and station configuration. AT3-350C documentation also covers 3D vision, laser marking and MES-related configurations.
These configurations map directly to the handoff points discussed earlier. Feeding methods correspond to packing formats. Laser marking distinguishes programmed devices. Vision and data interfaces support inspection and traceability. When selecting a system, first define the target devices and packages, the incoming and outgoing packing formats, the target UPH and how it is measured, and whether marking and data reporting are required. Then choose the model and configuration.
One more boundary should be clear. An automated programming system handles volume programming and material handling of packaged devices. It is not a substitute for the testers, probers or handlers on a packaging and test line. Before deployment, define which process step it belongs to and which manual tasks it replaces.
Device support, package compatibility, throughput and feature configurations for the above series are subject to the official specifications of the relevant models and project validation results.
Packaging, test and programming each own a different stage. The OSAT ensures the device is good; programming ensures the device carries the right content. Neither can replace the other. But every handoff between them is a potential point of failure: incoming condition, moisture sensitivity control, identification, packing format and lot traceability.
The first step in selection is pinpointing the process position. Does the write to the target device take place at the semiconductor vendor, in distribution, before placement or on the board? Once that is settled, consider packages, sockets, algorithms, Program/Verify and scalability. Package types are multiplying and device types diversifying, so the adaptation work that programming faces keeps getting more detailed. Ultimately, choosing a programming platform isn't about who has the longest support list. It's about whether the platform can program your target devices reliably and connect smoothly with the processes before and after it.
Need to evaluate programming solutions for multiple packages and part numbers, or plan how programming connects with marking, taping and other steps? Contact HILOMAX. Share your target part numbers, packages, incoming and outgoing packing formats and capacity targets, and we'll help confirm the right solution.
Next in this series: back to the production line, and how the entire process chain works together as programming moves from manual operation to automated volume production.
