160 lines
4.2 KiB
C++
160 lines
4.2 KiB
C++
/*
|
|
* Copyright (c) 2011, 2012, 2013, 2014 Jonas 'Sortie' Termansen.
|
|
*
|
|
* 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.
|
|
*
|
|
* interrupt.cpp
|
|
* High level interrupt services.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
|
|
#include <sortix/kernel/cpu.h>
|
|
#include <sortix/kernel/interrupt.h>
|
|
#include <sortix/kernel/kernel.h>
|
|
#include <sortix/kernel/process.h>
|
|
#include <sortix/kernel/scheduler.h>
|
|
#include <sortix/kernel/signal.h>
|
|
#include <sortix/kernel/syscall.h>
|
|
#include <sortix/kernel/thread.h>
|
|
|
|
// TODO: The interrupt worker isn't a reliable design.
|
|
|
|
namespace Sortix {
|
|
namespace Interrupt {
|
|
|
|
unsigned char* queue;
|
|
volatile size_t queue_offset;
|
|
volatile size_t queue_used;
|
|
const size_t QUEUE_SIZE = 4096;
|
|
|
|
struct worker_package
|
|
{
|
|
size_t payload_size;
|
|
void (*handler)(void*, void*, size_t);
|
|
void* handler_context;
|
|
};
|
|
|
|
void InitWorker()
|
|
{
|
|
queue = new unsigned char[QUEUE_SIZE];
|
|
if ( !queue )
|
|
Panic("Can't allocate interrupt worker queue");
|
|
queue_offset = 0;
|
|
queue_used = 0;
|
|
}
|
|
|
|
static void WriteToQueue(const void* src, size_t size)
|
|
{
|
|
assert(size <= QUEUE_SIZE - queue_used);
|
|
const unsigned char* input = (const unsigned char*) src;
|
|
for ( size_t i = 0; i < size; i++ )
|
|
{
|
|
size_t index = (queue_offset + queue_used + i) % QUEUE_SIZE;
|
|
queue[index] = input[i];
|
|
}
|
|
queue_used += size;
|
|
}
|
|
|
|
static void ReadFromQueue(void* dst, size_t size)
|
|
{
|
|
assert(size <= queue_used);
|
|
unsigned char* output = (unsigned char*) dst;
|
|
for ( size_t i = 0; i < size; i++ )
|
|
{
|
|
size_t index = (queue_offset + i) % QUEUE_SIZE;
|
|
output[i] = queue[index];
|
|
}
|
|
queue_offset = (queue_offset + size) % QUEUE_SIZE;
|
|
queue_used -= size;
|
|
}
|
|
|
|
static bool PopPackage(struct worker_package* package,
|
|
unsigned char* payload,
|
|
size_t payload_size)
|
|
{
|
|
bool interrupts_was_enabled = Interrupt::SetEnabled(false);
|
|
if ( !queue_used )
|
|
{
|
|
Interrupt::SetEnabled(interrupts_was_enabled);
|
|
return false;
|
|
}
|
|
|
|
ReadFromQueue(package, sizeof(*package));
|
|
if ( !(package->payload_size <= payload_size) )
|
|
{
|
|
Interrupt::SetEnabled(interrupts_was_enabled);
|
|
assert(package->payload_size <= payload_size);
|
|
queue_offset = (queue_offset + package->payload_size) % QUEUE_SIZE;
|
|
return false;
|
|
}
|
|
|
|
ReadFromQueue(payload, package->payload_size);
|
|
|
|
Interrupt::SetEnabled(interrupts_was_enabled);
|
|
return true;
|
|
}
|
|
|
|
void WorkerThread(void* /*user*/)
|
|
{
|
|
assert(Interrupt::IsEnabled());
|
|
|
|
struct worker_package package;
|
|
size_t storage_size = QUEUE_SIZE;
|
|
unsigned char* storage = new unsigned char[storage_size];
|
|
if ( !storage )
|
|
Panic("Can't allocate interrupt worker storage");
|
|
while ( true )
|
|
{
|
|
if ( !PopPackage(&package, storage, storage_size) )
|
|
{
|
|
Scheduler::Yield();
|
|
continue;
|
|
}
|
|
unsigned char* payload = storage;
|
|
size_t payload_size = package.payload_size;
|
|
assert(package.handler);
|
|
package.handler(package.handler_context, payload, payload_size);
|
|
}
|
|
}
|
|
|
|
bool ScheduleWork(void (*handler)(void*, void*, size_t),
|
|
void* handler_context,
|
|
void* payload,
|
|
size_t payload_size)
|
|
{
|
|
assert(!Interrupt::IsEnabled());
|
|
|
|
assert(handler);
|
|
assert(payload || !payload_size);
|
|
|
|
struct worker_package package;
|
|
memset(&package, 0, sizeof(package));
|
|
package.payload_size = payload_size;
|
|
package.handler = handler;
|
|
package.handler_context = handler_context;
|
|
|
|
if ( QUEUE_SIZE - queue_used < sizeof(package) + payload_size )
|
|
return false;
|
|
|
|
WriteToQueue(&package, sizeof(package));
|
|
WriteToQueue(payload, payload_size);
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace Interrupt
|
|
} // namespace Sortix
|