#!/usr/bin/python -u
#
# generate python wrappers from the XML API description
#

functions = {}
lxc_functions = {}
qemu_functions = {}
enums = {} # { enumType: { enumConstant: enumValue } }
lxc_enums = {} # { enumType: { enumConstant: enumValue } }
qemu_enums = {} # { enumType: { enumConstant: enumValue } }

import os
import sys
import string
import re

quiet=True

if __name__ == "__main__":
    # launched as a script
    srcPref = os.path.dirname(sys.argv[0])
    if len(sys.argv) > 1:
        python = sys.argv[1]
    else:
        print "Python binary not specified"
        sys.exit(1)
else:
    # imported
    srcPref = os.path.dirname(__file__)

#######################################################################
#
#  That part if purely the API acquisition phase from the
#  libvirt API description
#
#######################################################################
import os
import xml.sax

debug = 0

def getparser():
    # Attach parser to an unmarshalling object. return both objects.
    target = docParser()
    parser = xml.sax.make_parser()
    parser.setContentHandler(target)
    return parser, target

class docParser(xml.sax.handler.ContentHandler):
    def __init__(self):
        self._methodname = None
        self._data = []
        self.in_function = 0

        self.startElement = self.start
        self.endElement = self.end
        self.characters = self.data

    def close(self):
        if debug:
            print "close"

    def getmethodname(self):
        return self._methodname

    def data(self, text):
        if debug:
            print "data %s" % text
        self._data.append(text)

    def cdata(self, text):
        if debug:
            print "data %s" % text
        self._data.append(text)

    def start(self, tag, attrs):
        if debug:
            print "start %s, %s" % (tag, attrs)
        if tag == 'function':
            self._data = []
            self.in_function = 1
            self.function = None
            self.function_cond = None
            self.function_args = []
            self.function_descr = None
            self.function_return = None
            self.function_file = None
            self.function_module= None
            if attrs.has_key('name'):
                self.function = attrs['name']
            if attrs.has_key('file'):
                self.function_file = attrs['file']
            if attrs.has_key('module'):
                self.function_module= attrs['module']
        elif tag == 'cond':
            self._data = []
        elif tag == 'info':
            self._data = []
        elif tag == 'arg':
            if self.in_function == 1:
                self.function_arg_name = None
                self.function_arg_type = None
                self.function_arg_info = None
                if attrs.has_key('name'):
                    self.function_arg_name = attrs['name']
                    if self.function_arg_name == 'from':
                        self.function_arg_name = 'frm'
                if attrs.has_key('type'):
                    self.function_arg_type = attrs['type']
                if attrs.has_key('info'):
                    self.function_arg_info = attrs['info']
        elif tag == 'return':
            if self.in_function == 1:
                self.function_return_type = None
                self.function_return_info = None
                self.function_return_field = None
                if attrs.has_key('type'):
                    self.function_return_type = attrs['type']
                if attrs.has_key('info'):
                    self.function_return_info = attrs['info']
                if attrs.has_key('field'):
                    self.function_return_field = attrs['field']
        elif tag == 'enum':
            # enums come from header files, hence virterror.h
            if (attrs['file'] == "libvirt" or
                attrs['file'] == "virterror"):
                enum(attrs['type'],attrs['name'],attrs['value'])
            elif attrs['file'] == "libvirt-lxc":
                lxc_enum(attrs['type'],attrs['name'],attrs['value'])
            elif attrs['file'] == "libvirt-qemu":
                qemu_enum(attrs['type'],attrs['name'],attrs['value'])

    def end(self, tag):
        if debug:
            print "end %s" % tag
        if tag == 'function':
            # fuctions come from source files, hence 'virerror.c'
            if self.function != None:
                if (self.function_module == "libvirt" or
                    self.function_module == "virevent" or
                    self.function_module == "virerror"):
                    function(self.function, self.function_descr,
                             self.function_return, self.function_args,
                             self.function_file, self.function_module,
                             self.function_cond)
                elif self.function_module == "libvirt-lxc":
                    lxc_function(self.function, self.function_descr,
                             self.function_return, self.function_args,
                             self.function_file, self.function_module,
                             self.function_cond)
                elif self.function_module == "libvirt-qemu":
                    qemu_function(self.function, self.function_descr,
                             self.function_return, self.function_args,
                             self.function_file, self.function_module,
                             self.function_cond)
                elif self.function_file == "python":
                    function(self.function, self.function_descr,
                             self.function_return, self.function_args,
                             self.function_file, self.function_module,
                             self.function_cond)
                elif self.function_file == "python-lxc":
                    lxc_function(self.function, self.function_descr,
                                  self.function_return, self.function_args,
                                  self.function_file, self.function_module,
                                  self.function_cond)
                elif self.function_file == "python-qemu":
                    qemu_function(self.function, self.function_descr,
                                  self.function_return, self.function_args,
                                  self.function_file, self.function_module,
                                  self.function_cond)
                self.in_function = 0
        elif tag == 'arg':
            if self.in_function == 1:
                self.function_args.append([self.function_arg_name,
                                           self.function_arg_type,
                                           self.function_arg_info])
        elif tag == 'return':
            if self.in_function == 1:
                self.function_return = [self.function_return_type,
                                        self.function_return_info,
                                        self.function_return_field]
        elif tag == 'info':
            str = ''
            for c in self._data:
                str = str + c
            if self.in_function == 1:
                self.function_descr = str
        elif tag == 'cond':
            str = ''
            for c in self._data:
                str = str + c
            if self.in_function == 1:
                self.function_cond = str


def function(name, desc, ret, args, file, module, cond):
    functions[name] = (desc, ret, args, file, module, cond)

def qemu_function(name, desc, ret, args, file, module, cond):
    qemu_functions[name] = (desc, ret, args, file, module, cond)

def lxc_function(name, desc, ret, args, file, module, cond):
    lxc_functions[name] = (desc, ret, args, file, module, cond)

def enum(type, name, value):
    if not enums.has_key(type):
        enums[type] = {}
    if value == 'VIR_TYPED_PARAM_INT':
        value = 1
    elif value == 'VIR_TYPED_PARAM_UINT':
        value = 2
    elif value == 'VIR_TYPED_PARAM_LLONG':
        value = 3
    elif value == 'VIR_TYPED_PARAM_ULLONG':
        value = 4
    elif value == 'VIR_TYPED_PARAM_DOUBLE':
        value = 5
    elif value == 'VIR_TYPED_PARAM_BOOLEAN':
        value = 6
    elif value == 'VIR_DOMAIN_AFFECT_CURRENT':
        value = 0
    elif value == 'VIR_DOMAIN_AFFECT_LIVE':
        value = 1
    elif value == 'VIR_DOMAIN_AFFECT_CONFIG':
        value = 2
    if name[-5:] != '_LAST':
        enums[type][name] = value

def lxc_enum(type, name, value):
    if not lxc_enums.has_key(type):
        lxc_enums[type] = {}
    lxc_enums[type][name] = value

def qemu_enum(type, name, value):
    if not qemu_enums.has_key(type):
        qemu_enums[type] = {}
    qemu_enums[type][name] = value


#######################################################################
#
#  Some filtering rukes to drop functions/types which should not
#  be exposed as-is on the Python interface
#
#######################################################################

functions_failed = []
lxc_functions_failed = []
qemu_functions_failed = []
functions_skipped = [
    "virConnectListDomains",
]
lxc_functions_skipped = []
qemu_functions_skipped = []

skipped_modules = {
}

skipped_types = {
#    'int *': "usually a return type",
     'virConnectDomainEventCallback': "No function types in python",
     'virConnectDomainEventGenericCallback': "No function types in python",
     'virConnectDomainEventRTCChangeCallback': "No function types in python",
     'virConnectDomainEventWatchdogCallback': "No function types in python",
     'virConnectDomainEventIOErrorCallback': "No function types in python",
     'virConnectDomainEventGraphicsCallback': "No function types in python",
     'virStreamEventCallback': "No function types in python",
     'virEventHandleCallback': "No function types in python",
     'virEventTimeoutCallback': "No function types in python",
     'virDomainBlockJobInfoPtr': "Not implemented yet",
}

#######################################################################
#
#  Table of remapping to/from the python type or class to the C
#  counterpart.
#
#######################################################################

py_types = {
    'void': (None, None, None, None),
    'int':  ('i', None, "int", "int"),
    'long':  ('l', None, "long", "long"),
    'double':  ('d', None, "double", "double"),
    'unsigned int':  ('i', None, "int", "int"),
    'unsigned long':  ('l', None, "long", "long"),
    'long long':  ('L', None, "longlong", "long long"),
    'unsigned long long':  ('L', None, "longlong", "long long"),
    'unsigned char *':  ('z', None, "charPtr", "char *"),
    'char *':  ('z', None, "charPtr", "char *"),
    'const char *':  ('z', None, "constcharPtr", "const char *"),
    'size_t': ('n', None, "size_t", "size_t"),

    'virDomainPtr':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
    'const virDomainPtr':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
    'virDomain *':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),
    'const virDomain *':  ('O', "virDomain", "virDomainPtr", "virDomainPtr"),

    'virNetworkPtr':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
    'const virNetworkPtr':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
    'virNetwork *':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),
    'const virNetwork *':  ('O', "virNetwork", "virNetworkPtr", "virNetworkPtr"),

    'virInterfacePtr':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
    'const virInterfacePtr':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
    'virInterface *':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),
    'const virInterface *':  ('O', "virInterface", "virInterfacePtr", "virInterfacePtr"),

    'virStoragePoolPtr':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
    'const virStoragePoolPtr':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
    'virStoragePool *':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),
    'const virStoragePool *':  ('O', "virStoragePool", "virStoragePoolPtr", "virStoragePoolPtr"),

    'virStorageVolPtr':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
    'const virStorageVolPtr':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
    'virStorageVol *':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),
    'const virStorageVol *':  ('O', "virStorageVol", "virStorageVolPtr", "virStorageVolPtr"),

    'virConnectPtr':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
    'const virConnectPtr':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
    'virConnect *':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),
    'const virConnect *':  ('O', "virConnect", "virConnectPtr", "virConnectPtr"),

    'virNodeDevicePtr':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
    'const virNodeDevicePtr':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
    'virNodeDevice *':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),
    'const virNodeDevice *':  ('O', "virNodeDevice", "virNodeDevicePtr", "virNodeDevicePtr"),

    'virSecretPtr':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
    'const virSecretPtr':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
    'virSecret *':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),
    'const virSecret *':  ('O', "virSecret", "virSecretPtr", "virSecretPtr"),

    'virNWFilterPtr':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
    'const virNWFilterPtr':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
    'virNWFilter *':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),
    'const virNWFilter *':  ('O', "virNWFilter", "virNWFilterPtr", "virNWFilterPtr"),

    'virStreamPtr':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),
    'const virStreamPtr':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),
    'virStream *':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),
    'const virStream *':  ('O', "virStream", "virStreamPtr", "virStreamPtr"),

    'virDomainSnapshotPtr':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
    'const virDomainSnapshotPtr':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
    'virDomainSnapshot *':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
    'const virDomainSnapshot *':  ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
}

py_return_types = {
}

unknown_types = {}

foreign_encoding_args = (
)

#######################################################################
#
#  This part writes the C <-> Python stubs libvirt.[ch] and
#  the table libvirt-export.c to add when registrering the Python module
#
#######################################################################

# Class methods which are written by hand in libvirt.c but the Python-level
# code is still automatically generated (so they are not in skip_function()).
skip_impl = (
    'virConnectGetVersion',
    'virConnectGetLibVersion',
    'virConnectListDomainsID',
    'virConnectListDefinedDomains',
    'virConnectListNetworks',
    'virConnectListDefinedNetworks',
    'virConnectListSecrets',
    'virConnectListInterfaces',
    'virConnectListStoragePools',
    'virConnectListDefinedStoragePools',
    'virConnectListStorageVols',
    'virConnectListDefinedStorageVols',
    'virConnectListDefinedInterfaces',
    'virConnectListNWFilters',
    'virDomainSnapshotListNames',
    'virDomainSnapshotListChildrenNames',
    'virConnGetLastError',
    'virGetLastError',
    'virDomainGetInfo',
    'virDomainGetState',
    'virDomainGetControlInfo',
    'virDomainGetBlockInfo',
    'virDomainGetJobInfo',
    'virDomainGetJobStats',
    'virNodeGetInfo',
    'virDomainGetUUID',
    'virDomainGetUUIDString',
    'virDomainLookupByUUID',
    'virNetworkGetUUID',
    'virNetworkGetUUIDString',
    'virNetworkLookupByUUID',
    'virDomainGetAutostart',
    'virNetworkGetAutostart',
    'virDomainBlockStats',
    'virDomainInterfaceStats',
    'virDomainMemoryStats',
    'virNodeGetCellsFreeMemory',
    'virDomainGetSchedulerType',
    'virDomainGetSchedulerParameters',
    'virDomainGetSchedulerParametersFlags',
    'virDomainSetSchedulerParameters',
    'virDomainSetSchedulerParametersFlags',
    'virDomainSetBlkioParameters',
    'virDomainGetBlkioParameters',
    'virDomainSetMemoryParameters',
    'virDomainGetMemoryParameters',
    'virDomainSetNumaParameters',
    'virDomainGetNumaParameters',
    'virDomainGetVcpus',
    'virDomainPinVcpu',
    'virDomainPinVcpuFlags',
    'virDomainGetVcpuPinInfo',
    'virSecretGetValue',
    'virSecretSetValue',
    'virSecretGetUUID',
    'virSecretGetUUIDString',
    'virSecretLookupByUUID',
    'virNWFilterGetUUID',
    'virNWFilterGetUUIDString',
    'virNWFilterLookupByUUID',
    'virStoragePoolGetUUID',
    'virStoragePoolGetUUIDString',
    'virStoragePoolLookupByUUID',
    'virStoragePoolGetInfo',
    'virStorageVolGetInfo',
    'virStoragePoolGetAutostart',
    'virStoragePoolListVolumes',
    'virDomainBlockPeek',
    'virDomainMemoryPeek',
    'virEventRegisterImpl',
    'virNodeListDevices',
    'virNodeDeviceListCaps',
    'virConnectBaselineCPU',
    'virDomainRevertToSnapshot',
    'virDomainSendKey',
    'virNodeGetCPUStats',
    'virNodeGetMemoryStats',
    'virDomainGetBlockJobInfo',
    'virDomainMigrateGetMaxSpeed',
    'virDomainBlockStatsFlags',
    'virDomainSetBlockIoTune',
    'virDomainGetBlockIoTune',
    'virDomainSetInterfaceParameters',
    'virDomainGetInterfaceParameters',
    'virDomainGetCPUStats',
    'virDomainGetDiskErrors',
    'virNodeGetMemoryParameters',
    'virNodeSetMemoryParameters',
    'virNodeGetCPUMap',
)

lxc_skip_impl = (
    'virDomainLxcOpenNamespace',
)

qemu_skip_impl = (
    'virDomainQemuMonitorCommand',
    'virDomainQemuAgentCommand',
)


