IEEE 1275-1994：引导配置固件的核心需求与实践标准

5星 · 超过95%的资源需积分: 9 107 浏览量更新于2024-07-29 1 收藏 1022KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

IEEE 1275-1994 是一个专门针对计算机启动（初始化配置）固件的核心要求和实践标准。该标准定义了在操作系统执行前负责控制计算机硬件的软件架构，通常这些固件存储在只读存储器（ROM）或可编程只读存储器（PROM）中，以便在计算机开机后立即运行。 1. 目的与范围本标准的主要目标是确保在操作系统开始执行之前，固件能够可靠地进行机器硬件的检测和初始化，同时从磁盘或其他存储设备或网络引导操作系统。此外，它还关注操作系统可能依赖的其他服务，例如交互式硬件和软件调试的支持。固件设计应具备通用性，兼容各种总线、供应商、操作系统（如Unix、Windows等）以及不同的指令集架构（ISA），如x86、ARM等。标准参考了OpenBoot PROM架构规范[B6]，作为基础构建块，旨在提供一种标准化的方式来实现跨平台的启动流程。随着技术的发展，后续补充文档（例如1275.x系列）会针对该标准的应用进行细化，以适应不断变化的技术环境和需求。 1. 实施原则遵循IEEE 1275-1994，固件开发者需遵循一系列最佳实践，包括： - 硬件检测：确保在启动过程中对硬件组件进行充分测试，识别并处理潜在的硬件问题。 - 灵活性：固件设计应支持多种引导方式，以应对不同的启动场景。 - 安全性：考虑到固件可能成为攻击目标，必须实施适当的安全措施，防止恶意代码注入或篡改。 - 可维护性和升级性：便于固件的更新和维护，以适应新的系统需求和安全补丁。 - 日志记录与调试：提供有效的日志记录机制，便于诊断和调试过程中的问题追踪。 IEEE 1275-1994标准为计算机启动固件的设计提供了指导，确保了系统的稳定性和兼容性，这对于现代信息技术基础设施的高效运行至关重要。尽管标准发布于1994年，但其核心原则和最佳实践至今仍被广泛应用于现代设备的固件开发中，并随着技术迭代而得到相应的调整和扩展。

资源详情

资源推荐

IEEE

Std 1275-1994 IEEE STANDARD FOR BOOT (INITIALIZATION CONFIGURATION) FIRMWARE:

3.2.2.1.1 Property names

The property name is a human-readable text string consisting of one to thirty-one printable characters. Property

names shall not contain uppercase characters or the characters “/”, “\”, “:”, “[“, “]” and “@”.

Properties are accessed by name. Given a string, it is possible to determine whether or not there is a property with

that name in a particular device node, and if so, its value.

This standard defines some property names and the meanings of their values; properties with names that are not

defined by this standard may be used to convey other information at the developer’s discretion.

Property names beginning with the character “+” are reserved for use by future revisions of this standard.

Each device node has at least one property, whose property name is the string “name”, and whose value is a text

string naming the device. The value of this “name” property is the driver name component of the node name that

identifies the device in device pathnames.

3.2.2.1.2 Property values

The property value is an array of zero or more bytes containing the information associated with that property. The

meaning of those bytes depends on the particular property.

This standard defines standard ways to encode various types of information in property value byte arrays, and pro-

cedures for performing the encoding and decoding process. The encoding technique is called property encoding.

Property encoding has provisions for encoding text strings, integers, byte arrays, and various derived types that are

composed by concatenation of those primary data types.

The property-encoding format is independent of hardware byte order and alignment characteristics. The encoded

byte order is well-defined (in particular, it is big endian). Individual items are concatenated to form composed

types without any “padding” for alignment reasons.

A property may have a null value, i.e., a byte array of length zero. Such properties usually convey true/false

information. The presence of the property signifies true, and its absence signifies false.

The property encoding rules are as follows:

— byte array. An array of bytes is encoded in a property value byte array by storing the successive bytes of the

input array into successive locations in the property value byte array.

— 32-bit integer. A 32-bit integer is encoded into a property value byte array by storing the most significant byte

at the next available address, followed (at address+1) by the high middle byte, the low middle byte, and (at

address+3) the least significant byte.

— text string. A text string consisting of n printable characters is encoded into a property value byte array by stor-

ing the n characters at successive locations in the array, followed by a null byte (of binary value zero) denoting

the end of the string.

— composite values. A succession of individual data items is encoded into a property value byte array by

encoding the individual items in sequence. No alignment or padding is performed (i.e., the items are

“packed”); each successive item immediately follows its predecessor.

This standard specifies functions for performing these and other derived encodings and for performing the inverse

decoding operations. The program that creates a property and the program that uses it must agree on what

information is contained in the value of a property of a particular name and on the order in which that information

appears. The property encoding and decoding functions do not describe the meaning of the information; they

simply allow it to be expressed in an ISA-independent manner.

IEEE

CORE REQUIREMENTS AND PRACTICES Std 1275-1994

3.2.2.2 Methods

Methods are named software procedures that control hardware devices or provide other services. Each device node

