modules/drivers/common/ata/main.cc

/*
 * 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.
 */
 
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/linker/KernelElf.h"
#include "pedigree/kernel/machine/Controller.h"
#include "pedigree/kernel/machine/Device.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/new"
 
#include "IsaAtaController.h"
#include "PciAtaController.h"
#include "modules/Module.h"
 
static int nController = 0;
 
static bool bFound = false;
 
// Try for a PIIX IDE controller first. We prefer the PIIX as it enables us
// to use DMA (and is a little easier to use for device detection).
static bool bPiixControllerFound = false;
static int piixLevel = -1;
static bool bFallBackISA = false;
 
static bool allowProbing = false;
 
static Vector<AtaController*> g_Controllers;
 
class RestoredAtaController : public Controller {
 public:
  explicit RestoredAtaController(Controller* controller) : Controller(controller) {
    // Device's transfer constructor copies child pointers. The old ATA
    // controller remains their sole owner until foreach deletes it.
    m_Children.clear();
  }
};
 
static Device* probeIsaDevice(Controller* pDev) {
  // Create a new AtaController device node.
  IsaAtaController* pController = new IsaAtaController(pDev, nController++);
  g_Controllers.pushBack(pController);
 
  bFound = true;
 
  return pController;
}
 
static Device* probePiixController(Device* pDev) {
  EMIT_IF(PEDIGREE_MACHINE_HASPCI) {
    static uint8_t interrupt = 14;
 
    // Create a new AtaController device node.
    Controller* pDevController = new Controller(pDev);
    uintptr_t intnum = pDevController->getInterruptNumber();
    if (intnum == 0) {
      // No valid interrupt, handle
      pDevController->setInterruptNumber(interrupt);
      if (interrupt < 15)
        interrupt++;
      else {
        ERROR(
            "PCI IDE: Controller found with no IRQ and IRQs 14 and 15 "
            "are already allocated");
        delete pDevController;
 
        return pDev;
      }
    }
 
    PciAtaController* pController = new PciAtaController(pDevController, nController++);
    g_Controllers.pushBack(pController);
 
    bFound = true;
 
    return pController;
  }
  else {
    return nullptr;
  }
}
 
static Device* removeIsaAta(Device* dev) {
  if (dev->getType() == Device::Controller) {
    // Get its addresses, and search for "command" and "control".
    bool foundCommand = false;
    bool foundControl = false;
    for (unsigned int j = 0; j < dev->addresses().count(); j++) {
      if (dev->addresses()[j]->m_Name.compare("command"))
        foundCommand = true;
      if (dev->addresses()[j]->m_Name.compare("control"))
        foundControl = true;
    }
 
    if (foundCommand && foundControl) {
      // Destroy and remove this device.
      return 0;
    }
  }
 
  return dev;
}
 
static Device* probeDisk(Device* pDev) {
  // Native SATA controllers belong to the AHCI driver, not legacy IDE probing.
  if (pDev->getPciClassCode() == 0x01 && pDev->getPciSubclassCode() == 0x06)
    return pDev;
 
  // Look for a PIIX controller
  // Class/subclasss 1:1 == Mass storage + IDE.
  if (pDev->getPciVendorId() == 0x8086 && pDev->getPciClassCode() == 1 &&
      pDev->getPciSubclassCode() == 1) {
    // Ensure we probe the most modern PIIX that is present and available.
    // This is important as there may be a PIIX3 in a system that also has
    // a PIIX4, but the drives are likely to be attached to the PIIX4.
    bool shouldProbe = false;
    switch (pDev->getPciDeviceId()) {
      case 0x1230:  // PIIX
        if (allowProbing && piixLevel == 0) {
          shouldProbe = true;
        } else if (piixLevel < 0) {
          piixLevel = 0;
        }
        break;
 
      case 0x7010:  // PIIX3
        if (allowProbing && piixLevel == 3) {
          shouldProbe = true;
        } else if (piixLevel < 3) {
          piixLevel = 3;
        }
        break;
 
      case 0x7111:  // PIIX4
        if (allowProbing && piixLevel == 4) {
          shouldProbe = true;
        } else if (piixLevel < 4) {
          piixLevel = 4;
        }
        break;
    }
 
    if (piixLevel != -1) {
      bPiixControllerFound = true;
    }
 
    if (allowProbing && shouldProbe) {
      return probePiixController(pDev);
    }
  }
 
  // No PIIX controller found, fall back to ISA
  if (!bPiixControllerFound && bFallBackISA) {
    // Is this a controller?
    if (pDev->getType() == Device::Controller) {
      // Check it's not an ATA controller already.
      // Get its addresses, and search for "command" and "control".
      bool foundCommand = false;
      bool foundControl = false;
      for (unsigned int j = 0; j < pDev->addresses().count(); j++) {
        if (pDev->addresses()[j]->m_Name.compare("command"))
          foundCommand = true;
        if (pDev->addresses()[j]->m_Name.compare("control"))
          foundControl = true;
      }
      if (allowProbing && foundCommand && foundControl)
        return probeIsaDevice(static_cast<Controller*>(pDev));
    }
  }
 
  return pDev;
}
 
static Module::UnloadAdmission admitUnload(bool) {
  for (auto* controller : g_Controllers) {
    if (controller && !controller->prepareDiskRemoval()) {
      for (auto* rollback : g_Controllers) {
        if (rollback)
          rollback->cancelDiskRemoval();
      }
      return Module::UnloadAdmission::Busy;
    }
  }
  return Module::UnloadAdmission::Ready;
}
 
static bool entry() {
 
  // Walk the device tree looking for controllers that have
  // "control" and "command" addresses.
  Device::foreach (probeDisk);
 
  // Done initial probe to find out what exists, action the findings now.
  allowProbing = true;
  if (bPiixControllerFound) {
    // Right, we found a PIIX controller. Let's remove the ATA
    // controllers that are created early in the boot (ISA) now
    // so that when we probe the controller we don't run into used
    // ports.
    Device::foreach (removeIsaAta);
    Device::foreach (probeDisk);
  }
  if (!bFound) {
    // Try again, allowing ISA devices this time.
    bFallBackISA = true;
    Device::foreach (probeDisk);
  }
 
  return bFound && KernelElf::instance().registerUnloadAdmission(&entry, &admitUnload);
}
 
static Device* removeAtaController(Device* device) {
  for (size_t i = 0; i < g_Controllers.count(); ++i) {
    AtaController* controller = g_Controllers[i];
    if (controller != device) {
      continue;
    }
 
    // Hardware callbacks and disk caches need the live I/O mappings. Retire
    // them before the transfer constructor takes ownership of those mappings.
    controller->shutdown();
    g_Controllers[i] = nullptr;
    return new RestoredAtaController(controller);
  }
  return device;
}
 
static void exit() {
  Device::foreach (removeAtaController);
  g_Controllers.clear();
  nController = 0;
  bFound = false;
  bPiixControllerFound = false;
  piixLevel = -1;
  bFallBackISA = false;
  allowProbing = false;
}
 
#if X86_COMMON
MODULE_INFO("ata", &entry, &exit, "scsi", "pci", 0);
#endif