# These are functions which the generator skips completly - no python
# or C code is generated. Generally should not be used for any more
# functions than those already listed
skip_function = (
    'virConnectListDomains', # Python API is called virConectListDomainsID for unknown reasons
    'virConnSetErrorFunc', # Not used in Python API  XXX is this a bug ?
    'virResetError', # Not used in Python API  XXX is this a bug ?
    'virGetVersion', # Python C code is manually written
    'virSetErrorFunc', # Python API is called virRegisterErrorHandler for unknown reasons
    'virConnCopyLastError', # Python API is called virConnGetLastError instead
    'virCopyLastError', # Python API is called virGetLastError instead
    'virConnectOpenAuth', # Python C code is manually written
    'virDefaultErrorFunc', # Python virErrorFuncHandler impl calls this from C
    'virDomainGetSecurityLabel', # Needs investigation...
    'virDomainGetSecurityLabelList', # Needs investigation...
    'virNodeGetSecurityModel', # Needs investigation...
    'virConnectDomainEventRegister',   # overridden in virConnect.py
    'virConnectDomainEventDeregister', # overridden in virConnect.py
    'virConnectDomainEventRegisterAny',   # overridden in virConnect.py
    'virConnectDomainEventDeregisterAny', # overridden in virConnect.py
    'virSaveLastError', # We have our own python error wrapper
    'virFreeError', # Only needed if we use virSaveLastError
    'virConnectListAllDomains', # overridden in virConnect.py
    'virDomainListAllSnapshots', # overridden in virDomain.py
    'virDomainSnapshotListAllChildren', # overridden in virDomainSnapshot.py
    'virConnectListAllStoragePools', # overridden in virConnect.py
    'virStoragePoolListAllVolumes', # overridden in virStoragePool.py
    'virConnectListAllNetworks', # overridden in virConnect.py
    'virConnectListAllInterfaces', # overridden in virConnect.py
    'virConnectListAllNodeDevices', # overridden in virConnect.py
    'virConnectListAllNWFilters', # overridden in virConnect.py
    'virConnectListAllSecrets', # overridden in virConnect.py

    'virStreamRecvAll', # Pure python libvirt-override-virStream.py
    'virStreamSendAll', # Pure python libvirt-override-virStream.py
    'virStreamRecv', # overridden in libvirt-override-virStream.py
    'virStreamSend', # overridden in libvirt-override-virStream.py

    'virConnectUnregisterCloseCallback', # overriden in virConnect.py
    'virConnectRegisterCloseCallback', # overriden in virConnect.py

    # 'Ref' functions have no use for bindings users.
    "virConnectRef",
    "virDomainRef",
    "virInterfaceRef",
    "virNetworkRef",
    "virNodeDeviceRef",
    "virSecretRef",
    "virNWFilterRef",
    "virStoragePoolRef",
    "virStorageVolRef",
    'virStreamRef',

    # This functions shouldn't be called via the bindings (and even the docs
    # contain an explicit warning to that effect). The equivalent should be
    # implemented in pure python for each class
    "virDomainGetConnect",
    "virInterfaceGetConnect",
    "virNetworkGetConnect",
    "virSecretGetConnect",
    "virNWFilterGetConnect",
    "virStoragePoolGetConnect",
    "virStorageVolGetConnect",
    "virDomainSnapshotGetConnect",
    "virDomainSnapshotGetDomain",

    # only useful in C code, python code uses dict for typed parameters
    "virTypedParamsAddBoolean",
    "virTypedParamsAddDouble",
    "virTypedParamsAddFromString",
    "virTypedParamsAddInt",
    "virTypedParamsAddLLong",
    "virTypedParamsAddString",
    "virTypedParamsAddUInt",
    "virTypedParamsAddULLong",
    "virTypedParamsClear",
    "virTypedParamsFree",
    "virTypedParamsGet",
    "virTypedParamsGetBoolean",
    "virTypedParamsGetDouble",
    "virTypedParamsGetInt",
    "virTypedParamsGetLLong",
    "virTypedParamsGetString",
    "virTypedParamsGetUInt",
    "virTypedParamsGetULLong",
)

lxc_skip_function = (
  "virDomainLxcEnterNamespace",
)
qemu_skip_function = (
    #"virDomainQemuAttach",
)

# Generate C code, but skip python impl
function_skip_python_impl = (
    "virStreamFree", # Needed in custom virStream __del__, but free shouldn't
                     # be exposed in bindings
)

lxc_function_skip_python_impl = ()
qemu_function_skip_python_impl = ()

function_skip_index_one = (
    "virDomainRevertToSnapshot",
)

def print_function_wrapper(module, name, output, export, include):
    global py_types
    global unknown_types
    global functions
    global lxc_functions
    global qemu_functions
    global skipped_modules
    global function_skip_python_impl

    try:
        if module == "libvirt":
            (desc, ret, args, file, mod, cond) = functions[name]
        if module == "libvirt-lxc":
            (desc, ret, args, file, mod, cond) = lxc_functions[name]
        if module == "libvirt-qemu":
            (desc, ret, args, file, mod, cond) = qemu_functions[name]
    except:
        print "failed to get function %s infos" % name
        return

    if skipped_modules.has_key(module):
        return 0

    if module == "libvirt":
        if name in skip_function:
            return 0
        if name in skip_impl:
            # Don't delete the function entry in the caller.
            return 1
    elif module == "libvirt-lxc":
        if name in lxc_skip_function:
            return 0
        if name in lxc_skip_impl:
            # Don't delete the function entry in the caller.
            return 1
    elif module == "libvirt-qemu":
        if name in qemu_skip_function:
            return 0
        if name in qemu_skip_impl:
            # Don't delete the function entry in the caller.
            return 1

    c_call = ""
    format=""
    format_args=""
    c_args=""
    c_return=""
    c_convert=""
    num_bufs=0
    for arg in args:
        # This should be correct
        if arg[1][0:6] == "const ":
            arg[1] = arg[1][6:]
        c_args = c_args + "    %s %s;\n" % (arg[1], arg[0])
        if py_types.has_key(arg[1]):
            (f, t, n, c) = py_types[arg[1]]
            if (f == 'z') and (name in foreign_encoding_args) and (num_bufs == 0):
                f = 't#'
            if f != None:
                format = format + f
            if t != None:
                format_args = format_args + ", &pyobj_%s" % (arg[0])
                c_args = c_args + "    PyObject *pyobj_%s;\n" % (arg[0])
                c_convert = c_convert + \
                   "    %s = (%s) Py%s_Get(pyobj_%s);\n" % (arg[0],
                   arg[1], t, arg[0])
            else:
                format_args = format_args + ", &%s" % (arg[0])
            if f == 't#':
                format_args = format_args + ", &py_buffsize%d" % num_bufs
                c_args = c_args + "    int py_buffsize%d;\n" % num_bufs
                num_bufs = num_bufs + 1
            if c_call != "":
                c_call = c_call + ", "
            c_call = c_call + "%s" % (arg[0])
        else:
            if skipped_types.has_key(arg[1]):
                return 0
            if unknown_types.has_key(arg[1]):
                lst = unknown_types[arg[1]]
                lst.append(name)
            else:
                unknown_types[arg[1]] = [name]
            return -1
    if format != "":
        format = format + ":%s" % (name)

    if ret[0] == 'void':
        if file == "python_accessor":
            if args[1][1] == "char *":
                c_call = "\n    VIR_FREE(%s->%s);\n" % (
                                 args[0][0], args[1][0], args[0][0], args[1][0])
                c_call = c_call + "    %s->%s = (%s)strdup((const xmlChar *)%s);\n" % (args[0][0],
                                 args[1][0], args[1][1], args[1][0])
            else:
                c_call = "\n    %s->%s = %s;\n" % (args[0][0], args[1][0],
                                                   args[1][0])
        else:
            c_call = "\n    %s(%s);\n" % (name, c_call)
        ret_convert = "    Py_INCREF(Py_None);\n    return Py_None;\n"
    elif py_types.has_key(ret[0]):
        (f, t, n, c) = py_types[ret[0]]
        c_return = "    %s c_retval;\n" % (ret[0])
        if file == "python_accessor" and ret[2] != None:
            c_call = "\n    c_retval = %s->%s;\n" % (args[0][0], ret[2])
        else:
            c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)
        ret_convert = "    py_retval = libvirt_%sWrap((%s) c_retval);\n" % (n,c)
        ret_convert = ret_convert + "    return py_retval;\n"
    elif py_return_types.has_key(ret[0]):
        (f, t, n, c) = py_return_types[ret[0]]
        c_return = "    %s c_retval;\n" % (ret[0])
        c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)
        ret_convert = "    py_retval = libvirt_%sWrap((%s) c_retval);\n" % (n,c)
        ret_convert = ret_convert + "    return py_retval;\n"
    else:
        if skipped_types.has_key(ret[0]):
            return 0
        if unknown_types.has_key(ret[0]):
            lst = unknown_types[ret[0]]
            lst.append(name)
        else:
            unknown_types[ret[0]] = [name]
        return -1

    if cond != None and cond != "":
        include.write("#if %s\n" % cond)
        export.write("#if %s\n" % cond)
        output.write("#if %s\n" % cond)

    include.write("PyObject * ")
    if module == "libvirt":
        include.write("libvirt_%s(PyObject *self, PyObject *args);\n" % (name))
        export.write("    { (char *)\"%s\", libvirt_%s, METH_VARARGS, NULL },\n" %
                     (name, name))
    elif module == "libvirt-lxc":
        include.write("libvirt_lxc_%s(PyObject *self, PyObject *args);\n" % (name))
        export.write("    { (char *)\"%s\", libvirt_lxc_%s, METH_VARARGS, NULL },\n" %
                     (name, name))
    elif module == "libvirt-qemu":
        include.write("libvirt_qemu_%s(PyObject *self, PyObject *args);\n" % (name))
        export.write("    { (char *)\"%s\", libvirt_qemu_%s, METH_VARARGS, NULL },\n" %
                     (name, name))

    if file == "python":
        # Those have been manually generated
        if cond != None and cond != "":
            include.write("#endif\n")
            export.write("#endif\n")
            output.write("#endif\n")
        return 1
    if file == "python_accessor" and ret[0] != "void" and ret[2] is None:
        # Those have been manually generated
        if cond != None and cond != "":
            include.write("#endif\n")
            export.write("#endif\n")
            output.write("#endif\n")
        return 1

    output.write("PyObject *\n")
    if module == "libvirt":
        output.write("libvirt_%s(PyObject *self ATTRIBUTE_UNUSED," % (name))
    elif module == "libvirt-lxc":
        output.write("libvirt_lxc_%s(PyObject *self ATTRIBUTE_UNUSED," % (name))
    elif module == "libvirt-qemu":
        output.write("libvirt_qemu_%s(PyObject *self ATTRIBUTE_UNUSED," % (name))
    output.write(" PyObject *args")
    if format == "":
        output.write(" ATTRIBUTE_UNUSED")
    output.write(") {\n")
    if ret[0] != 'void':
        output.write("    PyObject *py_retval;\n")
    if c_return != "":
        output.write(c_return)
    if c_args != "":
        output.write(c_args)
    if format != "":
        output.write("\n    if (!PyArg_ParseTuple(args, (char *)\"%s\"%s))\n" %
                     (format, format_args))
        output.write("        return NULL;\n")
    if c_convert != "":
        output.write(c_convert + "\n")

    output.write("    LIBVIRT_BEGIN_ALLOW_THREADS;")
    output.write(c_call)
    output.write("    LIBVIRT_END_ALLOW_THREADS;\n")
    output.write(ret_convert)
    output.write("}\n\n")
    if cond != None and cond != "":
        include.write("#endif /* %s */\n" % cond)
        export.write("#endif /* %s */\n" % cond)
        output.write("#endif /* %s */\n" % cond)

    if module == "libvirt":
        if name in function_skip_python_impl:
            return 0
    elif module == "libvirt-lxc":
        if name in lxc_function_skip_python_impl:
            return 0
    elif module == "libvirt-qemu":
        if name in qemu_function_skip_python_impl:
            return 0
    return 1

def buildStubs(module):
    global py_types
    global py_return_types
    global unknown_types

    if module not in ["libvirt", "libvirt-qemu", "libvirt-lxc"]:
        print "ERROR: Unknown module type: %s" % module
        return None

    if module == "libvirt":
        funcs = functions
        funcs_failed = functions_failed
        funcs_skipped = functions_skipped
    elif module == "libvirt-lxc":
        funcs = lxc_functions
        funcs_failed = lxc_functions_failed
        funcs_skipped = functions_skipped
    elif module == "libvirt-qemu":
        funcs = qemu_functions
        funcs_failed = qemu_functions_failed
        funcs_skipped = functions_skipped

    api_xml = "%s-api.xml" % module

    try:
        f = open(os.path.join(srcPref,api_xml))
        data = f.read()
        (parser, target)  = getparser()
        parser.feed(data)
        parser.close()
    except IOError, msg:
        try:
            f = open(os.path.join(srcPref,"..","docs",api_xml))
            data = f.read()
            (parser, target)  = getparser()
            parser.feed(data)
            parser.close()
        except IOError, msg:
            print file, ":", msg
            sys.exit(1)

    n = len(funcs.keys())
    if not quiet:
        print "Found %d functions in %s" % ((n), api_xml)

    override_api_xml = "%s-override-api.xml" % module
    py_types['pythonObject'] = ('O', "pythonObject", "pythonObject", "pythonObject")

    try:
        f = open(os.path.join(srcPref, override_api_xml))
        data = f.read()
        (parser, target)  = getparser()
        parser.feed(data)
        parser.close()
    except IOError, msg:
        print file, ":", msg

    if not quiet:
        # XXX: This is not right, same function already in @functions
        # will be overwritten.
        print "Found %d functions in %s" % ((len(funcs.keys()) - n), override_api_xml)
    nb_wrap = 0
    failed = 0
    skipped = 0

    header_file = "%s.h" % module
    export_file = "%s-export.c" % module
    wrapper_file = "%s.c" % module

    include = open(header_file, "w")
    include.write("/* Generated */\n\n")

    export = open(export_file, "w")
    export.write("/* Generated */\n\n")

    wrapper = open(wrapper_file, "w")
    wrapper.write("/* Generated by generator.py */\n\n")
    wrapper.write("#include <config.h>\n")
    wrapper.write("#include <Python.h>\n")
    wrapper.write("#include <libvirt/" + module + ".h>\n")
    wrapper.write("#include \"typewrappers.h\"\n")
    wrapper.write("#include \"" + module + ".h\"\n\n")

    for function in funcs.keys():
        # Skip the functions which are not for the module
        ret = print_function_wrapper(module, function, wrapper, export, include)
        if ret < 0:
            failed = failed + 1
            funcs_failed.append(function)
            del funcs[function]
        if ret == 0:
            skipped = skipped + 1
            funcs_skipped.append(function)
            del funcs[function]
        if ret == 1:
            nb_wrap = nb_wrap + 1
    include.close()
    export.close()
    wrapper.close()

    if not quiet:
        print "Generated %d wrapper functions" % nb_wrap

    if unknown_types:
        print "Missing type converters: "
        for type in unknown_types.keys():
            print "%s:%d " % (type, len(unknown_types[type])),

    for f in funcs_failed:
        print "ERROR: failed %s" % f

    if failed > 0:
        return -1
    if len(unknown_types) > 0:
        return -1
    return 0

#######################################################################
#
#  This part writes part of the Python front-end classes based on
#  mapping rules between types and classes and also based on function
#  renaming to get consistent function names at the Python level
#
#######################################################################

#
# The type automatically remapped to generated classes
#
classes_type = {
    "virDomainPtr": ("._o", "virDomain(self,_obj=%s)", "virDomain"),
    "virDomain *": ("._o", "virDomain(self, _obj=%s)", "virDomain"),
    "virNetworkPtr": ("._o", "virNetwork(self, _obj=%s)", "virNetwork"),
    "virNetwork *": ("._o", "virNetwork(self, _obj=%s)", "virNetwork"),
    "virInterfacePtr": ("._o", "virInterface(self, _obj=%s)", "virInterface"),
    "virInterface *": ("._o", "virInterface(self, _obj=%s)", "virInterface"),
    "virStoragePoolPtr": ("._o", "virStoragePool(self, _obj=%s)", "virStoragePool"),
    "virStoragePool *": ("._o", "virStoragePool(self, _obj=%s)", "virStoragePool"),
    "virStorageVolPtr": ("._o", "virStorageVol(self, _obj=%s)", "virStorageVol"),
    "virStorageVol *": ("._o", "virStorageVol(self, _obj=%s)", "virStorageVol"),
    "virNodeDevicePtr": ("._o", "virNodeDevice(self, _obj=%s)", "virNodeDevice"),
    "virNodeDevice *": ("._o", "virNodeDevice(self, _obj=%s)", "virNodeDevice"),
    "virSecretPtr": ("._o", "virSecret(self, _obj=%s)", "virSecret"),
    "virSecret *": ("._o", "virSecret(self, _obj=%s)", "virSecret"),
    "virNWFilterPtr": ("._o", "virNWFilter(self, _obj=%s)", "virNWFilter"),
    "virNWFilter *": ("._o", "virNWFilter(self, _obj=%s)", "virNWFilter"),
    "virStreamPtr": ("._o", "virStream(self, _obj=%s)", "virStream"),
    "virStream *": ("._o", "virStream(self, _obj=%s)", "virStream"),
    "virConnectPtr": ("._o", "virConnect(_obj=%s)", "virConnect"),
    "virConnect *": ("._o", "virConnect(_obj=%s)", "virConnect"),
    "virDomainSnapshotPtr": ("._o", "virDomainSnapshot(self,_obj=%s)", "virDomainSnapshot"),
    "virDomainSnapshot *": ("._o", "virDomainSnapshot(self, _obj=%s)", "virDomainSnapshot"),
}

converter_type = {
}

primary_classes = ["virDomain", "virNetwork", "virInterface",
                   "virStoragePool", "virStorageVol",
                   "virConnect", "virNodeDevice", "virSecret",
                   "virNWFilter", "virStream", "virDomainSnapshot"]

classes_ancestor = {
}