may have zero or more methods.

The name space for a given device node’s methods is distinct from the name space of its properties.

Some device node methods are externally visible in that they may be invoked by software entities outside the device

node. Other methods are for internal use only and may be invoked only by other methods of the same device node.

The list of methods for a particular device node forms a Forth wordlist. Each method is a Forth word.

Arguments to and results from device methods are passed on the Forth stack. The method lists for different device

nodes are disjoint from one another. Although different device nodes often contain methods with identical names

(for example, many nodes contain a selftest method), those individual methods are distinct.

In general, before a package’s methods can be used, the package must be opened, thus creating an instance of the

package. However, it is possible to define methods that can be used without opening their packages; such methods

are called static methods. A static method can not refer to any instance-specific data, nor can it execute any

function that implicitly refers to the current instance. A static method can call another static method, and it can

call any method in a package that has been opened.

This standard defines several methods with predefined meanings as given in this clause.

3.2.2.3 Private data

Private data is used by package methods to maintain internal information. Unlike properties, which can be

accessed by external software, private data can not be directly accessed from outside the package; rather, any access

to package data is mediated by the package’s methods. Private data can be instance-specific or static.

3.2.2.3.1 Instance-specific data

When a package is opened, memory is allocated for its instance-specific data. The contents of that memory can be

changed without affecting any other instances of that package. Instance-specific data can be either initialized or

zero-filled.

A package contains initial values for its instance-specific data. When a package is opened, these initial values are

copied into the corresponding locations within the memory allocated for that instance. Subsequent modifications of

the instance’s initialized data do not affect the initial values contained within the package.

The Forth words variable, value, and defer, in conjunction with instance, and their FCode equivalents,

create initialized data items.

When a package is opened, the locations within the memory allocated for that instance corresponding to the zero-

filled data are set to zero.

The Forth word buffer:, in conjunction with instance, and their FCode equivalents, creates zero-filled data

items.

3.2.2.3.2 Static data

Static data is shared among all instances of a particular package and persists even when no instance exists. Static

data may thus be used to communicate between different instances of the same package. This includes two

instances that exist simultaneously as well as two instances that exist at different times.

IEEE

Std 1275-1994 IEEE STANDARD FOR BOOT (INITIALIZATION CONFIGURATION) FIRMWARE:

3.2.2.4 Package creation

Each package is a device node in the device tree. Packages implementing device drivers are located in the device

tree as children of the device node for the bus on which the device resides. Packages implementing utility functions

not associated with any specific device are usually located as children of the /packages device node, which

exists as a place to put those utility packages.

New packages are created during the probing portion of the system start-up sequence. The process of creating a

new package involves the following:

a) Creating a new “empty” device node at the appropriate location in the device tree and making it the active

package.

b) Interpreting an FCode program to define its methods and properties and allocating storage for its data.

c) Finishing the package to “freeze” the initial values of its instance-specific data.

At any given time, if there is an active package,

— Newly created Forth words become methods of the active package.

— Newly created Forth variables, values, buffers and defer words may define either static or instance-specific

data areas. The default is static. Instance-specific data is allocated if the defining word is preceded by the

instance modifier.

— If there is a current instance, newly created properties are added to the package from which that instance was

created; otherwise, newly created properties are added to the active package.

— The process of searching for Forth words considers first the methods of the active package, followed by globally

visible words.

If there is not an active package:

— Newly created Forth words are globally visible (i.e., not specific to any package).

— Newly created Forth variables, values, buffers, and defer words allocate global storage (not associated with

any particular package).

— If there is a current instance, newly created properties are added to the package from which that instance was

created; otherwise, new properties cannot be created.

— The process of searching for Forth words considers only globally visible words.

There is always an active package when an FCode program is being evaluated. When a new package is created by

probing an FCode program, the new package is placed in the device tree as a child of the hierarchical device that

performs the probing. (In general, hierarchical devices are responsible for knowing how to probe their children.)

3.2.3 Package instances

In most cases, in order to use a package, the package must be opened, thus creating an instance of that package. A

package instance consists of a copy of the package’s private data, copies of any arguments that were provided

when the instance was created, and linkage information that allows the package instance to locate an instance of its

parent device’s package. The numerical identifier of an instance is called an ihandle. In general, when a package is

opened, all of the packages in the path from the device tree to that package are opened also.

Several instances of the same package may be in use simultaneously, each with its own separate copy of the

package’s private data and instance arguments.

By analogy to traditional operating systems, a package is similar to a program residing in a disk file, and an

instance is similar to a running “process” or “task”. Similar to the way that multiple independent processes may be

created from a single program, multiple independent instances may be created from a single package.

IEEE

CORE REQUIREMENTS AND PRACTICES Std 1275-1994

3.2.3.1 Instance chains

A package is opened from a device path (or equivalent device alias) that specifies the path from the root of the

device tree to the device in question. Each component of that path, beginning at the root, is opened, creating an

instance for each device in the path. The instances are linked together so that each package instance may locate

the instance of its parent.

