Device.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef MACHINE_DEVICE_H
#define MACHINE_DEVICE_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
#ifdef THREADS
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/process/Mutex.h"
#endif
#ifdef OPENFIRMWARE
#include "pedigree/kernel/machine/openfirmware/OpenFirmware.h"
#endif
#include "pedigree/kernel/machine/Pci.h"
#include "pedigree/kernel/utilities/utility.h"

class IoBase;

class EXPORTED_PUBLIC Device
{
  public:
    typedef Device *(*Callback)(Device *);

    enum Type
    {
        Generic,  
        Root,     
        Disk,     
        Bus,      
        Display,  
        Network,  
        Sound,    
        Console,  
        Mouse,  
        Controller,     
        UsbController,  
        UsbGeneric,     
        UsbContainer,  
    };
    class Address
    {
      public:
        Address(
            const String &n, uintptr_t a, size_t s, bool io, size_t pad = 1);
        ~Address();
        void
        map(size_t forcedSize = 0, bool bUser = false,
            bool bWriteCombine = false, bool bWriteThrough = false);
        String m_Name;
        uintptr_t m_Address;
        size_t m_Size;
        bool m_IsIoSpace;
        IoBase *m_Io;
        size_t m_Padding;

      private:
        Address(const Address &);
        Address &operator=(const Address &);

        bool m_bMapped;
    };

    Device();
    Device(Device *p);
    virtual ~Device();

    static void foreach (Callback callback, Device *root = 0);
    template <class F, class... Args>
    static void foreach (
        pedigree_std::Callable<F> &callback, Device * root, Args... args);

    static void addToRoot(Device *device);

    inline Device *getParent() const
    {
        return m_pParent;
    }
    inline void setParent(Device *p)
    {
        m_pParent = p;
    }

    virtual void getName(String &str);

    virtual Type getType()
    {
        return Root;
    }

    virtual String getSpecificType()
    {
        return m_SpecificType;
    }
    virtual void setSpecificType(String str)
    {
        m_SpecificType = pedigree_std::move(str);
    }

    void setPciPosition(uint32_t bus, uint32_t device, uint32_t func)
    {
        m_PciBusPos = bus;
        m_PciDevicePos = device;
        m_PciFunctionNum = func;
    }
    void setPciIdentifiers(
        uint8_t classCode, uint8_t subclassCode, uint16_t vendorId,
        uint16_t deviceId, uint8_t progIf)
    {
        m_ClassCode = classCode;
        m_SubclassCode = subclassCode;
        m_VendorId = vendorId;
        m_DeviceId = deviceId;
        m_ProgInterface = progIf;
    }
    void setPciConfigHeader(const PciBus::ConfigSpace &space)
    {
        m_ConfigHeader = space;
    }
    inline PciBus::ConfigSpace getPciConfigHeader() const
    {
        return m_ConfigHeader;
    }
    inline uint8_t getPciClassCode()
    {
        return m_ClassCode;
    }
    inline uint8_t getPciSubclassCode()
    {
        return m_SubclassCode;
    }
    inline uint16_t getPciVendorId()
    {
        return m_VendorId;
    }
    inline uint16_t getPciDeviceId()
    {
        return m_DeviceId;
    }
    inline uint8_t getPciProgInterface()
    {
        return m_ProgInterface;
    }
    inline uint32_t getPciBusPosition()
    {
        return m_PciBusPos;
    }
    inline uint32_t getPciDevicePosition()
    {
        return m_PciDevicePos;
    }
    inline uint32_t getPciFunctionNumber()
    {
        return m_PciFunctionNum;
    }

    virtual void dump(String &str)
    {
        str = "Abstract Device";
    }

    virtual Vector<Address *> &addresses()
    {
        return m_Addresses;
    }

    virtual uintptr_t getInterruptNumber()
    {
        return m_InterruptNumber;
    }

    virtual void setInterruptNumber(uintptr_t n)
    {
        m_InterruptNumber = n;
    }

