Embedding soft processors in FPGA fabric offers a radical but robust new solution that effectively eradicates the problem of processor obsolescence.

Your biggest obsolescence problem is out-of-date microprocessors and microcontrollers. Processors have shorter life spans than ever and are often discontinued at short notice, victims of fluctuating consumer market trends and the demand for ever-greater speed. In addition, obsolescence is deliberately built into such items as consumer products, encouraging microprocessor manufacturers to abandon existing processors in pursuit of planned platform introductions, thus propagating a ripple effect of obsolescence. Even for designs coded in “C” (touted as being “portable code”), there are always architecture-specific instructions and features that hamper the changeover from the obsolete processor to the next-generation device. This changeover problem is exacerbated by different package options and I/O configurations, which can necessitate a complete board re-spin.

Soft processor cores offer an extremely attractive alternative to traditional approaches toward the problem of obsolescence, all of which are time-, labor-, and cost-intensive, and waste legacy development efforts.

A Look at Traditional Approaches

The predicament of automotive telematics equipment designers, for example, is representative of the problem. Although design and development time scales have shrunk from five years down to two, production is measured in years and the products remain active in the field for another 10 years plus. If we imagine a scenario in which every Electronic Control Unit (ECU) in a car contains at least one processor, and that every car contains up to 60 ECUs, this translates to a major problem every time a processor is obsoleted at relatively short notice.

Designers rely on several solutions to deal with processor obsolescence. The applicability of any given solution depends upon a number of variables: the value of the application software, the projected life of the system, and the amount of time and money available to solve the problem.

The most expensive solution is to redesign the system around a new processor. Depending on the volume of the code, a redesign can cost hundreds of worker-years, much of it devoted to validation and testing. Not only is the huge investment in debugging and refining the existing software lost – a clear case of throwing the baby out with the bath water – but the solution is temporary at best. If the system has a long projected life, the same problem will recur every few years.

Another solution is the Last Time Buy (LTB), which, on the surface, appears to be the most cost-effective option. The problem with this approach is that the designer must guess how much product to buy for the life of his program. If he guesses wrong, he is faced with an even more difficult problem: a larger legacy investment that must somehow be upgraded.

Inserting a new processor along with software written to emulate the old one is, at present, better in theory than in reality – although it’s an appealing concept that does have some operational history. This option preserves the legacy software, so the process is relatively cheap and fast. But once again, the solution is not permanent. If the system has a long projected life, a new solution might have to be repeated every few years.

More important, software emulation is inherently a serial process. Because so much performance is consumed running the emulation rather than the application, it is slow. It has been shown empirically that emulation requires, on average, about 20 clock cycles of the new processor for every legacy instruction it executes.

In addition, emulation breeds further obsolescence, because the processor used as the emulation engine will itself become obsolete and may force an entire rewrite of the emulator.

Off-the-shelf solutions often merely substitute new headaches for old ones. Let’s say you need a processor with 10 UARTs, an interrupt controller, and access to a block of external flash memory. Although there are many off-the-shelf processors offering multiple UARTs and other desired peripherals, they typically have numerous other peripherals that would go unused in your system. So, not only are you paying for the additional peripherals, but you often have to place unused peripherals into a safe mode or otherwise disable them via software.

Decommissioning unused peripherals places an additional burden on your software design team, who not only have to make the processor peripherals operate correctly, but now have to write code for the parts of the processor that are not used. Clearly, purchasing an off-the-shelf solution in this scenario would be highly wasteful, not only in terms of initial cost, but also in wasted engineering time during the design process.

The Soft Processor Solution

The soft processor solution eradicates processor obsolescence and preserves many years of legacy code and development. The new approach is to own the soft processor core and embed it in an FPGA host. Not only can you port the core to multiple FPGA platforms, but you can also design the peripheral set to meet your exact design requirements, thus eradicating architecture compromises and wasted peripherals.

The Xilinx MicroBlaze™ soft processor gives you the luxury of a different approach. Now, you can start with a processor core and build the peripheral set to meet your exact requirements. You’ve eliminated silicon wastage because you implement only what you need. You’ve reduced software design complexity because no code need ever be written to disable unwanted processor functionality. Creating unusual processor configurations – which can be changed at any time to suit changes in the specification – is now a simple task.

Even if after five or six years of field use, when the FPGA hardware may itself be nearing the end of its life, the soft processor core can simply be dropped into its new FPGA host, using the same “C” code. The hardware platform may need some PCB modifications but the legacy code remains usable and intact.

MicroBlaze and PicoBlaze Soft Processors

Xilinx offers both a 32-bit MicroBlaze soft processor core and an 8-bit PicoBlaze™ soft core. The PicoBlaze processor runs at speeds of 116 MHz, yet occupies a tiny footprint of just 35 configurable logic blocks (CLBs). (See Figure 1.)

Figure 1 - Xilinx PicoBlaze and MicroBlaze soft processors

The MicroBlaze 32-bit soft processor core is the industry’s fastest soft processing solution. It runs at 150 MHz and delivers 100 D-MIPS. It features a RISC architecture with Harvard-style, separate 32-bit instruction and data buses running at full speed to execute programs and access data from both on-chip and external memory. A standard set of peripherals is IBM CoreConnect™ bus- enabled to offer MicroBlaze designers compatibility and reuse.

Xilinx EDK Solutions

Xilinx Embedded Development Kits (EDKs), including the soft processor core and a standard set of peripherals, are available from Xilinx and its distribution partners (see Table 1). The kits include a complete set of GNU-based software tools, including compiler, assembler, debugger, and linker. MicroBlaze EDKs bought from Xilinx and its distribution partners also include development boards that support the Virtex™-E, Virtex-II, Spartan™-II, and Spartan-IIE series of FPGAs. Table 2 summarizes the specifications for the two processor cores.

Table 1 - EDK Development boards

Table 2 - Xilinx soft processors

Selected Xilinx FPGAs in the new IQ Solutions range have been qualified to operate over the -40ºC/-40ºF to 125ºC/257ºF temperature range and are designed for use in automotive applications, such as telematics systems.

Conclusion

Embedded in FPGA fabric, Xilinx soft processor cores such as MicroBlaze and PicoBlaze can eradicate processor obsolescence issues by providing a stable platform that is owned and configured by the designer. Used in combination with the new IQ Solutions extended temperature range FPGAs, they are ideal for such applications as automotive telematics.

Not only will you benefit from the flexibility, integration, and upgradeability offered by programmable logic, you can now take advantage of a processor tailored to your design needs that will not go obsolete, and will ultimately save the time and money associated with costly redesign.

For more information, visit these websites:
MicroBlaze Information
www.xilinx.com/microblaze/

PicoBlaze Information
www.xilinx.com/picoblaze/

Automotive IQ Solutions
www.xilinx.com/automotive/.

Printable PDF version of this article.  (02/10/03) 530 KB