classes_destructors = {
    "virDomain": "virDomainFree",
    "virNetwork": "virNetworkFree",
    "virInterface": "virInterfaceFree",
    "virStoragePool": "virStoragePoolFree",
    "virStorageVol": "virStorageVolFree",
    "virNodeDevice" : "virNodeDeviceFree",
    "virSecret": "virSecretFree",
    "virNWFilter": "virNWFilterFree",
    "virDomainSnapshot": "virDomainSnapshotFree",
    # We hand-craft __del__ for this one
    #"virStream": "virStreamFree",
}

class_skip_connect_impl = {
    "virConnect" : True,
}

class_domain_impl = {
    "virDomainSnapshot": True,
}

functions_noexcept = {
    'virDomainGetID': True,
    'virDomainGetName': True,
    'virNetworkGetName': True,
    'virInterfaceGetName': True,
    'virStoragePoolGetName': True,
    'virStorageVolGetName': True,
    'virStorageVolGetkey': True,
    'virNodeDeviceGetName': True,
    'virNodeDeviceGetParent': True,
    'virSecretGetUsageType': True,
    'virSecretGetUsageID': True,
    'virNWFilterGetName': True,
}

reference_keepers = {
}

function_classes = {}

function_classes["None"] = []

function_post = {}

# Functions returning an integral type which need special rules to
# check for errors and raise exceptions.
functions_int_exception_test = {
    'virDomainGetMaxMemory': "%s == 0",
}
functions_int_default_test = "%s == -1"

def is_integral_type (name):
    return not re.search ("^(unsigned)? ?(int|long)$", name) is None

# Functions returning lists which need special rules to check for errors
# and raise exceptions.
functions_list_exception_test = {
}
functions_list_default_test = "%s is None"

def is_list_type (name):
    whitelist = [ "virDomainBlockStats",
                  "virDomainInterfaceStats" ]

    return name[-1:] == "*" or name in whitelist

def nameFixup(name, classe, type, file):
    # avoid a desastrous clash
    listname = classe + "List"
    ll = len(listname)
    l = len(classe)
    if name[0:l] == listname:
        func = name[l:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:16] == "virNetworkDefine":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:19] == "virNetworkCreateXML":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:16] == "virNetworkLookup":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:18] == "virInterfaceDefine":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:21] == "virInterfaceCreateXML":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:18] == "virInterfaceLookup":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:15] == "virSecretDefine":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:15] == "virSecretLookup":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:17] == "virNWFilterDefine":
        func = name[3:]
        func = string.lower(func[0:3]) + func[3:]
    elif name[0:17] == "virNWFilterLookup":
        func = name[3:]
        func = string.lower(func[0:3]) + func[3:]
    elif name[0:20] == "virStoragePoolDefine":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:23] == "virStoragePoolCreateXML":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:20] == "virStoragePoolLookup":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:19] == "virStorageVolDefine":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:19] == "virStorageVolLookup":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:20] == "virDomainGetCPUStats":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:12] == "virDomainGet":
        func = name[12:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:29] == "virDomainSnapshotLookupByName":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:26] == "virDomainSnapshotListNames":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:28] == "virDomainSnapshotNumChildren":
        func = name[17:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:20] == "virDomainSnapshotNum":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:26] == "virDomainSnapshotCreateXML":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:24] == "virDomainSnapshotCurrent":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:17] == "virDomainSnapshot":
        func = name[17:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:9] == "virDomain":
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:13] == "virNetworkGet":
        func = name[13:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:10] == "virNetwork":
        func = name[10:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:15] == "virInterfaceGet":
        func = name[15:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:12] == "virInterface":
        func = name[12:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:12] == 'virSecretGet':
        func = name[12:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:9] == 'virSecret':
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:14] == 'virNWFilterGet':
        func = name[14:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:11] == 'virNWFilter':
        func = name[11:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:12] == 'virStreamNew':
        func = "newStream"
    elif name[0:9] == 'virStream':
        func = name[9:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:17] == "virStoragePoolGet":
        func = name[17:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:14] == "virStoragePool":
        func = name[14:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:16] == "virStorageVolGet":
        func = name[16:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:13] == "virStorageVol":
        func = name[13:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:13] == "virNodeDevice":
        if name[13:16] == "Get":
            func = string.lower(name[16]) + name[17:]
        elif name[13:19] == "Lookup" or name[13:19] == "Create":
            func = string.lower(name[3]) + name[4:]
        else:
            func = string.lower(name[13]) + name[14:]
    elif name[0:7] == "virNode":
        func = name[7:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:10] == "virConnect":
        func = name[10:]
        func = string.lower(func[0:1]) + func[1:]
    elif name[0:3] == "xml":
        func = name[3:]
        func = string.lower(func[0:1]) + func[1:]
    else:
        func = name
    if func == "iD":
        func = "ID"
    if func == "uUID":
        func = "UUID"
    if func == "uUIDString":
        func = "UUIDString"
    if func == "oSType":
        func = "OSType"
    if func == "xMLDesc":
        func = "XMLDesc"
    if func == "mACString":
        func = "MACString"

    return func


def functionCompare(info1, info2):
    (index1, func1, name1, ret1, args1, file1, mod1) = info1
    (index2, func2, name2, ret2, args2, file2, mod2) = info2
    if file1 == file2:
        if func1 < func2:
            return -1
        if func1 > func2:
            return 1
    if file1 == "python_accessor":
        return -1
    if file2 == "python_accessor":
        return 1
    if file1 < file2:
        return -1
    if file1 > file2:
        return 1
    return 0

def writeDoc(module, name, args, indent, output):
     if module == "libvirt":
         funcs = functions
     elif module == "libvirt-lxc":
         funcs = lxc_functions
     elif module == "libvirt-qemu":
         funcs = qemu_functions
     if funcs[name][0] is None or funcs[name][0] == "":
         return
     val = funcs[name][0]
     val = string.replace(val, "NULL", "None")
     output.write(indent)
     output.write('"""')
     i = string.find(val, "\n")
     while i >= 0:
         str = val[0:i+1]
         val = val[i+1:]
         output.write(str)
         i = string.find(val, "\n")
         output.write(indent)
     output.write(val)
     output.write(' """\n')

def buildWrappers(module):
    global ctypes
    global py_types
    global py_return_types
    global unknown_types
    global functions
    global function_classes
    global classes_type
    global classes_list
    global converter_type
    global primary_classes
    global converter_type
    global classes_ancestor
    global converter_type
    global primary_classes
    global classes_destructors
    global functions_noexcept

    if not module == "libvirt":
        print "ERROR: Unknown module type: %s" % module
        return None

    for type in classes_type.keys():
        function_classes[classes_type[type][2]] = []

    #
    # Build the list of C types to look for ordered to start
    # with primary classes
    #
    ctypes = []
    classes_list = []
    ctypes_processed = {}
    classes_processed = {}
    for classe in primary_classes:
        classes_list.append(classe)
        classes_processed[classe] = ()
        for type in classes_type.keys():
            tinfo = classes_type[type]
            if tinfo[2] == classe:
                ctypes.append(type)
                ctypes_processed[type] = ()
    for type in classes_type.keys():
        if ctypes_processed.has_key(type):
            continue
        tinfo = classes_type[type]
        if not classes_processed.has_key(tinfo[2]):
            classes_list.append(tinfo[2])
            classes_processed[tinfo[2]] = ()

        ctypes.append(type)
        ctypes_processed[type] = ()

    for name in functions.keys():
        found = 0
        (desc, ret, args, file, mod, cond) = functions[name]
        for type in ctypes:
            classe = classes_type[type][2]

            if name[0:3] == "vir" and len(args) >= 1 and args[0][1] == type:
                found = 1
                func = nameFixup(name, classe, type, file)
                info = (0, func, name, ret, args, file, mod)
                function_classes[classe].append(info)
            elif name[0:3] == "vir" and len(args) >= 2 and args[1][1] == type \
                and file != "python_accessor" and not name in function_skip_index_one:
                found = 1
                func = nameFixup(name, classe, type, file)
                info = (1, func, name, ret, args, file, mod)
                function_classes[classe].append(info)
        if found == 1:
            continue
        func = nameFixup(name, "None", file, file)
        info = (0, func, name, ret, args, file, mod)
        function_classes['None'].append(info)

    classes_file = "%s.py" % module
    extra_file = os.path.join(srcPref, "%s-override.py" % module)
    extra = None

    classes = open(classes_file, "w")

    if os.path.exists(extra_file):
        extra = open(extra_file, "r")
    classes.write("#! " + python + " -i\n")
    classes.write("#\n")
    classes.write("# WARNING WARNING WARNING WARNING\n")
    classes.write("#\n")
    classes.write("# This file is automatically written by generator.py. Any changes\n")
    classes.write("# made here will be lost.\n")
    classes.write("#\n")
    classes.write("# To change the manually written methods edit " + module + "-override.py\n")
    classes.write("# To change the automatically written methods edit generator.py\n")
    classes.write("#\n")
    classes.write("# WARNING WARNING WARNING WARNING\n")
    classes.write("#\n")
    if extra != None:
        classes.writelines(extra.readlines())
    classes.write("#\n")
    classes.write("# WARNING WARNING WARNING WARNING\n")
    classes.write("#\n")
    classes.write("# Automatically written part of python bindings for libvirt\n")
    classes.write("#\n")
    classes.write("# WARNING WARNING WARNING WARNING\n")
    if extra != None:
        extra.close()

    if function_classes.has_key("None"):
        flist = function_classes["None"]
        flist.sort(functionCompare)
        oldfile = ""
        for info in flist:
            (index, func, name, ret, args, file, mod) = info
            if file != oldfile:
                classes.write("#\n# Functions from module %s\n#\n\n" % file)
                oldfile = file
            classes.write("def %s(" % func)
            n = 0
            for arg in args:
                if n != 0:
                    classes.write(", ")
                classes.write("%s" % arg[0])
                n = n + 1
            classes.write("):\n")
            writeDoc(module, name, args, '    ', classes)

            for arg in args:
                if classes_type.has_key(arg[1]):
                    classes.write("    if %s is None: %s__o = None\n" %
                                  (arg[0], arg[0]))
                    classes.write("    else: %s__o = %s%s\n" %
                                  (arg[0], arg[0], classes_type[arg[1]][0]))
            if ret[0] != "void":
                classes.write("    ret = ")
            else:
                classes.write("    ")
            classes.write("libvirtmod.%s(" % name)
            n = 0
            for arg in args:
                if n != 0:
                    classes.write(", ")
                classes.write("%s" % arg[0])
                if classes_type.has_key(arg[1]):
                    classes.write("__o")
                n = n + 1
            classes.write(")\n")

            if ret[0] != "void":
                if classes_type.has_key(ret[0]):
                    #
                    # Raise an exception
                    #
                    if functions_noexcept.has_key(name):
                        classes.write("    if ret is None:return None\n")
                    else:
                        classes.write(
                     "    if ret is None:raise libvirtError('%s() failed')\n" %
                                      (name))

                    classes.write("    return ")
                    classes.write(classes_type[ret[0]][1] % ("ret"))
                    classes.write("\n")

                # For functions returning an integral type there are
                # several things that we can do, depending on the
                # contents of functions_int_*:
                elif is_integral_type (ret[0]):
                    if not functions_noexcept.has_key (name):
                        if functions_int_exception_test.has_key (name):
                            test = functions_int_exception_test[name]
                        else:
                            test = functions_int_default_test
                        classes.write (("    if " + test +
                                        ": raise libvirtError ('%s() failed')\n") %
                                       ("ret", name))
                    classes.write("    return ret\n")

                elif is_list_type (ret[0]):
                    if not functions_noexcept.has_key (name):
                        if functions_list_exception_test.has_key (name):
                            test = functions_list_exception_test[name]
                        else:
                            test = functions_list_default_test
                        classes.write (("    if " + test +
                                        ": raise libvirtError ('%s() failed')\n") %
                                       ("ret", name))
                    classes.write("    return ret\n")

                else:
                    classes.write("    return ret\n")

            classes.write("\n")

    for classname in classes_list:
        if classname == "None":
            pass
        else:
            if classes_ancestor.has_key(classname):
                classes.write("class %s(%s):\n" % (classname,
                              classes_ancestor[classname]))
                classes.write("    def __init__(self, _obj=None):\n")
                if reference_keepers.has_key(classname):
                    rlist = reference_keepers[classname]
                    for ref in rlist:
                        classes.write("        self.%s = None\n" % ref[1])
                classes.write("        self._o = _obj\n")
                classes.write("        %s.__init__(self, _obj=_obj)\n\n" % (
                              classes_ancestor[classname]))
            else:
                classes.write("class %s(object):\n" % (classname))
                if classname in [ "virDomain", "virNetwork", "virInterface", "virStoragePool",
                                  "virStorageVol", "virNodeDevice", "virSecret","virStream",
                                  "virNWFilter" ]:
                    classes.write("    def __init__(self, conn, _obj=None):\n")
                elif classname in [ 'virDomainSnapshot' ]:
                    classes.write("    def __init__(self, dom, _obj=None):\n")
                else:
                    classes.write("    def __init__(self, _obj=None):\n")
                if reference_keepers.has_key(classname):
                    list = reference_keepers[classname]
                    for ref in list:
                        classes.write("        self.%s = None\n" % ref[1])
                if classname in [ "virDomain", "virNetwork", "virInterface",
                                  "virNodeDevice", "virSecret", "virStream",
                                  "virNWFilter" ]:
                    classes.write("        self._conn = conn\n")
                elif classname in [ "virStorageVol", "virStoragePool" ]:
                    classes.write("        self._conn = conn\n" + \
                                  "        if not isinstance(conn, virConnect):\n" + \
                                  "            self._conn = conn._conn\n")
                elif classname in [ "virDomainSnapshot" ]:
                    classes.write("        self._dom = dom\n")
                    classes.write("        self._conn = dom.connect()\n")
                classes.write("        if _obj != None:self._o = _obj;return\n")
                classes.write("        self._o = None\n\n")
            destruct=None
            if classes_destructors.has_key(classname):
                classes.write("    def __del__(self):\n")
                classes.write("        if self._o != None:\n")
                classes.write("            libvirtmod.%s(self._o)\n" %
                              classes_destructors[classname])
                classes.write("        self._o = None\n\n")
                destruct=classes_destructors[classname]

            if not class_skip_connect_impl.has_key(classname):
                # Build python safe 'connect' method
                classes.write("    def connect(self):\n")
                classes.write("        return self._conn\n\n")

            if class_domain_impl.has_key(classname):
                classes.write("    def domain(self):\n")
                classes.write("        return self._dom\n\n")

            flist = function_classes[classname]
            flist.sort(functionCompare)
            oldfile = ""
            for info in flist:
                (index, func, name, ret, args, file, mod) = info
                #
                # Do not provide as method the destructors for the class
                # to avoid double free
                #
                if name == destruct:
                    continue
                if file != oldfile:
                    if file == "python_accessor":
                        classes.write("    # accessors for %s\n" % (classname))
                    else:
                        classes.write("    #\n")
                        classes.write("    # %s functions from module %s\n" % (
                                      classname, file))
                        classes.write("    #\n\n")
                oldfile = file
                classes.write("    def %s(self" % func)
                n = 0
                for arg in args:
                    if n != index:
                        classes.write(", %s" % arg[0])
                    n = n + 1
                classes.write("):\n")
                writeDoc(module, name, args, '        ', classes)
                n = 0
                for arg in args:
                    if classes_type.has_key(arg[1]):
                        if n != index:
                            classes.write("        if %s is None: %s__o = None\n" %
                                          (arg[0], arg[0]))
                            classes.write("        else: %s__o = %s%s\n" %
                                          (arg[0], arg[0], classes_type[arg[1]][0]))
                    n = n + 1
                if ret[0] != "void":
                    classes.write("        ret = ")
                else:
                    classes.write("        ")
                n = 0
                classes.write("libvirtmod.%s(" % name)
                for arg in args:
                    if n != 0:
                        classes.write(", ")
                    if n != index:
                        classes.write("%s" % arg[0])
                        if classes_type.has_key(arg[1]):
                            classes.write("__o")
                    else:
                        classes.write("self")
                        if classes_type.has_key(arg[1]):
                            classes.write(classes_type[arg[1]][0])
                    n = n + 1
                classes.write(")\n")

                if name == "virConnectClose":
                    classes.write("        self._o = None\n")

                # For functions returning object types:
                if ret[0] != "void":
                    if classes_type.has_key(ret[0]):
                        #
                        # Raise an exception
                        #
                        if functions_noexcept.has_key(name):
                            classes.write(
                                "        if ret is None:return None\n")
                        else:
                            if classname == "virConnect":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', conn=self)\n" %
                                              (name))
                            elif classname == "virDomain":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', dom=self)\n" %
                                              (name))
                            elif classname == "virNetwork":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', net=self)\n" %
                                              (name))
                            elif classname == "virInterface":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', net=self)\n" %
                                              (name))
                            elif classname == "virStoragePool":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', pool=self)\n" %
                                              (name))
                            elif classname == "virStorageVol":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', vol=self)\n" %
                                              (name))
                            elif classname == "virDomainSnapshot":
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed', dom=self._dom)\n" %
                                              (name))
                            else:
                                classes.write(
                     "        if ret is None:raise libvirtError('%s() failed')\n" %
                                              (name))

                        #
                        # generate the returned class wrapper for the object
                        #
                        classes.write("        __tmp = ")
                        classes.write(classes_type[ret[0]][1] % ("ret"))
                        classes.write("\n")

                        #
                        # Sometime one need to keep references of the source
                        # class in the returned class object.
                        # See reference_keepers for the list
                        #
                        tclass = classes_type[ret[0]][2]
                        if reference_keepers.has_key(tclass):
                            list = reference_keepers[tclass]
                            for pref in list:
                                if pref[0] == classname:
                                    classes.write("        __tmp.%s = self\n" %
                                                  pref[1])

                        # Post-processing - just before we return.
                        if function_post.has_key(name):
                            classes.write("        %s\n" %
                                          (function_post[name]))

                        #
                        # return the class
                        #
                        classes.write("        return __tmp\n")
                    elif converter_type.has_key(ret[0]):
                        #
                        # Raise an exception
                        #
                        if functions_noexcept.has_key(name):
                            classes.write(
                                "        if ret is None:return None")

                        # Post-processing - just before we return.
                        if function_post.has_key(name):
                            classes.write("        %s\n" %
                                          (function_post[name]))

                        classes.write("        return ")
                        classes.write(converter_type[ret[0]] % ("ret"))
                        classes.write("\n")

                    # For functions returning an integral type there
                    # are several things that we can do, depending on
                    # the contents of functions_int_*:
                    elif is_integral_type (ret[0]):
                        if not functions_noexcept.has_key (name):
                            if functions_int_exception_test.has_key (name):
                                test = functions_int_exception_test[name]
                            else:
                                test = functions_int_default_test
                            if classname == "virConnect":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', conn=self)\n") %
                                               ("ret", name))
                            elif classname == "virDomain":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', dom=self)\n") %
                                               ("ret", name))
                            elif classname == "virNetwork":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', net=self)\n") %
                                               ("ret", name))
                            elif classname == "virInterface":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', net=self)\n") %
                                               ("ret", name))
                            elif classname == "virStoragePool":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', pool=self)\n") %
                                               ("ret", name))
                            elif classname == "virStorageVol":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', vol=self)\n") %
                                               ("ret", name))
                            else:
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed')\n") %
                                               ("ret", name))

                        # Post-processing - just before we return.
                        if function_post.has_key(name):
                            classes.write("        %s\n" %
                                          (function_post[name]))

                        classes.write ("        return ret\n")

                    elif is_list_type (ret[0]):
                        if not functions_noexcept.has_key (name):
                            if functions_list_exception_test.has_key (name):
                                test = functions_list_exception_test[name]
                            else:
                                test = functions_list_default_test
                            if classname == "virConnect":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', conn=self)\n") %
                                               ("ret", name))
                            elif classname == "virDomain":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', dom=self)\n") %
                                               ("ret", name))
                            elif classname == "virNetwork":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', net=self)\n") %
                                               ("ret", name))
                            elif classname == "virInterface":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', net=self)\n") %
                                               ("ret", name))
                            elif classname == "virStoragePool":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', pool=self)\n") %
                                               ("ret", name))
                            elif classname == "virStorageVol":
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed', vol=self)\n") %
                                               ("ret", name))
                            else:
                                classes.write (("        if " + test +
                                                ": raise libvirtError ('%s() failed')\n") %
                                               ("ret", name))

                        # Post-processing - just before we return.
                        if function_post.has_key(name):
                            classes.write("        %s\n" %
                                          (function_post[name]))

                        classes.write ("        return ret\n")

                    else:
                        # Post-processing - just before we return.
                        if function_post.has_key(name):
                            classes.write("        %s\n" %
                                          (function_post[name]))

                        classes.write("        return ret\n")

                classes.write("\n")
            # Append "<classname>.py" to class def, iff it exists
            try:
                extra = open(os.path.join(srcPref,"libvirt-override-" + classname + ".py"), "r")
                classes.write ("    #\n")
                classes.write ("    # %s methods from %s.py (hand coded)\n" % (classname,classname))
                classes.write ("    #\n")
                classes.writelines(extra.readlines())
                classes.write("\n")
                extra.close()
            except:
                pass

    #
    # Generate enum constants
    #
    for type,enum in enums.items():
        classes.write("# %s\n" % type)
        items = enum.items()
        items.sort(lambda i1,i2: cmp(long(i1[1]),long(i2[1])))
        for name,value in items:
            classes.write("%s = %s\n" % (name,value))
        classes.write("\n")

    classes.close()

