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"
 
#include <config.h>
#if THREADS
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/process/Mutex.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*);
 
  class TreeLockGuard {
   public:
    TreeLockGuard() {
#if THREADS
      Device::m_TreeLock.acquire();
#endif
    }
 
    ~TreeLockGuard() {
#if THREADS
      Device::m_TreeLock.release();
#endif
    }
 
   private:
    TreeLockGuard(const TreeLockGuard&) = delete;
    TreeLockGuard& operator=(const TreeLockGuard&) = delete;
  };
 
  static bool treeLockHeldByCurrentThread();
 
  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 const 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;
  }
 
  Device* getPhysicalFunction() const {
    return m_PhysicalFunction;
  }
  size_t getVirtualFunctionIndex() const {
    return m_VirtualFunctionIndex;
  }
  void setVirtualFunction(Device* physicalFunction, size_t index) {
    m_PhysicalFunction = physicalFunction;
    m_VirtualFunctionIndex = index;
  }
 
  virtual void dump(String& str) {
    str.assign("Abstract Device", 16);
  }
 
  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);
 
 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;
  Device* m_PhysicalFunction;
  size_t m_VirtualFunctionIndex;
  static Device m_Root;
  uintptr_t m_InterruptNumber;
  String m_SpecificType;
  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;
#if THREADS
  static Mutex m_TreeLock;
#endif
};
 
template <class F, class... Args>
void Device::foreach (pedigree_std::Callable<F>& callback, Device * root, Args... args) {
#if 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, args...);
 
    ++i;
  }
}
 
#endif