From 36e4fbbe561892506990bb151fde5686bc7472da Mon Sep 17 00:00:00 2001 From: John Hodge Date: Sun, 26 Oct 2014 17:22:56 +0800 Subject: [PATCH] Kernel - Kill EDI binding with fire (never completed, and wasn't a good API) --- KernelLand/Modules/Interfaces/EDI/Makefile | 10 - .../Modules/Interfaces/EDI/edi/acess-edi.h | 41 -- KernelLand/Modules/Interfaces/EDI/edi/edi.h | 114 ---- .../Modules/Interfaces/EDI/edi/edi_devices.h | 135 ----- .../Interfaces/EDI/edi/edi_dma_streams.h | 52 -- .../Interfaces/EDI/edi/edi_interrupts.h | 65 --- .../Interfaces/EDI/edi/edi_memory_mapping.h | 86 --- .../Modules/Interfaces/EDI/edi/edi_objects.h | 257 --------- .../Modules/Interfaces/EDI/edi/edi_port_io.h | 90 ---- .../Modules/Interfaces/EDI/edi/edi_pthreads.h | 175 ------ .../Modules/Interfaces/EDI/edi/helpers.h | 20 - .../Modules/Interfaces/EDI/edi_int.inc.c | 195 ------- .../Modules/Interfaces/EDI/edi_io.inc.c | 391 -------------- KernelLand/Modules/Interfaces/EDI/main.c | 496 ------------------ 14 files changed, 2127 deletions(-) delete mode 100644 KernelLand/Modules/Interfaces/EDI/Makefile delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/acess-edi.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_devices.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_dma_streams.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_interrupts.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_memory_mapping.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_objects.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_port_io.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/edi_pthreads.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi/helpers.h delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi_int.inc.c delete mode 100644 KernelLand/Modules/Interfaces/EDI/edi_io.inc.c delete mode 100644 KernelLand/Modules/Interfaces/EDI/main.c diff --git a/KernelLand/Modules/Interfaces/EDI/Makefile b/KernelLand/Modules/Interfaces/EDI/Makefile deleted file mode 100644 index a93a8b7c..00000000 --- a/KernelLand/Modules/Interfaces/EDI/Makefile +++ /dev/null @@ -1,10 +0,0 @@ -# -# EDI - Extensible Driver Interface -# -# Acess Interface - - -OBJ = main.o edi.o -NAME = EDI - --include ../Makefile.tpl diff --git a/KernelLand/Modules/Interfaces/EDI/edi/acess-edi.h b/KernelLand/Modules/Interfaces/EDI/edi/acess-edi.h deleted file mode 100644 index 40713886..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/acess-edi.h +++ /dev/null @@ -1,41 +0,0 @@ -/*! \file acess-edi.h - * \brief Acess Specific EDI Objects - * - * Contains documentation and information for - * - Timers - */ - -/* Copyright (c) 2006 John Hodge - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#ifndef ACESS_EDI_H -#define ACESS_EDI_H - -#include "edi_objects.h" - -/// \brief Name of Acess EDI Time Class -#define ACESS_TIMER_CLASS "ACESSEDI-TIMER" - -#ifndef IMPLEMENTING_EDI -/*! \brief int32_t ACESSEDI-TIMER.init_timer(uint32_t Delay, void (*Callback)(int), int Arg); - * - * Takes a timer pointer and intialises the timer object to fire after \a Delay ms - * When the timer fires, \a Callback is called with \a Arg passed to it. - */ -EDI_DEFVAR int32_t (*init_timer)(object_pointer port_object, uint32_t Delay, void (*fcn)(int), int arg); - -/*! \brief void ACESSEDI-TIMER.disable_timer(); - * - * Disables the timer and prevents it from firing - * After this has been called, the timer can then be initialised again. - */ -EDI_DEFVAR void (*disable_timer)(object_pointer port_object); - - -#endif // defined(IMPLEMENTING_EDI) - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi.h b/KernelLand/Modules/Interfaces/EDI/edi/edi.h deleted file mode 100644 index 273f7a3d..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi.h +++ /dev/null @@ -1,114 +0,0 @@ -#ifndef EDI_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#define EDI_H -/*! \file edi.h - * \brief The unitive EDI header to include others, start EDI, and stop EDI. - * - * Data structures and algorithms this header represents: - * DATA STRUCTURE: CLASS QUOTAS - The runtime and the driver have the right to set a quota on how many objects of a given class - * owned by that party the other may construct. These quotas are kept internally by the driver or runtime, are optional and are - * exposed to the other party via the quota() function (for quotas of runtime-owned classes) and the k_quota() function pointer given - * to the runtime by the driver. - * - * ALGORITHMS: INITIALIZATION AND SHUTDOWN - On initialization of the runtime's EDI environment for this driver it calls the - * driver's driver_init() routine (which must match driver_init_t) to initialize the driver with a list of EDI objects the runtime - * thinks the driver should run with. The driver then initializes. This can include calling edi_negotiate_resources() to try and - * obtain more or different objects. Eventually driver_init() returns an edi_initialization_t structure containing its quota - * function and the list of classes belonging to the driver which the runtime can construct. Either the driver or the runtime can - * shut down EDI by calling edi_shutdown(), which in turn calls the driver's driver_finish() routine. On shutdown all objects, of - * classes belonging to both the runtime and driver, are destroyed. */ - -#include "edi_objects.h" -#include "edi_dma_streams.h" -#include "edi_pthreads.h" -#include "edi_port_io.h" -#include "edi_memory_mapping.h" -#include "edi_devices.h" -#include "edi_interrupts.h" - -/*! \brief A pointer to a function the runtime can call if it fails to construct one of the driver's classes to find out what the - * runtime's quota is for that class. - * - * A pointer to a function which takes an edi_string_t as a parameter and returns in int32_t. This function follows the same - * semantics as the quota() function, returning the number of objects of the given class that can be constructed, -1 for infinity or - * -2 for an erroneous class name. It is used to tell the runtime the location of such a function in the driver so that the runtime - * can check quotas on driver-owned classes. */ -typedef int32_t (*k_quota_t)(edi_string_t resource_class); -/*!\struct edi_initialization_t - * \brief Structure containing driver classes available to the runtime and the driver's quota function after the driver has initialized. - * - * Structure containing driver classes available to runtime, the driver's quota function and the driver's name provided to the runtime - * after the driver has initialized. driver_bus, vendor_id, and device_id are all optional fields which coders should consider - * supplementary information. Kernels can require these fields if they so please, but doing so for devices which don't run on a Vendor - * ID/Product ID supporting bus is rather unwise. */ -typedef struct { - /*!\brief The number of driver classes in the driver_classes array. */ - int32_t num_driver_classes; - /*!\brief An array of declarations of driver classes available to the runtime. - * - * This array should not necessarily contain the entire list of EDI classes implemented by the driver. Instead, it should - * contain a list of those classes which the driver has correctly initialized itself to provide instances of with full - * functionality. */ - edi_class_declaration_t *driver_classes; - /*!\brief The driver's quota function. */ - k_quota_t k_quota; - /*!\brief The driver's name. */ - edi_string_t driver_name; - /*!\brief The bus of the device this driver wants to drive, if applicable. - * - * The driver does not have to supply this field, and can also supply "MULTIPLE BUSES" here to indicate that it drives devices - * on multiple buses. */ - edi_string_t driver_bus; - /*!\brief The driver's vendor ID, if applicable. - * - * The driver does not need to supply this field, and should supply -1 to indicate that it does not wish to. */ - int16_t vendor_id; - /*!\brief The driver's device ID, if applicable. - * - * The driver does not need to supply this field, but can supply it along with vendor_id. If either vendor_id or this field are - * set to -1 the runtime should consider this field not supplied. */ - int16_t driver_id; -} edi_initialization_t; -/*!\brief A pointer to a driver's initialization function. - * - * The protocol for the driver's initialization function. The runtime gives the driver a set of EDI objects representing the - * resources it thinks the driver should run with. This function returns an edi_initialization_t structure containing declarations - * of the EDI classes the driver can make available to the runtime after initialization. If any member of that structure contains 0 - * or NULL, it is considered invalid and the runtime should destroy the driver without calling its driver_finish() routine. */ -typedef edi_initialization_t (*driver_init_t)(int32_t num_resources,edi_object_metadata_t *resources); -/*!\brief Requests more resources from the runtime. Can be called during driver initialization. - * - * Called to negotiate with the runtime for the right to create further EDI objects/obtain further resources owned by the runtime. - * When the driver calls this routine, the runtime decides whether to grant more resources. If yes, this call returns true, and the - * driver can proceed to try and create the objects it desires, in addition to destroying EDI objects it doesn't want. Otherwise, - * it returns false. - * The driver must deal with whatever value this routine returns. */ -bool edi_negotiate_resources(); - -/*! \brief Returns the driver's quota of objects for a given runtime-owned class. - * - * This function takes an edi_string_t with the name of a runtime-owned class in it and returns the number of objects of that class - * which drivers can construct, -1 for infinity, or -2 for an erroneous class name. */ -int32_t quota(edi_string_t resource_class); -/*! \brief Sends a string to the operating systems debug output or logging facilities. */ -void edi_debug_write(uint32_t debug_string_length, char *debug_string); -/*! \brief This call destroys all objects and shuts down the entire EDI environment of the driver. - * - * This function shuts down EDI as described in INITIALIZATION AND SHUTDOWN above. All objects are destroyed, EDI functions can no - * longer be successfully called, etc. This function only succeeds when EDI has already been initialized, so it returns -1 when EDI - * hasn't been, 1 on success, or 0 for all other errors. */ -int32_t shutdown_edi(void); - -/*!\brief A pointer to the driver's finishing/shutdown function. - * - * The protocol for the driver's shutting down. This function should do anything the driver wants done before it dies. */ -typedef void (*driver_finish_t)(); - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_devices.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_devices.h deleted file mode 100644 index 245e01f3..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_devices.h +++ /dev/null @@ -1,135 +0,0 @@ -#ifndef EDI_DEVICES_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -/* Edited by thePowersGang (John Hodge) June 2009 - * - Add #ifdef EDI_MAIN_FILE - */ - -#define EDI_DEVICES_H - -/*! \file edi_devices.h - * \brief Declaration and description of simple classes for implementation by EDI drivers to represent hardware devices. - * - * Data structures and algorithms this header represents: - * - * DATA STRUCTURE AND ALGORITHM: BASIC DEVICES - There are two functions, select() for waiting on devices and ioctl() for - * controlling them, common to many POSIX devices. Implementations of EDI-CHARACTER-DEVICE or EDI-BLOCK-DEVICE may implement either of - * these or both, and users of such objects much query for the methods to see if they're supported. Obviously, runtime or driver - * developers don't *need* to support these. - * - * DATA STRUCTURE AND ALGORITHM: CHARACTER DEVICES - The class EDI-CHARACTER-DEVICE provides a very basic interface to character - * devices, which read and write streams of characters. As such, this class only provides read() and write(). The calls attempt a - * likeness to POSIX. - * - * DATA STRUCTURE AND ALGORITHM: BLOCK DEVICES - The class EDI-BLOCK-DEVICE provides a very basic interface to block devices, which - * can read(), write() and seek() to blocks of a specific size in an array of blocks with a specific size. Its declarations and - * semantics should behave like those of most POSIX operating systems. - * - * Note that EDI runtimes should not implement these classes. Their declarations are provided for drivers to implement. */ - -#include "edi_objects.h" - -/* Methods common to all EDI device classes specified in this header. */ - -/*!\brief EAGAIN returned by functions for block and character devices. - * - * Means that the amount of data the device has ready is less than count. */ -#define EAGAIN -1 -/*!\brief EBADOBJ returned by functions for block and character devices. - * - * Means that the object passed as the method's this point was not a valid object of the needed class. */ -#define EBADOBJ -2 -/*!\brief EINVAL returned by functions for block and character devices. - * - * Means that the method got passed invalid parameters. */ -#ifdef EINVAL -# undef EINVAL -#endif -#define EINVAL -3 - -/*!\brief select() type to wait until device is writable. */ -#define EDI_SELECT_WRITABLE 0 -/*!\brief select() type to wait until device is readable. */ -#define EDI_SELECT_READABLE 1 - -/*!\brief Argument to seek(). Sets the block offset (ie: the "current block" index) to the given whence value. */ -#define EDI_SEEK_SET 0 -/*!\brief Argument to seek(). Sets the block offset (ie: the "current block" index) to its current value + whence. */ -#define EDI_SEEK_CURRENT 1 - -#ifdef EDI_MAIN_FILE -/*!\brief Arguments to EDI's basic select() function. */ -edi_variable_declaration_t select_arguments[2] = {{"pointer void","device",1}, - {"unsigned int32_t","select_type",1}}; -/*!\brief Declaration of EDI's basic select() function. - * - * Contrary to the POSIX version, this select() puts its error codes in its return value. */ -edi_function_declaration_t select_declaration = {"int32_t","edi_device_select",0,2,select_arguments,NULL}; -#else -extern edi_function_declaration_t select_declaration; // Declare for non main files -#endif - -#ifdef EDI_MAIN_FILE -/*!\brief Arguments to EDI's basic ioctl() function. */ -edi_variable_declaration_t ioctl_arguments[3] = {{"pointer void","device",1},{"int32_t","request",1},{"pointer void","argp",1}}; -/*!\brief Declaration of EDI's basic ioctl() function. - * - * Contrary to the POSIX version, this ioctl() puts its error codes in its return value. */ -edi_function_declaration_t ioctl_declaration = {"int32_t","edi_device_ioctl",0,3,ioctl_arguments,NULL}; -#else -extern edi_class_declaration_t ioctl_declaration; // Declare for non main files -#endif - -#ifdef EDI_MAIN_FILE -/*!\brief Declaration of the arguments EDI-CHARACTER-DEVICE's read() and write() methods. */ -edi_variable_declaration_t chardev_read_write_arguments[3] = {{"pointer void","chardev",1}, - {"pointer void","buffer",1}, - {"unsigned int32_t","char_count",1}}; -/*!\brief Declarations of the methods of EDI-CHARACTER-DEVICE, read() and write(). - * - * The code pointers of these function declarations are all given as NULL. Driver developers implementing EDI-CHARACTER-DEVICE should - * fill in these entries with pointers to their own functions. */ -EDI_DEFVAR edi_function_declaration_t chardev_methods[2]= {{"int32_t","edi_chardev_read",0,3,chardev_read_write_arguments,NULL}, - {"int32_t","edi_chardev_write",0,3,chardev_read_write_arguments,NULL}}; -/*!\brief Declaration of the EDI-CHARACTER-DEVICE class. - * - * Driver developers implementing this class should fill in their own values for constructor, destructor, and possibly even parent - * before passing the filled-in structure to the EDI runtime. */ -EDI_DEFVAR edi_class_declaration_t chardev_class = {"EDI-CHARACTER-DEVICE",0,2,chardev_methods,NULL,NULL,NULL}; -#else -extern edi_class_declaration_t chardev_class; // Declare for non main files -#endif - -#ifdef EDI_MAIN_FILE -/*!\brief Arguments to EDI-BLOCK-DEVICE's read() and write() methods. */ -edi_variable_declaration_t blockdev_read_write_arguments[3] = {{"pointer void","blockdev",1}, - {"pointer void","buffer",1}, - {"unsigned int32_t","blocks",1}}; -/*!\brief Arguments to EDI-BLOCK-DEVICE's seek() method. */ -edi_variable_declaration_t blockdev_seek_arguments[3] = {{"pointer void","blockdev",1}, - {"int32_t","offset",1}, - {"int32_t","whence",1}}; -/*!\brief Declaration of the methods of EDI-BLOCK-DEVICE, read(), write(), seek(), and get_block_size(). - * - * The code pointers of these function declarations are all given as NULL. Driver developers implementing EDI-BLOCK-DEVICE should fill - * these entries in with pointers to their own functions. */ -edi_function_declaration_t blockdev_methods[4] = {{"int32_t","edi_blockdev_read",0,3,blockdev_read_write_arguments,NULL}, - {"int32_t","edi_blockdev_write",0,3,blockdev_read_write_arguments,NULL}, - {"int32_t","edi_blockdev_seek",0,3,blockdev_seek_arguments,NULL}, - {"unsigned int32_t","edi_blockdev_get_block_size",0,0,NULL,NULL}}; -/*!\brief Declaration of the EDI-BLOCK-DEVICE class. - * - * Driver developers implementing this class should fill in their own values for constructor, destructor, and possibly even parent - * before passing the filled-in structure to the EDI runtime. */ -edi_class_declaration_t blockdev_class = {"EDI-BLOCK-DEVICE",0,4,blockdev_methods,NULL,NULL,NULL}; -#else -extern edi_class_declaration_t blockdev_class; // Declare for non main files -#endif - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_dma_streams.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_dma_streams.h deleted file mode 100644 index 8ab80ccb..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_dma_streams.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef EDI_DMA_STREAMS_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#define EDI_DMA_STREAMS_H - -/*! \file edi_dma_streams.h - * \brief EDI's stream subclass for handling Direct Memory Access hardware. - * - * Data structures and algorithms this header represents: - * - * DATA STRUCTURE: DMA STREAMS - DMA streams are objects of the class EDI-STREAM-DMA used to pass data between a buffer of - * memory and the computer's DMA hardware. It is the responsibility of the object to allocate memory for its stream memory buffer - * which can be used with DMA hardware and to program the DMA hardware for transmissions. DMA streams can be bidirectional if the - * correct DMA mode is used. */ - -#include "edi_objects.h" - -#define DMA_STREAM_CLASS "EDI-STREAM-DMA" - -/*! \brief The name of the EDI DMA stream class. - * - * An edi_string_t with the class name "EDI-STREAM-DMA" in it. */ -#if defined(EDI_MAIN_FILE) || defined(IMPLEMENTING_EDI) -const edi_string_t dma_stream_class = DMA_STREAM_CLASS; -#else -extern const edi_string_t dma_stream_class; -#endif - -#ifndef IMPLEMENTING_EDI -/*! \brief int32_t EDI-STREAM-DMA.init_dma_stream(unsigned int32_t channel,unsigned int32_t mode,unsigned int32_t buffer_pages); - * - * Pointer to the init_dma_stream() method of class EDI-STREAM-DMA, which initializes a DMA stream with a DMA channel, DMA mode, and - * the number of DMA-accessible memory pages to keep as a buffer. It will only work once per stream object. It's possible return - * values are 1 for sucess, -1 for invalid DMA channel, -2 for invalid DMA mode, -3 for inability to allocate enough buffer pages and - * 0 for all other errors. */ -EDI_DEFVAR int32_t (*init_dma_stream)(object_pointer stream, uint32_t channel, uint32_t mode, uint32_t buffer_pages); -/*! \brief int32_t EDI-STREAM-DMA.transmit(data_pointer *anchor,unsigned int32 num_bytes,bool sending); - * - * Pointer to the dma_stream_transmit() method of class EDI-STREAM-DMA, which transmits the given number of bytes of data through - * the DMA stream to/from the given anchor (either source or destination), in the given direction. It returns 1 on success, -1 on - * an uninitialized or invalid DMA stream object, -2 when the anchor was NULL or otherwise invalid, -3 if the DMA stream can't - * transmit in the given direction, and 0 for all other errors. */ -EDI_DEFVAR int32_t (*dma_stream_transmit)(object_pointer stream, data_pointer anchor, uint32_t num_bytes, bool sending); -#endif - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_interrupts.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_interrupts.h deleted file mode 100644 index ef2ffc9f..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_interrupts.h +++ /dev/null @@ -1,65 +0,0 @@ -#ifndef EDI_INTERRUPTS_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#define EDI_INTERRUPTS_H - -/*! \file edi_interrupts.h - * \brief Declaration and description of EDI's interrupt handling class. - * - * Data structures and algorithms this header represents: - * DATA STRUCTURE AND ALGORITHM: INTERRUPT OBJECTS - The class EDI-INTERRUPT encapsulates the handling of machine interrupts. - * It is initialized with an interrupt number to handle and a handler routine to call when that interrupt occurs. Only a couple of - * guarantees are made to the driver regarding the runtime's implementation of interrupt handling: 1) That the driver's handler is - * called for every time the interrupt associated with a valid and initialized interrupt object occurs, in the order of the - * occurences, 2) That the runtime handle the architecture-specific (general to the entire machine, not just this device) - * end-of-interrupt code when the driver is called without first returning from the machine interrupt. Note that the runtime hands - * out interrupt numbers at its own discretion and policy. */ - -#include "edi_objects.h" - -/*! \brief Macro constant containing the name of the interrupt class - */ -#define INTERRUPTS_CLASS "EDI-INTERRUPT" -/*! \brief The name of EDI's interrupt-handling class. - * - * An edi_string_t holding the name of the runtime-implemented interrupt object class. It's value is "EDI-INTERRUPT". */ -#if defined(EDI_MAIN_FILE) || defined(IMPLEMENTING_EDI) -const edi_string_t interrupts_class = INTERRUPTS_CLASS; -#else -extern const edi_string_t interrupts_class; -#endif - -/*! \brief A pointer to an interrupt handling function. - * - * A pointer to a function called to handle interrupts. Its unsigned int32_t parameter is the interrupt number that is being - * handled. */ -typedef void (*interrupt_handler_t)(uint32_t interrupt_number); - -#ifndef IMPLEMENTING_EDI -/*! \brief Initializes an interrupt object with an interrupt number and a pointer to a handler function. - * - * A pointer to the init_interrupt() method of class EDI-INTERRUPT. This method initializes a newly-created interrupt object with an - * interrupt number and a pointer to the driver's handler of type interrupt_handler_t. It can only be called once per object, and - * returns 1 on success, fails with -1 when the interrupt number is invalid or unacceptable to the runtime, fails with -2 when the - * pointer to the driver's interrupt handler is invalid, and fails with -3 for all other errors. */ -EDI_DEFVAR int32_t (*init_interrupt)(object_pointer interrupt, uint32_t interrupt_number, interrupt_handler_t handler); -/*! \brief Get this interrupt object's interrupt number. */ -EDI_DEFVAR uint32_t (*interrupt_get_irq)(object_pointer interrupt); -/*! \brief Set a new handler for this interrupt object. */ -EDI_DEFVAR void (*interrupt_set_handler)(object_pointer interrupt, interrupt_handler_t handler); -/*! \brief Return from this interrupt, letting the runtime run any necessary End-Of-Interrupt code. - * - * A pointer to the interrupt_return() method of class EDI-INTERRUPT. This method returns from the interrupt designated by the - * calling interrupt object. If there is a machine-wide end-of-interrupt procedure and the driver was called during the handling of - * the machine interrupt (as opposed to delaying the handling and letting the runtime EOI), the runtime runs it during this method. - * This method has no return value, since once it's called control leaves the calling thread. */ -EDI_DEFVAR void (*interrupt_return)(object_pointer interrupt); -#endif - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_memory_mapping.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_memory_mapping.h deleted file mode 100644 index ba8dff35..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_memory_mapping.h +++ /dev/null @@ -1,86 +0,0 @@ -#ifndef EDI_MEMORY_MAPPING_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#define EDI_MEMORY_MAPPING_H - -/*! \file edi_memory_mapping.h - * \brief Declaration and description of EDI's class for mapping physical pages into the driver's address space. - * - * Data structures and algorithms this header represents: - * ALGORITHM: MEMORY MAPPINGS - Memory mapping objects of the class EDI-MEMORY-MAPPING are used to give virtual (driver-visible) - * addresses to sections of physical memory. These can either be memory mappings belonging to hardware devices or plain RAM which - * the driver wants page-aligned. A memory mapping object is initialized with the physical address for the memory mapping and the - * number of pages the mapping takes up, or simply the desired length of the a physically contiguous buffer in pages. The class's - * two methods map the section of memory into and out of the driver's virtual address space. */ - -#include "edi_objects.h" - -/*! \brief The name of EDI's memory mapping class. - * - * An edi_string_t with the name of the memory mapping class, "EDI-MEMORY-MAPPING". */ -#if defined(EDI_MAIN_FILE) || defined(IMPLEMENTING_EDI) -const edi_string_t memory_mapping_class = "EDI-MEMORY-MAPPING"; -#else -extern const edi_string_t memory_mapping_class; -#endif - -/*! \brief Flag representing Strong Uncacheable caching method. */ -#define CACHING_STRONG_UNCACHEABLE 0 -/*! \brief Flag representing Uncacheable caching method. */ -#define CACHING_UNCACHEABLE 1 -/*! \brief Flag representing Write combining caching method. */ -#define CACHING_WRITE_COMBINING 2 -/*! \brief Flag representing Write Through caching method. */ -#define CACHING_WRITE_THROUGH 3 -/*! \brief Flag representing Write Back caching method. */ -#define CACHING_WRITE_BACK 3 -/*! \brief Flag representing Write Protected caching method. */ -#define CACHING_WRITE_PROTECTED 3 - -#ifndef IMPLEMENTING_EDI -/*! \brief Initialize an EDI-MEMORY-MAPPING object with a physical address range. - * - * This method takes the start_physical_address of a memory mapping and the number of pages in that mapping and uses these arguments - * to initialize an EDI-MEMORY-MAPPING object. It can only be called once per object. It returns 1 when successful, -1 when an - * invalid physical address is given (one that the runtime knows is neither a physical memory mapping belonging to a device nor - * normal RAM), -2 when the number of pages requested is bad (for the same reasons as the starting address can be bad), and 0 for - * all other errors. - * - * Note that this method can't be invoked on an object which has already initialized via init_memory_mapping_with_pages(). */ -EDI_DEFVAR int32_t (*init_memory_mapping_with_address)(object_pointer mapping, data_pointer start_physical_address, uint32_t pages); -/*! \brief Initialize an EDI-MEMORY-MAPPING object by requesting a number of new physical pages. - * - * This method takes a desired number of physical pages for a memory mapping, and uses that number to initialize an - * EDI-MEMORY-MAPPING object by creating a buffer of contiguous physical pages. It can only be called once per object. It returns - * 1 when successful, -1 when the request for pages cannot be fulfilled, and 0 for all other errors. - * - * Note that this method cannot be called if init_memory_mapping_with_address() has already been used on the given object. */ -EDI_DEFVAR int32_t (*init_memory_mapping_with_pages)(object_pointer mapping, uint32_t pages); -/*! \brief Map the memory-mapping into this driver's visible address space. - * - * This asks the runtime to map a given memory mapping into the driver's virtual address space. Its parameter is the address of a - * data_pointer to place the virtual address of the mapping into. This method returns 1 on success, -1 on an invalid argument, -2 - * for an uninitialized object, and 0 for all other errors. */ -EDI_DEFVAR int32_t (*map_in_mapping)(object_pointer mapping, data_pointer *address_mapped_to); -/*! \brief Unmap the memory mapping from this driver's visible address space. - * - * This method tries to map the given memory mapping out of the driver's virtual address space. It returns 1 for success, -1 - * for an uninitialized memory mapping object, -2 if the mapping isn't mapped into the driver's address space already, and 0 - * for all other errors. */ -EDI_DEFVAR int32_t (*map_out_mapping)(object_pointer mapping); - -/*! \brief Set the caching flags for a memory mapping. */ -EDI_DEFVAR void (*mapping_set_caching_method)(object_pointer mapping, uint32_t caching_method); -/*! \brief Get the current caching method for a memory mapping. */ -EDI_DEFVAR uint32_t (*mapping_get_caching_method)(object_pointer mapping); -/*! \brief Flush write-combining buffers on CPU to make sure changes to memory mapping actually get written. Only applies to a Write Combining caching method (I think.).*/ -EDI_DEFVAR void (*flush_write_combining_mapping)(object_pointer mapping); -#endif - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_objects.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_objects.h deleted file mode 100644 index 0e479517..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_objects.h +++ /dev/null @@ -1,257 +0,0 @@ -#ifndef EDI_OBJECTS_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#define EDI_OBJECTS_H - -/*! \file edi_objects.h - * \brief The header file for basic EDI types and the object system. - * - * This file contains declarations of EDI's primitive data types, as well as structures and functions for with the object system. - * It represents these data structures and algorithms: - * - * DATA STRUCTURE: THE CLASS LIST - EDI implementing runtime's must keep an internal list of classes implemented by the runtime - * and separate lists of classes implemented by each driver. Whoever implements a class is said to "own" that class. The - * internal format of this list is up to the runtime coders, but it must be possible to recreate the original list of - * edi_class_declaration structures the driver declared to the runtime from it. This list is declared to the runtime in an - * initialization function in the header edi.h. The object_class member of an edi_object_metadata structure must point to that - * object's class's entry in this list. - * - * ALGORITHM AND DATA STRUCTURE: CLASSES AND INHERITANCE - Classes are described using edi_class_declaration_t structures and - * follow very simple rules. All data is private and EDI provides no way to access instance data, so there are no member - * variable declarations. However, if the data isn't memory-protected (for example, driver data on the driver heap) EDI allows - * the possibility of pointer access to data, since runtime and driver coders could make use of that behavior. Classes may have - * one ancestor by declaring so in their class declaration structure, and if child methods are different then parent methods - * the children always override their parents. An EDI runtime must also be able to check the existence and ownership of a given - * class given its name in an edi_string_t. - * - * ALGORITHM: OBJECT CREATION AND DESTRUCTION - An EDI runtime should be able to call the constructor of a named class, put the - * resulting object_pointer into an edi_object_metadata_t and return that structure. The runtime should also be able to call an - * object's class's destructor when given a pointer to a valid edi_metadata_t for an already-existing object. Data equivalent - * to an edi_object_metadata_t should also be tracked by the runtime for every object in existence in case of sudden EDI shutdown - * (see edi.h). - * - * ALGORITHM: RUNTIME TYPE INFORMATION - When passed the data_pointer member of an edi_object_metadata_t to a valid object, an - * EDI runtime must be able to return an edi_string_t containing the name of that object's class and to return function_pointers - * to methods when the required information to find the correct method is given by calling a class's method getting function.*/ - -/* If the EDI headers are linked with the standard C library, they use its type definitions. Otherwise, equivalent definitions are - * made.*/ -#if __STDC_VERSION__ == 199901L -# include -# include -#else -# ifndef NULL -# define NULL ((void*)0) -# endif -typedef unsigned char bool; -# define true 1 -# define false 0 -typedef char int8_t; -typedef short int16_t; -typedef long int32_t; -typedef long long int64_t; -typedef unsigned char uint8_t; -typedef unsigned short uint16_t; -typedef unsigned long uint32_t; -typedef unsigned long long uint64_t; -#endif - -/*! \brief Define a variable in the header - */ -#ifdef EDI_MAIN_FILE -# define EDI_DEFVAR -#else -# define EDI_DEFVAR extern -#endif - -/*! \brief A pointer to the in-memory instance of an object. - * - * This type is sized just like a general C pointer type (whatever*) for the target architecture. It's passed as a first parameter - * to all methods, thus allowing EDI classes to be implemented as C++ classes and providing some protection from confusing objects - * with normal pointers. Equivalent to a C++ this pointer or an Object Pascal Self argument. */ -typedef void *object_pointer; -/*! \brief A basic pointer type pointing to arbitrary data in an arbitrary location. */ -typedef void *data_pointer; -/*! \brief A basic function pointer type. - * - * A pointer to a piece of code which can be called and return to its caller, used to distinguish between pointers to code and - * pointers to data. Its size is hardware-dependent. */ -typedef void (*function_pointer)(void); -/*! \brief The length of an EDI string without its null character. */ -#define EDI_STRING_LENGTH 31 -/*! \brief A type representing a 31-character long string with a terminating NULL character at the end. All of EDI uses this type - * for strings. - * - * A null-terminated string type which stores characters in int8s. It allows for 31 characters in each string, with the final - * character being the NULL terminator. Functions which use this type must check that its final character is NULL, a string which - * doesn't not have this property is invalid and insecure. I (the author of EDI) know and understand that this form of a string - * suffers from C programmer's disease, but I can't use anything else without either making string use far buggier or dragging - * everyone onto a better language than C. */ -typedef int8_t edi_string_t[0x20]; -/*! \brief A type representing a pointer form of #edi_string_t suitable for function returns - */ -typedef int8_t *edi_string_ptr_t; - -/*! \var EDI_BASE_TYPES - * \brief A constant array of edi_string_t's holding every available EDI primitive type. */ -/*! \var EDI_TYPE_MODIFIERS - * \brief A constant array of edi_string_t's holding available modifiers for EDI primitive types. */ -#ifdef IMPLEMENTING_EDI - const edi_string_t EDI_BASE_TYPES[9] = {"void","bool","int8_t","int16_t","int32_t","int64_t","function_pointer","intreg","edi_string_t"}; - const edi_string_t EDI_TYPE_MODIFIERS[2] = {"pointer","unsigned"}; -#else - //extern const edi_string_t EDI_BASE_TYPES[9] = {"void","bool","int8_t","int16_t","int32_t","int64_t","function_pointer","intreg", "edi_string_t"}; - //extern const edi_string_t EDI_TYPE_MODIFIERS[2] = {"pointer","unsigned"}; - extern const edi_string_t EDI_BASE_TYPES[9]; - extern const edi_string_t EDI_TYPE_MODIFIERS[2]; -#endif - -/*! \struct edi_object_metadata_t - * \brief A packed structure holding all data to identify an object to the EDI object system. */ -typedef struct { - /*! \brief Points to the instance data of the object represented by this structure. - * - * An object_pointer to the object this structure refers to. The this pointer, so to speak. */ - object_pointer object; - /*! \brief Points the internal record kept by the runtime describing the object's class. - * - * Points to wherever the runtime has stored the class data this object was built from. The class data doesn't need to be - * readable to the driver, and so this pointer can point to an arbitrary runtime-reachable location. */ - data_pointer object_class; -} edi_object_metadata_t; - -/*! \struct edi_variable_declaration_t - * \brief The data structure used to describe a variable declaration to the EDI object system. - * - * The data structure used to describe a variable declaration to the EDI object system. The context of the declaration depends on - * where the data structure appears, ie: alone, in a class declaration, in a parameter list, etc. */ -typedef struct { - /*! \brief The type of the declared variable. - * - * The type of the variable, which must be a valid EDI primitive type as specified in the constant EDI_BASE_TYPES and - * possibly modified by a modifier specified in the constant EDI_TYPE_MODIFIERS. */ - edi_string_t type; - /*! \brief The name of the declared variable. */ - edi_string_t name; - /*! \brief Number of array entries if this variable is an array declaration. - * - * An int32_t specifying the number of variables of 'type' in the array 'name'. For a single variable this value should - * simply be set to 1, for values greater than 1 a packed array of contiguous variables is being declared, and a value of 0 - * is invalid. */ - int32_t array_length; -} edi_variable_declaration_t; - -/*! \struct edi_function_declaration_t - * \brief The data structure used to declare a function to the EDI object system. */ -typedef struct { - /*! \brief The return type of the function. The same type rules which govern variable definitions apply here. */ - edi_string_t return_type; - /*! \brief The name of the declared function. */ - edi_string_t name; - /*! \brief The version number of the function, used to tell different implementations of the same function apart. */ - uint32_t version; - /*! \brief The number of arguments passed to the function. - * - * The number of entries in the member arguments that the object system should care about. Caring about less misses - * parameters to functions, caring about more results in buffer overflows. */ - uint32_t num_arguments; - /*! \brief An array of the declared function's arguments. - * - * A pointer to an array num_arguments long containing edi_variable_declaration_t's for each argument to the declared - * function.*/ - edi_variable_declaration_t *arguments; - /*!\brief A pointer to the declared function's code in memory. */ - function_pointer code; -} edi_function_declaration_t; - -/*! \brief A pointer to a function for constructing instances of a class. - * - * A pointer to a function which takes no parameters and returns an object_pointer pointing to the newly made instance of a class. - * It is the constructor's responsibility to allocate memory for the new object. Each EDI class needs one of these. */ -typedef object_pointer (*edi_constructor_t)(void); -/*! \brief A pointer to a function for destroying instances of a class. - * - * A pointer to a function which takes an object_pointer as a parameter and returns void. This is the destructor counterpart to a - * class's edi_constructor_t, it destroys the object pointed to by its parameter and frees the object's memory. Every class must - * have one */ -typedef void (*edi_destructor_t)(object_pointer); - -/*! \brief Information the driver must give the runtime about its classes so EDI can construct them and call their methods. - * - * A structure used to declare a class to an EDI runtime so instances of it can be constructed by the EDI object system. */ -typedef struct { - /*! \brief The name of the class declared by the structure. */ - edi_string_t name; - /*! \brief The version of the class. This number is used to tell identically named but differently - * implemented classes apart.*/ - uint32_t version; - /*! \brief The number of methods in the 'methods' function declaration array. */ - uint32_t num_methods; - /*! \brief An array of edi_function_declaration_t declaring the methods of this class. */ - edi_function_declaration_t *methods; - /*! \brief Allocates the memory for a new object of the declared class and constructs the object. Absolutely required.*/ - edi_constructor_t constructor; - /*! \brief Destroys the given object of the declared class and frees its memory. Absolutely required. */ - edi_destructor_t destructor; - /*! \brief A pointer to another EDI class declaration structure specifying the declared class's parent class. - * - * Points to a parent class declared in another class declaration. It can be NULL to mean this class has no parent. */ - struct edi_class_declaration_t *parent; -} edi_class_declaration_t; - -/*! \brief Checks the existence of the named class. - * - * This checks for the existence on THE CLASS LIST of the class named by its edi_string_t parameter and returns a signed int32_t. If - * the class isn't found (ie: it doesn't exist as far as EDI is concerned) -1 is returned, if the class is owned by the driver - * (implemented by the driver and declared to the runtime by the driver) 0, and if the class is owned by the runtime (implemented by - * the runtime) 1. */ -int32_t check_class_existence(edi_string_t class_name); -/*! \brief Constructs an object of the named class and returns its object_pointer and a data_pointer to its class data. - * - * Given a valid class name in an edi_string_t this function constructs the specified class and returns an edi_metadata_t describing - * the new object as detailed in OBJECT CREATION AND DESTRUCTION. If the construction fails it returns a structure full of NULL - * pointers. */ -edi_object_metadata_t construct_object(edi_string_t class_name); -/*! \brief Destroys the given object using its class data. - * - * As specified in OBJECT CREATION AND DESTRUCTION this function should destroy an object when given its valid edi_metadata_t. The - * destruction is accomplished by calling the class's destructor. */ -void destroy_object(edi_object_metadata_t object); -/*! \brief Obtains a function pointer to a named method of a given class. - * - * When given a valid data_pointer object_class from an edi_object_metadata_t and an edi_string_t representing the name of the - * desired method retrieves a function_pointer to the method's machine code in memory. If the desired method isn't found, NULL is - * returned. */ -function_pointer get_method_by_name(data_pointer object_class,edi_string_t method_name); -/*! \brief Obtains a function pointer to a method given by a declaration of the given class if the class's method matches the - * declaration. - * - * Works just like get_method_by_name(), but by giving an edi_function_declaration_t for the desired method instead of just its name. - * Performs detailed checking against THE CLASS LIST to make sure that the method returned exactly matches the declaration passed - * in. */ -function_pointer get_method_by_declaration(data_pointer object_class,edi_function_declaration_t declaration); - -/* Runtime typing information. */ -/*! \brief Returns the name of the class specified by a pointer to class data. - * - * Given the data_pointer to an object's class data as stored in an edi_object_metadata_t retrieves the name of the object's class - * and returns it in an edi_string_t. */ -edi_string_ptr_t get_object_class(data_pointer object_class); -/*! \brief Returns the name of a class's parent class. - * - * When given an edi_string_t with a class name in it, returns another edi_string_t containing the name of the class's parent, or an - * empty string. */ -edi_string_ptr_t get_class_parent(edi_string_t some_class); -/*! \brief Returns the internal class data of a named class (if it exists) or NULL. - * - * When given an edi_string_t with a valid class name in it, returns a pointer to the runtime's internal class data for that class. - * Otherwise, it returns NULL. */ -data_pointer get_internal_class(edi_string_t some_class); - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_port_io.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_port_io.h deleted file mode 100644 index a2a1773d..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_port_io.h +++ /dev/null @@ -1,90 +0,0 @@ -#ifndef EDI_PORT_IO_H - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -/* Modified by thePowersGang (John Hodge) - * - Surround variable definitions with an #ifdef IMPLEMENTING_EDI - */ - -#define EDI_PORT_IO_H - -/*! \file edi_port_io.h - * \brief Declaration and description of EDI's port I/O class. - * - * Data structures and algorithms this header represents: - * - * DATA STRUCTURE AND ALGORITHM: PORT I/O OBJECTS - A class named "EDI-IO-PORT" is defined as an encapsulation of the port I/O - * used on some machine architectures. Each object of this class represents a single I/O port which can be read from and written to - * in various sizes. Each port can be held by one object only at a time. */ - -#include "edi_objects.h" - -/*! \brief Macro to create methods for reading from ports. - * - * This macro creates four similar methods, differing in the size of the type they read from the I/O port held by the object. Their - * parameter is a pointer to the output type, which is filled with the value read from the I/O port. They return 1 for success, -1 - * for an uninitialized I/O port object, and 0 for other errors. */ -#define port_read_method(type,name) int32_t (*name)(object_pointer port_object, type *out) -/*! \brief Macro to create methods for writing to ports. - * - * This macro creates four more similar methods, differing in the size of the type they write to the I/O port held by the object. - * Their parameter is the value to write to the port. They return 1 for success, -1 for an uninitialized I/O port object and 0 for - * other errors. */ -#define port_write_method(type,name) int32_t (*name)(object_pointer port_object, type in) - -/*! \brief Name of EDI I/O port class. (Constant) - * - * A CPP constant with the value of #io_port_class */ -#define IO_PORT_CLASS "EDI-IO-PORT" -/*! \brief Name of EDI I/O port class. - * - * An edi_string_t containing the class name "EDI-IO-PORT". */ -#if defined(EDI_MAIN_FILE) || defined(IMPLEMENTING_EDI) -const edi_string_t io_port_class = IO_PORT_CLASS; -#else -extern const edi_string_t io_port_class; -#endif - -#ifndef IMPLEMENTING_EDI -/*! \brief int32_t EDI-IO-PORT.init_io_port(unsigned int16_t port); - * - * This method takes an unsigned int16_t representing a particular I/O port and initializes the invoked EDI-IO-PORT object with it. - * The method returns 1 if successful, -1 if the I/O port could not be obtained for the object, and 0 for all other errors. */ -EDI_DEFVAR int32_t (*init_io_port)(object_pointer port_object, uint16_t port); -/*! \brief Get the port number from a port object. */ -EDI_DEFVAR uint16_t (*get_port_number)(object_pointer port); -/*! \brief Method created by port_read_method() in order to read bytes (int8s) from I/O ports. */ -EDI_DEFVAR int32_t (*read_byte_io_port)(object_pointer port_object, int8_t *out); -/*! \brief Method created by port_read_method() in order to read words (int16s) from I/O ports. */ -EDI_DEFVAR int32_t (*read_word_io_port)(object_pointer port_object, int16_t *out); -/*! \brief Method created by port_read_method() in order to read longwords (int32s) from I/O ports. */ -EDI_DEFVAR int32_t (*read_long_io_port)(object_pointer port_object, int32_t *out); -/*! \brief Method created by port_read_method() in order to read long longwords (int64s) from I/O ports. */ -EDI_DEFVAR int32_t (*read_longlong_io_port)(object_pointer port_object,int64_t *out); -/*! \brief Method of EDI-IO-PORT to read long strings of data from I/O ports. - * - * Reads arbitrarily long strings of data from the given I/O port. Returns 1 for success, -1 for an uninitialized port object, -2 - * for a bad pointer to the destination buffer, and 0 for all other errors. */ -EDI_DEFVAR int32_t (*read_string_io_port)(object_pointer port_object, uint32_t data_length, uint8_t *out); -/*! \brief Method created by port_write_method() in order to write bytes (int8s) to I/O ports. */ -EDI_DEFVAR int32_t (*write_byte_io_port)(object_pointer port_object, int8_t in); -/*! \brief Method created by port_write_method() in order to write words (int16s) to I/O ports. */ -EDI_DEFVAR int32_t (*write_word_io_port)(object_pointer port_object, int16_t in); -/*! \brief Method created by port_write_method() in order to write longwords (int32s) to I/O ports. */ -EDI_DEFVAR int32_t (*write_long_io_port)(object_pointer port_object, int32_t in); -/*! \brief Method created by port_write_method() in order to write long longwords (int64s) to I/O ports. */ -EDI_DEFVAR int32_t (*write_longlong_io_port)(object_pointer port_object, int64_t in); -/*! \brief Method of EDI-IO-PORT to write long strings of data to I/O ports. - * - * Writes arbitrarily long strings of data to the given I/O port. Returns 1 for success, -1 for an uninitialized port object, -2 - * for a bad pointer to the source buffer, and 0 for all other errors. */ -EDI_DEFVAR int32_t (*write_string_io_port)(object_pointer port_object, uint32_t data_length, uint8_t *in); - -#endif // defined(IMPLEMENTING_EDI) - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/edi_pthreads.h b/KernelLand/Modules/Interfaces/EDI/edi/edi_pthreads.h deleted file mode 100644 index c21fa751..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/edi_pthreads.h +++ /dev/null @@ -1,175 +0,0 @@ -#ifndef EDI_PTHREADS - -/* Copyright (c) 2006 Eli Gottlieb. - * Permission is granted to copy, distribute and/or modify this document - * under the terms of the GNU Free Documentation License, Version 1.2 - * or any later version published by the Free Software Foundation; - * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover - * Texts. A copy of the license is included in the file entitled "COPYING". */ - -#define EDI_PTHREADS -/*!\file edi_pthreads.h - * \brief A basic subset of POSIX Threads functionality, providing threading and thread synchronization. - * - * A very basic POSIX Threads interface. Note that pthreads are not a class, because none of these calls really gels with - * object-oriented programming. Also, if drivers aren't processes or threads under the implementing operating system a small - * threading system must be implemented in-runtime just to multiplex the pthreads of EDI drivers. Sorry about that. - * - * Data structures and algorithms this header represents: - * - * ALGORITHM AND DATA STRUCTURE: POSIX Threading - The runtime must provide enough of a POSIX threading interface to implement - * the calls described here. The actual multithreading must be performed by the runtime, and the runtime can implement that - * multithreading however it likes as long as the given POSIX Threads subset works. There is, however, a caveat: since the runtime - * calls the driver like it would a library, the driver must perceive all calls made to it by the runtime as running under one thread. - * From this thread the driver can create others. Such behavior is a quirk of EDI, and does not come from the POSIX standard. - * However, it is necessary to provide the driver with a thread for its own main codepaths. For further details on a given POSIX - * Threading routine, consult its Unix manual page. */ - -#include "edi_objects.h" - -/* Placeholder type definitions. Users of the PThreads interface only ever need to define pointers to these types. */ -/*!\brief Opaque POSIX Threading thread attribute type. */ -typedef void pthread_attr_t; -/*!\brief Opaque POSIX Threading mutex (mutual exclusion semaphore) type. */ -typedef void pthread_mutex_t; -/*!\brief Opaque POSIX Threading mutex attribute type. */ -typedef void pthread_mutex_attr_t; - -/*!\struct sched_param - * \brief POSIX Threading scheduler parameters for a thread. */ -typedef struct { - /*!\brief The priority of the thread. */ - int32_t sched_priority; -} sched_param; - -/*!\brief POSIX Threading thread identifier. */ -typedef uint32_t pthread_t; -/*!\brief POSIX Threading thread function type. - * - * A function pointer to a thread function, with the required signature of a thread function. A thread function takes one untyped - * pointer as an argument and returns an untyped pointer. Such a function is a thread's main routine: it's started with the thread, - * and the thread exits if it returns. */ -typedef void *(*pthread_function_t)(void*); - -/*!\brief Insufficient resources. */ -#define EAGAIN -1 -/*!\brief Invalid parameter. */ -#define EINVAL -2 -/*!\brief Permission denied. */ -#define EPERM -3 -/*!\brief Operation not supported. */ -#define ENOTSUP -4 -/*!\brief Priority scheduling for POSIX/multiple schedulers is not implemented. */ -#define ENOSYS -5 -/*!\brief Out of memory. */ -#define ENOMEM -6 -/*!\brief Deadlock. Crap. */ -#define EDEADLK -7 -/*!\brief Busy. Mutex already locked. */ -#define EBUSY -8 - -/*!\brief Scheduling policy for regular, non-realtime scheduling. The default. */ -#define SCHED_OTHER 0 -/*!\brief Real-time, first-in first-out scheduling policy. Requires special (superuser, where such a thing exists) permissions. */ -#define SCHED_FIFO 1 -/*!\brief Real-time, round-robin scheduling policy. Requires special (superuser, where such a thing exists) permissions. */ -#define SCHED_RR 0 - -/*!\brief Creates a new thread with the given attributes, thread function and arguments, giving back the thread ID of the new - * thread. - * - * pthread_create() creates a new thread of control that executes concurrently with the calling thread. The new thread applies the - * function start_routine, passing it arg as its argument. The attr argument specifies thread attributes to apply to the new thread; - * it can also be NULL for the default thread attributes (joinable with default scheduling policy). On success this function returns - * 0 and places the identifier of the new thread into thread_id. On an error, pthread_create() can return EAGAIN if insufficient - * runtime resources are available to create the requested thread, EINVAL a value specified by attributes is invalid, or EPERM if the - * caller doesn't have permissions to set the given attributes. - * - * For further information: man 3 pthread_create */ -int32_t pthread_create(pthread_t *thread_id, const pthread_attr_t *attributes, pthread_function_t thread_function, void *arguments); -/*!\brief Terminates the execution of the calling thread. The thread's exit code with by status, and this routine never returns. */ -void pthread_exit(void *status); -/*!\brief Returns the thread identifier of the calling thread. */ -pthread_t pthread_self(); -/*!\brief Compares two thread identifiers. - * - * Determines of the given two thread identifiers refer to the same thread. If so, returns non-zero. Otherwise, 0 is returned. */ -int32_t pthread_equal(pthread_t thread1, pthread_t thread2); -/*!\brief Used by the calling thread to relinquish use of the processor. The thread then waits in the run queue to be scheduled - * again. */ -void pthread_yield(); - -/*!\brief Gets the scheduling policy of the given attributes. - * - * Places the scheduling policy for attributes into policy. Returns 0 on success, EINVAL if attributes was invalid, and ENOSYS if - * priority scheduling/multiple scheduler support is not implemented. */ -int32_t pthread_attr_getschedpolicy(const pthread_attr_t *attributes, int32_t *policy); -/*!\brief Sets the scheduling policy of the given attributes. - * - * Requests a switch of scheduling policy to policy for the given attributes. Can return 0 for success, EINVAL if the given policy - * is not one of SCHED_OTHER, SCHED_FIFO or SCHED_RR or ENOTSUP if policy is either SCHED_FIFO or SCHED_RR and the driver is not - * running with correct privileges. */ -int32_t pthread_attr_setschedpolicy(pthread_attr_t *attributes, int32_t policy); - -/*!\brief Gets the scheduling paramaters (priority) from the given attributes. - * - * On success, stores scheduling parameters in param from attributes, and returns 0. Otherwise, returns non-zero error code, such - * as EINVAL if the attributes object is invalid. */ -int32_t pthread_attr_getschedparam(const pthread_attr_t *attributes, sched_param *param); -/*!\brief Sets the scheduling parameters (priority) of the given attributes. - * - * Requests that the runtime set the scheduling parameters (priority) of attributes from param. Returns 0 for success, EINVAL for an - * invalid attributes object, ENOSYS when multiple schedulers/priority scheduling is not implemented, and ENOTSUP when the value of - * param isn't supported/allowed. */ -int32_t pthread_attr_setschedparam(pthread_attr_t *attributes, const sched_param *param); - -/*!\brief The thread obtains its scheduling properties explicitly from its attributes structure. */ -#define PTHREAD_EXPLICIT_SCHED 1 -/*!\brief The thread inherits its scheduling properties from its parent thread. */ -#define PTHREAD_INHERIT_SCHED 0 - -/*!\brief Returns the inheritsched attribute of the given attributes. - * - * On success, returns 0 and places the inheritsched attribute from attributes into inherit. This attribute specifies where the - * thread's scheduling properites shall come from, and can be set to PTHREAD_EXPLICIT_SCHED or PTHREAD_INHERIT_SCHED. On failure it - * returns EINVAL if attributes was invalid or ENOSYS if multiple schedulers/priority scheduling isn't implemented. */ -int32_t pthread_attr_getinheritsched(const pthread_attr_t *attributes, int32_t *inherit); -/*!\brief Sets the inheritsched attribute of the given attributes. - * - * On success, places inherit into the inheritsched attribute of attributes and returns 0. inherit must either contain - * PTHREAD_EXPLICIT_SCHED or PTHREAD_INHERIT_SCHED. On failure, this routine returns EINVAL if attributes is invalid, ENOSYS when - * multiple schedulers/priority scheduling isn't implemented, and ENOSUP if the inheritsched attribute isn't supported. */ -int32_t pthread_attr_setinheritsched(pthread_attr_t *attributes, int32_t inherit); - -/*!\brief Creates a new POSIX Threads mutex, which will initially be unlocked. - * - * Creates a new mutex with the given attributes. If attributes is NULL, the default attributes will be used. The mutex starts out - * unlocked. On success, the new mutex resides in the mutex structure pointed to by mutex, and this routine routines 0. On failure, - * it returns EAGAIN if the system lacked sufficient non-memory resources to initialize the mutex, EBUSY if the given mutex is - * already initialized and in use, EINVAL if either parameter is invalid, and ENOMEM if the system lacks the memory for a new - * mutex. Note: All EDI mutexes are created with the default attributes, and are of type PTHREAD_MUTEX_ERRORCHECK. This means - * undefined behavior can never result from an badly placed function call. */ -int32_t pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutex_attr_t *attributes); -/*!\brief Locks the given mutex. - * - * Locks the given mutex. If the mutex is already locked, blocks the calling thread until it can acquire the lock. When this - * routine returns successfully, it will return 0 and the calling thread will own the lock of the mutex. If the call fails, it can - * return EINVAL when mutex is invalid or EDEADLK if the calling thread already owns the mutex. */ -int32_t pthread_mutex_lock(pthread_mutex_t *mutex); -/*!\brief Unlocks the given mutex. - * - * Unlocks the given mutex, returning 0 on success. On failure, it can return EINVAL when mutex is invalid or EPERM when the - * calling thread doesn't own the mutex. */ -int32_t pthread_mutex_unlock(pthread_mutex_t *mutex); -/*!\brief Tries to lock the given mutex, returning immediately even if the mutex is already locked. - * - * Attempts to lock the given mutex, but returns immediately if it can't acquire a lock. Returns 0 when it has acquired a lock, - * EBUSY if the mutex is already locked, or EINVAL if mutex is invalid. */ -int32_t pthread_mutex_trylock(pthread_mutex_t *mutex); -/*!\brief Destroys the given mutex, or at least the internal structure of it. - * - * Deletes the given mutex, making mutex invalid until it should be initialized by pthread_mutex_init(). Returns 0 on success, - * EINVAL when mutex is invalid, or EBUSY when mutex is locked or referenced by another thread. */ -int32_t pthread_mutex_destroy (pthread_mutex_t *mutex); - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi/helpers.h b/KernelLand/Modules/Interfaces/EDI/edi/helpers.h deleted file mode 100644 index d7bc1388..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi/helpers.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef HELPERS_H - -#define HELPERS_H - -#include - -// Locally Defined -bool edi_string_equal(edi_string_t x,edi_string_t y); -bool descends_from(data_pointer object_class,edi_string_t desired_class); -data_pointer get_actual_class(edi_string_t ancestor,int32_t num_objects,edi_object_metadata_t *objects); - -// Local Copy/set -void *memcpyd(void *dest, void *src, unsigned int count); - -// Implementation Defined Common functions -void *memcpy(void *dest, void *src, unsigned int count); -void *memmove(void *dest, void *src, unsigned int count); -void *realloc(void *ptr, unsigned int size); - -#endif diff --git a/KernelLand/Modules/Interfaces/EDI/edi_int.inc.c b/KernelLand/Modules/Interfaces/EDI/edi_int.inc.c deleted file mode 100644 index 0ab3359e..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi_int.inc.c +++ /dev/null @@ -1,195 +0,0 @@ -/* - * AcessOS EDI Interface - * - IRQ Class - * - * By John Hodge (thePowersGang) - * - * This file has been released into the public domain. - * You are free to use it as you wish. - */ -#include "edi/edi.h" - -// === TYPES === -typedef struct { - uint16_t State; // 0: Unallocated, 1: Allocated, 2: Initialised, (Bit 0x8000 set if in heap) - uint16_t Num; - interrupt_handler_t Handler; -} tEdiIRQ; - -// === PROTOTYPES === -void EDI_Int_IRQ_Handler(tRegs *Regs); - -// === GLOBALS === -tEdiIRQ gEdi_IRQObjects[16]; - -// === FUNCTIONS === -/** - * \fn object_pointer Edi_Int_IRQ_Construct(void) - * \brief Creates a new IRQ Object - * \return Pointer to object - */ -object_pointer Edi_Int_IRQ_Construct(void) -{ - int i; - // Search for a free irq - for( i = 0; i < 16; i ++ ) - { - if(gEdi_IRQObjects[i].State) continue; - gEdi_IRQObjects[i].State = 1; - gEdi_IRQObjects[i].Num = 0; - gEdi_IRQObjects[i].Handler = NULL; - return &gEdi_IRQObjects[i]; - } - return NULL; -} - -/** - * \fn void Edi_Int_IRQ_Destruct(object_pointer Object) - * \brief Destruct an IRQ Object - * \param Object Object to destroy - */ -void Edi_Int_IRQ_Destruct(object_pointer Object) -{ - tEdiIRQ *obj; - - VALIDATE_PTR(Object,); - obj = GET_DATA(Object); - - if( !obj->State ) return; - - if( obj->Handler ) - irq_uninstall_handler( obj->Num ); - - if( obj->State & 0x8000 ) { // If in heap, free - free(Object); - } else { // Otherwise, mark as unallocated - obj->State = 0; - } -} - -/** - * \fn int32_t Edi_Int_IRQ_InitInt(object_pointer Object, uint16_t Num, interrupt_handler_t Handler) - * \brief Initialises an IRQ - * \param Object Object Pointer (this) - * \param Num IRQ Number to use - * \param Handler Callback for IRQ - */ -int32_t Edi_Int_IRQ_InitInt(object_pointer Object, uint16_t Num, interrupt_handler_t Handler) -{ - tEdiIRQ *obj; - - //LogF("Edi_Int_IRQ_InitInt: (Object=0x%x, Num=%i, Handler=0x%x)\n", Object, Num, Handler); - - VALIDATE_PTR(Object,0); - obj = GET_DATA(Object); - - if( !obj->State ) return 0; - - if(Num > 15) return 0; - - // Install the IRQ if a handler is passed - if(Handler) { - if( !irq_install_handler(Num, Edi_Int_IRQ_Handler) ) - return 0; - obj->Handler = Handler; - } - - obj->Num = Num; - obj->State &= ~0x3FFF; - obj->State |= 2; // Set initialised flag - return 1; -} - -/** - * \fn uint16_t Edi_Int_IRQ_GetInt(object_pointer Object) - * \brief Returns the irq number associated with the object - * \param Object IRQ Object to get number from - * \return IRQ Number - */ -uint16_t Edi_Int_IRQ_GetInt(object_pointer Object) -{ - tEdiIRQ *obj; - - VALIDATE_PTR(Object,0); - obj = GET_DATA(Object); - - if( !obj->State ) return 0; - return obj->Num; -} - -/** - * \fn void EDI_Int_IRQ_SetHandler(object_pointer Object, interrupt_handler_t Handler) - * \brief Set the IRQ handler for an IRQ object - * \param Object IRQ Object to alter - * \param Handler Function to use as handler - */ -void EDI_Int_IRQ_SetHandler(object_pointer Object, interrupt_handler_t Handler) -{ - tEdiIRQ *obj; - - // Get Data Pointer - VALIDATE_PTR(Object,); - obj = GET_DATA(Object); - - // Sanity Check arguments - if( !obj->State ) return ; - - // Only register the mediator if it is not already - if( Handler && !obj->Handler ) - if( !irq_install_handler(obj->Num, Edi_Int_IRQ_Handler) ) - return ; - obj->Handler = Handler; -} - -/** - * \fn void EDI_Int_IRQ_Return(object_pointer Object) - * \brief Return from interrupt - * \param Object IRQ Object - * \note Due to the structure of acess interrupts, this is a dummy - */ -void EDI_Int_IRQ_Return(object_pointer Object) -{ -} - -/** - * \fn void Edi_Int_IRQ_Handler(struct regs *Regs) - * \brief EDI IRQ Handler - Calls the handler - * \param Regs Register state at IRQ call - */ -void Edi_Int_IRQ_Handler(struct regs *Regs) -{ - int i; - for( i = 0; i < 16; i ++ ) - { - if(!gEdi_IRQObjects[i].State) continue; // Unused, Skip - if(gEdi_IRQObjects[i].Num != Regs->int_no) continue; // Another IRQ, Skip - if(!gEdi_IRQObjects[i].Handler) continue; // No Handler, Skip - gEdi_IRQObjects[i].Handler( Regs->int_no ); // Call Handler - return; - } -} - - -// === CLASS DECLARATION === -static edi_function_declaration_t scEdi_Int_Functions_IRQ[] = { - {"int32_t", "init_interrupt", 1, 3, NULL, //scEdi_Int_Variables_IO[0], - (function_pointer)Edi_Int_IRQ_InitInt - }, - {"uint32_t", "interrupt_get_irq", 1, 1, NULL, //scEdi_Int_Variables_IO[1], - (function_pointer)Edi_Int_IRQ_GetInt - }, - {"void", "interrupt_set_handler", 1, 2, NULL, //scEdi_Int_Variables_IO[2], - (function_pointer)Edi_Int_IRQ_GetInt - }, - {"void", "interrupt_return", 1, 1, NULL, //scEdi_Int_Variables_IO[3], - (function_pointer)Edi_Int_IRQ_GetInt - } - }; -static edi_class_declaration_t scEdi_Int_Class_IRQ = - { - INTERRUPTS_CLASS, 1, 12, - scEdi_Int_Functions_IRQ, - Edi_Int_IRQ_Construct, - Edi_Int_IRQ_Destruct, - NULL - }; diff --git a/KernelLand/Modules/Interfaces/EDI/edi_io.inc.c b/KernelLand/Modules/Interfaces/EDI/edi_io.inc.c deleted file mode 100644 index 8a6ef22e..00000000 --- a/KernelLand/Modules/Interfaces/EDI/edi_io.inc.c +++ /dev/null @@ -1,391 +0,0 @@ -/* - * AcessOS EDI Interface - * - IO Port Class - * - * By John Hodge (thePowersGang) - * - * This file has been released into the public domain. - * You are free to use it as you wish. - */ -#include "edi/edi.h" - -// === TYPES === -typedef struct { - uint16_t State; // 0: Unallocated, 1: Allocated, 2: Initialised, (Bit 0x8000 set if in heap) - uint16_t Num; -} tEdiPort; - -// === GLOBALS === -#define NUM_PREALLOC_PORTS 128 -tEdiPort gEdi_PortObjects[NUM_PREALLOC_PORTS]; - -// === FUNCTIONS === -/** - * \fn object_pointer Edi_Int_IO_Construct(void) - * \brief Creates a new IO Port Object - * \return Pointer to object - */ -object_pointer Edi_Int_IO_Construct(void) -{ - tEdiPort *ret; - int i; - // Search for a free preallocated port - for( i = 0; i < NUM_PREALLOC_PORTS; i ++ ) - { - if(gEdi_PortObjects[i].State) continue; - gEdi_PortObjects[i].State = 1; - gEdi_PortObjects[i].Num = 0; - return &gEdi_PortObjects[i]; - } - // Else, use heap space - ret = malloc( sizeof(tEdiPort) ); - ret->State = 0x8001; - ret->Num = 0; - return ret; -} - -/** - * \fn void Edi_Int_IO_Destruct(object_pointer Object) - * \brief Destruct an IO Port Object - * \param Object Object to destroy - */ -void Edi_Int_IO_Destruct(object_pointer Object) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object,); - obj = GET_DATA(Object); - - if(obj->State & 0x8000) { // If in heap, free - free(Object); - } else { // Otherwise, mark as unallocated - obj->State = 0; - } -} - -/** - * \fn int32_t Edi_Int_IO_InitPort(object_pointer Object, uint16_t Port) - * \brief Initialises an IO Port - * \param Object Object Pointer (this) - * \param Port Port Number to use - */ -int32_t Edi_Int_IO_InitPort(object_pointer Object, uint16_t Port) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - - if( !obj->State ) return 0; - obj->Num = Port; - obj->State &= ~0x3FFF; - obj->State |= 2; // Set initialised flag - return 1; -} - -/** - * \fn uint16_t Edi_Int_IO_GetPortNum(object_pointer Object) - * \brief Returns the port number associated with the object - * \param Object Port Object to get number from - * \return Port Number - */ -uint16_t Edi_Int_IO_GetPortNum(object_pointer Object) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - // Check if valid - if( !obj->State ) return 0; - // Return Port No - return obj->Num; -} - -/** - * \fn int32_t Edi_Int_IO_ReadByte(object_pointer Object, uint8_t *out) - * \brief Read a byte from an IO port - * \param Object Port Object - * \param out Pointer to put read data - */ -int32_t Edi_Int_IO_ReadByte(object_pointer Object, uint8_t *out) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "inb %%dx, %%al" : "=a" (*out) : "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_ReadWord(object_pointer Object, uint16_t *out) - * \brief Read a word from an IO port - * \param Object Port Object - * \param out Pointer to put read data - */ -int32_t Edi_Int_IO_ReadWord(object_pointer Object, uint16_t *out) -{ - - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "inw %%dx, %%ax" : "=a" (*out) : "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_ReadDWord(object_pointer Object, uint32_t *out) - * \brief Read a double word from an IO port - * \param Object Port Object - * \param out Pointer to put read data - */ -int32_t Edi_Int_IO_ReadDWord(object_pointer Object, uint32_t *out) -{ - - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "inl %%dx, %%eax" : "=a" (*out) : "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_ReadQWord(object_pointer Object, uint64_t *out) - * \brief Read a quad word from an IO port - * \param Object Port Object - * \param out Pointer to put read data - */ -int32_t Edi_Int_IO_ReadQWord(object_pointer Object, uint64_t *out) -{ - uint32_t *out32 = (uint32_t*)out; - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "inl %%dx, %%eax" : "=a" (*out32) : "d" ( obj->Num ) ); - __asm__ __volatile__ ( "inl %%dx, %%eax" : "=a" (*(out32+1)) : "d" ( obj->Num+4 ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_ReadString(object_pointer Object, uint32_t Length, uint8_t *out) - * \brief Read a byte from an IO port - * \param Object Port Object - * \param Length Number of bytes to read - * \param out Pointer to put read data - */ -int32_t Edi_Int_IO_ReadString(object_pointer Object, uint32_t Length, uint8_t *out) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "rep insb" : : "c" (Length), "D" (out), "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_WriteByte(object_pointer Object, uint8_t in) - * \brief Write a byte from an IO port - * \param Object Port Object - * \param in Data to write - */ -int32_t Edi_Int_IO_WriteByte(object_pointer Object, uint8_t in) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "outb %%al, %%dx" : : "a" (in), "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_WriteWord(object_pointer Object, uint16_t in) - * \brief Write a word from an IO port - * \param Object Port Object - * \param in Data to write - */ -int32_t Edi_Int_IO_WriteWord(object_pointer Object, uint16_t in) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "outw %%ax, %%dx" : : "a" (in), "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_WriteDWord(object_pointer Object, uint32_t in) - * \brief Write a double word from an IO port - * \param Object Port Object - * \param in Data to write - */ -int32_t Edi_Int_IO_WriteDWord(object_pointer Object, uint32_t in) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "outl %%eax, %%dx" : : "a" (in), "d" ( obj->Num ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_WriteQWord(object_pointer Object, uint64_t in) - * \brief Write a quad word from an IO port - * \param Object Port Object - * \param in Data to write - */ -int32_t Edi_Int_IO_WriteQWord(object_pointer Object, uint64_t in) -{ - uint32_t *in32 = (uint32_t*)∈ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "outl %%eax, %%dx" : : "a" (*in32), "d" ( obj->Num ) ); - __asm__ __volatile__ ( "outl %%eax, %%dx" : : "a" (*(in32+1)), "d" ( obj->Num+4 ) ); - - return 1; -} - -/** - * \fn int32_t Edi_Int_IO_WriteString(object_pointer Object, uint32_t Length, uint8_t *in) - * \brief Read a byte from an IO port - * \param Object Port Object - * \param Length Number of bytes to write - * \param in Pointer to of data to write - */ -int32_t Edi_Int_IO_WriteString(object_pointer Object, uint32_t Length, uint8_t *in) -{ - tEdiPort *obj; - // Get Data Pointer - VALIDATE_PTR(Object, 0); - obj = GET_DATA(Object); - if( !obj->State ) return 0; - if( obj->State & 1 ) return -1; // Unintialised - - __asm__ __volatile__ ( "rep outsb" : : "c" (Length), "D" (in), "d" ( obj->Num ) ); - - return 1; -} - -// === CLASS DECLARATION === -/*static edi_variable_declaration_t *scEdi_Int_Variables_IO[] = { - { - {"pointer", "port_object", 0}, - {"uint16_t", "port", 0} - }, - { - {"pointer", "port_object", 0} - }, - { - {"pointer", "port_object", 0}, - {"pointer int8_t", "out", 0} - } -};*/ -static edi_function_declaration_t scEdi_Int_Functions_IO[] = { - {"int32_t", "init_io_port", 1, 2, NULL, //scEdi_Int_Variables_IO[0], - (function_pointer)Edi_Int_IO_InitPort - }, - {"uint16_t", "get_port_number", 1, 1, NULL, //scEdi_Int_Variables_IO[1], - (function_pointer)Edi_Int_IO_GetPortNum - }, - {"int32_t", "read_byte_io_port", 1, 2, NULL, //scEdi_Int_Variables_IO[2], - (function_pointer)Edi_Int_IO_ReadByte - }, - {"int32_t", "read_word_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"pointer int16_t", "out", 0} - }*/, - (function_pointer)Edi_Int_IO_ReadWord - }, - {"int32_t", "read_long_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"pointer int32_t", "out", 0} - }*/, - (function_pointer)Edi_Int_IO_ReadDWord - }, - {"int32_t", "read_longlong_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"pointer int64_t", "out", 0} - }*/, - (function_pointer)Edi_Int_IO_ReadQWord - }, - {"int32_t", "read_string_io_port", 1, 3, NULL/*{ - {"pointer", "port_object", 0}, - {"int32_T", "data_length", 0}, - {"pointer int64_t", "out", 0} - }*/, - (function_pointer)Edi_Int_IO_ReadString - }, - - {"int32_t", "write_byte_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"int8_t", "in", 0} - }*/, - (function_pointer)Edi_Int_IO_WriteByte}, - {"int32_t", "write_word_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"int16_t", "in", 0} - }*/, - (function_pointer)Edi_Int_IO_WriteWord}, - {"int32_t", "write_long_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"int32_t", "in", 0} - }*/, - (function_pointer)Edi_Int_IO_WriteDWord}, - {"int32_t", "write_longlong_io_port", 1, 2, NULL/*{ - {"pointer", "port_object", 0}, - {"int64_t", "in", 0} - }*/, - (function_pointer)Edi_Int_IO_WriteQWord} - }; -static edi_class_declaration_t scEdi_Int_Class_IO = - { - IO_PORT_CLASS, 1, 12, - scEdi_Int_Functions_IO, - Edi_Int_IO_Construct, - Edi_Int_IO_Destruct, - NULL - }; diff --git a/KernelLand/Modules/Interfaces/EDI/main.c b/KernelLand/Modules/Interfaces/EDI/main.c deleted file mode 100644 index c3d0272a..00000000 --- a/KernelLand/Modules/Interfaces/EDI/main.c +++ /dev/null @@ -1,496 +0,0 @@ -/* - * Acess2 EDI Layer - */ -#define DEBUG 0 -#define VERSION ((0<<8)|1) -#include -#include -#include -#define IMPLEMENTING_EDI 1 -#include "edi/edi.h" - -#define VALIDATE_PTR(_ptr,_err) do{if(!(_ptr))return _err; }while(0) -#define GET_DATA(_ptr) (Object) - -#include "edi_io.inc.c" -#include "edi_int.inc.c" - -// === STRUCTURES === -typedef struct sAcessEdiDriver { - struct sAcessEdiDriver *Next; - tDevFS_Driver Driver; - int FileCount; - struct { - char *Name; - tVFS_Node Node; - } *Files; - edi_object_metadata_t *Objects; - edi_initialization_t Init; - driver_finish_t Finish; -} tAcessEdiDriver; - -// === PROTOTYPES === - int EDI_Install(char **Arguments); - int EDI_DetectDriver(void *Base); - int EDI_LoadDriver(void *Base); -vfs_node *EDI_FS_ReadDir(vfs_node *Node, int Pos); -vfs_node *EDI_FS_FindDir(vfs_node *Node, char *Name); - int EDI_FS_CharRead(vfs_node *Node, Uint64 Offset, Uint64 Length, void *Buffer); - int EDI_FS_CharWrite(vfs_node *Node, Uint64 Offset, Uint64 Length, void *Buffer); - int EDI_FS_IOCtl(vfs_node *Node, int Id, void *Data); -data_pointer EDI_GetInternalClass(edi_string_t ClassName); - -// === GLOBALS === -MODULE_DEFINE(0, VERSION, EDI, EDI_Install, NULL, NULL); -tModuleLoader gEDI_Loader = { - NULL, "EDI", EDI_DetectDriver, EDI_LoadDriver, NULL -}; -tSpinlock glEDI_Drivers; -tAcessEdiDriver *gEdi_Drivers = NULL; -edi_class_declaration_t *gcEdi_IntClasses[] = { - &scEdi_Int_Class_IO, &scEdi_Int_Class_IRQ -}; -#define NUM_INT_CLASSES (sizeof(gcEdi_IntClasses)/sizeof(gcEdi_IntClasses[0])) -char *csCharNumbers[] = {"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9"}; -char *csBlockNumbers[] = {"blk0", "blk1", "blk2", "blk3", "blk4", "blk5", "blk6", "blk7", "blk8", "blk9"}; - -// === CODE === -/** - * \fn int EDI_Install(char **Arguments) - * \brief Stub intialisation routine - */ -int EDI_Install(char **Arguments) -{ - Module_RegisterLoader( &gEDI_Loader ); - return 1; -} - -/** - * \brief Detects if a driver should be loaded by the EDI subsystem - */ -int EDI_DetectDriver(void *Base) -{ - if( Binary_FindSymbol(BASE, "driver_init", NULL) == 0 ) - return 0; - - return 1; -} - -/** - * \fn int Edi_LoadDriver(void *Base) - * \brief Load an EDI Driver from a loaded binary - * \param Base Binary Handle - * \return 0 on success, non zero on error - */ -int EDI_LoadDriver(void *Base) -{ - driver_init_t init; - driver_finish_t finish; - tAcessEdiDriver *info; - int i, j; - int devfsId; - edi_class_declaration_t *classes; - - ENTER("pBase", Base); - - // Get Functions - if( !Binary_FindSymbol(Base, "driver_init", (Uint*)&init) - || !Binary_FindSymbol(Base, "driver_finish", (Uint*)&finish) ) - { - Warning("[EDI ] Driver %p does not provide both `driver_init` and `driver_finish`\n", Base); - Binary_Unload(Base); - return 0; - } - - // Allocate Driver Information - info = malloc( sizeof(tAcessEdiDriver) ); - info->Finish = finish; - - // Initialise Driver - info->Init = init( 0, NULL ); // TODO: Implement Resources - - LOG("info->Init.driver_name = '%s'", info->Init.driver_name); - LOG("info->Init.num_driver_classes = %i", info->Init.num_driver_classes); - - // Count mappable classes - classes = info->Init.driver_classes; - info->FileCount = 0; - info->Objects = NULL; - for( i = 0, j = 0; i < info->Init.num_driver_classes; i++ ) - { - if( strncmp(classes[i].name, "EDI-CHARACTER-DEVICE", 32) == 0 ) - { - data_pointer *obj; - // Initialise Object Instances - for( ; (obj = classes[i].constructor()); j++ ) { - LOG("%i - Constructed '%s'", j, classes[i].name); - info->FileCount ++; - info->Objects = realloc(info->Objects, sizeof(*info->Objects)*info->FileCount); - info->Objects[j].object = obj; - info->Objects[j].object_class = &classes[i]; - } - } - else - LOG("%i - %s", i, classes[i].name); - } - - if(info->FileCount) - { - int iNumChar = 0; - // Create VFS Nodes - info->Files = malloc( info->FileCount * sizeof(*info->Files) ); - memset(info->Files, 0, info->FileCount * sizeof(*info->Files)); - j = 0; - for( j = 0; j < info->FileCount; j++ ) - { - classes = info->Objects[j].object_class; - if( strncmp(classes->name, "EDI-CHARACTER-DEVICE", 32) == 0 ) - { - LOG("%i - %s", j, csCharNumbers[iNumChar]); - info->Files[j].Name = csCharNumbers[iNumChar]; - info->Files[j].Node.NumACLs = 1; - info->Files[j].Node.ACLs = &gVFS_ACL_EveryoneRW; - info->Files[j].Node.ImplPtr = &info->Objects[j]; - info->Files[j].Node.Read = EDI_FS_CharRead; - info->Files[j].Node.Write = EDI_FS_CharWrite; - info->Files[j].Node.IOCtl = EDI_FS_IOCtl; - info->Files[j].Node.CTime = - info->Files[j].Node.MTime = - info->Files[j].Node.ATime = now(); - - iNumChar ++; - continue; - } - } - - // Create DevFS Driver - info->Driver.ioctl = EDI_FS_IOCtl; - memsetda(&info->Driver.rootNode, 0, sizeof(vfs_node) / 4); - info->Driver.Name = info->Init.driver_name; - info->Driver.RootNode.Flags = VFS_FFLAG_DIRECTORY; - info->Driver.RootNode.NumACLs = 1; - info->Driver.RootNode.ACLs = &gVFS_ACL_EveryoneRX; - info->Driver.RootNode.Length = info->FileCount; - info->Driver.RootNode.ImplPtr = info; - info->Driver.RootNode.ReadDir = EDI_FS_ReadDir; - info->Driver.RootNode.FindDir = EDI_FS_FindDir; - info->Driver.RootNode.IOCtl = EDI_FS_IOCtl; - - // Register - devfsId = dev_addDevice( &info->Driver ); - if(devfsId == -1) { - free(info->Files); // Free Files - info->Finish(); // Clean up driver - free(info); // Free info structure - Binary_Unload(iDriverBase); // Unload library - return -3; // Return error - } - } - - // Append to loaded list; - LOCK(&glEDI_Drivers); - info->Next = gEDI_Drivers; - gEDI_Drivers = info; - RELEASE(&glEDI_Drivers); - - LogF("[EDI ] Loaded Driver '%s' (%s)\n", info->Init.driver_name, Path); - LEAVE('i', 1); - return 1; -} - -// --- Filesystem Interaction --- -/** - * \brief Read from a drivers class list - * \param Node Driver's Root Node - * \param Pos Index of file to get - */ -char *EDI_FS_ReadDir(tVFS_Node *Node, int Pos) -{ - tAcessEdiDriver *info; - - // Sanity Check - if(!Node) return NULL; - - // Get Information Structure - info = (void *) Node->ImplPtr; - if(!info) return NULL; - - // Check Position - if(Pos < 0) return NULL; - if(Pos >= info->FileCount) return NULL; - - return strdup( info->Files[Pos].Name ); -} - -/** - * \fn tVFS_Node *EDI_FS_FindDir(tVFS_Node *Node, char *Name) - * \brief Find a named file in a driver - * \param Node Driver's Root Node - * \param Name Name of file to find - */ -tVFS_Node *EDI_FS_FindDir(tVFS_Node *Node, char *Name) -{ - tAcessEdiDriver *info; - int i; - - // Sanity Check - if(!Node) return NULL; - if(!Name) return NULL; - - // Get Information Structure - info = (void *) Node->ImplPtr; - if(!info) return NULL; - - for( i = 0; i < info->FileCount; i++ ) - { - if(strcmp(info->Files[i].name, Name) == 0) - return &info->Files[i].Node; - } - - return NULL; -} - -/** - * \fn Uint64 EDI_FS_CharRead(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer) - * \brief Read from an EDI Character Device - * \param Node File Node - * \param Offset Offset into file (ignored) - * \param Length Number of characters to read - * \param Buffer Destination for data - * \return Number of characters read - */ -Uint64 EDI_FS_CharRead(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer) -{ - edi_object_metadata_t *meta; - edi_class_declaration_t *class; - - // Sanity Check - if(!Node || !Buffer) return 0; - if(Length <= 0) return 0; - // Get Object Metadata - meta = (void *) Node->ImplPtr; - if(!meta) return 0; - - // Get Class - class = meta->object_class; - if(!class) return 0; - - // Read from object - if( ((tAnyFunction) class->methods[0].code)( meta->object, Buffer, Length )) - return Length; - - return 0; -} - -/** - * \fn Uint64 EDI_FS_CharWrite(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer) - * \brief Write to an EDI Character Device - * \param Node File Node - * \param Offset Offset into file (ignored) - * \param Length Number of characters to write - * \param Buffer Source for data - * \return Number of characters written - */ -Uint64 EDI_FS_CharWrite(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer) -{ - edi_object_metadata_t *meta; - edi_class_declaration_t *class; - - // Sanity Check - if(!Node || !Buffer) return 0; - if(Length <= 0) return 0; - // Get Object Metadata - meta = (void *) Node->ImplPtr; - if(!meta) return 0; - - // Get Class - class = meta->object_class; - if(!class) return 0; - - // Write to object - if( ((tAnyFunction) class->methods[1].code)( meta->object, Buffer, Length )) - return Length; - - return 0; -} - -/** - * \fn int EDI_FS_IOCtl(tVFS_Node *Node, int Id, void *Data) - * \brief Perfom an IOCtl call on the object - */ -int EDI_FS_IOCtl(tVFS_Node *Node, int Id, void *Data) -{ - return 0; -} - -// --- EDI Functions --- -/** - * \fn data_pointer EDI_GetDefinedClass(edi_string_t ClassName) - * \brief Gets the structure of a driver defined class - * \param ClassName Name of class to find - * \return Class definition or NULL - */ -data_pointer EDI_GetDefinedClass(edi_string_t ClassName) -{ - int i; - tAcessEdiDriver *drv; - edi_class_declaration_t *classes; - - for(drv = gEdi_Drivers; - drv; - drv = drv->Next ) - { - classes = drv->Init.driver_classes; - for( i = 0; i < drv->Init.num_driver_classes; i++ ) - { - if( strncmp(classes[i].name, ClassName, 32) == 0 ) - return &classes[i]; - } - } - return NULL; -} - -/** - * \fn int32_t EDI_CheckClassExistence(edi_string_t ClassName) - * \brief Checks if a class exists - * \param ClassName Name of class - * \return 1 if the class exists, -1 otherwise - */ -int32_t EDI_CheckClassExistence(edi_string_t ClassName) -{ - //LogF("check_class_existence: (ClassName='%s')\n", ClassName); - if(EDI_GetInternalClass(ClassName)) - return 1; - - if(EDI_GetDefinedClass(ClassName)) // Driver Defined - return 1; - - return -1; -} - -/** - * \fn edi_object_metadata_t EDI_ConstructObject(edi_string_t ClassName) - * \brief Construct an instance of an class (an object) - * \param ClassName Name of the class to construct - */ -edi_object_metadata_t EDI_ConstructObject(edi_string_t ClassName) -{ - edi_object_metadata_t ret = {0, 0}; - edi_class_declaration_t *class; - - //LogF("EDI_ConstructObject: (ClassName='%s')\n", ClassName); - - // Get class definition - if( !(class = EDI_GetInternalClass(ClassName)) ) // Internal - if( !(class = EDI_GetDefinedClass(ClassName)) ) // Driver Defined - return ret; // Return ERROR - - // Initialise - ret.object = class->constructor(); - if( !ret.object ) - return ret; // Return ERROR - - // Set declaration pointer - ret.object_class = class; - - //LogF("EDI_ConstructObject: RETURN {0x%x,0x%x}\n", ret.object, ret.object_class); - return ret; -} - -/** - * \fn void EDI_DestroyObject(edi_object_metadata_t Object) - * \brief Destroy an instance of a class - * \param Object Object to destroy - */ -void EDI_DestroyObject(edi_object_metadata_t Object) -{ - if( !Object.object ) return; - if( !Object.object_class ) return; - - ((edi_class_declaration_t*)(Object.object_class))->destructor( &Object ); -} - -/** - * \fn function_pointer EDI_GetMethodByName(data_pointer ObjectClass, edi_string_t MethodName) - * \brief Get a method of a class by it's name - * \param ObjectClass Pointer to a ::edi_object_metadata_t of the object - * \param MethodName Name of the desired method - * \return Function address or NULL - */ -function_pointer EDI_GetMethodByName(data_pointer ObjectClass, edi_string_t MethodName) -{ - edi_class_declaration_t *dec = ObjectClass; - int i; - - //LogF("get_method_by_name: (ObjectClass=0x%x, MethodName='%s')\n", ObjectClass, MethodName); - - if(!ObjectClass) return NULL; - - for(i = 0; i < dec->num_methods; i++) - { - if(strncmp(MethodName, dec->methods[i].name, 32) == 0) - return dec->methods[i].code; - } - return NULL; -} - -#if 0 -function_pointer get_method_by_declaration(data_pointer Class, edi_function_declaration_t Declaration); -#endif - -/** - * \fn edi_string_ptr_t EDI_GetClassParent(edi_string_t ClassName) - * \brief Get the parent of the named class - * \todo Implement - */ -edi_string_ptr_t EDI_GetClassParent(edi_string_t ClassName) -{ - WarningEx("EDI", "`get_class_parent` is unimplemented"); - return NULL; -} - -/** - * \fn data_pointer EDI_GetInternalClass(edi_string_t ClassName) - * \brief Get a builtin class - * \param ClassName Name of class to find - * \return Pointer to the ::edi_class_declaration_t of the class - */ -data_pointer EDI_GetInternalClass(edi_string_t ClassName) -{ - int i; - //LogF("get_internal_class: (ClassName='%s')\n", ClassName); - for( i = 0; i < NUM_INT_CLASSES; i++ ) - { - if( strncmp( gcEdi_IntClasses[i]->name, ClassName, 32 ) == 0 ) { - return gcEdi_IntClasses[i]; - } - } - //LogF("get_internal_class: RETURN NULL\n"); - return NULL; -} - -/** - * \fn edi_string_ptr_t EDI_GetObjectClass(data_pointer Object) - * \brief Get the name of the object of \a Object - * \param Object Object to get name of - * \return Pointer to the class name - */ -edi_string_ptr_t EDI_GetObjectClass(data_pointer ObjectClass) -{ - edi_object_metadata_t *Metadata = ObjectClass; - // Sanity Check - if(!ObjectClass) return NULL; - if(!(edi_class_declaration_t*) Metadata->object_class) return NULL; - - // Return Class Name - return ((edi_class_declaration_t*) Metadata->object_class)->name; -} - -// === EXPORTS === -EXPORTAS(EDI_CheckClassExistence, check_class_existence); -EXPORTAS(EDI_ConstructObject, construct_object); -EXPORTAS(EDI_DestroyObject, destroy_object); -EXPORTAS(EDI_GetMethodByName, get_method_by_name); -EXPORTAS(EDI_GetClassParent, get_class_parent); -EXPORTAS(EDI_GetInternalClass, get_internal_class); -EXPORTAS(EDI_GetObjectClass, get_object_class); -- 2.20.1