def qemuBuildWrappers(module):
    global qemu_functions

    if not module == "libvirt-qemu":
        print "ERROR: only libvirt-qemu is supported"
        return None

    extra_file = os.path.join(srcPref, "%s-override.py" % module)
    extra = None

    fd = open("libvirt_qemu.py", "w")

    if os.path.exists(extra_file):
        extra = open(extra_file, "r")
    fd.write("#! " + python + " -i\n")
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    fd.write("#\n")
    fd.write("# This file is automatically written by generator.py. Any changes\n")
    fd.write("# made here will be lost.\n")
    fd.write("#\n")
    fd.write("# To change the manually written methods edit " + module + "-override.py\n")
    fd.write("# To change the automatically written methods edit generator.py\n")
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    fd.write("#\n")
    if extra != None:
        fd.writelines(extra.readlines())
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    fd.write("#\n")
    fd.write("# Automatically written part of python bindings for libvirt\n")
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    if extra != None:
        extra.close()

    fd.write("try:\n")
    fd.write("    import libvirtmod_qemu\n")
    fd.write("except ImportError, lib_e:\n")
    fd.write("    try:\n")
    fd.write("        import cygvirtmod_qemu as libvirtmod_qemu\n")
    fd.write("    except ImportError, cyg_e:\n")
    fd.write("        if str(cyg_e).count(\"No module named\"):\n")
    fd.write("            raise lib_e\n\n")

    fd.write("import libvirt\n\n")
    fd.write("#\n# Functions from module %s\n#\n\n" % module)
    #
    # Generate functions directly, no classes
    #
    for name in qemu_functions.keys():
        func = nameFixup(name, 'None', None, None)
        (desc, ret, args, file, mod, cond) = qemu_functions[name]
        fd.write("def %s(" % func)
        n = 0
        for arg in args:
            if n != 0:
                fd.write(", ")
            fd.write("%s" % arg[0])
            n = n + 1
        fd.write("):\n")
        writeDoc(module, name, args, '    ', fd)

        if ret[0] != "void":
            fd.write("    ret = ")
        else:
            fd.write("    ")
        fd.write("libvirtmod_qemu.%s(" % name)
        n = 0

        conn = None

        for arg in args:
            if arg[1] == "virConnectPtr":
                conn = arg[0]

            if n != 0:
                fd.write(", ")
            if arg[1] in ["virDomainPtr", "virConnectPtr"]:
                # FIXME: This might have problem if the function
                # has multiple args which are objects.
                fd.write("%s.%s" % (arg[0], "_o"))
            else:
                fd.write("%s" % arg[0])
            n = n + 1
        fd.write(")\n")

        if ret[0] != "void":
            fd.write("    if ret is None: raise libvirt.libvirtError('" + name + "() failed')\n")
            if ret[0] == "virDomainPtr":
                fd.write("    __tmp = virDomain(" + conn + ",_obj=ret)\n")
                fd.write("    return __tmp\n")
            else:
                fd.write("    return ret\n")

        fd.write("\n")

    #
    # Generate enum constants
    #
    for type,enum in qemu_enums.items():
        fd.write("# %s\n" % type)
        items = enum.items()
        items.sort(lambda i1,i2: cmp(long(i1[1]),long(i2[1])))
        for name,value in items:
            fd.write("%s = %s\n" % (name,value))
        fd.write("\n")

    fd.close()


def lxcBuildWrappers(module):
    global lxc_functions

    if not module == "libvirt-lxc":
        print "ERROR: only libvirt-lxc is supported"
        return None

    extra_file = os.path.join(srcPref, "%s-override.py" % module)
    extra = None

    fd = open("libvirt_lxc.py", "w")

    if os.path.exists(extra_file):
        extra = open(extra_file, "r")
    fd.write("#! " + python + " -i\n")
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    fd.write("#\n")
    fd.write("# This file is automatically written by generator.py. Any changes\n")
    fd.write("# made here will be lost.\n")
    fd.write("#\n")
    fd.write("# To change the manually written methods edit " + module + "-override.py\n")
    fd.write("# To change the automatically written methods edit generator.py\n")
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    fd.write("#\n")
    if extra != None:
        fd.writelines(extra.readlines())
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    fd.write("#\n")
    fd.write("# Automatically written part of python bindings for libvirt\n")
    fd.write("#\n")
    fd.write("# WARNING WARNING WARNING WARNING\n")
    if extra != None:
        extra.close()

    fd.write("try:\n")
    fd.write("    import libvirtmod_lxc\n")
    fd.write("except ImportError, lib_e:\n")
    fd.write("    try:\n")
    fd.write("        import cygvirtmod_lxc as libvirtmod_lxc\n")
    fd.write("    except ImportError, cyg_e:\n")
    fd.write("        if str(cyg_e).count(\"No module named\"):\n")
    fd.write("            raise lib_e\n\n")

    fd.write("import libvirt\n\n")
    fd.write("#\n# Functions from module %s\n#\n\n" % module)
    #
    # Generate functions directly, no classes
    #
    for name in lxc_functions.keys():
        func = nameFixup(name, 'None', None, None)
        (desc, ret, args, file, mod, cond) = lxc_functions[name]
        fd.write("def %s(" % func)
        n = 0
        for arg in args:
            if n != 0:
                fd.write(", ")
            fd.write("%s" % arg[0])
            n = n + 1
        fd.write("):\n")
        writeDoc(module, name, args, '    ', fd)

        if ret[0] != "void":
            fd.write("    ret = ")
        else:
            fd.write("    ")
        fd.write("libvirtmod_lxc.%s(" % name)
        n = 0

        conn = None

        for arg in args:
            if arg[1] == "virConnectPtr":
                conn = arg[0]

            if n != 0:
                fd.write(", ")
            if arg[1] in ["virDomainPtr", "virConnectPtr"]:
                # FIXME: This might have problem if the function
                # has multiple args which are objects.
                fd.write("%s.%s" % (arg[0], "_o"))
            else:
                fd.write("%s" % arg[0])
            n = n + 1
        fd.write(")\n")

        if ret[0] != "void":
            fd.write("    if ret is None: raise libvirt.libvirtError('" + name + "() failed')\n")
            if ret[0] == "virDomainPtr":
                fd.write("    __tmp = virDomain(" + conn + ",_obj=ret)\n")
                fd.write("    return __tmp\n")
            else:
                fd.write("    return ret\n")

        fd.write("\n")

    #
    # Generate enum constants
    #
    for type,enum in lxc_enums.items():
        fd.write("# %s\n" % type)
        items = enum.items()
        items.sort(lambda i1,i2: cmp(long(i1[1]),long(i2[1])))
        for name,value in items:
            fd.write("%s = %s\n" % (name,value))
        fd.write("\n")

    fd.close()


quiet = 0
if buildStubs("libvirt") < 0:
    sys.exit(1)
if buildStubs("libvirt-lxc") < 0:
    sys.exit(1)
if buildStubs("libvirt-qemu") < 0:
    sys.exit(1)
