iris/boot-programs/devices.hhp

#pypp 0
// Iris: micro-kernel for a capability-based operating system.
// boot-programs/devices.hhp: interfaces for core devices.
// Copyright 2009 Bas Wijnen <wijnen@debian.org>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __IRIS_DEVICES_HH
#define __IRIS_DEVICES_HH

#include "iris.hh"

// This shouldn't really be here.  But where should it be?
// Requests made by initial threads to tell init about themselves.
enum init_requests:
	INIT_SET_GPIO
	INIT_SET_LCD

// List interface.
template <typename _T> //
struct List : public Cap:
	List (Cap c = Cap ()) : Cap (c):
	// TODO

struct String : public Cap:
	String (Cap c = Cap ()) : Cap (c):
	// TODO

// Keyboard interface.
struct Keyboard : public Cap:
	Keyboard (Cap c = Cap ()) : Cap (c):
	enum request:
		SET_CB
		GET_KEYS
	// At event: the callback is called with a keycode.  One bit defines if it's a press or release event.
	enum constant:
		RELEASE = 1 << 31
	// Set the event callback.  Currently pressed keys emit a key press event to the new callback immediately, plus a ~0 to signal the end of such events.
	void set_cb (Cap cb):
		ocall (cb, CAP_MASTER_DIRECT | SET_CB)
	// Get a list of keys on this keyboard.  The key codes start at zero with no gaps.
	List <String> get_keys (List <String> ret = Cap (0, alloc_cap ())):
		icall (ret, CAP_MASTER_DIRECT | GET_KEYS)
		return ret

// Display interface.
struct Display : public Cap:
	Display (Cap c = Cap ()) : Cap (c):
	enum request:
		EOF_CB
		CREATE_FB
		USE_FB
		GET_INFO
	// Register an end-of-frame callback.
	// At end of frame, the callback is invoked and forgotten.  It must be reregistered to keep a stream of events.
	void set_eof_cb (Cap cb):
		ocall (cb, CAP_MASTER_DIRECT | EOF_CB)
	// Create a framebuffer for the display.  When not in use, it can be freed by the user.
	// The pages must be cappages holding Page capabilities.  They are filled by the display.
	// The passed numbers must be 0 or match a mode that the device can use.
	// The returned number is the physical address of the framebuffer.  It can be used with display_use_framebuffer.
	unsigned create_framebuffer (Caps pages, unsigned w = 0, unsigned h = 0, unsigned mode = 0):
		return icall (pages, Num (CAP_MASTER_DIRECT | CREATE_FB, 0), Num ((w << 16) | h, mode)).l
	// Use a framebuffer.  The address must have been returned from display_create_framebuffer.
	// w, h and mode must match the values given at creation time.
	// unuse_cb is called the next time this operation is requested for this display.
	void use_framebuffer (unsigned addr, Cap unuse_cb = Cap (), unsigned w = 0, unsigned h = 0, unsigned mode = 0):
		ocall (unuse_cb, Num (CAP_MASTER_DIRECT | USE_FB, addr), Num ((w << 16) | h, mode))
	// Get information about the display.
	void get_info ():
		// TODO: Interface is to be designed.



// File system interface.
// filesystem-related interfaces: file, directory, stream, seekable, mappable.
// Normal files implement at least stream or seekable file.  Directories implement directory.
struct File : public Cap:
	File (Cap c = Cap ()) : Cap (c):
	enum request:
		INFO
		CLOSE
		MAP_HANDLE
	// Get information about the file.
	Num get_info (unsigned type, Caps ret = Cap ()):
		return icall (ret, Num (CAP_MASTER_DIRECT | INFO, type))
	// Close a file.  If this is a directory, it implicitly closes all files opened from it.
	void close ():
		call (CAP_MASTER_DIRECT | CLOSE)
	// Map a file handle.  This can be useful for closing all children at once.  The new handle itself is a child of the original handle.
	File map_handle (File ret):
		icall (ret, CAP_MASTER_DIRECT | MAP_HANDLE)

// Directory interface.
struct Directory : public File:
	Directory (Cap c = Cap ()) : File (c):
	enum request:
		GET_SIZE
		GET_NAME
		GET_FILE
		GET_FILE_INFO
		CREATE_FILE
		DELETE_FILE
	// Get the number of entries in this directory.
	Num get_size ():
		return call (CAP_MASTER_DIRECT | GET_SIZE)
	// Get the filename.  The return value is the size of the string, the page is filled with the string itself.
	void get_name (Num idx, String target):
		icall (target, CAP_MASTER_DIRECT | GET_NAME, idx)
	// Get the file.
	void get_file (Num idx, File ret):
		icall (ret, CAP_MASTER_DIRECT | GET_FILE, idx)
	// Get file info.  This returns the same information as file_get_info, without opening the file.
	Num get_file_info (Num idx, unsigned type, Caps ret = Cap ()):
		return icall (ret, Num (CAP_MASTER_DIRECT | GET_FILE_INFO, type), idx)
	// Create a new file.  After this, any index may map to a different file.
	void create_file (String name, File ret):
		icall (ret, CAP_MASTER_DIRECT | CREATE_FILE)
	// Delete a file.  After this, any index may map to a different file.
	void delete_file (Num idx):
		call (CAP_MASTER_DIRECT | DELETE_FILE, idx)

// Stream interface.
struct Stream : public File:
	Stream (Cap c = Cap ()) : File (c):
	enum request:
		READ
		WRITE
	// Try to read size bytes.  Returns the number of bytes successfully read.
	Num read (Num size, String ret):
		return icall (ret, CAP_MASTER_DIRECT | READ, size)
	// Try to write size bytes.  Returns the number of bytes successfully written.
	Num write (String s, Num size):
		return ocall (s, CAP_MASTER_DIRECT | WRITE, size)

// Seekable file interface.
struct Seekable : public File:
	Seekable (Cap c = Cap ()) : File (c):
	enum request:
		READ
		WRITE
		TRUNCATE
	// Try to read size bytes from position idx.  Returns the number of bytes successfully read.
	Num read (Num idx, unsigned size, String ret):
		return icall (ret, Num (CAP_MASTER_DIRECT | READ, size), idx)
	// Try to write size bytes at position idx; the file is extended with zeroes if the write is past the end.  Returns the number of bytes successfully written.
	Num write (Num idx, String s):
		return ocall (s, CAP_MASTER_DIRECT | WRITE, idx)
	// Truncate file to size idx.  The file is extended with zeroes if it gets longer.
	void truncate (Num idx):
		call (CAP_MASTER_DIRECT | TRUNCATE, idx)

// Mappable file interface.
struct Mappable : public Seekable:
	Mappable (Cap c = Cap ()) : Seekable (c):
	// TODO: to be designed.



// Block device interface.
struct Block_device : public Mappable:
	Block_device (Cap c = Cap ()) : Mappable (c):
	// TODO: to be designed.


// TODO.
// Sound interface.
// Usb interfaces (port, device).
// Pointer interface.  (Only movement; buttons follow keyboard interface.)
// Network interface.
// Camera interface.
// Terminal interfaces.

#endif