396 lines
9.5 KiB
C++
396 lines
9.5 KiB
C++
/**
|
|
* \brief AHCI-port driver for ATA devices
|
|
* \author Sebastian Sumpf
|
|
* \date 2015-04-29
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2015 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
#ifndef _ATA_DRIVER_H_
|
|
#define _ATA_DRIVER_H_
|
|
|
|
#include "ahci.h"
|
|
|
|
using namespace Genode;
|
|
|
|
|
|
/**
|
|
* Return data of 'identify_device' ATA command
|
|
*/
|
|
struct Identity : Genode::Mmio
|
|
{
|
|
Identity(Genode::addr_t base) : Mmio(base) { }
|
|
|
|
struct Serial_number : Register_array<0x14, 8, 20, 8> { };
|
|
struct Model_number : Register_array<0x36, 8, 40, 8> { };
|
|
|
|
struct Queue_depth : Register<0x96, 16>
|
|
{
|
|
struct Max_depth : Bitfield<0, 5> { };
|
|
};
|
|
|
|
struct Sata_caps : Register<0x98, 16>
|
|
{
|
|
struct Ncq_support : Bitfield<8, 1> { };
|
|
};
|
|
|
|
struct Sector_count : Register<0xc8, 64> { };
|
|
|
|
struct Logical_block : Register<0xd4, 16>
|
|
{
|
|
struct Per_physical : Bitfield<0, 3> { }; /* 2^X logical per physical */
|
|
struct Longer_512 : Bitfield<12, 1> { };
|
|
struct Multiple : Bitfield<13, 1> { }; /* multiple logical blocks per physical */
|
|
};
|
|
|
|
struct Logical_words : Register<0xea, 32> { }; /* words (16 bit) per logical block */
|
|
|
|
struct Alignment : Register<0x1a2, 16>
|
|
{
|
|
struct Logical_offset : Bitfield<0, 14> { }; /* offset first logical block in physical */
|
|
};
|
|
|
|
void info()
|
|
{
|
|
PLOG("\t\tqueue depth: %u ncq: %u",
|
|
read<Queue_depth::Max_depth>() + 1,
|
|
read<Sata_caps::Ncq_support>());
|
|
PLOG("\t\tnumer of sectors: %llu", read<Sector_count>());
|
|
PLOG("\t\tmultiple logical blocks per physical: %s",
|
|
read<Logical_block::Multiple>() ? "yes" : "no");
|
|
PLOG("\t\tlogical blocks per physical: %u",
|
|
1U << read<Logical_block::Per_physical>());
|
|
PLOG("\t\tlogical block size is above 512 byte: %s",
|
|
read<Logical_block::Longer_512>() ? "yes" : "no");
|
|
PLOG("\t\twords (16bit) per logical block: %u",
|
|
read<Logical_words>());
|
|
PLOG("\t\toffset of first logical block within physical: %u",
|
|
read<Alignment::Logical_offset>());
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* 16-bit word big endian device ASCII characters
|
|
*/
|
|
template <typename DEVICE_STRING>
|
|
struct String
|
|
{
|
|
char buf[DEVICE_STRING::ITEMS + 1];
|
|
|
|
String(Identity & info)
|
|
{
|
|
long j = 0;
|
|
for (unsigned long i = 0; i < DEVICE_STRING::ITEMS; i++) {
|
|
/* read and swap even and uneven characters */
|
|
char c = (char)info.read<DEVICE_STRING>(i ^ 1);
|
|
if (Genode::is_whitespace(c) && j == 0)
|
|
continue;
|
|
buf[j++] = c;
|
|
}
|
|
|
|
buf[j] = 0;
|
|
|
|
/* remove trailing white spaces */
|
|
while ((j > 0) && (buf[--j] == ' '))
|
|
buf[j] = 0;
|
|
}
|
|
|
|
bool operator == (char const *other) const
|
|
{
|
|
return strcmp(buf, other) == 0;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Commands to distinguish between ncq and non-ncq operation
|
|
*/
|
|
struct Io_command
|
|
{
|
|
virtual void command(Port &por,
|
|
Command_table &table,
|
|
bool read,
|
|
Block::sector_t block_number,
|
|
size_t count,
|
|
unsigned slot) = 0;
|
|
|
|
virtual void handle_irq(Port &port, Port::Is::access_t status) = 0;
|
|
};
|
|
|
|
struct Ncq_command : Io_command
|
|
{
|
|
void command(Port &port,
|
|
Command_table &table,
|
|
bool read,
|
|
Block::sector_t block_number,
|
|
size_t count,
|
|
unsigned slot) override
|
|
{
|
|
table.fis.fpdma(read, block_number, count, slot);
|
|
/* set pending */
|
|
port.write<Port::Sact>(1U << slot);
|
|
}
|
|
|
|
void handle_irq(Port &port, Port::Is::access_t status) override
|
|
{
|
|
/*
|
|
* Check for completions of other requests immediately
|
|
*/
|
|
while (Port::Is::Sdbs::get(status = port.read<Port::Is>()))
|
|
port.ack_irq();
|
|
}
|
|
};
|
|
|
|
struct Dma_ext_command : Io_command
|
|
{
|
|
void command(Port &port,
|
|
Command_table &table,
|
|
bool read,
|
|
Block::sector_t block_number,
|
|
size_t count,
|
|
unsigned /* slot */) override
|
|
{
|
|
table.fis.dma_ext(read, block_number, count);
|
|
}
|
|
|
|
void handle_irq(Port &port, Port::Is::access_t status) override
|
|
{
|
|
if (Port::Is::Dma_ext_irq::get(status))
|
|
port.ack_irq();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Drivers using ncq- and non-ncq commands
|
|
*/
|
|
struct Ata_driver : Port_driver
|
|
{
|
|
typedef ::String<Identity::Serial_number> Serial_string;
|
|
typedef ::String<Identity::Model_number> Model_string;
|
|
|
|
Genode::Lazy_volatile_object<Identity> info;
|
|
Genode::Lazy_volatile_object<Serial_string> serial;
|
|
Genode::Lazy_volatile_object<Model_string> model;
|
|
|
|
Io_command *io_cmd = nullptr;
|
|
Block::Packet_descriptor pending[32];
|
|
|
|
Ata_driver(Port &port, Signal_context_capability state_change)
|
|
: Port_driver(port, state_change)
|
|
{
|
|
Port::init();
|
|
identify_device();
|
|
}
|
|
|
|
~Ata_driver()
|
|
{
|
|
if (io_cmd)
|
|
destroy (Genode::env()->heap(), io_cmd);
|
|
}
|
|
|
|
unsigned find_free_cmd_slot()
|
|
{
|
|
for (unsigned slot = 0; slot < cmd_slots; slot++)
|
|
if (!pending[slot].valid())
|
|
return slot;
|
|
|
|
throw Block::Driver::Request_congestion();
|
|
}
|
|
|
|
void ack_packets()
|
|
{
|
|
unsigned slots = Port::read<Ci>() | Port::read<Sact>();
|
|
|
|
for (unsigned slot = 0; slot < cmd_slots; slot++) {
|
|
if ((slots & (1U << slot)) || !pending[slot].valid())
|
|
continue;
|
|
|
|
Block::Packet_descriptor p = pending[slot];
|
|
pending[slot] = Block::Packet_descriptor();
|
|
ack_packet(p, true);
|
|
}
|
|
}
|
|
|
|
void overlap_check(Block::sector_t block_number,
|
|
size_t count)
|
|
{
|
|
Block::sector_t end = block_number + count - 1;
|
|
|
|
for (unsigned slot = 0; slot < cmd_slots; slot++) {
|
|
if (!pending[slot].valid())
|
|
continue;
|
|
|
|
Block::sector_t pending_start = pending[slot].block_number();
|
|
Block::sector_t pending_end = pending_start + pending[slot].block_count() - 1;
|
|
/* check if a pending packet overlaps */
|
|
if ((block_number >= pending_start && block_number <= pending_end) ||
|
|
(end >= pending_start && end <= pending_end) ||
|
|
(pending_start >= block_number && pending_start <= end) ||
|
|
(pending_end >= block_number && pending_end <= end)) {
|
|
PWRN("Overlap: pending %llu + %zu, request: %llu + %zu", pending[slot].block_number(),
|
|
pending[slot].block_count(), block_number, count);
|
|
throw Block::Driver::Request_congestion();
|
|
}
|
|
}
|
|
}
|
|
|
|
void io(bool read,
|
|
Block::sector_t block_number,
|
|
size_t count,
|
|
addr_t phys,
|
|
Block::Packet_descriptor &packet)
|
|
{
|
|
sanity_check(block_number, count);
|
|
overlap_check(block_number, count);
|
|
|
|
unsigned slot = find_free_cmd_slot();
|
|
pending[slot] = packet;
|
|
|
|
/* setup fis */
|
|
Command_table table(command_table_addr(slot), phys, count * block_size());
|
|
|
|
/* set ATA command */
|
|
io_cmd->command(*this, table, read, block_number, count, slot);
|
|
|
|
/* set or clear write flag in command header */
|
|
Command_header header(command_header_addr(slot));
|
|
header.write<Command_header::Bits::W>(read ? 0 : 1);
|
|
header.clear_byte_count();
|
|
|
|
execute(slot);
|
|
}
|
|
|
|
|
|
/*****************
|
|
** Port_driver **
|
|
*****************/
|
|
|
|
void handle_irq() override
|
|
{
|
|
Is::access_t status = Port::read<Is>();
|
|
|
|
if (verbose)
|
|
PDBG("irq: %x state: %u", status, state);
|
|
|
|
switch (state) {
|
|
|
|
case IDENTIFY:
|
|
|
|
if (Port::Is::Dss::get(status) || Port::Is::Pss::get(status)) {
|
|
info.construct(device_info);
|
|
serial.construct(*info);
|
|
model.construct(*info);
|
|
|
|
if (verbose) {
|
|
PLOG("\t\tmodel number: %s", model->buf);
|
|
PLOG("\t\tserial number: %s", serial->buf);
|
|
info->info();
|
|
}
|
|
|
|
check_device();
|
|
if (ncq_support())
|
|
io_cmd = new (Genode::env()->heap()) Ncq_command();
|
|
else
|
|
io_cmd = new (Genode::env()->heap()) Dma_ext_command();
|
|
|
|
ack_irq();
|
|
}
|
|
break;
|
|
|
|
case READY:
|
|
|
|
io_cmd->handle_irq(*this, status);
|
|
ack_packets();
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
stop();
|
|
}
|
|
|
|
bool ncq_support()
|
|
{
|
|
return info->read<Identity::Sata_caps::Ncq_support>() && hba.ncq();
|
|
}
|
|
|
|
void check_device()
|
|
{
|
|
cmd_slots = min((int)cmd_slots,
|
|
info->read<Identity::Queue_depth::Max_depth >() + 1);
|
|
|
|
/* no native command queueing */
|
|
if (!ncq_support())
|
|
cmd_slots = 1;
|
|
|
|
state = READY;
|
|
state_change();
|
|
}
|
|
|
|
void identify_device()
|
|
{
|
|
state = IDENTIFY;
|
|
addr_t phys = (addr_t)Dataspace_client(device_info_ds).phys_addr();
|
|
|
|
Command_table table(command_table_addr(0), phys, 0x1000);
|
|
table.fis.identify_device();
|
|
execute(0);
|
|
}
|
|
|
|
|
|
/*****************************
|
|
** Block::Driver interface **
|
|
*****************************/
|
|
|
|
bool dma_enabled() { return true; };
|
|
|
|
Block::Session::Operations ops() override
|
|
{
|
|
Block::Session::Operations o;
|
|
o.set_operation(Block::Packet_descriptor::READ);
|
|
o.set_operation(Block::Packet_descriptor::WRITE);
|
|
return o;
|
|
}
|
|
|
|
void read_dma(Block::sector_t block_number,
|
|
size_t block_count,
|
|
addr_t phys,
|
|
Block::Packet_descriptor &packet) override
|
|
{
|
|
io(true, block_number, block_count, phys, packet);
|
|
}
|
|
|
|
void write_dma(Block::sector_t block_number,
|
|
size_t block_count,
|
|
addr_t phys,
|
|
Block::Packet_descriptor &packet) override
|
|
{
|
|
io(false, block_number, block_count, phys, packet);
|
|
}
|
|
|
|
Genode::size_t block_size() override
|
|
{
|
|
Genode::size_t size = 512;
|
|
|
|
if (info->read<Identity::Logical_block::Longer_512>())
|
|
size = info->read<Identity::Logical_words>() / 2;
|
|
|
|
return size;
|
|
}
|
|
|
|
Block::sector_t block_count() override
|
|
{
|
|
return info->read<Identity::Sector_count>();
|
|
}
|
|
};
|
|
|
|
|
|
#endif /* _ATA_DRIVER_H_ */
|