buildWrappers("libvirt")
lxcBuildWrappers("libvirt-lxc")
qemuBuildWrappers("libvirt-qemu")
sys.exit(0)
='n2081' href='#n2081'>2081</a>
<a id='n2082' href='#n2082'>2082</a>
<a id='n2083' href='#n2083'>2083</a>
<a id='n2084' href='#n2084'>2084</a>
<a id='n2085' href='#n2085'>2085</a>
<a id='n2086' href='#n2086'>2086</a>
<a id='n2087' href='#n2087'>2087</a>
<a id='n2088' href='#n2088'>2088</a>
<a id='n2089' href='#n2089'>2089</a>
<a id='n2090' href='#n2090'>2090</a>
<a id='n2091' href='#n2091'>2091</a>
<a id='n2092' href='#n2092'>2092</a>
<a id='n2093' href='#n2093'>2093</a>
<a id='n2094' href='#n2094'>2094</a>
<a id='n2095' href='#n2095'>2095</a>
<a id='n2096' href='#n2096'>2096</a>
<a id='n2097' href='#n2097'>2097</a>
<a id='n2098' href='#n2098'>2098</a>
<a id='n2099' href='#n2099'>2099</a>
<a id='n2100' href='#n2100'>2100</a>
<a id='n2101' href='#n2101'>2101</a>
<a id='n2102' href='#n2102'>2102</a>
<a id='n2103' href='#n2103'>2103</a>
<a id='n2104' href='#n2104'>2104</a>
<a id='n2105' href='#n2105'>2105</a>
<a id='n2106' href='#n2106'>2106</a>
<a id='n2107' href='#n2107'>2107</a>
<a id='n2108' href='#n2108'>2108</a>
<a id='n2109' href='#n2109'>2109</a>
<a id='n2110' href='#n2110'>2110</a>
<a id='n2111' href='#n2111'>2111</a>
<a id='n2112' href='#n2112'>2112</a>
<a id='n2113' href='#n2113'>2113</a>
<a id='n2114' href='#n2114'>2114</a>
<a id='n2115' href='#n2115'>2115</a>
<a id='n2116' href='#n2116'>2116</a>
<a id='n2117' href='#n2117'>2117</a>
<a id='n2118' href='#n2118'>2118</a>
<a id='n2119' href='#n2119'>2119</a>
<a id='n2120' href='#n2120'>2120</a>
<a id='n2121' href='#n2121'>2121</a>
<a id='n2122' href='#n2122'>2122</a>
<a id='n2123' href='#n2123'>2123</a>
<a id='n2124' href='#n2124'>2124</a>
<a id='n2125' href='#n2125'>2125</a>
<a id='n2126' href='#n2126'>2126</a>
<a id='n2127' href='#n2127'>2127</a>
<a id='n2128' href='#n2128'>2128</a>
<a id='n2129' href='#n2129'>2129</a>
<a id='n2130' href='#n2130'>2130</a>
<a id='n2131' href='#n2131'>2131</a>
<a id='n2132' href='#n2132'>2132</a>
<a id='n2133' href='#n2133'>2133</a>
<a id='n2134' href='#n2134'>2134</a>
<a id='n2135' href='#n2135'>2135</a>
<a id='n2136' href='#n2136'>2136</a>
<a id='n2137' href='#n2137'>2137</a>
<a id='n2138' href='#n2138'>2138</a>
<a id='n2139' href='#n2139'>2139</a>
<a id='n2140' href='#n2140'>2140</a>
<a id='n2141' href='#n2141'>2141</a>
<a id='n2142' href='#n2142'>2142</a>
<a id='n2143' href='#n2143'>2143</a>
<a id='n2144' href='#n2144'>2144</a>
<a id='n2145' href='#n2145'>2145</a>
<a id='n2146' href='#n2146'>2146</a>
<a id='n2147' href='#n2147'>2147</a>
<a id='n2148' href='#n2148'>2148</a>
<a id='n2149' href='#n2149'>2149</a>
<a id='n2150' href='#n2150'>2150</a>
<a id='n2151' href='#n2151'>2151</a>
<a id='n2152' href='#n2152'>2152</a>
<a id='n2153' href='#n2153'>2153</a>
<a id='n2154' href='#n2154'>2154</a>
<a id='n2155' href='#n2155'>2155</a>
<a id='n2156' href='#n2156'>2156</a>
<a id='n2157' href='#n2157'>2157</a>
<a id='n2158' href='#n2158'>2158</a>
<a id='n2159' href='#n2159'>2159</a>
<a id='n2160' href='#n2160'>2160</a>
<a id='n2161' href='#n2161'>2161</a>
<a id='n2162' href='#n2162'>2162</a>
<a id='n2163' href='#n2163'>2163</a>
<a id='n2164' href='#n2164'>2164</a>
<a id='n2165' href='#n2165'>2165</a>
<a id='n2166' href='#n2166'>2166</a>
<a id='n2167' href='#n2167'>2167</a>
<a id='n2168' href='#n2168'>2168</a>
<a id='n2169' href='#n2169'>2169</a>
<a id='n2170' href='#n2170'>2170</a>
<a id='n2171' href='#n2171'>2171</a>
<a id='n2172' href='#n2172'>2172</a>
<a id='n2173' href='#n2173'>2173</a>
<a id='n2174' href='#n2174'>2174</a>
<a id='n2175' href='#n2175'>2175</a>
<a id='n2176' href='#n2176'>2176</a>
<a id='n2177' href='#n2177'>2177</a>
<a id='n2178' href='#n2178'>2178</a>
<a id='n2179' href='#n2179'>2179</a>
<a id='n2180' href='#n2180'>2180</a>
<a id='n2181' href='#n2181'>2181</a>
<a id='n2182' href='#n2182'>2182</a>
<a id='n2183' href='#n2183'>2183</a>
<a id='n2184' href='#n2184'>2184</a>
<a id='n2185' href='#n2185'>2185</a>
<a id='n2186' href='#n2186'>2186</a>
<a id='n2187' href='#n2187'>2187</a>
<a id='n2188' href='#n2188'>2188</a>
<a id='n2189' href='#n2189'>2189</a>
<a id='n2190' href='#n2190'>2190</a>
<a id='n2191' href='#n2191'>2191</a>
<a id='n2192' href='#n2192'>2192</a>
<a id='n2193' href='#n2193'>2193</a>
<a id='n2194' href='#n2194'>2194</a>
<a id='n2195' href='#n2195'>2195</a>
<a id='n2196' href='#n2196'>2196</a>
<a id='n2197' href='#n2197'>2197</a>
<a id='n2198' href='#n2198'>2198</a>
<a id='n2199' href='#n2199'>2199</a>
<a id='n2200' href='#n2200'>2200</a>
<a id='n2201' href='#n2201'>2201</a>
<a id='n2202' href='#n2202'>2202</a>
<a id='n2203' href='#n2203'>2203</a>
<a id='n2204' href='#n2204'>2204</a>
<a id='n2205' href='#n2205'>2205</a>
<a id='n2206' href='#n2206'>2206</a>
<a id='n2207' href='#n2207'>2207</a>
<a id='n2208' href='#n2208'>2208</a>
<a id='n2209' href='#n2209'>2209</a>
<a id='n2210' href='#n2210'>2210</a>
<a id='n2211' href='#n2211'>2211</a>
<a id='n2212' href='#n2212'>2212</a>
<a id='n2213' href='#n2213'>2213</a>
<a id='n2214' href='#n2214'>2214</a>
<a id='n2215' href='#n2215'>2215</a>
<a id='n2216' href='#n2216'>2216</a>
<a id='n2217' href='#n2217'>2217</a>
<a id='n2218' href='#n2218'>2218</a>
<a id='n2219' href='#n2219'>2219</a>
<a id='n2220' href='#n2220'>2220</a>
<a id='n2221' href='#n2221'>2221</a>
<a id='n2222' href='#n2222'>2222</a>
<a id='n2223' href='#n2223'>2223</a>
<a id='n2224' href='#n2224'>2224</a>
<a id='n2225' href='#n2225'>2225</a>
<a id='n2226' href='#n2226'>2226</a>
<a id='n2227' href='#n2227'>2227</a>
<a id='n2228' href='#n2228'>2228</a>
<a id='n2229' href='#n2229'>2229</a>
<a id='n2230' href='#n2230'>2230</a>
<a id='n2231' href='#n2231'>2231</a>
<a id='n2232' href='#n2232'>2232</a>
<a id='n2233' href='#n2233'>2233</a>
<a id='n2234' href='#n2234'>2234</a>
<a id='n2235' href='#n2235'>2235</a>
<a id='n2236' href='#n2236'>2236</a>
<a id='n2237' href='#n2237'>2237</a>
<a id='n2238' href='#n2238'>2238</a>
<a id='n2239' href='#n2239'>2239</a>
<a id='n2240' href='#n2240'>2240</a>
<a id='n2241' href='#n2241'>2241</a>
<a id='n2242' href='#n2242'>2242</a>
<a id='n2243' href='#n2243'>2243</a>
<a id='n2244' href='#n2244'>2244</a>
<a id='n2245' href='#n2245'>2245</a>
<a id='n2246' href='#n2246'>2246</a>
<a id='n2247' href='#n2247'>2247</a>
<a id='n2248' href='#n2248'>2248</a>
<a id='n2249' href='#n2249'>2249</a>
<a id='n2250' href='#n2250'>2250</a>
<a id='n2251' href='#n2251'>2251</a>
<a id='n2252' href='#n2252'>2252</a>
<a id='n2253' href='#n2253'>2253</a>
<a id='n2254' href='#n2254'>2254</a>
<a id='n2255' href='#n2255'>2255</a>
<a id='n2256' href='#n2256'>2256</a>
<a id='n2257' href='#n2257'>2257</a>
<a id='n2258' href='#n2258'>2258</a>
<a id='n2259' href='#n2259'>2259</a>
<a id='n2260' href='#n2260'>2260</a>
<a id='n2261' href='#n2261'>2261</a>
<a id='n2262' href='#n2262'>2262</a>
<a id='n2263' href='#n2263'>2263</a>
<a id='n2264' href='#n2264'>2264</a>
<a id='n2265' href='#n2265'>2265</a>
<a id='n2266' href='#n2266'>2266</a>
<a id='n2267' href='#n2267'>2267</a>
<a id='n2268' href='#n2268'>2268</a>
<a id='n2269' href='#n2269'>2269</a>
<a id='n2270' href='#n2270'>2270</a>
<a id='n2271' href='#n2271'>2271</a>
<a id='n2272' href='#n2272'>2272</a>
<a id='n2273' href='#n2273'>2273</a>
<a id='n2274' href='#n2274'>2274</a>
<a id='n2275' href='#n2275'>2275</a>
<a id='n2276' href='#n2276'>2276</a>
<a id='n2277' href='#n2277'>2277</a>
<a id='n2278' href='#n2278'>2278</a>
<a id='n2279' href='#n2279'>2279</a>
<a id='n2280' href='#n2280'>2280</a>
<a id='n2281' href='#n2281'>2281</a>
<a id='n2282' href='#n2282'>2282</a>
<a id='n2283' href='#n2283'>2283</a>
<a id='n2284' href='#n2284'>2284</a>
<a id='n2285' href='#n2285'>2285</a>
<a id='n2286' href='#n2286'>2286</a>
<a id='n2287' href='#n2287'>2287</a>
<a id='n2288' href='#n2288'>2288</a>
<a id='n2289' href='#n2289'>2289</a>
<a id='n2290' href='#n2290'>2290</a>
<a id='n2291' href='#n2291'>2291</a>
<a id='n2292' href='#n2292'>2292</a>
<a id='n2293' href='#n2293'>2293</a>
<a id='n2294' href='#n2294'>2294</a>
<a id='n2295' href='#n2295'>2295</a>
<a id='n2296' href='#n2296'>2296</a>
<a id='n2297' href='#n2297'>2297</a>
<a id='n2298' href='#n2298'>2298</a>
<a id='n2299' href='#n2299'>2299</a>
<a id='n2300' href='#n2300'>2300</a>
<a id='n2301' href='#n2301'>2301</a>
<a id='n2302' href='#n2302'>2302</a>
<a id='n2303' href='#n2303'>2303</a>
<a id='n2304' href='#n2304'>2304</a>
<a id='n2305' href='#n2305'>2305</a>
<a id='n2306' href='#n2306'>2306</a>
<a id='n2307' href='#n2307'>2307</a>
<a id='n2308' href='#n2308'>2308</a>
<a id='n2309' href='#n2309'>2309</a>
<a id='n2310' href='#n2310'>2310</a>
<a id='n2311' href='#n2311'>2311</a>
<a id='n2312' href='#n2312'>2312</a>
<a id='n2313' href='#n2313'>2313</a>
<a id='n2314' href='#n2314'>2314</a>
<a id='n2315' href='#n2315'>2315</a>
<a id='n2316' href='#n2316'>2316</a>
<a id='n2317' href='#n2317'>2317</a>
<a id='n2318' href='#n2318'>2318</a>
<a id='n2319' href='#n2319'>2319</a>
<a id='n2320' href='#n2320'>2320</a>
<a id='n2321' href='#n2321'>2321</a>
<a id='n2322' href='#n2322'>2322</a>
<a id='n2323' href='#n2323'>2323</a>
<a id='n2324' href='#n2324'>2324</a>
<a id='n2325' href='#n2325'>2325</a>
<a id='n2326' href='#n2326'>2326</a>
<a id='n2327' href='#n2327'>2327</a>
<a id='n2328' href='#n2328'>2328</a>
<a id='n2329' href='#n2329'>2329</a>
<a id='n2330' href='#n2330'>2330</a>
<a id='n2331' href='#n2331'>2331</a>
<a id='n2332' href='#n2332'>2332</a>
<a id='n2333' href='#n2333'>2333</a>
<a id='n2334' href='#n2334'>2334</a>
<a id='n2335' href='#n2335'>2335</a>
<a id='n2336' href='#n2336'>2336</a>
<a id='n2337' href='#n2337'>2337</a>
<a id='n2338' href='#n2338'>2338</a>
<a id='n2339' href='#n2339'>2339</a>
<a id='n2340' href='#n2340'>2340</a>
<a id='n2341' href='#n2341'>2341</a>
<a id='n2342' href='#n2342'>2342</a>
<a id='n2343' href='#n2343'>2343</a>
<a id='n2344' href='#n2344'>2344</a>
<a id='n2345' href='#n2345'>2345</a>
<a id='n2346' href='#n2346'>2346</a>
<a id='n2347' href='#n2347'>2347</a>
<a id='n2348' href='#n2348'>2348</a>
<a id='n2349' href='#n2349'>2349</a>
<a id='n2350' href='#n2350'>2350</a>
<a id='n2351' href='#n2351'>2351</a>
<a id='n2352' href='#n2352'>2352</a>
<a id='n2353' href='#n2353'>2353</a>
<a id='n2354' href='#n2354'>2354</a>
<a id='n2355' href='#n2355'>2355</a>
<a id='n2356' href='#n2356'>2356</a>
<a id='n2357' href='#n2357'>2357</a>
<a id='n2358' href='#n2358'>2358</a>
<a id='n2359' href='#n2359'>2359</a>
<a id='n2360' href='#n2360'>2360</a>
<a id='n2361' href='#n2361'>2361</a>
<a id='n2362' href='#n2362'>2362</a>
<a id='n2363' href='#n2363'>2363</a>
<a id='n2364' href='#n2364'>2364</a>
<a id='n2365' href='#n2365'>2365</a>
<a id='n2366' href='#n2366'>2366</a>
<a id='n2367' href='#n2367'>2367</a>
<a id='n2368' href='#n2368'>2368</a>
<a id='n2369' href='#n2369'>2369</a>
<a id='n2370' href='#n2370'>2370</a>
<a id='n2371' href='#n2371'>2371</a>
<a id='n2372' href='#n2372'>2372</a>
<a id='n2373' href='#n2373'>2373</a>
<a id='n2374' href='#n2374'>2374</a>
<a id='n2375' href='#n2375'>2375</a>
<a id='n2376' href='#n2376'>2376</a>
<a id='n2377' href='#n2377'>2377</a>
<a id='n2378' href='#n2378'>2378</a>
<a id='n2379' href='#n2379'>2379</a>
<a id='n2380' href='#n2380'>2380</a>
<a id='n2381' href='#n2381'>2381</a>
<a id='n2382' href='#n2382'>2382</a>
<a id='n2383' href='#n2383'>2383</a>
<a id='n2384' href='#n2384'>2384</a>
<a id='n2385' href='#n2385'>2385</a>
<a id='n2386' href='#n2386'>2386</a>
<a id='n2387' href='#n2387'>2387</a>
<a id='n2388' href='#n2388'>2388</a>
<a id='n2389' href='#n2389'>2389</a>
<a id='n2390' href='#n2390'>2390</a>
<a id='n2391' href='#n2391'>2391</a>
<a id='n2392' href='#n2392'>2392</a>
<a id='n2393' href='#n2393'>2393</a>
<a id='n2394' href='#n2394'>2394</a>
<a id='n2395' href='#n2395'>2395</a>
<a id='n2396' href='#n2396'>2396</a>
<a id='n2397' href='#n2397'>2397</a>
<a id='n2398' href='#n2398'>2398</a>
<a id='n2399' href='#n2399'>2399</a>
<a id='n2400' href='#n2400'>2400</a>
<a id='n2401' href='#n2401'>2401</a>
<a id='n2402' href='#n2402'>2402</a>
<a id='n2403' href='#n2403'>2403</a>
<a id='n2404' href='#n2404'>2404</a>
<a id='n2405' href='#n2405'>2405</a>
<a id='n2406' href='#n2406'>2406</a>
<a id='n2407' href='#n2407'>2407</a>
<a id='n2408' href='#n2408'>2408</a>
<a id='n2409' href='#n2409'>2409</a>
<a id='n2410' href='#n2410'>2410</a>
<a id='n2411' href='#n2411'>2411</a>
<a id='n2412' href='#n2412'>2412</a>
<a id='n2413' href='#n2413'>2413</a>
<a id='n2414' href='#n2414'>2414</a>
<a id='n2415' href='#n2415'>2415</a>
<a id='n2416' href='#n2416'>2416</a>
<a id='n2417' href='#n2417'>2417</a>
<a id='n2418' href='#n2418'>2418</a>
<a id='n2419' href='#n2419'>2419</a>
<a id='n2420' href='#n2420'>2420</a>
<a id='n2421' href='#n2421'>2421</a>
<a id='n2422' href='#n2422'>2422</a>
<a id='n2423' href='#n2423'>2423</a>
<a id='n2424' href='#n2424'>2424</a>
<a id='n2425' href='#n2425'>2425</a>
<a id='n2426' href='#n2426'>2426</a>
<a id='n2427' href='#n2427'>2427</a>
<a id='n2428' href='#n2428'>2428</a>
<a id='n2429' href='#n2429'>2429</a>
<a id='n2430' href='#n2430'>2430</a>
<a id='n2431' href='#n2431'>2431</a>
<a id='n2432' href='#n2432'>2432</a>
<a id='n2433' href='#n2433'>2433</a>
<a id='n2434' href='#n2434'>2434</a>
<a id='n2435' href='#n2435'>2435</a>
<a id='n2436' href='#n2436'>2436</a>
<a id='n2437' href='#n2437'>2437</a>
<a id='n2438' href='#n2438'>2438</a>
<a id='n2439' href='#n2439'>2439</a>
<a id='n2440' href='#n2440'>2440</a>
<a id='n2441' href='#n2441'>2441</a>
<a id='n2442' href='#n2442'>2442</a>
<a id='n2443' href='#n2443'>2443</a>
<a id='n2444' href='#n2444'>2444</a>
<a id='n2445' href='#n2445'>2445</a>
<a id='n2446' href='#n2446'>2446</a>
<a id='n2447' href='#n2447'>2447</a>
<a id='n2448' href='#n2448'>2448</a>
<a id='n2449' href='#n2449'>2449</a>
<a id='n2450' href='#n2450'>2450</a>
<a id='n2451' href='#n2451'>2451</a>
<a id='n2452' href='#n2452'>2452</a>
<a id='n2453' href='#n2453'>2453</a>
<a id='n2454' href='#n2454'>2454</a>
<a id='n2455' href='#n2455'>2455</a>
<a id='n2456' href='#n2456'>2456</a>
<a id='n2457' href='#n2457'>2457</a>
<a id='n2458' href='#n2458'>2458</a>
<a id='n2459' href='#n2459'>2459</a>
<a id='n2460' href='#n2460'>2460</a>
<a id='n2461' href='#n2461'>2461</a>
<a id='n2462' href='#n2462'>2462</a>
<a id='n2463' href='#n2463'>2463</a>
<a id='n2464' href='#n2464'>2464</a>
<a id='n2465' href='#n2465'>2465</a>
<a id='n2466' href='#n2466'>2466</a>
<a id='n2467' href='#n2467'>2467</a>
<a id='n2468' href='#n2468'>2468</a>
<a id='n2469' href='#n2469'>2469</a>
<a id='n2470' href='#n2470'>2470</a>
<a id='n2471' href='#n2471'>2471</a>
<a id='n2472' href='#n2472'>2472</a>
<a id='n2473' href='#n2473'>2473</a>
<a id='n2474' href='#n2474'>2474</a>
<a id='n2475' href='#n2475'>2475</a>
<a id='n2476' href='#n2476'>2476</a>
<a id='n2477' href='#n2477'>2477</a>
<a id='n2478' href='#n2478'>2478</a>
<a id='n2479' href='#n2479'>2479</a>
<a id='n2480' href='#n2480'>2480</a>
<a id='n2481' href='#n2481'>2481</a>
<a id='n2482' href='#n2482'>2482</a>
<a id='n2483' href='#n2483'>2483</a>
<a id='n2484' href='#n2484'>2484</a>
<a id='n2485' href='#n2485'>2485</a>
<a id='n2486' href='#n2486'>2486</a>
<a id='n2487' href='#n2487'>2487</a>
<a id='n2488' href='#n2488'>2488</a>
<a id='n2489' href='#n2489'>2489</a>
<a id='n2490' href='#n2490'>2490</a>
<a id='n2491' href='#n2491'>2491</a>
<a id='n2492' href='#n2492'>2492</a>
<a id='n2493' href='#n2493'>2493</a>
<a id='n2494' href='#n2494'>2494</a>
<a id='n2495' href='#n2495'>2495</a>
<a id='n2496' href='#n2496'>2496</a>
<a id='n2497' href='#n2497'>2497</a>
<a id='n2498' href='#n2498'>2498</a>
<a id='n2499' href='#n2499'>2499</a>
<a id='n2500' href='#n2500'>2500</a>
<a id='n2501' href='#n2501'>2501</a>
<a id='n2502' href='#n2502'>2502</a>
<a id='n2503' href='#n2503'>2503</a>
<a id='n2504' href='#n2504'>2504</a>
<a id='n2505' href='#n2505'>2505</a>
<a id='n2506' href='#n2506'>2506</a>
<a id='n2507' href='#n2507'>2507</a>
<a id='n2508' href='#n2508'>2508</a>
<a id='n2509' href='#n2509'>2509</a>
<a id='n2510' href='#n2510'>2510</a>
<a id='n2511' href='#n2511'>2511</a>
<a id='n2512' href='#n2512'>2512</a>
<a id='n2513' href='#n2513'>2513</a>
<a id='n2514' href='#n2514'>2514</a>
<a id='n2515' href='#n2515'>2515</a>
<a id='n2516' href='#n2516'>2516</a>
<a id='n2517' href='#n2517'>2517</a>
<a id='n2518' href='#n2518'>2518</a>
<a id='n2519' href='#n2519'>2519</a>
<a id='n2520' href='#n2520'>2520</a>
<a id='n2521' href='#n2521'>2521</a>
<a id='n2522' href='#n2522'>2522</a>
<a id='n2523' href='#n2523'>2523</a>
<a id='n2524' href='#n2524'>2524</a>
<a id='n2525' href='#n2525'>2525</a>
<a id='n2526' href='#n2526'>2526</a>
<a id='n2527' href='#n2527'>2527</a>
<a id='n2528' href='#n2528'>2528</a>
<a id='n2529' href='#n2529'>2529</a>
<a id='n2530' href='#n2530'>2530</a>
<a id='n2531' href='#n2531'>2531</a>
<a id='n2532' href='#n2532'>2532</a>
<a id='n2533' href='#n2533'>2533</a>
<a id='n2534' href='#n2534'>2534</a>
<a id='n2535' href='#n2535'>2535</a>
<a id='n2536' href='#n2536'>2536</a>
<a id='n2537' href='#n2537'>2537</a>
<a id='n2538' href='#n2538'>2538</a>
<a id='n2539' href='#n2539'>2539</a>
<a id='n2540' href='#n2540'>2540</a>
<a id='n2541' href='#n2541'>2541</a>
<a id='n2542' href='#n2542'>2542</a>
<a id='n2543' href='#n2543'>2543</a>
<a id='n2544' href='#n2544'>2544</a>
<a id='n2545' href='#n2545'>2545</a>
<a id='n2546' href='#n2546'>2546</a>
<a id='n2547' href='#n2547'>2547</a>
<a id='n2548' href='#n2548'>2548</a>
<a id='n2549' href='#n2549'>2549</a>
<a id='n2550' href='#n2550'>2550</a>
<a id='n2551' href='#n2551'>2551</a>
<a id='n2552' href='#n2552'>2552</a>
<a id='n2553' href='#n2553'>2553</a>
<a id='n2554' href='#n2554'>2554</a>
<a id='n2555' href='#n2555'>2555</a>
<a id='n2556' href='#n2556'>2556</a>
<a id='n2557' href='#n2557'>2557</a>
<a id='n2558' href='#n2558'>2558</a>
<a id='n2559' href='#n2559'>2559</a>
<a id='n2560' href='#n2560'>2560</a>
<a id='n2561' href='#n2561'>2561</a>
<a id='n2562' href='#n2562'>2562</a>
<a id='n2563' href='#n2563'>2563</a>
<a id='n2564' href='#n2564'>2564</a>
<a id='n2565' href='#n2565'>2565</a>
<a id='n2566' href='#n2566'>2566</a>
<a id='n2567' href='#n2567'>2567</a>
<a id='n2568' href='#n2568'>2568</a>
<a id='n2569' href='#n2569'>2569</a>
<a id='n2570' href='#n2570'>2570</a>
<a id='n2571' href='#n2571'>2571</a>
<a id='n2572' href='#n2572'>2572</a>
<a id='n2573' href='#n2573'>2573</a>
<a id='n2574' href='#n2574'>2574</a>
<a id='n2575' href='#n2575'>2575</a>
<a id='n2576' href='#n2576'>2576</a>
<a id='n2577' href='#n2577'>2577</a>
<a id='n2578' href='#n2578'>2578</a>
<a id='n2579' href='#n2579'>2579</a>
<a id='n2580' href='#n2580'>2580</a>
<a id='n2581' href='#n2581'>2581</a>
<a id='n2582' href='#n2582'>2582</a>
<a id='n2583' href='#n2583'>2583</a>
<a id='n2584' href='#n2584'>2584</a>
<a id='n2585' href='#n2585'>2585</a>
<a id='n2586' href='#n2586'>2586</a>
<a id='n2587' href='#n2587'>2587</a>
<a id='n2588' href='#n2588'>2588</a>
<a id='n2589' href='#n2589'>2589</a>
<a id='n2590' href='#n2590'>2590</a>
<a id='n2591' href='#n2591'>2591</a>
<a id='n2592' href='#n2592'>2592</a>
<a id='n2593' href='#n2593'>2593</a>
<a id='n2594' href='#n2594'>2594</a>
<a id='n2595' href='#n2595'>2595</a>
<a id='n2596' href='#n2596'>2596</a>
<a id='n2597' href='#n2597'>2597</a>
<a id='n2598' href='#n2598'>2598</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/* SPDX-License-Identifier: GPL-2.0+ */</span>
<span class="hl com">/*******************************************************************************</span>
<span class="hl com"></span>
<span class="hl com"></span>
<span class="hl com">  Copyright(c) 1999 - 2002 Intel Corporation. All rights reserved.</span>
<span class="hl com">  Copyright 2011 Freescale Semiconductor, Inc.</span>
<span class="hl com"></span>
<span class="hl com">  Contact Information:</span>
<span class="hl com">  Linux NICS &lt;linux.nics&#64;intel.com&gt;</span>
<span class="hl com">  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497</span>
<span class="hl com"></span>
<span class="hl com">*******************************************************************************/</span>

