Return to AppleATAPIIXTiming.h CVS log

Up to [Apple XNU] / XNU / iokit / Drivers / ata / drvAppleATA

Annotation of XNU/iokit/Drivers/ata/drvAppleATA/AppleATAPIIXTiming.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 2000 Apple Computer, Inc.  All rights reserved. 
                      3:  *
                      4:  * AppleATAPIIXTiming.h - Timing tables.
                      5:  *
                      6:  * HISTORY
                      7:  *
                      8:  */
                      9: 
                     10: #ifndef _APPLEATAPIIXTIMING_H
                     11: #define _APPLEATAPIIXTIMING_H
                     12: 
                     13: /*
                     14:  * Supported transfer protocols. Entries in this table must map to the
                     15:  * entries in ATATimingProtocol table.
                     16:  */
                     17: typedef enum {
                     18:     kPIIXProtocolPIO  = 0,
                     19:     kPIIXProtocolDMA,
                     20:     kPIIXProtocolUDMA33,
                     21:     kPIIXProtocolUDMA66,
                     22:     kPIIXProtocolLast
                     23: } PIIXProtocol;
                     24: 
                     25: /*
                     26:  * PIIX PIO/DMA timing table.
                     27:  */
                     28: typedef struct {
                     29:     UInt8    pioMode;        // PIO mode
                     30:     UInt8    swDMAMode;      // single-word DMA mode (obsolete)
                     31:     UInt8    mwDMAMode;      // multiword DMA mode
                     32:     UInt8    isp;            // IORDY sample point in PCI clocks
                     33:     UInt8    rtc;            // Recovery time in PCI clocks
                     34:     UInt16   cycle;          // cycle time in ns
                     35: } PIIXTiming;
                     36: 
                     37: #define _NVM_    0xff        // not a valid mode
                     38: 
                     39: static const
                     40: PIIXTiming PIIXPIOTimingTable[] = {
                     41: /*  PIO     SW     MW     ISP   RTC   CYCLE (ns)   */
                     42:     {0,     0,     0,     5,    4,    600},
                     43:     {1,     1,     _NVM_, 5,    4,    600},
                     44:     {2,     2,     _NVM_, 4,    4,    240},
                     45:     {3,     _NVM_, 1,     3,    3,    180},
                     46:     {4,     _NVM_, 2,     3,    1,    120},
                     47:     {5,     _NVM_, 2,     3,    1,    120},
                     48: };
                     49: 
                     50: static const UInt8 PIIXPIOTimingTableSize = sizeof(PIIXPIOTimingTable) / 
                     51:                                             sizeof(PIIXPIOTimingTable[0]);
                     52: 
                     53: /*
                     54:  * PIIX Ultra-DMA/33 timing table.
                     55:  */
                     56: typedef struct {
                     57:     UInt8    mode;           // mode number
                     58:     UInt8    ct;             // cycle time in PCI clocks
                     59:     UInt8    rp;             // Ready to Pause time in PCI clocks
                     60:     UInt8    bits;           // register bit setting
                     61:     UInt16   strobe;         // strobe period (cycle) in ns
                     62: } PIIXUDMATiming;
                     63: 
                     64: static const
                     65: PIIXUDMATiming PIIXUDMATimingTable[] = {
                     66: /*  MODE    CT     RP     BITS   STROBE/CYCLE (ns)   */
                     67:     {0,     4,     6,     0,     120},
                     68:     {1,     3,     5,     1,     90},
                     69:     {2,     2,     4,     2,     60},
                     70: };
                     71: 
                     72: static const UInt8
                     73: PIIXUDMATimingTableSize = sizeof(PIIXUDMATimingTable) / 
                     74:                           sizeof(PIIXUDMATimingTable[0]);
                     75: 
                     76: /*
                     77:  * For each drive, the following table will store the chosen timings
                     78:  * for each supported protocol.
                     79:  */
                     80: typedef struct {
                     81:     UInt8   activeTimings[kPIIXProtocolLast];   // selected timings
                     82:     UInt8   validTimings[kPIIXProtocolLast];    // calculated timings
                     83:     UInt32  validFlag;
                     84:     UInt32  activeFlag;
                     85: } PIIXSelectedTimings;
                     86: 
                     87: /*
                     88:  * Convert from ATATimingProtocol to PIIXProtocol.
                     89:  */
                     90: inline PIIXProtocol ataToPIIXProtocol(ATATimingProtocol timingProtocol)
                     91: {
                     92:     int piixProtocol = kPIIXProtocolPIO;
                     93:     int ataProtocol  = timingProtocol;
                     94:     
                     95:     while (ataProtocol != 1) {
                     96:         ataProtocol >>= 1; piixProtocol++;
                     97:     }
                     98:     return ((PIIXProtocol) piixProtocol);
                     99: }
                    100: 
                    101: /*
                    102:  * Misc macros to get information from the PIIXSelectedTimings table.
                    103:  */
                    104: #define PIIX_ACTIVATE_PROTOCOL(p) {                                  \
                    105:     timings[unit].activeTimings[p] = timings[unit].validTimings[p];  \
                    106:     timings[unit].activeFlag |= (1 << (p));                          \
                    107: }
                    108: 
                    109: #define PIIX_DEACTIVATE_PROTOCOL(p) {                                \
                    110:     timings[unit].activeFlag &= ~(1 << (p));                         \
                    111: }
                    112: 
                    113: #define PIIX_GET_ACTIVE_TIMING(p)    (timings[unit].activeTimings[p])
                    114: 
                    115: #define PIIX_PROTOCOL_IS_ACTIVE(p)   ((bool) \
                    116:                                       (timings[unit].activeFlag & (1 << (p))))
                    117: 
                    118: #define PIIX_PROTOCOL_IS_VALID(p)    ((bool) \
                    119:                                       (timings[unit].validFlag & (1 << (p))))
                    120: 
                    121: #endif /* !_APPLEATAPIIXTIMING_H */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.