    void addChild(Device *pDevice);

    Device *getChild(size_t n);

    size_t getNumChildren();

    void removeChild(size_t n);

    void removeChild(Device *d);

    void replaceChild(Device *src, Device *dest);

    static void searchByVendorId(
        uint16_t vendorId, void (*callback)(Device *), Device *root = 0);
    static void searchByVendorIdAndDeviceId(
        uint16_t vendorId, uint16_t deviceId, void (*callback)(Device *),
        Device *root = 0);
    static void searchByClass(
        uint16_t classCode, void (*callback)(Device *), Device *root = 0);
    static void searchByClassAndSubclass(
        uint16_t classCode, uint16_t subclassCode, void (*callback)(Device *),
        Device *root = 0);
    static void searchByClassSubclassAndProgInterface(
        uint16_t classCode, uint16_t subclassCode, uint8_t progInterface,
        void (*callback)(Device *), Device *root = 0);

#ifdef OPENFIRMWARE

    OFHandle getOFHandle()
    {
        return m_OfHandle;
    }
    void setOFHandle(OFHandle h)
    {
        m_OfHandle = h;
    }
#endif
  private:
    static void foreachInternal(Callback callback, Device *root);
    template <class F, class... Args>
    static void foreachInternal(
        pedigree_std::Callable<F> &callback, Device *root, Args... args);
    static void searchByVendorIdInternal(
        uint16_t vendorId, void (*callback)(Device *), Device *root);
    static void searchByVendorIdAndDeviceIdInternal(
        uint16_t vendorId, uint16_t deviceId, void (*callback)(Device *),
        Device *root);
    static void searchByClassInternal(
        uint16_t classCode, void (*callback)(Device *), Device *root);
    static void searchByClassAndSubclassInternal(
        uint16_t classCode, uint16_t subclassCode, void (*callback)(Device *),
        Device *root);
    static void searchByClassSubclassAndProgInterfaceInternal(
        uint16_t classCode, uint16_t subclassCode, uint8_t progInterface,
        void (*callback)(Device *), Device *root);

    void removeIoMappings();

  protected:
    NOT_COPYABLE_OR_ASSIGNABLE(Device);

    static Device &root()
    {
        return m_Root;
    }

    Vector<Address *> m_Addresses;
    Vector<Device *> m_Children;
    Device *m_pParent;
    static Device m_Root;
    uintptr_t m_InterruptNumber;
    String m_SpecificType;
#ifdef OPENFIRMWARE

    OFHandle m_OfHandle;
#endif

    PciBus::ConfigSpace m_ConfigHeader;
    uint8_t m_ClassCode;
    uint8_t m_SubclassCode;
    uint16_t m_VendorId;
    uint16_t m_DeviceId;
    uint8_t m_ProgInterface;

    uint32_t m_PciBusPos;
    uint32_t m_PciDevicePos;
    uint32_t m_PciFunctionNum;
#ifdef THREADS

    static Mutex m_TreeLock;
#endif
};

template <class F, class... Args>
void Device::foreach (
    pedigree_std::Callable<F> &callback, Device * root, Args... args)
{
#ifdef THREADS
    LockGuard<Mutex> guard(m_TreeLock);
#endif

    if (!root)
    {
        root = &Device::root();
    }

    foreachInternal(callback, root, args...);
}

template <class F, class... Args>
void Device::foreachInternal(
    pedigree_std::Callable<F> &callback, Device *root, Args... args)
{
    for (size_t i = 0; i < root->getNumChildren();)
    {
        // Provide the callback for this child.
        Device *child = root->getChild(i);
        Device *result = callback(child, args...);
        if (!result)
        {
            // Remove & skip traversal.
            root->removeChild(i);
            delete child;
            continue;
        }
        else if (result != child)
        {
            // Replace, but we can still traverse the child.
            root->replaceChild(child, result);
            delete child;
            child = result;
        }

        // Traverse this child's tree.
        foreachInternal(callback, child);

        ++i;
    }
}

#endif