<span class="hl com">/* e1000_hw.h</span>
<span class="hl com"> * Structures, enums, and macros for the MAC</span>
<span class="hl com"> */</span>

<span class="hl ppc">#ifndef _E1000_HW_H_</span>
<span class="hl ppc">#define _E1000_HW_H_</span>

<span class="hl ppc">#include &lt;linux/list.h&gt;</span>
<span class="hl ppc">#include &lt;malloc.h&gt;</span>
<span class="hl ppc">#include &lt;net.h&gt;</span>
<span class="hl com">/* Avoids a compile error since struct eth_device is not defined */</span>
<span class="hl ppc">#ifndef CONFIG_DM_ETH</span>
<span class="hl ppc">#include &lt;netdev.h&gt;</span>
<span class="hl ppc">#endif</span>
<span class="hl ppc">#include &lt;asm/io.h&gt;</span>
<span class="hl ppc">#include &lt;pci.h&gt;</span>

<span class="hl ppc">#ifdef CONFIG_E1000_SPI</span>
<span class="hl ppc">#include &lt;spi.h&gt;</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#define E1000_ERR(NIC, fmt, args...) \</span>
<span class="hl ppc">	printf(</span><span class="hl pps">&quot;e1000:</span> <span class="hl ipl">%s</span><span class="hl pps">: ERROR: &quot;</span><span class="hl ppc"> fmt, (NIC)-&gt;name ,##args)</span>

<span class="hl ppc">#ifdef E1000_DEBUG</span>
<span class="hl ppc">#define E1000_DBG(NIC, fmt, args...) \</span>
<span class="hl ppc">	printf(</span><span class="hl pps">&quot;e1000:</span> <span class="hl ipl">%s</span><span class="hl pps">: DEBUG: &quot;</span><span class="hl ppc"> fmt, (NIC)-&gt;name ,##args)</span>
<span class="hl ppc">#define DEBUGOUT(fmt, args...)	printf(fmt ,##args)</span>
<span class="hl ppc">#define DEBUGFUNC()		printf(</span><span class="hl pps">&quot;</span><span class="hl ipl">%s</span><span class="hl pps"></span><span class="hl esc">\n</span><span class="hl pps">&quot;</span><span class="hl ppc">, __func__);</span>
<span class="hl ppc">#else</span>
<span class="hl ppc">#define E1000_DBG(HW, args...)	do { } while (0)</span>
<span class="hl ppc">#define DEBUGFUNC()		do { } while (0)</span>
<span class="hl ppc">#define DEBUGOUT(fmt, args...)	do { } while (0)</span>
<span class="hl ppc">#endif</span>

<span class="hl com">/* I/O wrapper functions */</span>
<span class="hl ppc">#define E1000_WRITE_REG(a, reg, value) \</span>
<span class="hl ppc">	writel((value), ((a)-&gt;hw_addr + E1000_##reg))</span>
<span class="hl ppc">#define E1000_READ_REG(a, reg) \</span>
<span class="hl ppc">	readl((a)-&gt;hw_addr + E1000_##reg)</span>
<span class="hl ppc">#define E1000_WRITE_REG_ARRAY(a, reg, offset, value) \</span>
<span class="hl ppc">	writel((value), ((a)-&gt;hw_addr + E1000_##reg + ((offset) &lt;&lt; 2)))</span>
<span class="hl ppc">#define E1000_READ_REG_ARRAY(a, reg, offset) \</span>
<span class="hl ppc">	readl((a)-&gt;hw_addr + E1000_##reg + ((offset) &lt;&lt; 2))</span>
<span class="hl ppc">#define E1000_WRITE_FLUSH(a) \</span>
<span class="hl ppc">	do { E1000_READ_REG(a, STATUS); } while (0)</span>

<span class="hl com">/* Forward declarations of structures used by the shared code */</span>
<span class="hl kwb">struct</span> e1000_hw<span class="hl opt">;</span>
<span class="hl kwb">struct</span> e1000_hw_stats<span class="hl opt">;</span>

<span class="hl com">/* Internal E1000 helper functions */</span>
<span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span><span class="hl kwd">e1000_find_card</span><span class="hl opt">(</span><span class="hl kwb">unsigned int</span> cardnum<span class="hl opt">);</span>

<span class="hl ppc">#ifndef CONFIG_E1000_NO_NVM</span>
<span class="hl kwb">int32_t</span> <span class="hl kwd">e1000_acquire_eeprom</span><span class="hl opt">(</span><span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span>hw<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl kwd">e1000_standby_eeprom</span><span class="hl opt">(</span><span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span>hw<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl kwd">e1000_release_eeprom</span><span class="hl opt">(</span><span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span>hw<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl kwd">e1000_raise_ee_clk</span><span class="hl opt">(</span><span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span>hw<span class="hl opt">,</span> <span class="hl kwb">uint32_t</span> <span class="hl opt">*</span>eecd<span class="hl opt">);</span>
<span class="hl kwb">void</span> <span class="hl kwd">e1000_lower_ee_clk</span><span class="hl opt">(</span><span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span>hw<span class="hl opt">,</span> <span class="hl kwb">uint32_t</span> <span class="hl opt">*</span>eecd<span class="hl opt">);</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifdef CONFIG_E1000_SPI</span>
<span class="hl kwb">int</span> <span class="hl kwd">do_e1000_spi</span><span class="hl opt">(</span><span class="hl kwb">struct</span> cmd_tbl <span class="hl opt">*</span>cmdtp<span class="hl opt">,</span> <span class="hl kwb">struct</span> e1000_hw <span class="hl opt">*</span>hw<span class="hl opt">,</span>
		 <span class="hl kwb">int</span> argc<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span><span class="hl kwb">const</span> argv<span class="hl opt">[]);</span>
<span class="hl ppc">#endif</span>

<span class="hl com">/* Enumerated types specific to the e1000 hardware */</span>
<span class="hl com">/* Media Access Controlers */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_undefined <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_82542_rev2_0<span class="hl opt">,</span>
	e1000_82542_rev2_1<span class="hl opt">,</span>
	e1000_82543<span class="hl opt">,</span>
	e1000_82544<span class="hl opt">,</span>
	e1000_82540<span class="hl opt">,</span>
	e1000_82545<span class="hl opt">,</span>
	e1000_82545_rev_3<span class="hl opt">,</span>
	e1000_82546<span class="hl opt">,</span>
	e1000_82546_rev_3<span class="hl opt">,</span>
	e1000_82541<span class="hl opt">,</span>
	e1000_82541_rev_2<span class="hl opt">,</span>
	e1000_82547<span class="hl opt">,</span>
	e1000_82547_rev_2<span class="hl opt">,</span>
	e1000_82571<span class="hl opt">,</span>
	e1000_82572<span class="hl opt">,</span>
	e1000_82573<span class="hl opt">,</span>
	e1000_82574<span class="hl opt">,</span>
	e1000_80003es2lan<span class="hl opt">,</span>
	e1000_ich8lan<span class="hl opt">,</span>
	e1000_igb<span class="hl opt">,</span>
	e1000_num_macs
<span class="hl opt">}</span> e1000_mac_type<span class="hl opt">;</span>

<span class="hl com">/* Media Types */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_media_type_copper <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_media_type_fiber <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">,</span>
	e1000_media_type_internal_serdes <span class="hl opt">=</span> <span class="hl num">2</span><span class="hl opt">,</span>
	e1000_num_media_types
<span class="hl opt">}</span> e1000_media_type<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_eeprom_uninitialized <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_eeprom_spi<span class="hl opt">,</span>
	e1000_eeprom_microwire<span class="hl opt">,</span>
	e1000_eeprom_flash<span class="hl opt">,</span>
	e1000_eeprom_ich8<span class="hl opt">,</span>
	e1000_eeprom_none<span class="hl opt">,</span> <span class="hl com">/* No NVM support */</span>
	e1000_eeprom_invm<span class="hl opt">,</span>
	e1000_num_eeprom_types
<span class="hl opt">}</span> e1000_eeprom_type<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_10_half <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_10_full <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">,</span>
	e1000_100_half <span class="hl opt">=</span> <span class="hl num">2</span><span class="hl opt">,</span>
	e1000_100_full <span class="hl opt">=</span> <span class="hl num">3</span>
<span class="hl opt">}</span> e1000_speed_duplex_type<span class="hl opt">;</span>

<span class="hl com">/* Flow Control Settings */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_fc_none <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_fc_rx_pause <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">,</span>
	e1000_fc_tx_pause <span class="hl opt">=</span> <span class="hl num">2</span><span class="hl opt">,</span>
	e1000_fc_full <span class="hl opt">=</span> <span class="hl num">3</span><span class="hl opt">,</span>
	e1000_fc_default <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_fc_type<span class="hl opt">;</span>

<span class="hl com">/* PCI bus types */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_bus_type_unknown <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_bus_type_pci<span class="hl opt">,</span>
	e1000_bus_type_pcix<span class="hl opt">,</span>
	e1000_bus_type_pci_express<span class="hl opt">,</span>
	e1000_bus_type_reserved
<span class="hl opt">}</span> e1000_bus_type<span class="hl opt">;</span>

<span class="hl com">/* PCI bus speeds */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_bus_speed_unknown <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_bus_speed_33<span class="hl opt">,</span>
	e1000_bus_speed_66<span class="hl opt">,</span>
	e1000_bus_speed_100<span class="hl opt">,</span>
	e1000_bus_speed_133<span class="hl opt">,</span>
	e1000_bus_speed_reserved
<span class="hl opt">}</span> e1000_bus_speed<span class="hl opt">;</span>

<span class="hl com">/* PCI bus widths */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_bus_width_unknown <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_bus_width_32<span class="hl opt">,</span>
	e1000_bus_width_64
<span class="hl opt">}</span> e1000_bus_width<span class="hl opt">;</span>

<span class="hl com">/* PHY status info structure and supporting enums */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_cable_length_50 <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_cable_length_50_80<span class="hl opt">,</span>
	e1000_cable_length_80_110<span class="hl opt">,</span>
	e1000_cable_length_110_140<span class="hl opt">,</span>
	e1000_cable_length_140<span class="hl opt">,</span>
	e1000_cable_length_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_cable_length<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_10bt_ext_dist_enable_normal <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_10bt_ext_dist_enable_lower<span class="hl opt">,</span>
	e1000_10bt_ext_dist_enable_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_10bt_ext_dist_enable<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_rev_polarity_normal <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_rev_polarity_reversed<span class="hl opt">,</span>
	e1000_rev_polarity_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_rev_polarity<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_polarity_reversal_enabled <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_polarity_reversal_disabled<span class="hl opt">,</span>
	e1000_polarity_reversal_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_polarity_reversal<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_auto_x_mode_manual_mdi <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_auto_x_mode_manual_mdix<span class="hl opt">,</span>
	e1000_auto_x_mode_auto1<span class="hl opt">,</span>
	e1000_auto_x_mode_auto2<span class="hl opt">,</span>
	e1000_auto_x_mode_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_auto_x_mode<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_1000t_rx_status_not_ok <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_1000t_rx_status_ok<span class="hl opt">,</span>
	e1000_1000t_rx_status_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_1000t_rx_status<span class="hl opt">;</span>

<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
	e1000_phy_m88 <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">,</span>
	e1000_phy_igp<span class="hl opt">,</span>
	e1000_phy_igp_2<span class="hl opt">,</span>
	e1000_phy_gg82563<span class="hl opt">,</span>
	e1000_phy_igp_3<span class="hl opt">,</span>
	e1000_phy_ife<span class="hl opt">,</span>
	e1000_phy_igb<span class="hl opt">,</span>
	e1000_phy_bm<span class="hl opt">,</span>
	e1000_phy_undefined <span class="hl opt">=</span> <span class="hl num">0xFF</span>
<span class="hl opt">}</span> e1000_phy_type<span class="hl opt">;</span>

<span class="hl kwb">struct</span> e1000_phy_info <span class="hl opt">{</span>
	e1000_cable_length cable_length<span class="hl opt">;</span>
	e1000_10bt_ext_dist_enable extended_10bt_distance<span class="hl opt">;</span>
	e1000_rev_polarity cable_polarity<span class="hl opt">;</span>
	e1000_polarity_reversal polarity_correction<span class="hl opt">;</span>
	e1000_auto_x_mode mdix_mode<span class="hl opt">;</span>
	e1000_1000t_rx_status local_rx<span class="hl opt">;</span>
	e1000_1000t_rx_status remote_rx<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl kwb">struct</span> e1000_phy_stats <span class="hl opt">{</span>
	<span class="hl kwb">uint32_t</span> idle_errors<span class="hl opt">;</span>
	<span class="hl kwb">uint32_t</span> receive_errors<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl com">/* Error Codes */</span>
<span class="hl ppc">#define E1000_SUCCESS				0</span>
<span class="hl ppc">#define E1000_ERR_EEPROM			1</span>
<span class="hl ppc">#define E1000_ERR_PHY				2</span>
<span class="hl ppc">#define E1000_ERR_CONFIG			3</span>
<span class="hl ppc">#define E1000_ERR_PARAM				4</span>
<span class="hl ppc">#define E1000_ERR_MAC_TYPE			5</span>
<span class="hl ppc">#define E1000_ERR_PHY_TYPE			6</span>
<span class="hl ppc">#define E1000_ERR_NOLINK			7</span>
<span class="hl ppc">#define E1000_ERR_TIMEOUT			8</span>
<span class="hl ppc">#define E1000_ERR_RESET				9</span>
<span class="hl ppc">#define E1000_ERR_MASTER_REQUESTS_PENDING	10</span>
<span class="hl ppc">#define E1000_ERR_HOST_INTERFACE_COMMAND	11</span>
<span class="hl ppc">#define E1000_BLK_PHY_RESET			12</span>
<span class="hl ppc">#define E1000_ERR_SWFW_SYNC 			13</span>

<span class="hl com">/* PCI Device IDs */</span>
<span class="hl ppc">#define E1000_DEV_ID_82542	    0x1000</span>
<span class="hl ppc">#define E1000_DEV_ID_82543GC_FIBER  0x1001</span>
<span class="hl ppc">#define E1000_DEV_ID_82543GC_COPPER 0x1004</span>
<span class="hl ppc">#define E1000_DEV_ID_82544EI_COPPER 0x1008</span>
<span class="hl ppc">#define E1000_DEV_ID_82544EI_FIBER  0x1009</span>
<span class="hl ppc">#define E1000_DEV_ID_82544GC_COPPER 0x100C</span>
<span class="hl ppc">#define E1000_DEV_ID_82544GC_LOM    0x100D</span>
<span class="hl ppc">#define E1000_DEV_ID_82540EM	    0x100E</span>
<span class="hl ppc">#define E1000_DEV_ID_82540EM_LOM         0x1015</span>
<span class="hl ppc">#define E1000_DEV_ID_82540EP_LOM         0x1016</span>
<span class="hl ppc">#define E1000_DEV_ID_82540EP             0x1017</span>
<span class="hl ppc">#define E1000_DEV_ID_82540EP_LP          0x101E</span>
<span class="hl ppc">#define E1000_DEV_ID_82545EM_COPPER      0x100F</span>
<span class="hl ppc">#define E1000_DEV_ID_82545EM_FIBER       0x1011</span>
<span class="hl ppc">#define E1000_DEV_ID_82545GM_COPPER      0x1026</span>
<span class="hl ppc">#define E1000_DEV_ID_82545GM_FIBER       0x1027</span>
<span class="hl ppc">#define E1000_DEV_ID_82545GM_SERDES      0x1028</span>
<span class="hl ppc">#define E1000_DEV_ID_82546EB_COPPER      0x1010</span>
<span class="hl ppc">#define E1000_DEV_ID_82546EB_FIBER       0x1012</span>
<span class="hl ppc">#define E1000_DEV_ID_82546EB_QUAD_COPPER 0x101D</span>
<span class="hl ppc">#define E1000_DEV_ID_82541EI             0x1013</span>
<span class="hl ppc">#define E1000_DEV_ID_82541EI_MOBILE      0x1018</span>
<span class="hl ppc">#define E1000_DEV_ID_82541ER_LOM         0x1014</span>
<span class="hl ppc">#define E1000_DEV_ID_82541ER             0x1078</span>
<span class="hl ppc">#define E1000_DEV_ID_82547GI             0x1075</span>
<span class="hl ppc">#define E1000_DEV_ID_82541GI             0x1076</span>
<span class="hl ppc">#define E1000_DEV_ID_82541GI_MOBILE      0x1077</span>
<span class="hl ppc">#define E1000_DEV_ID_82541GI_LF          0x107C</span>
<span class="hl ppc">#define E1000_DEV_ID_82546GB_COPPER      0x1079</span>
<span class="hl ppc">#define E1000_DEV_ID_82546GB_FIBER       0x107A</span>
<span class="hl ppc">#define E1000_DEV_ID_82546GB_SERDES      0x107B</span>
<span class="hl ppc">#define E1000_DEV_ID_82546GB_PCIE        0x108A</span>
<span class="hl ppc">#define E1000_DEV_ID_82546GB_QUAD_COPPER 0x1099</span>
<span class="hl ppc">#define E1000_DEV_ID_82547EI             0x1019</span>
<span class="hl ppc">#define E1000_DEV_ID_82547EI_MOBILE      0x101A</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_COPPER      0x105E</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_FIBER       0x105F</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_SERDES      0x1060</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_QUAD_COPPER 0x10A4</span>
<span class="hl ppc">#define E1000_DEV_ID_82571PT_QUAD_COPPER 0x10D5</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_QUAD_FIBER  0x10A5</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE  0x10BC</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_SERDES_DUAL 0x10D9</span>
<span class="hl ppc">#define E1000_DEV_ID_82571EB_SERDES_QUAD 0x10DA</span>
<span class="hl ppc">#define E1000_DEV_ID_82572EI_COPPER      0x107D</span>
<span class="hl ppc">#define E1000_DEV_ID_82572EI_FIBER       0x107E</span>
<span class="hl ppc">#define E1000_DEV_ID_82572EI_SERDES      0x107F</span>
<span class="hl ppc">#define E1000_DEV_ID_82572EI             0x10B9</span>
<span class="hl ppc">#define E1000_DEV_ID_82573E              0x108B</span>
<span class="hl ppc">#define E1000_DEV_ID_82573E_IAMT         0x108C</span>
<span class="hl ppc">#define E1000_DEV_ID_82573L              0x109A</span>
<span class="hl ppc">#define E1000_DEV_ID_82574L              0x10D3</span>
<span class="hl ppc">#define E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3 0x10B5</span>
<span class="hl ppc">#define E1000_DEV_ID_80003ES2LAN_COPPER_DPT     0x1096</span>
<span class="hl ppc">#define E1000_DEV_ID_80003ES2LAN_SERDES_DPT     0x1098</span>
<span class="hl ppc">#define E1000_DEV_ID_80003ES2LAN_COPPER_SPT     0x10BA</span>
<span class="hl ppc">#define E1000_DEV_ID_80003ES2LAN_SERDES_SPT     0x10BB</span>

<span class="hl ppc">#define E1000_DEV_ID_ICH8_IGP_M_AMT      0x1049</span>
<span class="hl ppc">#define E1000_DEV_ID_ICH8_IGP_AMT        0x104A</span>
<span class="hl ppc">#define E1000_DEV_ID_ICH8_IGP_C          0x104B</span>
<span class="hl ppc">#define E1000_DEV_ID_ICH8_IFE            0x104C</span>
<span class="hl ppc">#define E1000_DEV_ID_ICH8_IFE_GT         0x10C4</span>
<span class="hl ppc">#define E1000_DEV_ID_ICH8_IFE_G          0x10C5</span>
<span class="hl ppc">#define E1000_DEV_ID_ICH8_IGP_M          0x104D</span>

<span class="hl ppc">#define IGP03E1000_E_PHY_ID  0x02A80390</span>
<span class="hl ppc">#define IFE_E_PHY_ID         0x02A80330</span> <span class="hl com">/* 10/100 PHY */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PLUS_E_PHY_ID    0x02A80320</span>
<span class="hl ppc">#define IFE_C_E_PHY_ID       0x02A80310</span>

<span class="hl ppc">#define IFE_PHY_EXTENDED_STATUS_CONTROL   0x10</span>  <span class="hl com">/* 100BaseTx Extended Status,</span>
<span class="hl com">						   Control and Address */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_SPECIAL_CONTROL           0x11</span>  <span class="hl com">/* 100BaseTx PHY special</span>
<span class="hl com">						   control register */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_RCV_FALSE_CARRIER         0x13</span>  <span class="hl com">/* 100BaseTx Receive false</span>
<span class="hl com">						   Carrier Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_RCV_DISCONNECT            0x14</span>  <span class="hl com">/* 100BaseTx Receive Disconnet</span>
<span class="hl com">						   Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_RCV_ERROT_FRAME           0x15</span>  <span class="hl com">/* 100BaseTx Receive Error</span>
<span class="hl com">						   Frame Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_RCV_SYMBOL_ERR            0x16</span>  <span class="hl com">/* Receive Symbol Error</span>
<span class="hl com">						   Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_PREM_EOF_ERR              0x17</span>  <span class="hl com">/* 100BaseTx Receive</span>
<span class="hl com">						   Premature End Of Frame</span>
<span class="hl com">						   Error Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_RCV_EOF_ERR               0x18</span>  <span class="hl com">/* 10BaseT Receive End Of</span>
<span class="hl com">						   Frame Error Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_TX_JABBER_DETECT          0x19</span>  <span class="hl com">/* 10BaseT Transmit Jabber</span>
<span class="hl com">						   Detect Counter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_EQUALIZER                 0x1A</span>  <span class="hl com">/* PHY Equalizer Control and</span>
<span class="hl com">						   Status */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_SPECIAL_CONTROL_LED       0x1B</span>  <span class="hl com">/* PHY special control and</span>
<span class="hl com">						   LED configuration */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_MDIX_CONTROL              0x1C</span>  <span class="hl com">/* MDI/MDI-X Control register */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHY_HWI_CONTROL               0x1D</span>  <span class="hl com">/* Hardware Integrity Control</span>
<span class="hl com">						   (HWI) */</span><span class="hl ppc"></span>

<span class="hl ppc">#define IFE_PESC_REDUCED_POWER_DOWN_DISABLE  0x2000</span>  <span class="hl com">/* Defaut 1 = Disable auto</span>
<span class="hl com">							reduced power down */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_100BTX_POWER_DOWN           0x0400</span>  <span class="hl com">/* Indicates the power</span>
<span class="hl com">							state of 100BASE-TX */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_10BTX_POWER_DOWN            0x0200</span>  <span class="hl com">/* Indicates the power</span>
<span class="hl com">							state of 10BASE-T */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_POLARITY_REVERSED           0x0100</span>  <span class="hl com">/* Indicates 10BASE-T</span>
<span class="hl com">							polarity */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_PHY_ADDR_MASK               0x007C</span>  <span class="hl com">/* Bit 6:2 for sampled PHY</span>
<span class="hl com">							address */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_SPEED                       0x0002</span>  <span class="hl com">/* Auto-negotiation speed</span>
<span class="hl com">						result 1=100Mbs, 0=10Mbs */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_DUPLEX                      0x0001</span>  <span class="hl com">/* Auto-negotiation</span>
<span class="hl com">						duplex result 1=Full, 0=Half */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PESC_POLARITY_REVERSED_SHIFT     8</span>

<span class="hl ppc">#define IFE_PSC_DISABLE_DYNAMIC_POWER_DOWN   0x0100</span>  <span class="hl com">/* 1 = Dyanmic Power Down</span>
<span class="hl com">							disabled */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSC_FORCE_POLARITY               0x0020</span>  <span class="hl com">/* 1=Reversed Polarity,</span>
<span class="hl com">							0=Normal */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSC_AUTO_POLARITY_DISABLE        0x0010</span>  <span class="hl com">/* 1=Auto Polarity</span>
<span class="hl com">							Disabled, 0=Enabled */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSC_JABBER_FUNC_DISABLE          0x0001</span>  <span class="hl com">/* 1=Jabber Disabled,</span>
<span class="hl com">						0=Normal Jabber Operation */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSC_FORCE_POLARITY_SHIFT         5</span>
<span class="hl ppc">#define IFE_PSC_AUTO_POLARITY_DISABLE_SHIFT  4</span>

<span class="hl ppc">#define IFE_PMC_AUTO_MDIX                    0x0080</span>  <span class="hl com">/* 1=enable MDI/MDI-X</span>
<span class="hl com">						feature, default 0=disabled */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PMC_FORCE_MDIX                   0x0040</span>  <span class="hl com">/* 1=force MDIX-X,</span>
<span class="hl com">							0=force MDI */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PMC_MDIX_STATUS                  0x0020</span>  <span class="hl com">/* 1=MDI-X, 0=MDI */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PMC_AUTO_MDIX_COMPLETE           0x0010</span>  <span class="hl com">/* Resolution algorithm</span>
<span class="hl com">							is completed */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PMC_MDIX_MODE_SHIFT              6</span>
<span class="hl ppc">#define IFE_PHC_MDIX_RESET_ALL_MASK          0x0000</span>  <span class="hl com">/* Disable auto MDI-X */</span><span class="hl ppc"></span>

<span class="hl ppc">#define IFE_PHC_HWI_ENABLE                   0x8000</span>  <span class="hl com">/* Enable the HWI</span>
<span class="hl com">							feature */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_ABILITY_CHECK                0x4000</span>  <span class="hl com">/* 1= Test Passed,</span>
<span class="hl com">							0=failed */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_TEST_EXEC                    0x2000</span>  <span class="hl com">/* PHY launch test pulses</span>
<span class="hl com">							on the wire */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_HIGHZ                        0x0200</span>  <span class="hl com">/* 1 = Open Circuit */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_LOWZ                         0x0400</span>  <span class="hl com">/* 1 = Short Circuit */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_LOW_HIGH_Z_MASK              0x0600</span>  <span class="hl com">/* Mask for indication</span>
<span class="hl com">						type of problem on the line */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_DISTANCE_MASK                0x01FF</span>  <span class="hl com">/* Mask for distance to</span>
<span class="hl com">				the cable problem, in 80cm granularity */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PHC_RESET_ALL_MASK               0x0000</span>  <span class="hl com">/* Disable HWI */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSCL_PROBE_MODE                  0x0020</span>  <span class="hl com">/* LED Probe mode */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSCL_PROBE_LEDS_OFF              0x0006</span>  <span class="hl com">/* Force LEDs 0 and 2</span>
<span class="hl com">							off */</span><span class="hl ppc"></span>
<span class="hl ppc">#define IFE_PSCL_PROBE_LEDS_ON               0x0007</span>  <span class="hl com">/* Force LEDs 0 and 2 on */</span><span class="hl ppc"></span>


<span class="hl ppc">#define NUM_DEV_IDS 16</span>

<span class="hl ppc">#define NODE_ADDRESS_SIZE 6</span>
<span class="hl ppc">#define ETH_LENGTH_OF_ADDRESS 6</span>

<span class="hl com">/* MAC decode size is 128K - This is the size of BAR0 */</span>
<span class="hl ppc">#define MAC_DECODE_SIZE (128 * 1024)</span>

<span class="hl ppc">#define E1000_82542_2_0_REV_ID 2</span>
<span class="hl ppc">#define E1000_82542_2_1_REV_ID 3</span>
<span class="hl ppc">#define E1000_REVISION_0       0</span>
<span class="hl ppc">#define E1000_REVISION_1       1</span>
<span class="hl ppc">#define E1000_REVISION_2       2</span>
<span class="hl ppc">#define E1000_REVISION_3       3</span>

<span class="hl ppc">#define SPEED_10    10</span>
<span class="hl ppc">#define SPEED_100   100</span>
<span class="hl ppc">#define SPEED_1000  1000</span>
<span class="hl ppc">#define HALF_DUPLEX 1</span>
<span class="hl ppc">#define FULL_DUPLEX 2</span>

<span class="hl com">/* The sizes (in bytes) of a ethernet packet */</span>
<span class="hl ppc">#define ENET_HEADER_SIZE	     14</span>
<span class="hl ppc">#define MAXIMUM_ETHERNET_FRAME_SIZE  1518</span>	<span class="hl com">/* With FCS */</span><span class="hl ppc"></span>
<span class="hl ppc">#define MINIMUM_ETHERNET_FRAME_SIZE  64</span>	<span class="hl com">/* With FCS */</span><span class="hl ppc"></span>
<span class="hl ppc">#define MAXIMUM_ETHERNET_PACKET_SIZE \</span>
<span class="hl ppc">	(MAXIMUM_ETHERNET_FRAME_SIZE - ETH_FCS_LEN)</span>
<span class="hl ppc">#define MINIMUM_ETHERNET_PACKET_SIZE \</span>
<span class="hl ppc">	(MINIMUM_ETHERNET_FRAME_SIZE - ETH_FCS_LEN)</span>
<span class="hl ppc">#define CRC_LENGTH		     ETH_FCS_LEN</span>
<span class="hl ppc">#define MAX_JUMBO_FRAME_SIZE	     0x3F00</span>

<span class="hl com">/* 802.1q VLAN Packet Sizes */</span>
<span class="hl ppc">#define VLAN_TAG_SIZE			  4</span>	<span class="hl com">/* 802.3ac tag (not DMAed) */</span><span class="hl ppc"></span>

<span class="hl com">/* Ethertype field values */</span>
<span class="hl ppc">#define ETHERNET_IEEE_VLAN_TYPE 0x8100</span>	<span class="hl com">/* 802.3ac packet */</span><span class="hl ppc"></span>
<span class="hl ppc">#define ETHERNET_IP_TYPE	0x0800</span>	<span class="hl com">/* IP packets */</span><span class="hl ppc"></span>
<span class="hl ppc">#define ETHERNET_ARP_TYPE	0x0806</span>	<span class="hl com">/* Address Resolution Protocol (ARP) */</span><span class="hl ppc"></span>

<span class="hl com">/* Packet Header defines */</span>
<span class="hl ppc">#define IP_PROTOCOL_TCP    6</span>
<span class="hl ppc">#define IP_PROTOCOL_UDP    0x11</span>

<span class="hl com">/* This defines the bits that are set in the Interrupt Mask</span>
<span class="hl com"> * Set/Read Register.  Each bit is documented below:</span>
<span class="hl com"> *   o RXDMT0 = Receive Descriptor Minimum Threshold hit (ring 0)</span>
<span class="hl com"> *   o RXSEQ  = Receive Sequence Error</span>
<span class="hl com"> */</span>
<span class="hl ppc">#define POLL_IMS_ENABLE_MASK ( \</span>
<span class="hl ppc">    E1000_IMS_RXDMT0 |	       \</span>
<span class="hl ppc">    E1000_IMS_RXSEQ)</span>

<span class="hl com">/* This defines the bits that are set in the Interrupt Mask</span>
<span class="hl com"> * Set/Read Register.  Each bit is documented below:</span>
<span class="hl com"> *   o RXT0   = Receiver Timer Interrupt (ring 0)</span>
<span class="hl com"> *   o TXDW   = Transmit Descriptor Written Back</span>
<span class="hl com"> *   o RXDMT0 = Receive Descriptor Minimum Threshold hit (ring 0)</span>
<span class="hl com"> *   o RXSEQ  = Receive Sequence Error</span>
<span class="hl com"> *   o LSC    = Link Status Change</span>
<span class="hl com"> */</span>
<span class="hl ppc">#define IMS_ENABLE_MASK ( \</span>
<span class="hl ppc">    E1000_IMS_RXT0   |	  \</span>
<span class="hl ppc">    E1000_IMS_TXDW   |	  \</span>
<span class="hl ppc">    E1000_IMS_RXDMT0 |	  \</span>
<span class="hl ppc">    E1000_IMS_RXSEQ  |	  \</span>
<span class="hl ppc">    E1000_IMS_LSC)</span>

<span class="hl com">/* The number of high/low register pairs in the RAR. The RAR (Receive Address</span>
<span class="hl com"> * Registers) holds the directed and multicast addresses that we monitor. We</span>
<span class="hl com"> * reserve one of these spots for our directed address, allowing us room for</span>
<span class="hl com"> * E1000_RAR_ENTRIES - 1 multicast addresses.</span>
<span class="hl com"> */</span>
<span class="hl ppc">#define E1000_RAR_ENTRIES 16</span>

<span class="hl ppc">#define MIN_NUMBER_OF_DESCRIPTORS 8</span>
<span class="hl ppc">#define MAX_NUMBER_OF_DESCRIPTORS 0xFFF8</span>

<span class="hl com">/* Receive Descriptor */</span>
<span class="hl kwb">struct</span> e1000_rx_desc <span class="hl opt">{</span>
	<span class="hl kwb">uint64_t</span> buffer_addr<span class="hl opt">;</span>	<span class="hl com">/* Address of the descriptor&#39;s data buffer */</span>
	<span class="hl kwb">uint16_t</span> length<span class="hl opt">;</span>	<span class="hl com">/* Length of data DMAed into data buffer */</span>
	<span class="hl kwb">uint16_t</span> csum<span class="hl opt">;</span>		<span class="hl com">/* Packet checksum */</span>
	<span class="hl kwb">uint8_t</span> status<span class="hl opt">;</span>		<span class="hl com">/* Descriptor status */</span>
	<span class="hl kwb">uint8_t</span> errors<span class="hl opt">;</span>		<span class="hl com">/* Descriptor Errors */</span>
	<span class="hl kwb">uint16_t</span> special<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl com">/* Receive Decriptor bit definitions */</span>
<span class="hl ppc">#define E1000_RXD_STAT_DD	0x01</span>	<span class="hl com">/* Descriptor Done */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_STAT_EOP	0x02</span>	<span class="hl com">/* End of Packet */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_STAT_IXSM	0x04</span>	<span class="hl com">/* Ignore checksum */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_STAT_VP	0x08</span>	<span class="hl com">/* IEEE VLAN Packet */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_STAT_TCPCS	0x20</span>	<span class="hl com">/* TCP xsum calculated */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_STAT_IPCS	0x40</span>	<span class="hl com">/* IP xsum calculated */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_STAT_PIF	0x80</span>	<span class="hl com">/* passed in-exact filter */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_CE	0x01</span>	<span class="hl com">/* CRC Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_SE	0x02</span>	<span class="hl com">/* Symbol Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_SEQ	0x04</span>	<span class="hl com">/* Sequence Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_CXE	0x10</span>	<span class="hl com">/* Carrier Extension Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_TCPE	0x20</span>	<span class="hl com">/* TCP/UDP Checksum Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_IPE	0x40</span>	<span class="hl com">/* IP Checksum Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_ERR_RXE	0x80</span>	<span class="hl com">/* Rx Data Error */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_SPC_VLAN_MASK 0x0FFF</span>	<span class="hl com">/* VLAN ID is in lower 12 bits */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_SPC_PRI_MASK	0xE000</span>	<span class="hl com">/* Priority is in upper 3 bits */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_SPC_PRI_SHIFT 0x000D</span>	<span class="hl com">/* Priority is in upper 3 of 16 */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_SPC_CFI_MASK	0x1000</span>	<span class="hl com">/* CFI is bit 12 */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_RXD_SPC_CFI_SHIFT 0x000C</span>	<span class="hl com">/* CFI is bit 12 */</span><span class="hl ppc"></span>

<span class="hl com">/* mask to determine if packets should be dropped due to frame errors */</span>
<span class="hl ppc">#define E1000_RXD_ERR_FRAME_ERR_MASK ( \</span>
<span class="hl ppc">    E1000_RXD_ERR_CE  |		       \</span>
<span class="hl ppc">    E1000_RXD_ERR_SE  |		       \</span>
<span class="hl ppc">    E1000_RXD_ERR_SEQ |		       \</span>
<span class="hl ppc">    E1000_RXD_ERR_CXE |		       \</span>
<span class="hl ppc">    E1000_RXD_ERR_RXE)</span>

<span class="hl com">/* Transmit Descriptor */</span>
<span class="hl kwb">struct</span> e1000_tx_desc <span class="hl opt">{</span>
	<span class="hl kwb">uint64_t</span> buffer_addr<span class="hl opt">;</span>	<span class="hl com">/* Address of the descriptor&#39;s data buffer */</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> data<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint16_t</span> length<span class="hl opt">;</span>	<span class="hl com">/* Data buffer length */</span>
			<span class="hl kwb">uint8_t</span> cso<span class="hl opt">;</span>	<span class="hl com">/* Checksum offset */</span>
			<span class="hl kwb">uint8_t</span> cmd<span class="hl opt">;</span>	<span class="hl com">/* Descriptor control */</span>
		<span class="hl opt">}</span> flags<span class="hl opt">;</span>
	<span class="hl opt">}</span> lower<span class="hl opt">;</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> data<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint8_t</span> status<span class="hl opt">;</span>	<span class="hl com">/* Descriptor status */</span>
			<span class="hl kwb">uint8_t</span> css<span class="hl opt">;</span>	<span class="hl com">/* Checksum start */</span>
			<span class="hl kwb">uint16_t</span> special<span class="hl opt">;</span>
		<span class="hl opt">}</span> fields<span class="hl opt">;</span>
	<span class="hl opt">}</span> upper<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl com">/* Transmit Descriptor bit definitions */</span>
