device/driver.h header reference
[Devices support library module]
The source code of this header can be browsed online.
Description [link]
Driver structures and driver API classes
Members [link]
Types [link]
- typedef error_t (dev_cleanup_t)(struct device_s *dev)
- struct dev_enum_ident_s
- enum dev_enum_type_e
- typedef error_t (dev_init_t)(struct device_s *dev, uint32_t cl_missing)
- enum dev_use_op_e
- typedef error_t (dev_use_t)(void *param, enum dev_use_op_e op)
- struct device_accessor_s
- enum driver_class_e
- enum driver_flags_e
- struct driver_s
- struct driver_class_s
- struct driver_registry_s
Functions [link]
- error_t dev_driver_notsup_fcn(void )
- error_t dev_use_generic(void *param, enum dev_use_op_e op)
- void device_async_cleanup_done(struct device_s *dev)
- void device_async_init_done(struct device_s *dev, error_t error)
- error_t device_bind_driver(struct device_s *dev, const struct driver_s *drv)
- bool_t device_check_accessor(const struct device_accessor_s *acc)
- bool_t device_cmp_accessor(const struct device_accessor_s *a, const struct device_accessor_s *b)
- error_t device_copy_accessor(struct device_accessor_s *dst, const struct device_accessor_s *src)
- error_t device_get_accessor(struct device_accessor_s *acc, struct device_s *dev, enum driver_class_e cl, uint_fast8_t number)
- error_t device_get_accessor_by_path(struct device_accessor_s *acc, struct device_node_s *root, const char *path, enum driver_class_e cl)
- void device_init_accessor(struct device_accessor_s *acc)
- error_t device_init_driver(struct device_s *dev)
- void device_init_enable_api(struct device_s *dev, uint_fast8_t index)
- bool_t device_init_is_partial(struct device_s *dev)
- bool_t device_init_test_api(struct device_s *dev, uint_fast8_t index)
- error_t device_last_number(struct device_s *dev, enum driver_class_e cl, uint_fast8_t *num)
- void device_put_accessor(struct device_accessor_s *acc)
- error_t device_release_driver(struct device_s *dev)
- error_t device_start(struct device_accessor_s *acc)
- error_t device_stop(struct device_accessor_s *acc)
- error_t device_unbind_driver(struct device_s *dev)
- error_t device_wait_accessor(struct device_accessor_s *acc, struct device_s *dev, enum driver_class_e cl, uint_fast8_t number)
- error_t device_wait_accessor_by_path(struct device_accessor_s *acc, struct device_node_s *root, const char *path, enum driver_class_e cl)
- error_t device_get_api(struct device_s *dev, enum driver_class_e cl, const struct driver_class_s **api)
Constants [link]
- const char dev_enum_type_e[]
- const char driver_class_e[]
- const struct driver_registry_s driver_registry_table[]
- const struct driver_registry_s driver_registry_table_end[]
Macros [link]
- DEVICE_ACCESSOR_INIT
- DEVICE_HAS_OP
- DEVICE_OP
- DEVICE_PV
- DEVICE_START_COUNT_INC
- DEV_CLEANUP
- DEV_ENUM_ATA_ENTRY
- DEV_ENUM_FDTNAME_ENTRY
- DEV_ENUM_GAISLER_ENTRY
- DEV_ENUM_GENERIC_ENTRY
- DEV_ENUM_ISA_ENTRY
- DEV_ENUM_PCI_ENTRY
- DEV_INIT
- DEV_USE
- DRIVER_DECLARE
- DRIVER_PV
- DRIVER_REGISTER
- DRIVER_REGISTER
- DRIVER_CLASS_TYPES
- DRIVER_CTX_CLASS_TYPES
Members detail [link]
#define DEVICE_ACCESSOR_INIT [link]
This macro is declared in device/driver.h source file, line 592.
This macro initializes a struct device_accessor_s object to the null accessor.
#define DEVICE_HAS_OP(dev_accessor, op) [link]
This macro is declared in device/driver.h source file, line 584.
This macro tells whether device defines said function.
See also Device accessor.
#define DEVICE_OP(dev_accessor, op, ...) [link]
This macro is declared in device/driver.h source file, line 576.
This macro invokes the requested operation on a device accessor object. The function must be provided by the driver.
See also Device accessor.
#define DEVICE_PV(pvdata, device) [link]
This macro is declared in device/driver.h source file, line 436.
This macro is used to declare a driver private data local variable from dev
#define DEVICE_START_COUNT_INC [link]
This macro is declared in device/driver.h source file, line 765.
This macro specifies the value added to the device_s::start_count value when the device_start function is invoked.
#define DEV_CLEANUP(n) [link]
This macro is declared in device/driver.h source file, line 260.
See also dev_cleanup_t.
#define DEV_ENUM_ATA_ENTRY(_str) [link]
This macro is declared in device/driver.h source file, line 159.
Shortcut for creating an ATA entry in a static struct dev_enum_ident_s array.
Parameter list:
- _str: the string to match from the device
#define DEV_ENUM_FDTNAME_ENTRY(_name) [link]
This macro is declared in device/driver.h source file, line 169.
Shortcut for creating a flat-device-tree entry in a static struct dev_enum_ident_s array.
Parameter list:
- _name: The string to match from the device-tree
#define DEV_ENUM_GAISLER_ENTRY(_vendor, _device) [link]
This macro is declared in device/driver.h source file, line 180.
Shortcut for creating a Gaisler entry in a static struct dev_enum_ident_s array.
Parameter list:
- _vendor: the vendor id to match, -1 for wildcard
- _device: the device id to match, -1 for wildcard
#define DEV_ENUM_GENERIC_ENTRY(_vendor, _device, _rev_major, _rev_minor) [link]
This macro is declared in device/driver.h source file, line 193.
Shortcut for creating a Generic with vendor/device ids and version number in a static struct dev_enum_ident_s array.
Parameter list:
- _vendor: the vendor id to match, -1 for wildcard
- _device: the device id to match, -1 for wildcard
- _rev_major: the device major revision, -1 for wildcard
- _rev_minor: the minimum supported minor revision, -1 for wildcard
#define DEV_ENUM_ISA_ENTRY(_vendor) [link]
This macro is declared in device/driver.h source file, line 149.
Shortcut for creating an ISA entry in a static struct dev_enum_ident_s array.
Parameter list:
- _vendor: the vendor id to match
#define DEV_ENUM_PCI_ENTRY(_vendor, _device, _class) [link]
This macro is declared in device/driver.h source file, line 138.
Shortcut for creating a PCI entry in a static struct dev_enum_ident_s array.
Parameter list:
- _vendor: the vendor id to match, -1 for wildcard
- _device: the device id to match, -1 for wildcard
- _class: the class to match, -1 for wildcard
#define DEV_INIT(n) [link]
This macro is declared in device/driver.h source file, line 203.
See also dev_init_t.
#define DEV_USE(n) [link]
This macro is declared in device/driver.h source file, line 368.
See also dev_use_t.
#define DRIVER_DECLARE(symbol_, flags_, pretty_, prefix_, ...) [link]
This macro is declared in device/driver.h source file, line 441.
This macro declares a struct driver_s object. Implemented device classes must be specified as extra parameters.
#define DRIVER_DECLARE_CLEANUP(x) [link]
This macro is declared in device/driver.h source file, line 425.
Preprocessor condition: defined( CONFIG_DEVICE_CLEANUP )
#define DRIVER_DECLARE_CLEANUP(x) [link]
This macro is declared in device/driver.h source file, line 427.
Preprocessor condition: not defined( CONFIG_DEVICE_CLEANUP )
#define DRIVER_DECLARE_DESC(x) [link]
This macro is declared in device/driver.h source file, line 419.
Preprocessor condition: defined( CONFIG_DEVICE_DRIVER_DESC )
#define DRIVER_DECLARE_DESC(x) [link]
This macro is declared in device/driver.h source file, line 421.
Preprocessor condition: not defined( CONFIG_DEVICE_DRIVER_DESC )
#define DRIVER_PV(...) [link]
This macro is declared in device/driver.h source file, line 431.
This macro is used to declare a driver private data structure
#define DRIVER_REGISTER(driver_, ...) [link]
This macro is declared in device/driver.h source file, line 480.
This macro registers a struct driver_s object in the driver_registry_table table. This enables lookup and dynamic binding of the driver to a device.
When this macro is not used, the driver can't be used for enumerated devices. In this case, a pointer to the driver must be passed to the DEV_DECLARE_STATIC macro or to the device_bind_driver function.
Alternate declarations with same identifier: [1], [2].
Preprocessor condition: defined( CONFIG_DEVICE_DRIVER_REGISTRY )
#define DRIVER_REGISTER(driver_, ...) [link]
This macro is declared in device/driver.h source file, line 492.
Documentation from alternate declaration:
This macro registers a struct driver_s object in the driver_registry_table table. This enables lookup and dynamic binding of the driver to a device.
When this macro is not used, the driver can't be used for enumerated devices. In this case, a pointer to the driver must be passed to the DEV_DECLARE_STATIC macro or to the device_bind_driver function.
Alternate declarations with same identifier: [1], [2].
Preprocessor condition: not defined( CONFIG_DEVICE_DRIVER_REGISTRY )
#define DRIVER_REGISTRY_SECTION(x) [link]
This macro is declared in device/driver.h source file, line 466.
Preprocessor condition: defined( CONFIG_ARCH_EMU_DARWIN )
#define DRIVER_REGISTRY_SECTION(x) [link]
This macro is declared in device/driver.h source file, line 468.
Preprocessor condition: not defined( CONFIG_ARCH_EMU_DARWIN )
#define __DRIVER_H__ [link]
This macro is declared in device/driver.h source file, line 29.
This typedef is declared in device/driver.h source file, line 286.
This typedef is the device cleanup function type. This typedef tries to release all ressources allocated by the dev_init_t function.
This function will only be called these conditions are met:
the device status is either DEVICE_INIT_DONE, DEVICE_INIT_PARTIAL or DEVICE_INIT_DECLINE.
The device_s::ref_count field is zero.
The device_s::start_count field is zero.
The device has no children.
This function is called with the device lock held. This typedef function must return -EBUSY if it is not possible to release the device yet.
This typedef function may also return -EAGAIN if cleanup has been initiated but requires completion of some asynchronous operations. The cleanup will complete when the device_async_cleanup_done function is called from a deferred kroutine. This requires definition of the CONFIG_DEVICE_INIT_ASYNC token.
This declaration involves expansion of the DEV_CLEANUP macro.
This function is declared in device/driver.h source file, line 826.
This function function does nothing but returning -ENOTUP
struct dev_enum_ident_s [link]
This struct is declared in device/driver.h source file, line 99.
device structure identification informations. wildcard values are enum driver dependent
Field | Description |
---|---|
enum dev_enum_type_e type; | |
union <anonymous> { | |
struct <anonymous> { | |
uint16_t vendor; | |
uint16_t device; | |
uint16_t rev_minor; | |
uint16_t rev_major; | |
} generic; | |
struct <anonymous> { | |
uint16_t vendor; | |
uint16_t device; | |
uint32_t class; | |
} pci; | |
struct <anonymous> { | |
uint16_t vendor; | |
uint16_t device; | |
} grlib; | |
struct <anonymous> { | |
uint16_t vendor; | |
} isa; | |
struct <anonymous> { | |
const char * name; | |
} fdtname; | |
struct <anonymous> { | |
const char * str; | |
} ata; | |
}; |
const char dev_enum_type_e[] [link]
This constant is declared in ENUM_DESCRIPTOR function like macro expansion, line 1 in device/driver.h source file, line 81.
Alternate declarations with same identifier: [1], [2].
enum dev_enum_type_e [link]
This enum is declared in device/driver.h source file, line 86.
This enum specifies types of enumeration data
Alternate declarations with same identifier: [1], [2].
See also struct dev_enum_ident_s.
Identifier | Description |
---|---|
DEV_ENUM_TYPE_INVALID | |
DEV_ENUM_TYPE_GENERIC | |
DEV_ENUM_TYPE_PCI | |
DEV_ENUM_TYPE_ISA | |
DEV_ENUM_TYPE_ATA | |
DEV_ENUM_TYPE_FDTNAME | |
DEV_ENUM_TYPE_GAISLER |
This typedef is declared in device/driver.h source file, line 256.
This typedef is the device driver initialization function type. This function allocates device private data and initialize the hardware. It will be called before using any other functions on the device.
The device initialization status will be updated depending on the return value of this function:
If 0 is returned, the device status changes to DEVICE_INIT_DONE.
The first call to this function might not be able to fully complete the initialization of the device. In this case, it should return -EAGAIN to indicate that initialization will complete later. The device status will then be changed to DEVICE_INIT_ONGOING. The initialization may complete either when the device_async_init_done is called by the driver or when the dev_init_t function is called again. The later occurs when some progress are made on initialization of related devices and the DRIVER_FLAGS_INIT_RETRY flag of the driver is set. The device_init_is_partial function should be used to test for the initial invocation.
If an error is returned and the driver has not invoked the device_init_enable_api function, the status is changed to DEVICE_INIT_FAILED. The driver must have released all resource associated to the device in this case as the dev_cleanup_t function will not be called.
If an error is returned but some classes have been reported as initialized, the status is changed to DEVICE_INIT_PARTIAL.
The DRIVER_FLAGS_NO_DEPEND flag can be used so that this function is called even if some resource dependencies are not satisfied. The driver is then responsible for testing missing dependencies. In this case the cl_missing mask parameter indicates any driver classes related to a missing resource dependencies.
The DRIVER_FLAGS_EARLY_INIT flag can be used so that this function is called early during startup. Some kernel service can not be used in this case, especially, asynchronous initialization can not be used.
This declaration involves expansion of the DEV_INIT macro.
See also Device status.
error_t dev_use_generic(void *param, enum dev_use_op_e op) [link]
This function is declared in device/driver.h source file, line 379.
This declaration involves expansion of the DEV_USE macro.
enum dev_use_op_e [link]
This enum is declared in device/driver.h source file, line 290.
This enum specifies device usage operations.
See also dev_use_t.
Identifier | Description |
---|---|
DEV_USE_GET_ACCESSOR | Get and Put operations are used when the device_get_accessor and device_put_accessor functions are called. An error code may be returned on DEV_USE_GET_ACCESSOR in order to prevent the caller from acquiring an accessor. The param argument is a pointer to a struct device_accessor_s object. |
DEV_USE_PUT_ACCESSOR | |
DEV_USE_LAST_NUMBER | This operation is used when device_last_number is called. The param argument is a pointer to a struct device_accessor_s structure with the dev and api field properly initialized. The default implementation reports 0. |
DEV_USE_START | Start and stop operations are invoked from the device_start and device_stop functions. An error code may be returned on DEV_USE_START. The param argument is a pointer to a struct device_accessor_s object. The default implementation does nothing and always succeed. The driver may test if the value of device_s::start_count is zero. This field is updated by the device_start and device_stop functions. The driver may also manage the lower bits of the value directly if they were reserved by providing a suitable value for the CONFIG_DEVICE_START_LOG2INC token. The driver may still maintain some other internal start counters if sub-devices do require separate counters. |
DEV_USE_STOP | See DEV_USE_START. |
DEV_USE_SLEEP | This operation is only used when the driver has previously called the device_sleep_schedule function. The device power must be reduced if the device is not currently in use. The param argument is a pointer to a struct device_s object. What is actually performed by the driver is device dependent. This may include releasing clock and power endpoints, calling device_stop on associated spi or i2c bus controllers or enabling a device specific low power mode. When this operation is performed on multiple devices, driver initialization order is used to determine the call order. This ensure a bus controller is not disabled then re-enabled in order to put a dependent device in low power mode. See also device_sleep_schedule. |
DEV_USE_CLOCK_SINK_GATE_DONE | This operation is used when a clock or power enable operation requested by the driver has been satisfied. The param argument is a pointer to the sink endpoint. See also dev_clock_sink_gate. |
DEV_USE_CLOCK_SINK_FREQ_CHANGED | This operation is used when a clock frequency change occurred on a clock sink endpoint and the change notifications is enabled. The change might not have been solicited by the driver. The param argument is a pointer to a struct dev_clock_notify_s object. |
DEV_USE_ENUM_CHILD_INIT | This operation is used when a device child initialization completes. The param argument is a pointer to the child device. |
typedef error_t (dev_use_t)(void *param, enum dev_use_op_e op) [link]
This typedef is declared in device/driver.h source file, line 377.
This typedef is called when the usage status of a device changes. The dev_use_generic function provides a default implementation of this driver API function.
This function is called with the device lock held. Valid operations are defined in enum dev_use_op_e.
This declaration involves expansion of the DEV_USE macro.
struct device_accessor_s [link]
This struct is declared in device/resources.h source file, line 40.
This struct is the generic device accessor.
See also device_get_accessor and Device accessor.
Field | Description |
---|---|
struct device_s * dev; | |
const struct driver_class_s * api; | |
uint_fast8_t number; |
This function is declared in device/driver.h source file, line 634.
This function function may be called from a deferred kroutine handler of the device driver when the dev_cleanup_t has previously returned -EAGAIN and the cleanup eventually terminates. It must be called with the device lock held.
This is available when CONFIG_DEVICE_CLEANUP and CONFIG_DEVICE_INIT_ASYNC are both defined.
This function is declared in device/driver.h source file, line 627.
This function function may be called from a deferred kroutine handler of the device driver when the dev_init_t has previously returned -EAGAIN and some progress has been made. It must be called with the device lock held.
This is used to notify waiters, start a new pass on the device tree for initialization of depending devices and optionally update the device status.
If no error is reported, the device status changes to DEVICE_INIT_DONE.
If the -EAGAIN error code is used, the device is left in the DEVICE_INIT_ONGOING state.
If an error is reported and the driver has not invoked the device_init_enable_api function yet, the status is changed to DEVICE_INIT_FAILED. The driver must have released all resource associated to the device in this case as the dev_cleanup_t function will not be called.
If an error is reported and some classes have been reported as initialized, the status is changed to DEVICE_INIT_PARTIAL.
This is available when CONFIG_DEVICE_INIT_ASYNC is defined.
This function is declared in device/driver.h source file, line 812.
This function binds a device to a device driver. No check is performed to determine if the driver is appropriate.
bool_t device_check_accessor(const struct device_accessor_s *acc) [link]
This function is declared in device/driver.h source file, line 751.
This function returns true is the device accessor has been successfully bound to a device by either the device_get_accessor or device_get_accessor_by_path function. This function returns false if one of these functions failed or if the accessor has not been touched since it was cleaned-up by device_put_accessor or initialized with DEVICE_ACCESSOR_INIT.
bool_t device_cmp_accessor(const struct device_accessor_s *a, const struct device_accessor_s *b) [link]
This function is declared in device/driver.h source file, line 704.
error_t device_copy_accessor(struct device_accessor_s *dst, const struct device_accessor_s *src) [link]
This function is declared in device/driver.h source file, line 700.
This function copies a device accessor. This gets a new reference to the accessor that must be released with device_put_accessor by itself.
See also Device accessor and device_put_accessor.
error_t device_get_accessor(struct device_accessor_s *acc, struct device_s *dev, enum driver_class_e cl, uint_fast8_t number) [link]
This function is declared in device/driver.h source file, line 691.
This function initializes a device accessor object. If the return value is 0, the accessor object can then be used to access device driver functions of requested api class.
The number parameter can be used when the device provides multiple sub-devices of the requested class type.
See also Device accessor and device_put_accessor.
error_t device_get_accessor_by_path(struct device_accessor_s *acc, struct device_node_s *root, const char *path, enum driver_class_e cl) [link]
This function is declared in device/driver.h source file, line 725.
This function initializes a device accessor object after lookup in the device tree. The root parameter may be NULL to lookup from the device tree root.
The path is of the form "node0/node1". An additionnal instance number may be added: "node0/node1[2]", the default instance number is 0. Multiple space separated paths can be specified as fallbacks: "node0 node1[0] node1[1]".
See device_get_by_path for more details in the path string format.
See also device_get_accessor and Device accessor.
void device_init_accessor(struct device_accessor_s *acc) [link]
This function is declared in device/driver.h source file, line 760.
This function initializes an accessor so that the device_check_accessor function return false.
This function is declared in device/driver.h source file, line 819.
This function performs device initialization using previously bound driver.
void device_init_enable_api(struct device_s *dev, uint_fast8_t index) [link]
This function is declared in device/driver.h source file, line 644.
This function marks an API of the driver as available during partial initialization. The index specifies an API as passed to the DRIVER_DECLARE macro of the driver.
This is available when CONFIG_DEVICE_INIT_PARTIAL is defined.
See also DEVICE_INIT_ONGOING.
This function is declared in device/driver.h source file, line 667.
This function can be used from the dev_init_t function to test if we are doing additional passes of partial device initialization. This function returns false if we are in the first call to the initialization function which is always the case when CONFIG_DEVICE_INIT_PARTIAL is not defined.
bool_t device_init_test_api(struct device_s *dev, uint_fast8_t index) [link]
This function is declared in device/driver.h source file, line 652.
This function can be used during the initialization phase of a device to test if a specified API is initialized. The index specifies an API as passed to the DRIVER_DECLARE macro of the driver. This function always returns true if CONFIG_DEVICE_INIT_PARTIAL is not defined.
error_t device_last_number(struct device_s *dev, enum driver_class_e cl, uint_fast8_t *num) [link]
This function is declared in device/driver.h source file, line 808.
This function retreives the value of the last possibly valid sub-devices number. It returns -ENOTSUP if the class does not implement sub-devices. Other errors indicate that the driver class is not ready for use.
Numbers are used to specify an instance of a hardware device function, a logical driver feature or both. Implemented sub-devices numbers may not be contiguous. This allows binding a number to a particular feature or a special way of using the hardware which never changes for a given driver. In this case the driver may report a last number which may not be available with the current configuration.
void device_put_accessor(struct device_accessor_s *acc) [link]
This function is declared in device/driver.h source file, line 740.
This function must be called when device driver accessor is discarded. This function is used to decrement device usage references count.
See also device_get_accessor.
This function is declared in device/driver.h source file, line 823.
This function stops the device and cleanup driver allocated resources.
This is available when CONFIG_DEVICE_CLEANUP is defined.
error_t device_start(struct device_accessor_s *acc) [link]
This function is declared in device/driver.h source file, line 783.
This function instructs the driver to keep the device in active state. This function internally invoke the DEV_USE_START operation of the driver increases the value of device_s::start_count and.
This function always returns immediately. It is implementation defined if the actual device startup is delayed by the driver.
Depending on the device class, the device operation may also get started when submitting requests to the device driver. In this case, this function can be used when the device must remain active between requests. Refer to the device class specific documentation for details..
See also device_stop and DEVICE_START_COUNT_INC.
error_t device_stop(struct device_accessor_s *acc) [link]
This function is declared in device/driver.h source file, line 791.
This function reverts the effect of the device_start function. This function internally decreases the value of device_s::start_count and invoke the DEV_USE_STOP operation of the driver..
See also device_start.
This function is declared in device/driver.h source file, line 816.
This function leave the device without any associated driver.
This is available when CONFIG_DEVICE_CLEANUP is defined.
error_t device_wait_accessor(struct device_accessor_s *acc, struct device_s *dev, enum driver_class_e cl, uint_fast8_t number) [link]
This function is declared in device/driver.h source file, line 679.
This function function is similar to device_get_accessor, the current scheduler context is suspended until the device is initialized.
This is available when CONFIG_DEVICE_ENUM and CONFIG_MUTEK_CONTEXT_SCHED are both defined.
error_t device_wait_accessor_by_path(struct device_accessor_s *acc, struct device_node_s *root, const char *path, enum driver_class_e cl) [link]
This function is declared in device/driver.h source file, line 732.
This function function is similar to device_get_accessor_by_path, the current scheduler context is suspended until the device is initialized.
This is available when CONFIG_DEVICE_ENUM and CONFIG_MUTEK_CONTEXT_SCHED are both defined.
const char driver_class_e[] [link]
This constant is declared in ENUM_DESCRIPTOR function like macro expansion, line 1 in device/driver.h source file, line 37.
Alternate declarations with same identifier: [1], [2].
enum driver_class_e [link]
This enum is declared in device/driver.h source file, line 42.
This enum specifies identifiers of device driver API classes.
Alternate declarations with same identifier: [1], [2].
See also Device classes.
Identifier | Description |
---|---|
DRIVER_CLASS_NONE | |
DRIVER_CLASS_BLOCK | |
DRIVER_CLASS_CHAR | See device/class/char.h and device/valio/uart_config.h. |
DRIVER_CLASS_ENUM | See device/class/enum.h. |
DRIVER_CLASS_FB | |
DRIVER_CLASS_ICU | Interrupt Controller Unit See also device/class/icu.h. |
DRIVER_CLASS_DMA | See device/class/dma.h. |
DRIVER_CLASS_INPUT | |
DRIVER_CLASS_NET | See device/class/net.h. |
DRIVER_CLASS_PCM | See device/class/pcm.h. |
DRIVER_CLASS_TIMER | See device/class/timer.h. |
DRIVER_CLASS_PWM | See device/class/pwm.h. |
DRIVER_CLASS_SPI_CTRL | See device/class/spi.h. |
DRIVER_CLASS_LCD | |
DRIVER_CLASS_CMU | Clock Management Unit See also device/class/cmu.h. |
DRIVER_CLASS_GPIO | See device/class/gpio.h. |
DRIVER_CLASS_IOMUX | See device/class/iomux.h. |
DRIVER_CLASS_I2C_CTRL | See device/class/i2c.h. |
DRIVER_CLASS_I2C_SLAVE | |
DRIVER_CLASS_MEM | See device/class/mem.h. |
DRIVER_CLASS_RFPACKET | See device/class/rfpacket.h. |
DRIVER_CLASS_CRYPTO | See device/class/crypto.h. |
DRIVER_CLASS_CPU | See device/class/cpu.h. |
DRIVER_CLASS_VALIO | See device/class/valio.h. |
DRIVER_CLASS_USBDEV | See device/class/usbdev.h. |
DRIVER_CLASS_DISPLAY | See device/class/display.h. |
DRIVER_CLASS_SMI | |
DRIVER_CLASS_PHY | |
DRIVER_CLASS_BITBANG | See device/class/bitbang.h. |
DRIVER_CLASS_ONEWIRE |
enum driver_flags_e [link]
This enum is declared in device/driver.h source file, line 383.
This enum specifies struct driver_s flags
Identifier | Description |
---|---|
DRIVER_FLAGS_EARLY_INIT | Perform initialization of the device during the INIT_BOOTSTRAP phase instead of INIT_SMP. This is needed mainly for processor and memory devices. It is not possible to rely on some kernel features (scheduler, irq, kroutines) being functional during the early initialization phase. |
DRIVER_FLAGS_NO_DEPEND | Do not test for missing resource dependencies before calling the driver initialization function on a device. |
DRIVER_FLAGS_RETRY_INIT | The dev_init_t function of the driver will be called again when the -EAGAIN error code is returned. |
struct driver_s [link]
This struct is declared in device/class/valio.h source file, line 139.
device driver object structure
Field | Description |
---|---|
const char * desc; | driver description string |
dev_init_t * f_init; | |
dev_cleanup_t * f_cleanup; | |
dev_use_t * f_use; | |
enum driver_flags_e flags:8; | |
uint16_t pv_size; | |
const struct driver_class_s * classes[]; | NULL terminated array of pointers to driver classes structs |
#define DRIVER_CLASS_TYPES(id, cl, ...) [link]
This macro is declared in device/driver.h source file, line 499.
This macro declares a driver class.
This macro is for internal use only.
See also driver_class_e and Device classes.
#define DRIVER_CTX_CLASS_TYPES(id, cl, ...) [link]
This macro is declared in device/driver.h source file, line 541.
This macro declares a driver class which uses a libdevice context.
This macro is for internal use only.
See also DRIVER_CLASS_TYPES.
error_t device_get_api(struct device_s *dev, enum driver_class_e cl, const struct driver_class_s **api) [link]
This function is declared in device/driver.h source file, line 598.
This function is for internal use only.
struct driver_class_s [link]
This struct is declared in device/driver.h source file, line 558.
This struct is the generic device driver class struct header.
This struct is for internal use only.
Field | Description |
---|---|
uint16_t class_; | |
uint16_t ctx_offset; | |
void * functions[]; |
struct driver_registry_s [link]
This struct is declared in device/driver.h source file, line 455.
This struct is for internal use only.
Field | Description |
---|---|
const struct driver_s * driver; | |
const struct dev_enum_ident_s * id_table; | |
size_t id_count; |
const struct driver_registry_s driver_registry_table[] [link]
This constant is declared in device/driver.h source file, line 462.
This constant is for internal use only.
const struct driver_registry_s driver_registry_table_end[] [link]
This constant is declared in device/driver.h source file, line 464.
This constant is for internal use only.