When an instance is no longer needed (i.e., the program that opened a package decides that it will no longer need

the function provided by that package), the instance may be closed, thus freeing the memory used by its private

data and perhaps deactivating devices controlled by that package or its parents. An instance may be closed

individually or the entire instance chain to which it belongs may be closed. In the latter case, the instances in the

chain are closed in the order opposite to the order in which they were opened. In other words, an instance is closed,

and then its parent instance is closed, and then its parent’s parent, and so on.

3.2.3.2 Instance methods

Before using a package method, in most cases the package must first be opened, thus creating an instance. The

instance is represented by an ihandle, a numerical value that refers to a particular instance. At any given time, one

instance, at most, may be the current instance. The private data of the current instance is accessible; the private

data of other instances is not.

In order to use a package method, its instance must be made current.

To call a method from another method within the same package, no special action need be taken; since the

appropriate instance must already be the current instance for the calling method to run, the called method may be

invoked directly, without changing the current instance.

To call a package method from the “outside” (i.e., from some execution context other than the instance containing

the method in question), a different approach is used. The caller identifies both the method to be called and the in-

stance that is to be current for the duration of that method’s execution. There are various commands for calling

methods, differing in the forms of method and instance identification. In general, such a command saves the

ihandle of the current instance by pushing it on the return stack, makes the called instance the current instance,

executes the method, and then pops the saved ihandle from the return stack, restoring the current instance to that

value.

The caller must know the ihandle of the instance corresponding to the method to be called. There are two common

ways to acquire this knowledge:

— The caller may have opened the package whose method is to be called. The process of opening a package

returns the resulting ihandle, which the caller may save for later use in calling the ihandle’s associated

methods.

— The package to be called may be the parent of the calling instance. As mentioned in 3.2.3.1, each instance

automatically knows the ihandle of its parent.

A static method can be executed at any time, regardless of whether or not its package is open. It can be executed

directly by other methods within the same package, or its execution token may be passed to execute or catch

or stored in a defer word for later execution. There are various ways to determine its execution token in various

circumstances, for example, find-method or ['].'

IEEE

Std 1275-1994 IEEE STANDARD FOR BOOT (INITIALIZATION CONFIGURATION) FIRMWARE:

3.3 Configuration memory

Configuration memory stores information that affects the behavior of various Open Firmware functions according

to the user’s preferences. The choices are stored in some form of nonvolatile memory, such as electrically erasable

PROM or battery-backed RAM.

Open Firmware provides functions for setting the configuration memory through the user interface and the client

interface.

The precise layout of the data stored in configuration memory is not exposed through any of the Open Firmware

external interfaces. Configuration memory fields are accessed by name, as with device-node properties. This

facilitates the addition of new fields and the deletion of fields that are no longer needed, since external software is

unaware of precise storage locations and internal storage formats.

3.3.1 Configuration variables

Configuration variables are predefined configuration memory choices that affect Open Firmware in well-defined

ways.

The list of configuration variables varies from system to system. Such choices often include the device from which

to boot the operating system, the device to use as the console, and the amount of memory to be tested.

For each configuration variable supported by a particular implementation, Open Firmware maintains both the

default value of the variable, typically stored in ROM, and the current value, stored in configuration memory. The

default values are useful for restoring the settings to their factory defaults, which may be done either upon user

command or automatically, if the firmware determines that the contents of configuration memory have been

corrupted.

3.3.2 Custom start-up script

The custom start-up script is a portion of configuration memory that can contain an arbitrary user-supplied Forth

language program. That program can be executed automatically as part of the Open Firmware start-up sequence. It

can be used for a variety of purposes, including work-arounds or patches for firmware or device driver bugs, user

enhancements, or customizations beyond the capabilities of the configuration variables.

The custom start-up script occupies the portion of configuration memory that is not dedicated to other purposes

such as configuration variables. Its length can vary from zero up to the amount of available configuration memory.

The custom start-up script can execute essentially any of the commands that are present in the user interface.

The contents of the custom start-up script can be set either through the client interface or with the text editor that

is an optional part of the user interface.

3.4 Standard property names

These standard property names apply to all device nodes, regardless of type; particular types of devices have addi-

tional properties specified in subsequent sections. Most of the following properties are optional; a package includes

the property to declare a particular characteristic if desired. The “name” property is required for all packages.

剩余265页未读，继续阅读

chieffon

粉丝: 1
资源: 15

IEEE 1275-1994：引导配置固件的核心需求与实践标准

IEEE并口协议文档1994版

pcibusbinding1275-1994.pdf

ieee 29148-2018

ieee 1588-2019

ieee 24748-2

ieee 1901-2020

ieee 42010-2011

ieee 1722-2016 csdn

ieee1588-2008

基于fpga的ieee1588-2008硬件实现

ieee 13-bus system

ieee 1364-2005标准

iec/ieee 24765-2010

ieee 1471-2000 中文

ieee1547-2018

ieee 1800-2017 system verilog pdf

ieee 1858-2023 cpiq网盘下载

ieee1012-2012

iso∕iec∕ieee 12207-202

IEEE60870-103

最新资源