<span class="hl ppc">#define E1000_TXD_DTYP_D     0x00100000</span>	<span class="hl com">/* Data Descriptor */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_DTYP_C     0x00000000</span>	<span class="hl com">/* Context Descriptor */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_POPTS_IXSM 0x01</span>	<span class="hl com">/* Insert IP checksum */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_POPTS_TXSM 0x02</span>	<span class="hl com">/* Insert TCP/UDP checksum */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_EOP    0x01000000</span>	<span class="hl com">/* End of Packet */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_IFCS   0x02000000</span>	<span class="hl com">/* Insert FCS (Ethernet CRC) */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_IC     0x04000000</span>	<span class="hl com">/* Insert Checksum */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_RS     0x08000000</span>	<span class="hl com">/* Report Status */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_RPS    0x10000000</span>	<span class="hl com">/* Report Packet Sent */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_DEXT   0x20000000</span>	<span class="hl com">/* Descriptor extension (0 = legacy) */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_VLE    0x40000000</span>	<span class="hl com">/* Add VLAN tag */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_IDE    0x80000000</span>	<span class="hl com">/* Enable Tidv register */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_STAT_DD    0x00000001</span>	<span class="hl com">/* Descriptor Done */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_STAT_EC    0x00000002</span>	<span class="hl com">/* Excess Collisions */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_STAT_LC    0x00000004</span>	<span class="hl com">/* Late Collisions */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_STAT_TU    0x00000008</span>	<span class="hl com">/* Transmit underrun */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_TCP    0x01000000</span>	<span class="hl com">/* TCP packet */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_IP     0x02000000</span>	<span class="hl com">/* IP packet */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_CMD_TSE    0x04000000</span>	<span class="hl com">/* TCP Seg enable */</span><span class="hl ppc"></span>
<span class="hl ppc">#define E1000_TXD_STAT_TC    0x00000004</span>	<span class="hl com">/* Tx Underrun */</span><span class="hl ppc"></span>

