Abstract:
The present invention is directed to a reconfigurable memory controller. A reconfigurable memory controller may include a plurality of communicatively coupled memory controllers. The plurality of communicatively coupled memory controllers is reconfigurable so that the controllers are groupable into a first memory configuration and a second memory configuration. The first memory configuration has a different bandwidth grouping than the second memory configuration.

Description:
FIELD OF THE INVENTION  
         [0001]    The present invention generally relates to the field of electronic memories, and particularly to a reconfigurable memory controller.  
         BACKGROUND OF THE INVENTION  
         [0002]    Information handling systems, such as desktop computers, servers, digital information appliances, and the like, rely on memories to store information used by such systems in performing tasks. A memory may be used, for example, to store a portion of a computer program that is executed by a computer, as well as the data that is operated upon by the computer. Thus, the reading and writing of data to a memory may have a profound impact on the operation of an information handling system.  
           [0003]    A dedicated memory controller may be provided to handle the data transfer to and from memory storage devices. Previously, to control data transfer with a given type of memory storage device, a memory controller must often be specifically tailored to meet the various parameters for that device.  
           [0004]    Some memory controllers, however, may need to be used with different types of memory storage devices. For example, it may be desirable to support multiple types of memory storage devices so that the memory controller may be used in different applications.  
           [0005]    Additionally, in programmable chip platforms (e.g., field-programmable, metal-programmable, and the like) it may be desirable to place custom DRAM transceivers on the chip for connection to external DRAMs. It is also useful to place minimal controller logic for the chip IOs to manage technology-specific timing-critical aspects of DRAM.  
           [0006]    Therefore, it would be desirable to provide a solution to problem of defining a framework for a configurable, flexible memory controller that may be customized to wok as one or several distinct memory controllers having a useful set of features.  
         SUMMARY OF THE INVENTION  
         [0007]    Accordingly, the present invention is directed to a reconfigurable memory controller. In an aspect of the present invention, a reconfigurable memory controller includes a plurality of communicatively coupled memory controllers. The plurality of communicatively coupled memory controllers is reconfigurable so that the controllers are groupable into a first memory configuration and a second memory configuration. The first memory configuration has a different bandwidth grouping than the second memory configuration.  
           [0008]    In an additional aspect of the present invention, a reconfigurable memory controller includes a plurality of communicatively coupled memory controllers including a first memory controller, a second memory controller, and a third memory controller. The plurality of communicatively coupled memory controllers are reconfigurable so that the first memory controller and the second memory controller are groupable into a first memory configuration, and the first memory controller and the third memory controller are groupable into a second memory configuration. The first memory configuration is distinct from the second memory configuration.  
           [0009]    In a further aspect of the present invention, a system includes a programmable chip platform and an external memory communicatively coupled to the programmable chip platform. The programmable chip platform has a reconfigurable memory controller including a plurality of communicatively coupled memory controllers. The plurality of communicatively coupled memory controllers is flexibly configurable so that the controllers are groupable into a first memory configuration and a second memory configuration. The first memory configuration has a different bandwidth grouping than the second memory configuration.  
           [0010]    In an aspect of the present invention, a method for reconfiguring a memory controller to support different configurations includes providing a reconfigurable memory controller having a plurality of communicatively coupled memory controllers which are groupable. The plurality of communicatively coupled memory controllers are configured into a first memory configuration, the first memory configuration having a first grouping of memory controllers and a second grouping of memory controllers. The first grouping of memory controllers has a first bandwidth and the second grouping of memory controllers have a second bandwidth. The plurality of communicatively coupled memory controllers are then reconfigured into a second memory configuration, the second memory configuration having a third grouping of memory controllers and a fourth grouping of memory controllers. The third grouping of memory controllers has a third bandwidth and the fourth grouping of memory controllers has a fourth bandwidth. The bandwidths as grouped by the first grouping and the second grouping of the first memory configuration are different from the bandwidths of the third grouping and the fourth grouping of the second memory configuration.  
           [0011]    It is to be understood that both the forgoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention as claimed. The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate an embodiment of the invention and together with the general description, serve to explain the principles of the invention.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0012]    The numerous advantages of the present invention may be better understood by those skilled in the art by reference to the accompanying figures in which:  
         [0013]    [0013]FIG. 1 is an illustration of an exemplary embodiment of a reconfigurable memory controller of the present invention;  
         [0014]    [0014]FIG. 2 is an illustration of an exemplary embodiment of a reconfigurable memory controller of the present invention wherein two of the 32-bit controllers of FIG. 1 have been combined into a single 64-bit controller;  
         [0015]    [0015]FIG. 3 is an illustration of an exemplary embodiment of the present invention wherein the four 32-bit controllers have been combined into two 64-bit controllers;  
         [0016]    [0016]FIG. 4 is an illustration of an exemplary embodiment of the present invention wherein four 32-bit controllers of FIG. 1 have been combined into one 128-bit controller;  
         [0017]    [0017]FIG. 5 is a depiction of an exemplary non-pipelined operation mode;  
         [0018]    [0018]FIG. 6 is a depiction of an exemplary pipelined operation mode of a plurality of controllers of the present invention;  
         [0019]    [0019]FIG. 7 is an illustration of an exemplary embodiment of the present invention in which generalized controller flow is shown;  
         [0020]    [0020]FIG. 8 is an illustration of an exemplary embodiment of the present invention wherein a memory data path unit block diagram is shown;  
         [0021]    [0021]FIG. 9 is a depiction of an exemplary command format of the present invention; and  
         [0022]    [0022]FIG. 10 is a depiction of an exemplary response format of the present invention.  
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0023]    Reference will now be made in detail to the presently preferred embodiments of the invention, examples of which are illustrated in the accompanying drawings.  
         [0024]    Referring generally now to FIGS. 1 through 10, exemplary embodiments of the present invention are shown. The present invention relates to DRAM memory controllers and provides a solution to problem of defining a framework for a configurable, flexible memory controller that may be customized to work as one or several distinct memory controllers having a useful set of features.  
         [0025]    In programmable chip platforms (e.g., field-programmable, metal-programmable, and the like) it may be desirable to place custom DRAM transceivers on the chip for connection to external DRAMs. It is also useful to place minimal controller logic for the chip IOs to manage technology-specific timing-critical aspects of DRAM. Therefore, in an embodiment of the present invention, a framework is described for a flexible set of memory controllers that are designed and pre-placed on a chip that may be configured to work as one of several distinct memory controllers. Degrees of freedom within this framework include not only the number of memory controllers in the collection of memory controllers supported, but also a variety of other aspects, including the following:  
         [0026]    technology type and speed of DRAM memory for each memory controller  
         [0027]    width and depth of the memory array for each memory controller  
         [0028]    memory operators supported by each memory controller  
         [0029]    address map of each memory controller  
         [0030]    type, speed, and width of interface to other logic for each memory controller  
         [0031]    aggregation of memory controllers/interfaces  
         [0032]    access models for each memory controller, e.g. packet storage, line storage, counter/statistics storage, and the like  
         [0033]    While it is recognized that prior art designs offer DRAM-specific off-chip drivers and minimal control logic (DDR coreware), higher-level memory controller logic for use in programmable platforms which supports layering and is flexible, configurable, and partitionable as provided by the present invention is not shown in the prior art. It should also be recognized by a person of ordinary skill in the art that this technique may be applied to on-chip memories where the technology is fixed but where flexible control is useful for programmable platforms.  
       Flexible Memory Controller  
       [0034]    A flexible memory controller may include communicatively coupled controllers that may be configured in a variety of groupings to perform as desired. For example, a flexible memory controller may include a set of four 32-bit DDR SDRAM controllers that may be communicatively coupled, to operate in a variety of configurations. For instance, exemplary configurations for a set of four 32-bit controllers may include the following:  
         [0035]    (A) Four 32-bit controllers;  
         [0036]    (B) Two 64-bit controllers;  
         [0037]    (C) One 128-bit controller; and  
         [0038]    (D) Two 32-bit controllers and one 64 bit controller.  
         [0039]    The following assumptions will be made for purposes of simplifying the following discussion, and are not meant to necessarily limit the scope of the present invention.  
         [0040]    1. Operations to the same bank are not reordered.  
         [0041]    2. Clock speeds of approximately 166-200 MHz.  
         [0042]    3. Support for vertical and horizontal ECC. Horizontal ECC utilizes an extra memory module connected to each controller. Vertical ECC partitions the address space differently and creates regions in which to store the ECC within the data modules.  
         [0043]    4. Programmable CAS latency with values of 2, 2.5, 3, and 4.  
         [0044]    5. Write commands do not return a tag unless there is an error.  
         [0045]    6. Increment commands with no return data do not return a tag unless there is an error.  
         [0046]    7. Fence commands do not return a response.  
         [0047]    8. Both DDR SDRAM and FC dram are supported.  
         [0048]    9. The AHB bus is only used for register accesses, so locking and split transactions are not supported by the slave interface.  
       Special Functions  
       [0049]    Beyond the typical read/write capabilities, two special operations are supported by the present invention.  
         [0050]    Fence  
         [0051]    A fence command forces all currently pending operations to be completed before any further operations are accepted. A fence command may be directed at a particular controller(s) or at all controllers.  
         [0052]    Increment  
         [0053]    An increment operation may read a value from memory, increment the value by 1, and write the incremented value back to memory. Further, the increment operation may be performed on a single 32-bit value, both 16-bit halves of a 32-bit value, and the like. The operation may optionally return the value read, but generally does not do so.  
       Addressing  
       [0054]    In addition to the special functions, the controller of the present invention may also support a variety of forms of addressing for read/write commands. For example, a first addressing scheme may employ a wrapping addressing scheme in which accesses that do not start on an even burst boundary “wrap around” when the accesses reach the end of the burst address. For instance, starting an access at address 0x4 would result in accesses to 0x4, 0x8, 0xC, and 0x0.  
         [0055]    An additional form of addressing contemplated by the present invention is sequential, in which the address continues to increment past the end of a burst. For example, an access at address 0x4 would result in accesses to 0x4, 0x8, 0xC, and 0x10. The only limitation on sequential addressing is that the addressing may not cross a 1 Kbyte boundary.  
       Architecture  
       [0056]    Referring now to FIG. 1, an exemplary embodiment of a reconfigurable memory controller of the present invention is shown. In this example, four independent 32-bit wide memory controllers  102 ,  104 ,  106  &amp;  108  are depicted. Each of the controllers  102 ,  104 ,  106  &amp;  108  in this instance are configured to be accessed independently, and are communicatively coupled between gate array logic  110  and an I/O  112  for communicatively coupling the gate array logic  110  through use of the controllers  102 ,  104 ,  106  &amp;  108  to external memory modules  114 ,  116 ,  118  &amp;  120 . (Add Data path PHYs)  
         [0057]    Referring now to FIG. 2, an exemplary embodiment of a reconfigurable memory controller of the present invention is shown wherein two of the 32-bit data paths of FIG. 1 have been combined into a single 64-bit controller. The memory controllers  102  &amp;  104  that are paired together are controlled by a single interface  122 , Both Data paths are under the control of a single controller. Because the logic is implemented in metal programmable regions of the chip, the interconnection of the data path and arraignment of controllers is flexible. The PHYs 124 are implemented in precisely placed and timed diffused logic. The single interface  122  enables the gate array logic  110  to utilize the two 32-bit controllers  102  &amp;  104  as a single 64-bit controller. The other controllers  106  &amp;  108  are still viewable as separate 32-bit controllers.  
         [0058]    In FIG. 3, an additional embodiment of the present invention is shown wherein the four 32-bit data paths have been combined into two 64-bit controllers. Each pair of 32-bit data paths may be controlled by corresponding interfaces  126  &amp;  128 , as described previously.  
         [0059]    Referring now to FIG. 4, a further embodiment of the present invention is shown wherein the four 32-bit data paths of FIG. 1 have been combined into one 128-bit controller. In this instance, all four of the 32-bit data paths are controlled by one interface  126 . Thus, the gate array logic utilizes the controllers  102 ,  104 ,  106  &amp;  108  as a single controller  126 .  
         [0060]    Therefore, through use of the present invention, a reconfigurable memory controller is provided which may be tailored to the functionality desired.  
       Modes of Operation  
       [0061]    When combining multiple controllers together, a variety of architected modes of operation may be employed, such as non-pipelined and pipelined.  
         [0062]    Non-pipelined Operation  
         [0063]    A non-pipelined mode assumes that the interface is wired with transistors of sufficient drive strength that the flight times to/from the combined controllers are balanced. In this mode, each controller receives a same command on the same clock cycle and should respond in the same clock cycle. An example of non-pipelined operation is shown in FIG. 5.  
         [0064]    Pipelined Operation  
         [0065]    A pipelined mode staggers the sending of commands to each controller to allow time for the commands to reach each controller. In this mode, each controller receives the same command on a different clock cycle and responds in a different clock cycle. An example of pipelined operation is shown in FIG. 6.  
       Controller Overview  
       [0066]    Control Unit  
         [0067]    Referring now to FIG. 7, a high level flow of the controller of the present invention is shown. Each memory controller operates on commands presented to the controller by gate array logic. The commands are further discussed subsequently in the “Command/Response” section of the present discussion. Each command includes an identifying tag, opcode, and address. If the command is an increment, byte enables are also included. If the command is a write, byte enables and write data are also part of the command. For writes, half of the byte enables and write data are presented with the command and the other half are presented the cycle immediately after the write command is accepted by the controller.  
         [0068]    Since the path through the flow is different for write and non-write commands, the commands shall be described separately. However, the use of the tag part of the command will first be described.  
         [0069]    Tag Usage  
         [0070]    Generally, the tags are carried through the flow to link the requester and the operation. An assumption for the present discussion is that there is an operation Y that enters the controller with tag X, and Y is expected to return data. When Y completes, the requester may be sent a response with tag X and status indicating that the data is ready to be read or that an error occurred during the operation. An operation that does not return data need only send a tag to the requester to indicate an error has occurred. The requester should not wait for a response on such an operation, but preferably will be able to handle the error response being sent.  
         [0071]    Write Operation  
         [0072]    When a write command is received by the command processor, two conditions should be met for the command to be accepted. First, there is space available in the command queue. Second, there is a write buffer available to store the data and the byte enables. If a write buffer is not available, the command processor will receive “Buffer Full” from the write buffer. If a buffer is available, the index of the buffer is returned.  
         [0073]    Since a write buffer for receipt of the data is allocated upon acceptance of the command, the tag information may be stored in the corresponding entry in the write tag queue rather than the inbound tag queue. Rather than the tag, the index of the buffer is placed in the inbound tag queue so the index does not need to be looked up again when the arbiter selects the write command.  
         [0074]    When the arbiter selects the command, the arbiter accesses the address CAM and write buffer and passes the address, write data, and byte enables to the sequencer for the bank that is the target of the command. If the command is a full write, the operation is done and the buffer may be freed. If the command is a partial write, an ECC error may occur on the read portion of the access. If an error does occur, an error response should be sent which may include the command&#39;s tag from the write tag queue. Once the error response has been sent, the buffer may be freed.  
         [0075]    Read Operation  
         [0076]    When the command processor receives a read command, space need only be available in the command queue. The arbiter determines buffer availability for the read data before selecting a read command from the queue. Assuming a buffer is available, the tag for the read command is taken off the inbound tag queue and placed in the read tag queue and the address and buffer index are sent to the sequencer for the appropriate bank. Once the read is complete, a response with the read command&#39;s tag is sent indicating either the data is ready to use or that an error occurred during the operation.  
         [0077]    Data Coherency and the Address Cam  
         [0078]    As the command processor processes each command, the address is sent to the address CAM for comparison to the addresses of already pending operations. If there is an address match, the arbiter is sent a hit signal as well as the index of the matching address. This command is processed immediately to prevent data coherency problems.  
         [0079]    Data Interface  
         [0080]    The DDR data interface block in FIG. 7 may be expanded as shown in FIG. 8. Four 8-bit DDR hardmacs form the 32-bit data bus plus a fifth one for ECC. The write data holding latches capture an entire burst and partitions the burst into 32-bit transfers, and also generates ECC over each 32-bit transfer. Conversely, as each 32-bit transfer is completed on a read, the read data synchronization latches verify the ECC and stores the data until the burst is complete, and then transfers the data to a read buffer.  
         [0081]    The delay control logic contains a (for example LSI G12 technology HM20DYLDDR) master delay hardmac and monitor logic to adjust the DQS delay in each CW000701 Data path PHY Besides during initialization, it may be beneficial to adjust delays during refresh as well to account for voltage and temperature variations in the technology.  
       Command/Response  
       [0082]    Format  
         [0083]    The control interface between the system and the memory controllers is a series of commands and responses. In the present example, the commands are up to 128-bits wide and the responses are each 32-bits wide. The commands may take the general form below:  
         [0084]    Tag  
         [0085]    The tag is a 16-bit identifier that links the operation to its initiator and allows the response to be routed to the proper location.  
         [0086]    Opcode  
         [0087]    The opcode is an 8-bit value that identifies the type of operation that is being requested. Defined values may include the following:  
         [0088]    0x10: Read with Wrapping Address  
         [0089]    0x18: Read with Sequential Address  
         [0090]    0x20: Write with Wrapping Address  
         [0091]    0x28: Write with Sequential Address  
         [0092]    0x30: Partial Write with Wrapping Address  
         [0093]    0x38: Partial Write with Sequential Address  
         [0094]    0x40: Increment 32 bit vale with no data returned.  
         [0095]    0x48: Increment 32 bit value and return data.  
         [0096]    0x50: Increment both 16 bit halves of a 32 bit value with no data returned.  
         [0097]    0x58: Increment both  16  bit halves of a 32 bit value and return data.  
         [0098]    0x81: Fence operation to controller  1 .  
         [0099]    0x82: Fence operation to controller  2 .  
         [0100]    0x84: Fence operation to controller  3 .  
         [0101]    0x88: Fence operation to controller  4 .  
         [0102]    0x8F: Fence operation to all controllers.  
         [0103]    Byte Enables  
         [0104]    “Byte enables” indicate which bytes are valid on a write. When there are multiple controllers grouped together, gate array logic routes the appropriate byte enables to each controller.  
         [0105]    Address  
         [0106]    The 32-bit address represents the target location of the operation.  
         [0107]    Write Data  
         [0108]    The write data may include 8-bytes of data that (depending on the byte enables) will be written into memory. When there are multiple controllers grouped together, gate array logic routes the appropriate data to each controller.  
         [0109]    Return Code  
         [0110]    The return code indicates status of a completed operation. A return code of zero means no errors. Preferably, only reads and increments that return data will ever send a response with a zero return code. The other operations do not provide a response unless an error occurs.  
         [0111]    Buffer Index  
         [0112]    For reads and increments that return data, the buffer index indicates to a requester which of the read buffers from which to get the requested read data. For other commands, this value may be meaningless.  
         [0113]    Write Command  
         [0114]    When a write command is received by the command processor, the command processor verifies that the opcode queue and the write buffer are not full. Assuming the queue and buffer are not full, the command processor accepts the command and requests a buffer from the write buffer. The write buffer allocates a buffer for the command and returns the index of the buffer to the command processor. The command processor then writes the command&#39;s data and byte enables to the allocated write buffer, the address to the address CAM, the opcode to the opcode queue, and the index of the write buffer to the inbound tag queue.  
         [0115]    When the arbiter selects the operation, the arbiter passes the address, opcode and write buffer index to the appropriate bank sequencer. The sequencer schedules the commands to the DDR with appropriate timings and directs data from the write data buffer at the proper time. If performing a partial write, the sequencer first schedules a read command. Once the read data has been captured, the read command is merged with the write data, a new ECC is generated, and the new data and FCC are written out to memory.  
         [0116]    Read Command  
         [0117]    When a read command is received by the command processor, the command processor verifies that the opcode queue is not full. Assuming the queue is not full; the command processor accepts the read command and writes the command&#39;s address to the address CAM, the opcode to the opcode queue, and the tag to the inbound tag queue.  
         [0118]    When the arbiter attempts to select the operation, the arbiter first verifies that there is available space in the read buffer. Assuming there is space, the arbiter requests a buffer, and the read buffer returns the index of the read buffer allocated. Once the buffer is allocated, the arbiter passes the address, opcode, and buffer index to the appropriate bank sequencer and writes the tag into the tag queue at the same index as the buffer allocated. The sequencer schedules the commands to the DDR with appropriate timings and directs the data from the DDR to the read data buffer at the proper time.  
         [0119]    Fence Command  
         [0120]    When a fence command is received, the command processor stops accepting commands until the opcode queue has been completely emptied. Once the queue is empty, command acceptance resumes.  
         [0121]    Increment Command  
         [0122]    An increment command that does not return data is very similar to a partial write. However, when the address is read, rather than merging in data from the write queue, the read data is fed through an incrementer and written back out. Preferably, each sequencer will have the incrementers necessary to implement the function and will not require the allocation of a write buffer.  
         [0123]    If the increment command does return data, performance of the increment command is still very similar to a partial write, but with three exceptions. First, a read buffer is allocated for the return data before the operation is sent to the appropriate bank sequencer. Second, the data read is routed to both the incrementer and the allocated read buffer. Finally, a response is sent to the requester to indicate availability of the data in the read buffer.  
       Register  
       [0124]    Each controller may include a copy of the registers as described in the following sections.  
       Register Type Conventions  
       [0125]    Clear/Set (C/S) Register  
         [0126]    Writing to the Clear address causes all bits written to a b‘ 1 ’ to be cleared. Writing to the Set address causes all bits written to a b‘ 1 ’ to be set. The register may be read from either address. The value of this Clear/Set capability is that code written for this controller does not have to perform read/modify/write operations to change register bits.  
         [0127]    Read/Write (R/W) Register  
         [0128]    These registers have a single address that may be read or written.  
         [0129]    Read Only (R) Register  
         [0130]    These registers may only be read.  
         [0131]    Control Register  
         [0132]    This register controls how the memory controller operates.  
                                                                     Address Offset (Clear):   0x 0000           Address Offset (Set):   0x 0004           Reset Value:   0x 0000 0000           Register Type:   Clear/Set                        Bit(s)   Type   Description               31:16   R   Reserved.       15   C/S   ECC Enable. When set to a b’1’, ECC will be generated               on writes and checked on reads. When set to a b’0’,               generation or checking will not be done.       14   C/S   Vertical ECC. When set to a b’1’, the ECC will be               vertical, i.e. regions of the DRAM address space will               be dedicated to ECC storage. When set to a b’0’,               ECC will be horizontal, i.e. ECC is stored in a               separate DRAM module from the data.       13   C/S   Capture ECC SBE Address. When set to a b’1’, the               address of any ECC single bit error (SBE) will be               captured in the Memory Error Address Register. When               set to a b’0’, only the address of multi-bit errors               will be captured. See “Memory Error Address Register”               on page 22 for more information.       12   C/S   Capture First Error Address Only: When set to a b’1’,               the Memory Error Address Register will capture the               address of the first memory error. When set to a b’0’,               the Memory Error Address Register will continuously               update with the most current error address.       11   C/S   Ink Mode. When set to a b’1’, this bit allows the               address and control pins of the external memory bus to               be driven by the bits of the Init Sequence Register.               When this bit is b’0’, internal state machines               control the pin.       10   C/S   CKE Control. This bit directly drives the CKE(PD for               FCRAM) pin on the DDRs.       9   C/S   Serialize Operations: When set to a b’1’, the arbiter               will remove operations from the opcode queue in the               order received and will wait for each to finish before               starting another. When set to a b’0’, the arbiter will               attempt to optimize accesses and overlap them as much               as possible.       8   C/S   FCRAM. When set to a b’1’, DDR fast cycle RAM is               connected to the controller. When set to a b’0’,               standard DDR SDRAM is attached.       7   C/S   Auto Precharge Address Bit. When set to a b’1’, dram               address bit 8 will be used for auto precharge as used               by graphics DDRs. When set to a b’0’, address bit 10               is used. This bit has no effect if using FCRAM.       6:4   C/S   Column Address Bits. Determines how many address bits               are used for the column address on a DDR SDRAM or for               the lower address of a DDR FCRAM. These bits decode to:               b’000” - 7               b”001” - 8               b”010” - 9               b”011” - 10       1:0   C/S   Memory Size. These bits indicate how much memory is               connected to the controller. These bits decode to:               b”00” - 32 MBytes               b”01” - 64 MBytes               b”10” - 128 MBytes               b”11” - 256 MBytes                  
 
         [0133]    Status Register  
         [0134]    This register captures significant error events that occur in the controller. When the corresponding bit in the Interrupt Enable Register is a b‘ 1 ’, an interrupt is generated.  
                                                                     Address Offset (Clear):   0x 0008           Address Offset (Set):   0x 000C           Reset Value:   0x 0000 0000           Register Type:   Clear/Set                        Bit(s)   Type   Description               1   C/S   Correctable ECC Error. A single bit ECC error has               occurred.       0   C/S   Uncorrectable ECC Error. A multi-bit ECC error has               occurred.                  
 
         [0135]    Interrupt Enable Register  
         [0136]    The bits of this register are identical to the bits in the Status Register. When a bit in this register is a b‘ 1 ’ and the corresponding bit in the Status Register is also a b‘ 1 ’, an interrupt is generated.  
                                                       Address Offset (Clear):   0x 0010           Address Offset (Set):   0x 0014           Reset Value:   0x 0000 0000           Register Type:   Clear/Set                      
 
         [0137]    Control Register Write Enable Register  
         [0138]    This register is designed to prevent accidental alteration of the Control Register.  
                                                                     Address Offset:   0x 0018           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31:8   R   Reserved.        7:0   R/W   Control Register Write Enable. These bits are written               to x”B4” before the Control Register may be written.                  
 
         [0139]    Ecc Syndrome Register  
         [0140]    This register logs the syndrome (error pattern) of the last ECC error.  
                                                                     Address Offset:   0x 001C           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31:7   R   Reserved.       6-0   R/W   Syndrome Bits. These bits indicate which bit was in               error on a single bit ECC error and/or indicate the               pattern that triggered an uncorrectable error. If the               error was a correctable, single bit error, the “ECC               Syndrome Table” may be used to determine which bit               was in error.                  
 
         [0141]    [0141]                                                                                                                                                                                               ECC ALGORITHM TABLE                                    Data Bit            ECC Bit   31   30   29   28   27   26   25   24   23   22   21   20   19   18   17   16               6   0   0   0   0   0   0   0   0   1   1   1   1   1   1   1   1       5   1   0   0   0   0   1   0   0   0   0   0   0   0   0   0   0       4   0   1   0   0   1   0   1   0   1   0   0   0   0   1   1   1       3   0   0   1   0   1   0   0   1   0   1   1   0   0   1   0   0       2   0   0   0   1   0   1   1   1   0   1   0   1   0   0   1   0       1   1   1   1   1   1   1   1   1   0   0   1   1   1   0   0   1       0   1   1   1   1   0   0   0   0   1   0   0   0   1   0   0   0                        Data Bit            ECC Bit   15   14   13   12   11   10   9   8   7   6   5   4   3   2   1   0               6   0   0   0   1   0   0   0   1   0   0   0   0   1   1   1   1       5   1   0   0   1   1   1   0   0   1   1   1   1   1   1   1   1       4   0   1   0   0   1   0   1   0   1   1   1   0   1   0   0   0       3   0   0   1   0   0   1   1   0   1   0   0   1   0   1   0   0       2   1   1   1   0   0   0   0   1   0   1   0   1   0   0   1   0       1   0   0   0   0   0   0   0   0   0   0   1   0   0   0   0   1       0   1   1   1   1   1   1   1   1   0   0   0   0   0   0   0   0                    
         [0142]    [0142]                                                                                             Bit   Syndrome   Bit   Syndrome   Bit   Syndrome   Bit   Syndrome                                31   0100011   23   1010001   15   0100101   7   0111000       30   0010011   22   1001100   14   0010101   6   0110100       29   0001011   21   1001010   13   0001101   5   0110010       28   0000111   20   1000110   12   1100001   4   0101100       27   0011010   19   1000011   11   0110001   3   1110000       26   0100110   18   1011000   10   0101001   2   1101000       25   0010110   17   1010100   9   0011001   1   1100100       24   0001110   16   1010010   8   1000101   0   1100010       ECC(6)   1000000   ECC(4)   0010000   ECC(2)   0000100   ECC(0)   0000001       ECC(5)   0100000   ECC(3)   0001000   ECC(1)   00000010                    
         [0143]    Ecc Inversion Register  
         [0144]    The ECC inversion register allows the selective inversion of ECC bits for testing purposes. An example use of this register would be to set this register to:  
         [0145]    1. Write a particular syndrome value to this register.  
         [0146]    2. Write zero to a location in memory.  
         [0147]    3. Read the memory back.  
         [0148]    4. The data read should have the bit corresponding to the syndrome flipped to a b‘ 1 ’.  
         [0149]    Address Offset: 0x0020  
         [0150]    Reset Value: 0x0000 0000  
         [0151]    Register Type: Read/Write  
                                       Bit(s)   Type   Description                   31:7   R   Reserved.       6-0   R/W   ECC Inversion Bits. When a bit in this register is set               to a b’1’, the corresponding outgoing ECC bit is               inverted. Bit 6 corresponds to ECC bit 6, etc.                  
 
         [0152]    ECC SBE Count Register  
         [0153]    The ECC SBE count register counts the number of single bit errors that have occurred.  
                                                                     Address Offset:   0x 0024           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31:16   R   Reserved.       15-0   R/W   ECC Single Bit Error Count. Tally of single bit errors               that have occurred in this controller since this               register was last cleared.                  
 
         [0154]    Memory Error Address Register  
         [0155]    This register contains the address of the last captured memory error. Which error is the last captured memory error is based on the setting of bits  13 : 12  of the Control Register. If bit  13  is a b‘ 1 ’, the address of any ECC error is captured; if bit  13  is a b‘ 0 ’, then only multibit ECC errors will be captured. If bit  12  is a b‘ 1 ’, the address captured is from the first memory error that occurred based on the value of bit  13 ; if bit  12  is a b‘ 0 ’, the address captured is from the latest error.  
                                       Bit(s)   Type   Description                   31-0   R   Error Address. The address of the last captured memory               error.                  
 
         [0156]    Init Sequence Register  
         [0157]    This register is used to drive the address and control signals of the DDR so that software may perform the required initialization sequence for the DDR. When this register is written, the value written is placed on the DDR bus for 1 cycle.  
                                                                     Address Offset:   0x 002C           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31:24   R   Reserved.       23   R/W   CS. This bit is driven on the DDR chip select pin.       22   R/W   RAS. This bit is driven on the DDR row address strobe.       21   R/W   CAS. This bit is driven on the DDR column address               strobe.       20   R/W   WE. This bit is driven on the DDR write enable (FN for               FCRAM) pin.       19:18   R   Reserved.       17-16   R/W   Bank Address. These bits are driven on the DDR bank               address lines.       15   R   Reserved.       14-0   R/W   Address. These bits are driven on the DDR address bus.                  
 
         [0158]    Timing Parameter Register  
         [0159]    This register defines the timings to use for the controller. The default value of this register is for PC333 and a CAS latency of 2.5. The timing parameter register may be used ot implement an adjustable DRAM timing method, a further discussion of which may be found in U.S. Pat. No. 6,43 8,670, which is herein incorporated by reference in its entirety.  
                                                                     Address Offset:   0x 0030           Reset Value:   0x 0001 45BA           Register Type:   Read/Write                        Bit(s)   Type   Description               31:20   R   Reserved.       19:16   R/W   CAS Latency. These bits define the number of               cycles between a read command and read data               being valid. A value of x’0’ yields a               CAS latency of 2 cycles and each increment of               these bits adds a half cycle.       15-12   R/W   Write to Read Time. The number of cycles               between a read and write to 2 different banks.       11-8    R/W   Read to Write Time. The number of cycles               between a read and write to 2 different banks.       7-4   R/W   Refresh Random Cycle Time (t REFC  or I REFC ).               The number of cycles between a DDR SDRAM               refresh command and a bank activate, or the               number of cycles between a FCRAM refresh               command and a WRA or RDA command.       3-0   R/W   Random Cycle Time (t RC  or I RC ). The number               of cycles between DDR SDRAM bank activate               commands to the same bank, or the number of               cycles between FCRAM WRA or RDA commands to               the same bank.                  
 
         [0160]    Debug Registers  
         [0161]    The following registers allow an AHB slave interface to inject commands into the command processor. Injected commands have a predefined tag of 0xTBD as identification so that the response is sent to proper location.  
         [0162]    Injection Control Register  
         [0163]    This register contains the tag, opcode, and byte enables (if needed) of a command being injected into the controller.  
                                                                     Address Offset:   0x 0040           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31:2   R   Reserved.       1   R/W   Read Returned Read Buffer. Setting this bit               causes the buffer indicated by bits 15:8 of               the Injection Response Register to be read and               stored in the data injection registers. This               bit will be automatically cleared when the               read completes.       0   R/W   Inject Command. Inject into the command               processor the command indicated by the               injection register. This bit will be automa-               tically cleared once the operation is accepted.                  
 
         [0164]    Injection Response Register  
         [0165]    This register captures any response sent back for an injected command.  
                                                                     Address Offset:   0x 0044           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description                31:16   R/W   Return TAG. The identifying tag for the               completed operation.       15:8   R/W   Return Code. The return code of the               completed operation.        7:0   R/W   Return Buffer Index. Buffer index at which               to find data returned by the operation.                  
 
         [0166]    Tag/Opcode/Byte Enable Injection Register  
         [0167]    This register contains the tag, opcode, and byte enables (if needed) of a command being injected into the controller.  
                                                                         Address Offset:   0x 0048           Reset Value:   0x 0000 0000           Register Type:   Read/Write                            Bit(s)   Type   Description                       31:16   R/W   Injected TAG. The identifying tag for this                   operation.           15-8   R/W   Injected Opcode. The opcode for this                   operation.            7-0   R/W   Injected Byte Enables. If doing an operation                   that requires byte enables, these bits define                   what they are.                      
 
         [0168]    Address Injection Register  
         [0169]    This register sets the address of an operation injected into the controller by software.  
                                                                         Address Offset:   0x 004C           Reset Value:   0x 0000 0000           Register Type:   Read/Write                            Bit(s)   Type   Description                       31-0   R/W   Injected Address. Address of operation                   injected into the controller.                      
 
         [0170]    Upper Data Injection Register  
         [0171]    This register contains bits  128 - 96  of any data written/read by an injected command.  
                                                                         Address Offset:   0x 0050           Reset Value:   0x 0000 0000           Register Type:   Read/Write                            Bit(s)   Type   Description                       31-0   R/W   Upper Data. Bytes 0-3 of a 16 byte burst.                      
 
         [0172]    Upper Middle Data Injection Register  
         [0173]    This register contains bits  95 - 72  of any data written/read by an injected command.  
                                                                     Address Offset:   0x 0054           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31-0   R/W   Upper Middle Data. Bytes 4-7 of a 16 byte burst.                  
 
         [0174]    Lower Middle Data Injection Register This register contains bits  63 - 32  of any data written/read by an injected command.  
                                                                     Address Offset:   0x 0058           Reset Value:   0x 0000 0000           Register Type:   Read/Write                        Bit(s)   Type   Description               31-0   R/W   Lower Middle Data. Bytes 8-11 of a 16 byte burst.                  
 
         [0175]    Lower Data Injection Register  
         [0176]    This register contains bits  31 - 0  of any data written/read by an injected command.  
                                                                         Address Offset:   0x 005C           Reset Value:   0x 0000 0000           Register Type:   Read/Write                            Bit(s)   Type   Description                       31-0   R/W   Lower Data. Bytes 12-15 of a 16 byte burst.                      
 
       Module I/O  
       [0177]    The I/O of an exemplary controller is listed in the table below.  
                                                                                                                                               Direc-           Name   tion   Description                                General I/O            clk1x   IN   System clock running at DDR clock               speed.       clk2x   IN   System clock running at twice DDR               clock speed.       Reset   IN   System reset.       test_io -   EITHER   TBD.       number       unknown            AMBA Bus I/O            hsel   IN   Controller select.       haddr(31:0)   IN   Register address.       hwrite   IN   Write data.       htrans(1:0)   IN   Transaction type.       hsize(1:0)   IN   Transaction size.       hburst(2:0)   IN   Burst.       hwdata(31:0)   IN   Write data.       hready   OUT   Indicates transaction ready or is               used to insert wait states.       hresp(1:0)   OUT   Slave response to transaction.       hrdata(31:0)   OUT   Read data.            Command I/O            mem_req   IN   Memory operation request. Should               remain on until mem_ack indicates               the operation is acknowledged.       mem_address   IN   Address of memory operation.       (31:0)       mem_tag   IN   Unique tag to identify memory       (15:0)       operation.       mem_byte —     IN   Byte enables for memory operation       enab(7:0)       (if necessary).       mem_opcode   IN   Encoded description of memory       (7:0)       operation.       mem_write —     IN   Write data for memory operation       data(63:0)       (if necessary).       mem_accept   OUT   Indication to requester of the types       (1:0)       of operations that the controller may               currently accept. Preferably, fence               commands may always be accepted.               b”00” - Any operation               b”01” - Read/Increment               operations only               b”10” - Write operations only               b”11” - No operations       mem_ack   OUT   The currently requested operation               was accepted.            Response I/O            response —     OUT   Signal indicating that response_tag,       valid       response_rc, and response_index are               valid.       response —     OUT   Unique tag to identify completed       tag(15:0)       memory operation.       response_rc   OUT   Return code for the response.       (7:0)       response —     OUT   Buffer index related to the response       index(7:0)       (if necessary).       response —     IN   Indication that the response infor-       ack       mation has been captured by the               requester logic.       read_req   IN   Request to extract read data from               read buffers.       read_index   IN   Index of buffer that is to be read.       (7:0)       read_data   OUT   Read data. 128 bits of data may be       (63:0)       presented on 2 consecutive cycles.       read_data —     OUT   Returned with read data to indicate       ack       it is valid. Valid for 2 consecutive               cycles.            External Memory I/O            ddr_address   OUT   Address to the external memory.       (14:0)       ddr_bank —     OUT   Bank address to the external memory.       address(1:0)       ddr_cs_n   OUT   Low active chip select to the               external memory.       ddr_ras_n   OUT   Low active row address strobe to               the external memory.       ddr_cas_n   OUT   Low active column address strobe               to the external memory.       ddr_we_n   OUT   Low active write enable to the               external memory. In the case of               FCRAM, this is the FN pin.       ddr_dm   OUT   Data mask to external memory. When       (3:0)       driven high on writes, data is               masked (not written) to external               memory.       ddr_data —     OUT   Data to be sent to the external       out(38:0)       memory.       ddr_data —     IN   Data coming from the external       in(38:0)       memory.       ddr_data —     OUT   Driver enable for data.       drv_enab       ddr_dqs —     OUT   Data qualification strobe to the       out(3:0)       external memory.       ddr_dqs —     IN   Data qualification strobe from the       in(3:0)       external memory.       ddr_dqs —     OUT   Driver enable for DQS.       drv_enab       ddr_cke   OUT   Clock enable for external memory.               In the case of FCRAM, this is the               PD pin.       ddr_clk?   OUT   Positive differential clock to               external memory.       ddr_clk_n   OUT   Negative differential clock to               external memory.                  
 
         [0178]    In exemplary embodiments, the methods disclosed may be implemented as sets of instructions or software readable by a device. Further, it is understood that the specific order or hierarchy of steps in the methods disclosed are examples of exemplary approaches. Based upon design preferences, it is understood that the specific order or hierarchy of steps in the method can be rearranged while remaining within the scope of the present invention. The accompanying method claims present elements of the various step in a sample order, and are not meant to be limited to the specific order or hierarchy presented.  
         [0179]    It is believed that the system and method of the present invention and many of its attendent advantages will be understood by the forgoing description. It is also believed that it will be apparent that various changes may be made in the form, construction and arrangement of the components thereof without departing from the scope and spirit of the invention or without sacrificing all of its material advantages. The form herein before described being merely an explanatory embodiment thereof. It is the intention of the following claims to encompass and include such changes.