LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-14 22:31:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
a803c4026c
ladybird/Kernel/Storage/AHCIPort.h

127 lines
4.2 KiB
C
Raw Normal View History

Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
/*
* Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 11:24:48 +03:00
* SPDX-License-Identifier: BSD-2-Clause
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
*/
#pragma once
#include <AK/OwnPtr.h>
#include <AK/RefPtr.h>
#include <Kernel/Devices/Device.h>
#include <Kernel/IO.h>
#include <Kernel/Interrupts/IRQHandler.h>
#include <Kernel/Lock.h>
#include <Kernel/PhysicalAddress.h>
#include <Kernel/Random.h>
Kernel: Move special sections into Sections.h This also removes a lot of CPU.h includes infavor for Sections.h
2021-06-22 18:40:16 +03:00
#include <Kernel/Sections.h>
Kernel/AHCI: Use interrupts for IO operations Instead of polling if the device ended the operation, we can just use interrupts for signalling about end of IO operation. In similar way, we use interrupts during device detection. Also, we use the new Work Queue mechanism introduced by @tomuta to allow better performance and stability :)
2021-03-19 02:32:42 +03:00
#include <Kernel/SpinLock.h>
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
#include <Kernel/Storage/AHCI.h>
#include <Kernel/Storage/AHCIPortHandler.h>
#include <Kernel/Storage/StorageDevice.h>
Kernel: Implement ScatterList for handling scattered DMA pages This class is used in the AHCI code to handle a big request of read/write to the disk. If we happen to encounter such request, we will get the needed amount of physical pages from the already-allocated physical pages in AHCIPort, and with that we will create a ScatterList that will create a Region that maps all of these pages in a contiguous virtual memory range. Then, we could easily copy to/from this range, before and after calling the operation on the StorageDevice as needed with read or write operations.
2021-02-26 15:38:17 +03:00
#include <Kernel/VM/AnonymousVMObject.h>
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
#include <Kernel/VM/PhysicalPage.h>
Kernel: Move AHCIPort::ScatterList to VM::ScatterGatherList We want to move this out of the AHCI subsystem into the VM system, since other parts of the kernel may need to perform scatter-gather IO. We rename the current VM::ScatterGatherList impl that's used in the virtio subsystem to VM::ScatterGatherRefList, since its distinguishing feature from the AHCI scatter-gather list is that it doesn't own its buffers.
2021-04-24 04:30:27 +03:00
#include <Kernel/VM/ScatterGatherList.h>
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
#include <Kernel/WaitQueue.h>
namespace Kernel {
class AsyncBlockDeviceRequest;
class AHCIPortHandler;
class SATADiskDevice;
class AHCIPort : public RefCounted<AHCIPort> {
friend class AHCIPortHandler;
friend class SATADiskDevice;
public:
UNMAP_AFTER_INIT static NonnullRefPtr<AHCIPort> create(const AHCIPortHandler&, volatile AHCI::PortRegisters&, u32 port_index);
u32 port_index() const { return m_port_index; }
u32 representative_port_index() const { return port_index() + 1; }
bool is_operable() const;
bool is_hot_pluggable() const;
bool is_atapi_attached() const { return m_port_registers.sig == (u32)AHCI::DeviceSignature::ATAPI; };
RefPtr<StorageDevice> connected_device() const { return m_connected_device; }
bool reset();
Kernel: Don't reset AHCI ports during boot unless requested Instead of blindly resetting every AHCI port, let's just reset only the controller by default. The user can still request to reset everything with a new kernel boot argument called ahci_reset_mode which is set by default to "controller", so the code will only invoke an HBA reset. This kernel boot argument can be set to 3 different values: 1. "controller" - reset the HBA and skip resetting AHCI ports 2. "none" - don't reset anything, so we rely on the firmware to initialize the AHCI HBA and ports for us. 3. "complete" - reset the AHCI HBA and ports.
2021-03-12 19:35:16 +03:00
UNMAP_AFTER_INIT bool initialize_without_reset();
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
void handle_interrupt();
private:
Kernel: Don't reset AHCI ports during boot unless requested Instead of blindly resetting every AHCI port, let's just reset only the controller by default. The user can still request to reset everything with a new kernel boot argument called ahci_reset_mode which is set by default to "controller", so the code will only invoke an HBA reset. This kernel boot argument can be set to 3 different values: 1. "controller" - reset the HBA and skip resetting AHCI ports 2. "none" - don't reset anything, so we rely on the firmware to initialize the AHCI HBA and ports for us. 3. "complete" - reset the AHCI HBA and ports.
2021-03-12 19:35:16 +03:00
bool is_phy_enabled() const { return (m_port_registers.ssts & 0xf) == 3; }
Kernel/AHCI: Use interrupts for IO operations Instead of polling if the device ended the operation, we can just use interrupts for signalling about end of IO operation. In similar way, we use interrupts during device detection. Also, we use the new Work Queue mechanism introduced by @tomuta to allow better performance and stability :)
2021-03-19 02:32:42 +03:00
bool initialize(ScopedSpinLock<SpinLock<u8>>&);
Kernel: Don't reset AHCI ports during boot unless requested Instead of blindly resetting every AHCI port, let's just reset only the controller by default. The user can still request to reset everything with a new kernel boot argument called ahci_reset_mode which is set by default to "controller", so the code will only invoke an HBA reset. This kernel boot argument can be set to 3 different values: 1. "controller" - reset the HBA and skip resetting AHCI ports 2. "none" - don't reset anything, so we rely on the firmware to initialize the AHCI HBA and ports for us. 3. "complete" - reset the AHCI HBA and ports.
2021-03-12 19:35:16 +03:00
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
UNMAP_AFTER_INIT AHCIPort(const AHCIPortHandler&, volatile AHCI::PortRegisters&, u32 port_index);
ALWAYS_INLINE void clear_sata_error_register() const;
void eject();
const char* try_disambiguate_sata_status();
Kernel/Storage: Add SATA error disambiguation
2021-03-15 10:29:39 +03:00
void try_disambiguate_sata_error();
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
Kernel/AHCI: Use interrupts for IO operations Instead of polling if the device ended the operation, we can just use interrupts for signalling about end of IO operation. In similar way, we use interrupts during device detection. Also, we use the new Work Queue mechanism introduced by @tomuta to allow better performance and stability :)
2021-03-19 02:32:42 +03:00
bool initiate_sata_reset(ScopedSpinLock<SpinLock<u8>>&);
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
void rebase();
void recover_from_fatal_error();
bool shutdown();
ALWAYS_INLINE void spin_up() const;
ALWAYS_INLINE void power_on() const;
void start_request(AsyncBlockDeviceRequest&);
void complete_current_request(AsyncDeviceRequest::RequestResult);
bool access_device(AsyncBlockDeviceRequest::RequestType, u64 lba, u8 block_count);
Kernel: Implement ScatterList for handling scattered DMA pages This class is used in the AHCI code to handle a big request of read/write to the disk. If we happen to encounter such request, we will get the needed amount of physical pages from the already-allocated physical pages in AHCIPort, and with that we will create a ScatterList that will create a Region that maps all of these pages in a contiguous virtual memory range. Then, we could easily copy to/from this range, before and after calling the operation on the StorageDevice as needed with read or write operations.
2021-02-26 15:38:17 +03:00
size_t calculate_descriptors_count(size_t block_count) const;
[[nodiscard]] Optional<AsyncDeviceRequest::RequestResult> prepare_and_set_scatter_list(AsyncBlockDeviceRequest& request);
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
ALWAYS_INLINE bool is_interrupts_enabled() const;
bool spin_until_ready() const;
Kernel/AHCI: Use interrupts for IO operations Instead of polling if the device ended the operation, we can just use interrupts for signalling about end of IO operation. In similar way, we use interrupts during device detection. Also, we use the new Work Queue mechanism introduced by @tomuta to allow better performance and stability :)
2021-03-19 02:32:42 +03:00
bool identify_device(ScopedSpinLock<SpinLock<u8>>&);
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
ALWAYS_INLINE void start_command_list_processing() const;
ALWAYS_INLINE void mark_command_header_ready_to_process(u8 command_header_index) const;
ALWAYS_INLINE void stop_command_list_processing() const;
ALWAYS_INLINE void start_fis_receiving() const;
ALWAYS_INLINE void stop_fis_receiving() const;
ALWAYS_INLINE void set_active_state() const;
ALWAYS_INLINE void set_sleep_state() const;
void set_interface_state(AHCI::DeviceDetectionInitialization);
Optional<u8> try_to_find_unused_command_header();
ALWAYS_INLINE bool is_interface_disabled() const { return (m_port_registers.ssts & 0xf) == 4; };
// Data members
EntropySource m_entropy_source;
Kernel/AHCI: Use interrupts for IO operations Instead of polling if the device ended the operation, we can just use interrupts for signalling about end of IO operation. In similar way, we use interrupts during device detection. Also, we use the new Work Queue mechanism introduced by @tomuta to allow better performance and stability :)
2021-03-19 02:32:42 +03:00
RefPtr<AsyncBlockDeviceRequest> m_current_request;
SpinLock<u8> m_hard_lock;
Lock m_lock { "AHCIPort" };
mutable bool m_wait_for_completion { false };
bool m_wait_connect_for_completion { false };
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
NonnullRefPtrVector<PhysicalPage> m_dma_buffers;
NonnullRefPtrVector<PhysicalPage> m_command_table_pages;
RefPtr<PhysicalPage> m_command_list_page;
OwnPtr<Region> m_command_list_region;
RefPtr<PhysicalPage> m_fis_receive_page;
RefPtr<StorageDevice> m_connected_device;
u32 m_port_index;
volatile AHCI::PortRegisters& m_port_registers;
NonnullRefPtr<AHCIPortHandler> m_parent_handler;
AHCI::PortInterruptStatusBitField m_interrupt_status;
AHCI::PortInterruptEnableBitField m_interrupt_enable;
Kernel: Implement ScatterList for handling scattered DMA pages This class is used in the AHCI code to handle a big request of read/write to the disk. If we happen to encounter such request, we will get the needed amount of physical pages from the already-allocated physical pages in AHCIPort, and with that we will create a ScatterList that will create a Region that maps all of these pages in a contiguous virtual memory range. Then, we could easily copy to/from this range, before and after calling the operation on the StorageDevice as needed with read or write operations.
2021-02-26 15:38:17 +03:00
Kernel: Move AHCIPort::ScatterList to VM::ScatterGatherList We want to move this out of the AHCI subsystem into the VM system, since other parts of the kernel may need to perform scatter-gather IO. We rename the current VM::ScatterGatherList impl that's used in the virtio subsystem to VM::ScatterGatherRefList, since its distinguishing feature from the AHCI scatter-gather list is that it doesn't own its buffers.
2021-04-24 04:30:27 +03:00
RefPtr<ScatterGatherList> m_current_scatter_list;
Kernel: Add basic AHCI functionality The hierarchy is AHCIController, AHCIPortHandler, AHCIPort and SATADiskDevice. Each AHCIController has at least one AHCIPortHandler. An AHCIPortHandler is an interrupt handler that takes care of enumeration of handled AHCI ports when an interrupt occurs. Each AHCIPort takes care of one SATADiskDevice, and later on we can add support for Port multiplier. When we implement support of Message signalled interrupts, we can spawn many AHCIPortHandlers, and allow each one of them to be responsible for a set of AHCIPorts.
2021-02-26 07:25:45 +03:00
bool m_disabled_by_firmware { false };
};
}
Reference in New Issue Copy Permalink