<span class="hl com">/* Offload Context Descriptor */</span>
<span class="hl kwb">struct</span> e1000_context_desc <span class="hl opt">{</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> ip_config<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint8_t</span> ipcss<span class="hl opt">;</span>	<span class="hl com">/* IP checksum start */</span>
			<span class="hl kwb">uint8_t</span> ipcso<span class="hl opt">;</span>	<span class="hl com">/* IP checksum offset */</span>
			<span class="hl kwb">uint16_t</span> ipcse<span class="hl opt">;</span>	<span class="hl com">/* IP checksum end */</span>
		<span class="hl opt">}</span> ip_fields<span class="hl opt">;</span>
	<span class="hl opt">}</span> lower_setup<span class="hl opt">;</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> tcp_config<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint8_t</span> tucss<span class="hl opt">;</span>	<span class="hl com">/* TCP checksum start */</span>
			<span class="hl kwb">uint8_t</span> tucso<span class="hl opt">;</span>	<span class="hl com">/* TCP checksum offset */</span>
			<span class="hl kwb">uint16_t</span> tucse<span class="hl opt">;</span>	<span class="hl com">/* TCP checksum end */</span>
		<span class="hl opt">}</span> tcp_fields<span class="hl opt">;</span>
	<span class="hl opt">}</span> upper_setup<span class="hl opt">;</span>
	<span class="hl kwb">uint32_t</span> cmd_and_length<span class="hl opt">;</span>	<span class="hl com">/* */</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> data<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint8_t</span> status<span class="hl opt">;</span>	<span class="hl com">/* Descriptor status */</span>
			<span class="hl kwb">uint8_t</span> hdr_len<span class="hl opt">;</span>	<span class="hl com">/* Header length */</span>
			<span class="hl kwb">uint16_t</span> mss<span class="hl opt">;</span>	<span class="hl com">/* Maximum segment size */</span>
		<span class="hl opt">}</span> fields<span class="hl opt">;</span>
	<span class="hl opt">}</span> tcp_seg_setup<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl com">/* Offload data descriptor */</span>
<span class="hl kwb">struct</span> e1000_data_desc <span class="hl opt">{</span>
	<span class="hl kwb">uint64_t</span> buffer_addr<span class="hl opt">;</span>	<span class="hl com">/* Address of the descriptor&#39;s buffer address */</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> data<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint16_t</span> length<span class="hl opt">;</span>	<span class="hl com">/* Data buffer length */</span>
			<span class="hl kwb">uint8_t</span> typ_len_ext<span class="hl opt">;</span>	<span class="hl com">/* */</span>
			<span class="hl kwb">uint8_t</span> cmd<span class="hl opt">;</span>	<span class="hl com">/* */</span>
		<span class="hl opt">}</span> flags<span class="hl opt">;</span>
	<span class="hl opt">}</span> lower<span class="hl opt">;</span>
	<span class="hl kwb">union</span> <span class="hl opt">{</span>
		<span class="hl kwb">uint32_t</span> data<span class="hl opt">;</span>
		<span class="hl kwb">struct</span> <span class="hl opt">{</span>
			<span class="hl kwb">uint8_t</span> status<span class="hl opt">;</span>	<span class="hl com">/* Descriptor status */</span>
			<span class="hl kwb">uint8_t</span> popts<span class="hl opt">;</span>	<span class="hl com">/* Packet Options */</span>
			<span class="hl kwb">uint16_t</span> special<span class="hl opt">;</span>	<span class="hl com">/* */</span>
		<span class="hl opt">}</span> fields<span class="hl opt">;</span>
	<span class="hl opt">}</span> upper<span class="hl opt">;</span>
<span class="hl opt">};</span>

<span class="hl com">/* Filters */</span>
<span class="hl ppc">#define E1000_NUM_UNICAST	   16</span>	<span class="hl com">/* Unicast filter entries */</span><span class="hl ppc">