|
PowerQUICC II Solutions
Arabella Linux for the PowerQUICC II Processor Family
Arabella Linux is based on the popular Debian distribution and has been tailored for embedded use on popular devices. Debian Linux features over 10,000 common packages (an embedded distribution consists of a small subset of these) and is widely recognized as a stable, broadly-supported and very popular Linux distribution.
Arabella adds to this its specific value-add in terms of hardware-software integration, device driver development and customization services to create the optimal embedded Linux solutions for its customers: what we call “Customized Open-Source Solutions”. Our Linux distribution includes a complete development environment (for either Debian or Red-Hat Linux hosts), our Linux kernel customized for the 82xx and a includes complete set of run-time packages.
This document briefly describes the 82xx-specific changes that Arabella engineers have designed for Linux to provide better support for this popular family of devices.
1. Code modularity
The code that handles the underlying hardware (chip and board) is divided modularly into three hierarchical elements as follows:
- Chip level
Chip-level initialization – essentially this is power mode options and the memory controller. This is the code that is specific to the actual device and that needs to be run during very basic system initialization before any communication services can be enabled.
- Peripheral level
This is the code that enables, configures, operates and disables the peripherals themselves – FCC, SCC, etc and underlying internal resources (see resource manager, below). If an FCC peripheral is identical in an 8250 and 8260 device, then the code may be simply re-used as-is.
- Board level
This deals with code-level dependencies such as memory map, memory busses, board-specific initializations and so on.
The current Linux code mixes up all levels of this. Even changes to the memory map require changes to source code in several files. There is no simple way of re-using an identical driver for the same peripheral on different boards. This is done today by simply cloning the whole system, modifying and then maintaining multiple code bases that are essentially identical. This creates obvious problems for code maintainability and re-use.
All of these issues are addressed in Arabella Linux – the different levels of dependencies are handled separately in a much more modular system. Code is re-used according to its function rather than cloned – the same peripherals always have the same drivers across different devices; the same chip-level code works across any board on which it is used and so on.
2. Dynamic configuration
Currently, a Linux user is expected to make many mode and configuration selections at compile time and others during system initialization, but has very little ability to modify these in run-time. For example, choosing which FCC’s are to be used, which modes they are to be used (Ethernet, Utopia, etc.) and basic configuration parameters are set at kernel compile time. Their activation is done during system initialization and little may be changed thereafter. Clocking options, parallel pin assignment and internal memory usage cannot be changed (most of this is simply hard-coded within the code itself).
This is unacceptable for many applications that need to control peripherals in a much more dynamic manner: either through management options or via software control during different stages of the application.
Arabella Linux addresses this by defining a generic device that is used to perform only basic initialization. Selection, configuration and activation/de-activation of peripherals are done by ioctl system calls on the “parent” device. Peripherals can then be completed (re)configured, activated and de-activated any time.
3. Supporting chip functionality
Device drivers in existing Linux distributions support just Uart and Ethernet peripherals, and even these with only minimal coverage of the device’s functionality. Arabella’s support matrix roadmap includes support for ATM, HDLC, PCI, USB, RapidIO and others. Please contact Arabella for an up to date list of supported functionality.
4. Resource management
Each peripheral in the 82xx requires internal resources within the device in order to function. These resources include internal DPRAM, clocks (BRGs), parallel pins and others. Each time a peripheral is set up, internal resources must be allocated (or released) by it; it is important to manage these resources in an orderly way to give the user flexibility in how to allocate them among these competing peripherals.
Arabella Linux contains a resource manager that tracks and manages all use of internal resources. Drivers allocate resources and associate them with a peripheral, when the peripheral is de-activated, all internal resources associated with it are released automatically. Furthermore, by accessing the device via the proc file system, a user may see all internal resources currently associated with a peripheral.
In a little more detail, the RM is used to define “consumers” and any internal resources that may be allocated to such consumers. Examples of consumers are an AAL5-SAR object, an Ethernet object and so on. Resources are the communication devices (FCC, SCC, SMC, MCC and so on), parallel pins, baud-rate generators, clocks and internal memory. By allocating these internal resources via the RM and associating them with a nominated consumer, we achieve the following:
- orderly and structured methods for handling chip resources
- full run-time checks for resource overlap (e.g. parallel pins that are required by more than one consumer)
- hierarchical release of all resources associated with a consumer when the consumer is shut down
- rich diagnostics information. This includes lists of all kmalloc’d memory block allocated via the RM (useful in finding memory corruption or mismanagement problems), physical memory space display/patch mechanism, intelligent DPRAM allocator/releaser and textual displays of all resources allocated to a specific consumer or, inversely, all consumers using a particular type of resource.
Microcode packages
In addition to the above infra-structure elements within the Linux kernel, Arabella is also one of the few third-party companies licensed by Freescale to develop proprietary microcode packages on the embedded CPM microprocessor within the 82xx (and 85xx) device. Details and plans are available from Arabella under NDA.
The microcode packages provide opportunities for:
- Fast handshakes with external devices
- Acceleration for fast-path operations
- Support for proprietary functions per user requirements
Arabella microcode packages for the 82xx are fully integrated with Arabella Linux, providing a unique and very complete solution for these popular processors.
|
|
