AtaDisk.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 ATA_ATA_DISK_H
#define ATA_ATA_DISK_H
 
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/processor/MemoryRegion.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
 
#include "BusMasterIde.h"
#include "ata-common.h"
#include "modules/drivers/common/scsi/ScsiDisk.h"
 
class IoBase;
class AtaPagingTransport;
 
class AtaDisk : public ScsiDisk {
 private:
  friend class AtaPagingTransport;
  void preparePagingStorage();
  void releasePagingStorage();
  AtaPagingTransport* m_Paging;
 
  class IrqCompletion {
   public:
    explicit IrqCompletion(AtaDisk& disk);
    ~IrqCompletion();
 
    Semaphore* operator->() {
      return &m_Completion;
    }
 
   private:
    static void discard(void* context);
    void withdraw();
 
    AtaDisk& m_Disk;
    Semaphore m_Completion;
    bool m_Published;
    Thread::StackDiscardScope m_StackDiscardScope;
  };
 
  enum AtaDiskType {
    Block = 0x00,
    Sequential = 0x01,
    Printer = 0x02,
    Processor = 0x03,
    WriteOnce = 0x04,
    CdDvd = 0x05,
    OpticalMemory = 0x07,
    MediumChanger = 0x08,
    Raid = 0x0C,
    Enclosure = 0x0D,
    None = 0x1F,
    NotPacket = 0xFF,
  };
 
 public:
  AtaDisk(class AtaController* pDev, bool isMaster, IoBase* commandRegs, IoBase* controlRegs,
          BusMasterIde* busMaster = 0);
  virtual ~AtaDisk();
  void shutdownDeviceCache() override;
 
  virtual void getName(String& str) {
    str.assign(m_pName);
  }
 
  bool initialise(size_t nUnit = ~0);
 
  // Do-ers for read/write operations. For PACKET devices, these forward to
  // the ScsiDisk implementations. For non-PACKET devices, these perform real
  // disk I/O.
  virtual uint64_t doRead(uint64_t location);
  virtual uint64_t doWrite(uint64_t location);
  virtual uint64_t doSync(uint64_t location);
  PagingStatus preparePagingTransport(PagingTransport*& transport) override;
  PagingStatus doPagingTransfer(PagingOperation operation, uint64_t offset, void* page) override;
 
  virtual void irqReceived();
 
  void maskInterrupts();
 
  void stopDma();
 
  virtual BusMasterIde* getBusMaster() const {
    return m_BusMaster;
  }
 
  virtual size_t getSize() const;
  virtual size_t getBlockSize() const;
  virtual size_t getNativeBlockSize() const;
  virtual size_t getBlockCount() const;
 
  // SCSI controller interface calls this to send a PACKET command.
  virtual bool sendCommand(size_t nUnit, uintptr_t pCommand, uint8_t nCommandSize,
                           uintptr_t pRespBuffer, uint16_t nRespBytes, bool bWrite);
 
 private:
  virtual size_t getCacheFillSize() const;
 
  void setupLBA28(uint64_t n, uint32_t nSectors);
  void setupLBA48(uint64_t n, uint32_t nSectors);
 
  virtual size_t defaultBlockSize() {
    if (m_AtaDiskType == CdDvd) {
      return 2048;
    } else {
      return 512;
    }
  }
 
 public:
  MUST_USE_RESULT virtual uint64_t doWriteDirect(uint64_t location, uintptr_t page);
 
 private:
  uint64_t writePageBuffer(uint64_t location, uintptr_t page);
 
  struct Buffer {
    uintptr_t buffer;
 
    size_t offset;
  };
 
  bool m_IsMaster;
 
  IdentifyData m_pIdent;
  char m_pName[64];
  char m_pSerialNumber[64];
  char m_pFirmwareRevision[64];
  bool m_SupportsLBA28;
  bool m_SupportsLBA48;
  size_t m_BlockSize;
 
  Semaphore* m_IrqReceived;
  Spinlock m_IrqLock;
 
  AtaDiskType m_AtaDiskType;
 
  uint8_t m_PacketSize;
 
  bool m_Removable;
 
  void setFeatures(uint8_t command, uint8_t countreg, uint8_t lowreg, uint8_t midreg,
                   uint8_t hireg);
 
  IoBase* m_CommandRegs;
  IoBase* m_ControlRegs;
  BusMasterIde* m_BusMaster;
 
  Mutex m_PrdTableLock;
 
  PhysicalRegionDescriptor* m_PrdTable;
 
  size_t m_LastPrdTableOffset;
 
  physical_uintptr_t m_PrdTablePhys;
 
  MemoryRegion m_PrdTableMemRegion;
 
  bool m_bDma;
 
  Atomic<size_t> m_IrqCount;
};
 
#endif