#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"

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

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

// Keyboard interface.
struct Keyboard : public Kernel::Cap:
	Keyboard (Kernel::Cap c = Kernel::Cap ()) : Kernel::Cap (c):
	enum request:
		SET_CB = 1
		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 (Kernel::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 ():
		icall (CAP_MASTER_DIRECT | GET_KEYS)
		return Kernel::get_arg ()

// Display interface.
struct Display : public Kernel::Cap:
	Display (Kernel::Cap c = Kernel::Cap ()) : Kernel::Cap (c):
	enum request:
		EOF_CB = 1
		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 (Kernel::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 (unsigned w = 0, unsigned h = 0, unsigned mode = 0):
		return icall (Kernel::Num (CAP_MASTER_DIRECT | CREATE_FB, 0), Kernel::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, Kernel::Cap unuse_cb = Kernel::Cap (), unsigned w = 0, unsigned h = 0, unsigned mode = 0):
		ocall (unuse_cb, Kernel::Num (CAP_MASTER_DIRECT | USE_FB, addr), Kernel::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 Kernel::Cap:
	File (Kernel::Cap c = Kernel::Cap ()) : Kernel::Cap (c):
	enum request:
		INFO = 1
		CLOSE
		MAP_HANDLE
	// Get information about the file.
	Kernel::Num get_info (unsigned type):
		return icall (Kernel::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 ():
		icall (CAP_MASTER_DIRECT | MAP_HANDLE)
		return Kernel::get_arg ()

// Directory interface.
struct Directory : public File:
	Directory (Kernel::Cap c = Kernel::Cap ()) : File (c):
	enum request:
		GET_SIZE = 1
		GET_NAME
		GET_FILE
		GET_FILE_INFO
		CREATE_FILE
		DELETE_FILE
	// Get the number of entries in this directory.
	Kernel::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.
	String get_name (Kernel::Num idx):
		icall (CAP_MASTER_DIRECT | GET_NAME, idx)
		return Kernel::get_arg ()
	// Get the file.
	File get_file (Kernel::Num idx):
		icall (CAP_MASTER_DIRECT | GET_FILE, idx)
		return Kernel::get_arg ()
	// Get file info.  This returns the same information as file_get_info, without opening the file.
	Kernel::Num get_file_info (Kernel::Num idx, unsigned type):
		return icall (Kernel::Num (CAP_MASTER_DIRECT | GET_FILE_INFO, type), idx)
	// Create a new file.  After this, any index may map to a different file.
	File create_file (String name):
		icall (CAP_MASTER_DIRECT | CREATE_FILE)
		return Kernel::get_arg ()
	// Delete a file.  After this, any index may map to a different file.
	void delete_file (Kernel::Num idx):
		call (CAP_MASTER_DIRECT | DELETE_FILE, idx)

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

// Seekable file interface.
struct Seekable : public File:
	Seekable (Kernel::Cap c = Kernel::Cap ()) : File (c):
	enum request:
		READ = 1
		WRITE
		TRUNCATE
	// Try to read size bytes from position idx.  Returns the number of bytes successfully read.
	Kernel::Num read (Kernel::Num idx, unsigned size):
		return icall (Kernel::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.
	Kernel::Num write (Kernel::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 (Kernel::Num idx):
		call (CAP_MASTER_DIRECT | TRUNCATE, idx)

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



// Block device interface.
struct Block_device : public Mappable:
	Block_device (Kernel::Cap c = Kernel::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