X-Git-Url: https://scm.lunaixsky.com/lunaix-os.git/blobdiff_plain/c50398ab4cb09658b3b3fff74804d2f26df785e7..2236410f4582ab45ae8c384dd6eeeef5d10aab15:/lunaix-os/includes/lunaix/device.h diff --git a/lunaix-os/includes/lunaix/device.h b/lunaix-os/includes/lunaix/device.h index c456df4..f650821 100644 --- a/lunaix-os/includes/lunaix/device.h +++ b/lunaix-os/includes/lunaix/device.h @@ -3,10 +3,87 @@ #define DEVICE_NAME_SIZE 32 +#include +#include #include +#include #include +#include #include +#include + +/** + * @brief Export a device definition (i.e., device driver metadata) + * + */ +#define EXPORT_DEVICE(id, devdef, load_order) \ + export_ldga_el(devdefs, id, ptr_t, devdef); \ + export_ldga_el_sfx(devdefs, id##_ldorder, ptr_t, devdef, load_order); + +/** + * @brief Mark the device definition can be loaded on demand, all other loading + * options are extended from this + */ +#define load_on_demand ld_ondemand + +/** + * @brief Mark the device definition to be loaded as system configuration + * device. These kind of devices are defined to be the devices that talk to the + * system firmware to do config, or collecting crucial information about the + * system. For instances, ACPI, SoC components, and other **interconnection** + * buese (not USB!). Such device driver must only rely on basic memory + * management service, and must not try accessing subsystems other than the mm + * unit, for example, timer, interrupt, file-system, must not assumed exist. + * + */ +#define load_sysconf ld_sysconf + +/** + * @brief Mark the device definition should be loaded as time device, for + * example a real time clock device. Such device will be loaded and managed by + * clock subsystem + */ +#define load_timedev ld_timedev + +/** + * @brief Mark the device definition should be loaded automatically during the + * bootstrapping stage. Most of the driver do load there. + * + */ +#define load_onboot ld_kboot + +/** + * @brief Mark the device definition should be loaded automatically in + * the post boostrapping stage (i.e., the start up of proc0), where most of + * kernel sub-system are became ready to use. Do your load there if your driver + * depends on such condition + * + */ +#define load_postboot ld_post + +#define __foreach_exported_device_of(stage, index, pos) \ + ldga_foreach(dev_##stage, struct device_def*, index, pos) +#define foreach_exported_device_of(stage, index, pos) \ + __foreach_exported_device_of(stage, index, pos) + +/** + * @brief Declare a device class + * + */ +#define DEVCLASS(devif, devfn, dev) \ + (struct devclass) \ + { \ + .fn_grp = DEV_FNGRP(devif, devfn), .device = (dev), .variant = 0 \ + } + +#define DEVCLASSV(devif, devfn, dev, devvar) \ + (struct devclass) \ + { \ + .fn_grp = DEV_FNGRP(devif, devfn), .device = (dev), \ + .variant = (devvar) \ + } + #define DEV_STRUCT_MAGIC 0x5645444c #define DEV_MSKIF 0x00000003 @@ -14,37 +91,114 @@ #define DEV_IFVOL 0x0 // volumetric (block) device #define DEV_IFSEQ 0x1 // sequential (character) device #define DEV_IFCAT 0x2 // a device category (as device groupping) - -typedef unsigned int dev_t; +#define DEV_IFSYS 0x3 // a system device struct device { - uint32_t magic; + u32_t magic; struct llist_header siblings; struct llist_header children; struct device* parent; + mutex_t lock; + + // TODO investigate event polling + struct hstr name; - dev_t dev_id; + struct devident ident; + + u32_t dev_uid; int dev_type; char name_val[DEVICE_NAME_SIZE]; void* underlay; - int (*read)(struct device* dev, void* buf, size_t offset, size_t len); - int (*write)(struct device* dev, void* buf, size_t offset, size_t len); - int (*exec_cmd)(struct device* dev, uint32_t req, va_list args); + + struct + { + // TODO Think about where will they fit. + int (*acquire)(struct device* dev); + int (*release)(struct device* dev); + + int (*read)(struct device* dev, void* buf, size_t offset, size_t len); + int (*write)(struct device* dev, void* buf, size_t offset, size_t len); + int (*read_page)(struct device* dev, void* buf, size_t offset); + int (*write_page)(struct device* dev, void* buf, size_t offset); + int (*exec_cmd)(struct device* dev, u32_t req, va_list args); + } ops; }; -struct device* -device_add(struct device* parent, - void* underlay, - char* name_fmt, - uint32_t type, - va_list args); +struct device_def +{ + struct llist_header dev_list; + struct hlist_node hlist; + struct hlist_node hlist_if; + char* name; -struct device* -device_addseq(struct device* parent, void* underlay, char* name_fmt, ...); + struct devclass class; + + /** + * @brief Called when the driver is required to initialize itself. + * + */ + int (*init)(struct device_def*); + + /** + * @brief Called when the driver is required to bind with a device. This is + * the case for a real-hardware-oriented driver + * + */ + int (*bind)(struct device_def*, struct device*); + + /** + * @brief Called when a driver is requested to detach from the device and + * free up all it's resources + * + */ + int (*free)(struct device_def*, void* instance); +}; + +static inline u32_t +device_id_from_class(struct devclass* class) +{ + return ((class->device & 0xffff) << 16) | ((class->variant & 0xffff)); +} + +void +device_scan_drivers(); + +void +device_setname_vargs(struct device* dev, char* fmt, va_list args); + +void +device_setname(struct device* dev, char* fmt, ...); + +void +device_register(struct device* dev, struct devclass* class, char* fmt, ...); + +void +device_create(struct device* dev, + struct device* parent, + u32_t type, + void* underlay); struct device* -device_addvol(struct device* parent, void* underlay, char* name_fmt, ...); +device_alloc(struct device* parent, u32_t type, void* underlay); + +static inline struct device* +device_allocsys(struct device* parent, void* underlay) +{ + return device_alloc(parent, DEV_IFSYS, underlay); +} + +static inline struct device* +device_allocseq(struct device* parent, void* underlay) +{ + return device_alloc(parent, DEV_IFSEQ, underlay); +} + +static inline struct device* +device_allocvol(struct device* parent, void* underlay) +{ + return device_alloc(parent, DEV_IFVOL, underlay); +} struct device* device_addcat(struct device* parent, char* name_fmt, ...); @@ -53,7 +207,7 @@ void device_remove(struct device* dev); struct device* -device_getbyid(struct llist_header* devlist, dev_t id); +device_getbyid(struct llist_header* devlist, u32_t id); struct device* device_getbyhname(struct device* root_dev, struct hstr* name); @@ -64,4 +218,50 @@ device_getbyname(struct device* root_dev, const char* name, size_t len); struct device* device_getbyoffset(struct device* root_dev, int pos); +struct device* +device_cast(void* obj); + +struct hbucket* +device_definitions_byif(int if_type); + +struct device_def* +devdef_byident(struct devident* class); + +void +device_populate_info(struct device* dev, struct dev_info* devinfo); + +void +device_scan_drivers(); + +/*------ Load hooks ------*/ + +void +device_onbooot_load(); + +void +device_postboot_load(); + +void +device_sysconf_load(); + +static inline void +device_lock(struct device* dev) +{ + mutex_lock(&dev->lock); +} + +static inline void +device_unlock(struct device* dev) +{ + mutex_unlock(&dev->lock); +} + +static inline int +device_locked(struct device* dev) +{ + return mutex_on_hold(&dev->lock); +} + +#define devprintf_expand(devident) (devident)->fn_grp, (devident)->unique + #endif /* __LUNAIX_DEVICE_H */