Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Work in progress:

Browse Source 
* added [un]publish_device() calls to the device manager.
* added a very basic devfs emulation to the playground to be able to test how
  the manager reacts to opened devices.
* renamed *_device() functions to *_node() in the device manager API.
* made B_DEVICE_FIND_CHILD_FLAGS a generic flags field, and renamed it to
  B_DEVICE_FLAGS.
* added support for keeping a driver loaded as long as its device is available.
* implemented get_next_child_node().
* added test for device removal, and implemented unregister_node() for this.
* fixed some bugs in the device node reference/initialization count maintenance.
* moved more code from register_node() to device_node::Register().
* initialize the device_node::fFlags member to the value of B_DEVICE_FLAGS, and
  have additional private flags.
* renamed UninitUnusedChildren() to UninitUnusedDriver(), and fixed this
  function by adding the new flag NODE_FLAG_REGISTER_INITIALIZED.
* Now remembers the support when a driver is registered - this will be used
  later to be able to compare with a new driver without having to call
  supports_device() again.
* Removed NODE_FLAG_REMOVE_ON_UNINIT again, as that was pretty stupid - there
  is reference counting for a reason.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@25498 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler 2008-05-14 20:05:40 +00:00
parent c27f3926a0
commit 7a6818d3fa
7 changed files with 384 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/tests/system/kernel/device_manager/playground/bus.cpp
View File

@ -10,7 +10,27 @@
#include <PCI.h>
#define BUS_MODULE_NAME "bus_managers/sample_bus/driver_v1"
void
bus_trigger_device_removed(device_node* node)
{
// the network device
device_attr attrs[] = {
{B_DEVICE_VENDOR_ID, B_UINT16_TYPE, {ui16: 0x1001}},
{B_DEVICE_ID, B_UINT16_TYPE, {ui16: 0x0001}},
{NULL}
};
device_node* child = NULL;
while (gDeviceManager->get_next_child_node(node, attrs, &child) == B_OK) {
gDeviceManager->unregister_node(child);
}
}
void
bus_trigger_device_added(device_node* node)
{
}
// #pragma mark - bus
@ -40,7 +60,7 @@ register_device(device_node *parent)
{NULL}
};
return gDeviceManager->register_device(parent, BUS_MODULE_NAME, attrs, NULL,
return gDeviceManager->register_node(parent, BUS_MODULE_NAME, attrs, NULL,
NULL);
}
@ -90,12 +110,11 @@ register_child_devices(device_node *node)
{B_DEVICE_INTERFACE, B_UINT16_TYPE,
{ui16: kDevices[i].interface}},
{B_DEVICE_FIND_CHILD_FLAGS, B_UINT32_TYPE,
{ui32: B_FIND_CHILD_ON_DEMAND}},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {ui32: B_FIND_CHILD_ON_DEMAND}},
{NULL}
};
gDeviceManager->register_device(node, BUS_FOR_DRIVER_NAME, attrs, NULL,
gDeviceManager->register_node(node, BUS_FOR_DRIVER_NAME, attrs, NULL,
NULL);
}
@ -107,7 +126,7 @@ register_child_devices(device_node *node)
#if 1
// this is supposed to fail
dprintf("non-existing child: %ld\n", gDeviceManager->register_device(node,
dprintf("non-existing child: %ld\n", gDeviceManager->register_node(node,
BUS_FOR_DRIVER_NAME, attrs, NULL, NULL));
#endif
return B_OK;

7
src/tests/system/kernel/device_manager/playground/bus.h
View File

@ -20,7 +20,14 @@ struct bus_for_driver_module_info {
status_t (*get_bus_info)(void* cookie, bus_info* info);
};
// Note: this file is also used by the device manager test to control the bus
// driver
#define BUS_MODULE_NAME "bus_managers/sample_bus/driver_v1"
#define BUS_FOR_DRIVER_NAME "bus_managers/sample_bus/device/driver_v1"
#define BUS_NAME "mybus"
extern void bus_trigger_device_removed(device_node* node);
extern void bus_trigger_device_added(device_node* node);
#endif // BUS_H

381
src/tests/system/kernel/device_manager/playground/device_manager.cpp
View File

@ -22,6 +22,7 @@
#include <util/DoublyLinkedList.h>
#include <util/Stack.h>
#include "bus.h"
#define TRACE(a) dprintf a
@ -69,7 +70,6 @@ private:
typedef DoublyLinkedList<device_attr_private> AttributeList;
// I/O resource
typedef struct io_resource_info {
struct io_resource_info *prev, *next;
@ -77,13 +77,20 @@ typedef struct io_resource_info {
io_resource resource; // info about actual resource
} io_resource_info;
struct device : DoublyLinkedListLinkImpl<device> {
device() : node(NULL), path(NULL), module_name(NULL) {}
~device()
{
free((char*)path);
free((char*)module_name);
}
// a structure to put nodes into lists
struct node_entry {
struct list_link link;
device_node* node;
const char* path;
const char* module_name;
};
typedef DoublyLinkedList<device> DeviceList;
typedef DoublyLinkedList<device_node> NodeList;
struct device_node : DoublyLinkedListLinkImpl<device_node> {
@ -101,6 +108,7 @@ struct device_node : DoublyLinkedListLinkImpl<device_node> {
status_t InitDriver();
bool UninitDriver();
void UninitUnusedDriver();
// The following two are only valid, if the node's driver is
// initialized
@ -110,9 +118,9 @@ struct device_node : DoublyLinkedListLinkImpl<device_node> {
void AddChild(device_node *node);
void RemoveChild(device_node *node);
const NodeList& Children() const { return fChildren; }
void UninitUnusedChildren();
void DeviceRemoved();
status_t Register();
status_t Register(device_node* parent);
status_t Probe(const char* devicePath);
bool IsRegistered() const { return fRegistered; }
bool IsInitialized() const { return fInitialized > 0; }
@ -122,6 +130,7 @@ struct device_node : DoublyLinkedListLinkImpl<device_node> {
int CompareTo(const device_attr* attributes) const;
device_node* FindChild(const device_attr* attributes) const;
device_node* FindChild(const char* moduleName) const;
void Dump(int32 level = 0);
@ -139,7 +148,6 @@ private:
status_t _RegisterPath(const char* path);
status_t _RegisterDynamic();
status_t _RemoveChildren();
bool _UninitUnusedChildren();
device_node* fParent;
NodeList fChildren;
@ -147,16 +155,21 @@ private:
int32 fInitialized;
bool fRegistered;
uint32 fFlags;
float fSupportsParent;
const char* fModuleName;
driver_module_info* fDriver;
void* fDriverData;
AttributeList fAttributes;
};
// flags in addition to those specified by B_DEVICE_FLAGS
enum node_flags {
NODE_FLAG_REMOVE_ON_UNINIT = 0x01
NODE_FLAG_REGISTER_INITIALIZED = 0x00010000,
NODE_FLAG_PUBLIC_MASK = 0x0000ffff
};
device_manager_info *gDeviceManager;
@ -164,6 +177,9 @@ device_manager_info *gDeviceManager;
static device_node *sRootNode;
static recursive_lock sLock;
static DeviceList sDeviceList;
// this is a *very* basic devfs emulation
// #pragma mark - device_attr
@ -376,19 +392,51 @@ dump_attribute(device_attr* attr, int32 level)
static void
uninit_unused()
{
puts("uninit unused");
RecursiveLocker _(sLock);
sRootNode->UninitUnusedChildren();
sRootNode->UninitUnusedDriver();
}
static status_t
probe_path(const char* path)
{
printf("probe path \"%s\"\n", path);
RecursiveLocker _(sLock);
return sRootNode->Probe(path);
}
static void
close_path(void* cookie)
{
struct device* device = (struct device*)cookie;
printf("close path \"%s\" (node %p)\n", device->path, device->node);
device->node->UninitDriver();
}
static void*
open_path(const char* path)
{
DeviceList::Iterator iterator = sDeviceList.GetIterator();
while (iterator.HasNext()) {
struct device* device = iterator.Next();
if (!strcmp(device->path, path)) {
status_t status = device->node->InitDriver();
if (status != B_OK)
return NULL;
printf("open path \"%s\" (node %p)\n", device->path, device->node);
return device;
}
}
return NULL;
}
// #pragma mark - device_node
@ -406,6 +454,8 @@ device_node::device_node(const char* moduleName, const device_attr* attrs,
fRefCount = 1;
fInitialized = 0;
fRegistered = false;
fFlags = 0;
fSupportsParent = 0.0;
fDriver = NULL;
fDriverData = NULL;
@ -420,12 +470,19 @@ device_node::device_node(const char* moduleName, const device_attr* attrs,
fAttributes.Add(attr);
attrs++;
}
dm_get_attr_uint32(this, B_DEVICE_FLAGS, &fFlags, false);
fFlags &= NODE_FLAG_PUBLIC_MASK;
}
device_node::~device_node()
{
TRACE(("delete node %p\n", this));
ASSERT(DriverModule() == NULL);
if (Parent() != NULL)
Parent()->RemoveChild(this);
// Delete children
NodeList::Iterator nodeIterator = fChildren.GetIterator();
@ -468,7 +525,7 @@ device_node::InitDriver()
status_t status = get_module(ModuleName(), (module_info**)&fDriver);
if (status == B_OK && Parent() != NULL) {
// our parent always have to be initialized
// our parent always has to be initialized
status = Parent()->InitDriver();
}
if (status < B_OK) {
@ -480,6 +537,8 @@ device_node::InitDriver()
status = fDriver->init_driver(this, &fDriverData);
if (status < B_OK) {
if (Parent() != NULL)
Parent()->UninitDriver();
fInitialized--;
put_module(ModuleName());
@ -497,9 +556,12 @@ bool
device_node::UninitDriver()
{
if (fInitialized-- > 1) {
if (Parent() != NULL)
Parent()->UninitDriver();
Release();
return false;
}
TRACE(("uninit driver for node %p\n", this));
if (fDriver->uninit_driver != NULL)
@ -510,12 +572,9 @@ device_node::UninitDriver()
put_module(ModuleName());
Release();
if (Parent() != NULL)
Parent()->UninitDriver();
if ((fFlags & NODE_FLAG_REMOVE_ON_UNINIT) != 0)
Release();
Release();
return true;
}
@ -540,13 +599,38 @@ device_node::RemoveChild(device_node* node)
}
/*! Registers this node, and all of its children that have to be registered.
Also initializes the driver and keeps it that way on return in case
it returns successfully.
*/
status_t
device_node::Register()
device_node::Register(device_node* parent)
{
uint32 registered;
status_t status = _RegisterFixed(registered);
// make it public
if (parent != NULL)
parent->AddChild(this);
else
sRootNode = this;
status_t status = InitDriver();
if (status != B_OK)
return status;
if ((fFlags & B_KEEP_DRIVER_LOADED) != 0) {
// We keep this driver loaded by having it always initialized
InitDriver();
}
fFlags |= NODE_FLAG_REGISTER_INITIALIZED;
// We don't uninitialize the driver - this is done by the caller
// in order to save reinitializing during driver loading.
uint32 registered;
status = _RegisterFixed(registered);
if (status != B_OK) {
UninitUnusedDriver();
return status;
}
if (registered > 0) {
fRegistered = true;
return B_OK;
@ -556,8 +640,10 @@ device_node::Register()
if (DriverModule()->register_child_devices != NULL) {
status = DriverModule()->register_child_devices(this);
if (status != B_OK)
if (status != B_OK) {
UninitUnusedDriver();
return status;
}
if (!fChildren.IsEmpty()) {
fRegistered = true;
@ -570,6 +656,8 @@ device_node::Register()
status = _RegisterDynamic();
if (status == B_OK)
fRegistered = true;
else
UninitUnusedDriver();
return status;
}
@ -578,7 +666,7 @@ device_node::Register()
/*! Registers any children that are identified via the B_DRIVER_FIXED_CHILD
attribute.
If any of these children cannot be registered, this call will fail (we
don't remove already registered children in this case).
don't remove children we already registered up to this point in this case).
*/
status_t
device_node::_RegisterFixed(uint32& registered)
@ -828,18 +916,15 @@ device_node::_AlwaysRegisterDynamic()
status_t
device_node::_RegisterDynamic()
{
uint32 findFlags = 0;
dm_get_attr_uint32(this, B_DEVICE_FIND_CHILD_FLAGS, &findFlags, false);
// If this is our initial registration, we honour the B_FIND_CHILD_ON_DEMAND
// requirements
if (!fRegistered && (findFlags & B_FIND_CHILD_ON_DEMAND) != 0
if (!fRegistered && (fFlags & B_FIND_CHILD_ON_DEMAND) != 0
&& !_AlwaysRegisterDynamic())
return B_OK;
KPath path;
if ((findFlags & B_FIND_MULTIPLE_CHILDREN) == 0) {
if ((fFlags & B_FIND_MULTIPLE_CHILDREN) == 0) {
// find the one driver
driver_module_info* bestDriver = NULL;
float bestSupport = 0.0;
@ -852,7 +937,16 @@ device_node::_RegisterDynamic()
if (bestDriver != NULL) {
TRACE((" register best module \"%s\", support %f\n",
bestDriver->info.name, bestSupport));
bestDriver->register_device(this);
if (bestDriver->register_device(this) == B_OK) {
// There can only be one node of this driver
// (usually only one at all, but there might be a new driver
// "waiting" for its turn)
device_node* child = FindChild(bestDriver->info.name);
if (child != NULL)
child->fSupportsParent = bestSupport;
// TODO: if this fails, we could try the second best driver,
// and so on...
}
put_module(bestDriver->info.name);
}
} else {
@ -878,11 +972,12 @@ device_node::_RemoveChildren()
// this child is not used currently, and can be removed safely
iterator.Remove();
child->fParent = NULL;
delete child;
child->Release();
if (Release())
panic("died early");
} else
child->fFlags |= NODE_FLAG_REMOVE_ON_UNINIT;
child->Release();
}
return fChildren.IsEmpty() ? B_OK : B_BUSY;
@ -939,7 +1034,7 @@ device_node::Probe(const char* devicePath)
NodeList::Iterator iterator = fChildren.GetIterator();
while (iterator.HasNext()) {
device_node* child = iterator.Next();
status = child->Probe(devicePath);
if (status != B_OK)
return status;
@ -949,42 +1044,57 @@ device_node::Probe(const char* devicePath)
}
bool
device_node::_UninitUnusedChildren()
/*! Uninitializes all temporary references to the driver. The registration
process keeps the driver initialized to optimize the startup procedure;
this function gives this reference away again.
*/
void
device_node::UninitUnusedDriver()
{
// First, we need to go to the leaf, and go back from there
bool uninit = true;
NodeList::Iterator iterator = fChildren.GetIterator();
while (iterator.HasNext()) {
device_node* child = iterator.Next();
if (!child->_UninitUnusedChildren())
uninit = false;
child->UninitUnusedDriver();
}
// Not all of our children could be uninitialized
if (!uninit)
return false;
if (!IsInitialized()
|| (fFlags & NODE_FLAG_REGISTER_INITIALIZED) == 0)
return;
if (!IsInitialized())
return true;
fFlags &= ~NODE_FLAG_REGISTER_INITIALIZED;
if ((DriverModule()->info.flags & B_KEEP_LOADED) != 0) {
// We must not get unloaded
return false;
}
return UninitDriver();
UninitDriver();
}
/*! Calls device_removed() on this node and all of its children - starting
with the deepest and last child.
It will also remove the one reference that every node gets on its creation.
*/
void
device_node::UninitUnusedChildren()
device_node::DeviceRemoved()
{
_UninitUnusedChildren();
NodeList::ConstIterator iterator = Children().GetIterator();
while (iterator.HasNext()) {
device_node* child = iterator.Next();
child->DeviceRemoved();
}
if (IsInitialized() && DriverModule()->device_removed != NULL)
DriverModule()->device_removed(this);
if ((fFlags & B_KEEP_DRIVER_LOADED) != 0) {
// There is no point in keeping this driver loaded when its device
// is gone
UninitDriver();
}
UninitUnusedDriver();
Release();
}
@ -1001,8 +1111,6 @@ device_node::Release()
if (atomic_add(&fRefCount, -1) > 1)
return false;
if (Parent() != NULL)
Parent()->RemoveChild(this);
delete this;
return true;
}
@ -1054,6 +1162,24 @@ device_node::FindChild(const device_attr* attributes) const
}
device_node*
device_node::FindChild(const char* moduleName) const
{
if (moduleName == NULL)
return NULL;
NodeList::ConstIterator iterator = Children().GetIterator();
while (iterator.HasNext()) {
device_node* child = iterator.Next();
if (!strcmp(child->ModuleName(), moduleName))
return child;
}
return NULL;
}
void
device_node::Dump(int32 level = 0)
{
@ -1077,14 +1203,14 @@ device_node::Dump(int32 level = 0)
static status_t
rescan_device(device_node* node)
rescan_node(device_node* node)
{
return B_ERROR;
}
static status_t
register_device(device_node* parent, const char* moduleName,
register_node(device_node* parent, const char* moduleName,
const device_attr* attrs, const io_resource* ioResources,
device_node** _node)
{
@ -1103,7 +1229,7 @@ register_device(device_node* parent, const char* moduleName,
if (newNode == NULL)
return B_NO_MEMORY;
TRACE(("%p: register device \"%s\", parent %p\n", newNode, moduleName,
TRACE(("%p: register node \"%s\", parent %p\n", newNode, moduleName,
parent));
RecursiveLocker _(sLock);
@ -1112,16 +1238,6 @@ register_device(device_node* parent, const char* moduleName,
if (status != B_OK)
goto err1;
// make it public
if (parent != NULL)
parent->AddChild(newNode);
else
sRootNode = newNode;
status = newNode->InitDriver();
if (status != B_OK)
goto err1;
#if 0
// The following is done to reduce the stack usage of deeply nested
// child device nodes.
@ -1136,7 +1252,7 @@ register_device(device_node* parent, const char* moduleName,
}
#endif
status = newNode->Register();
status = newNode->Register(parent);
if (status < B_OK) {
parent->RemoveChild(newNode);
goto err1;
@ -1148,15 +1264,27 @@ register_device(device_node* parent, const char* moduleName,
return B_OK;
err1:
delete newNode;
newNode->Release();
return status;
}
static status_t
unregister_device(device_node* node)
unregister_node(device_node* node)
{
return B_ERROR;
TRACE(("unregister_node(node %p)\n", node));
RecursiveLocker _(sLock);
bool initialized = node->IsInitialized();
node->DeviceRemoved();
// TODO: We can't just remove it from its parent, as it might still be in
// use. However, we shouldn't really fail in this case, either.
// We should try to uninit the device - if it's just a bus, we can just do
// this. If it has devfs device, there are several options on how to do
// that (for example, by disconnecting the file descriptor).
return initialized ? B_BUSY : B_OK;
}
@ -1176,7 +1304,7 @@ get_driver(device_node* node, driver_module_info** _module, void** _data)
static device_node*
get_device_root(void)
get_root_node(void)
{
if (sRootNode != NULL)
sRootNode->Acquire();
@ -1186,15 +1314,48 @@ get_device_root(void)
static status_t
get_next_child_device(device_node* parent, device_node* _node,
const device_attr* attrs)
get_next_child_node(device_node* parent, const device_attr* attributes,
device_node** _node)
{
return B_ERROR;
RecursiveLocker _(sLock);
NodeList::ConstIterator iterator = parent->Children().GetIterator();
device_node* last = *_node;
// skip those we already traversed
while (iterator.HasNext() && last != NULL) {
device_node* node = iterator.Next();
if (node != last)
continue;
}
// find the next one that fits
while (iterator.HasNext()) {
device_node* node = iterator.Next();
if (!node->IsRegistered())
continue;
if (!node->CompareTo(attributes)) {
if (last != NULL)
last->Release();
node->Acquire();
*_node = node;
return B_OK;
}
}
if (last != NULL)
last->Release();
return B_ENTRY_NOT_FOUND;
}
static device_node*
get_parent(device_node* node)
get_parent_node(device_node* node)
{
if (node == NULL)
return NULL;
@ -1209,13 +1370,50 @@ get_parent(device_node* node)
static void
put_device_node(device_node* node)
put_node(device_node* node)
{
RecursiveLocker _(sLock);
node->Release();
}
static status_t
publish_device(device_node *node, const char *path, const char *moduleName)
{
RecursiveLocker _(sLock);
dprintf("publish device: node %p, path %s, module %s\n", node, path,
moduleName);
struct device* device = new(std::nothrow) ::device;
if (device == NULL)
return B_NO_MEMORY;
device->node = node;
device->path = strdup(path);
device->module_name = strdup(moduleName);
sDeviceList.Add(device);
return B_OK;
}
static status_t
unpublish_device(device_node *node, const char *path)
{
DeviceList::Iterator iterator = sDeviceList.GetIterator();
while (iterator.HasNext()) {
struct device* device = iterator.Next();
if (!strcmp(device->path, path)) {
iterator.Remove();
delete device;
return B_OK;
}
}
return B_ENTRY_NOT_FOUND;
}
status_t
dm_get_attr_uint8(const device_node* node, const char* name, uint8* _value,
bool recursive)
@ -1351,14 +1549,18 @@ static struct device_manager_info sDeviceManagerModule = {
},
// device nodes
rescan_device,
register_device,
unregister_device,
rescan_node,
register_node,
unregister_node,
get_driver,
get_device_root,
get_next_child_device,
get_parent,
put_device_node,
get_root_node,
get_next_child_node,
get_parent_node,
put_node,
// devices
publish_device,
unpublish_device,
// attributes
dm_get_attr_uint8,
@ -1380,12 +1582,12 @@ dm_init_root_node(void)
device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Devices Root"}},
{B_DEVICE_BUS, B_STRING_TYPE, {string: "root"}},
{B_DEVICE_FIND_CHILD_FLAGS, B_UINT32_TYPE,
{ui32: B_FIND_MULTIPLE_CHILDREN}},
{B_DEVICE_FLAGS, B_UINT32_TYPE,
{ui32: B_FIND_MULTIPLE_CHILDREN | B_KEEP_DRIVER_LOADED }},
{NULL}
};
if (register_device(NULL, DEVICE_MANAGER_ROOT_NAME, attrs, NULL, NULL)
if (register_node(NULL, DEVICE_MANAGER_ROOT_NAME, attrs, NULL, NULL)
!= B_OK) {
dprintf("Cannot register Devices Root Node\n");
}
@ -1439,12 +1641,19 @@ main(int argc, char** argv)
probe_path("net");
probe_path("graphics");
// TODO: opened devices need to keep a "initialized" reference of the
// device_node
sRootNode->Dump();
void* graphicsHandle = open_path("graphics/generic/0");
// void* netHandle = open_path("net/sample/0");
uninit_unused();
puts("remove net driver");
device_node* busNode = sRootNode->FindChild(BUS_MODULE_NAME);
bus_trigger_device_removed(busNode);
close_path(graphicsHandle);
// close_path(netHandle);
// add specific video driver - ie. simulate installing it
_add_builtin_module((module_info*)&gSpecificVideoDriverModuleInfo);
_add_builtin_module((module_info*)&gSpecificVideoDeviceModuleInfo);

71
src/tests/system/kernel/device_manager/playground/device_manager.h
View File

@ -11,7 +11,7 @@
#include <module.h>
// type of I/O resource
/* type of I/O resource */
enum {
IO_MEM = 1,
IO_PORT = 2,
@ -19,33 +19,35 @@ enum {
};
// I/O resource description
/* I/O resource description */
typedef struct {
uint32 type;
// type of I/O resource
/* type of I/O resource */
uint32 base;
// I/O memory: first physical address (32 bit)
// I/O port: first port address (16 bit)
// ISA DMA channel: channel number (0-7)
/* I/O memory: first physical address (32 bit)
* I/O port: first port address (16 bit)
* ISA DMA channel: channel number (0-7)
*/
uint32 length;
// I/O memory: size of address range (32 bit)
// I/O port: size of port range (16 bit)
// ISA DMA channel: must be 1
/* I/O memory: size of address range (32 bit)
* I/O port: size of port range (16 bit)
* ISA DMA channel: must be 1
*/
} io_resource;
// attribute of a device node
/* attribute of a device node */
typedef struct {
const char *name;
type_code type; // for supported types, see value
type_code type; /* for supported types, see value */
union {
uint8 ui8; // B_UINT8_TYPE
uint16 ui16; // B_UINT16_TYPE
uint32 ui32; // B_UINT32_TYPE
uint64 ui64; // B_UINT64_TYPE
const char *string; // B_STRING_TYPE
struct { // B_RAW_TYPE
uint8 ui8; /* B_UINT8_TYPE */
uint16 ui16; /* B_UINT16_TYPE */
uint32 ui32; /* B_UINT32_TYPE */
uint64 ui64; /* B_UINT64_TYPE */
const char *string; /* B_STRING_TYPE */
struct { /* B_RAW_TYPE */
const void *data;
size_t length;
} raw;
@ -57,26 +59,30 @@ typedef struct device_node device_node;
typedef struct driver_module_info driver_module_info;
// interface of the device manager
/* interface of the device manager */
typedef struct device_manager_info {
module_info info;
status_t (*rescan)(device_node *node);
status_t (*rescan_node)(device_node *node);
status_t (*register_device)(device_node *parent, const char *moduleName,
status_t (*register_node)(device_node *parent, const char *moduleName,
const device_attr *attrs, const io_resource *ioResources,
device_node **_node);
status_t (*unregister_device)(device_node *node);
status_t (*unregister_node)(device_node *node);
status_t (*get_driver)(device_node *node, driver_module_info **_module,
void **_cookie);
device_node *(*get_root_device)();
status_t (*get_next_child_device)(device_node *parent, device_node *node,
const device_attr *attrs);
device_node *(*get_parent)(device_node *node);
void (*put_device_node)(device_node *node);
device_node *(*get_root_node)();
status_t (*get_next_child_node)(device_node *parent,
const device_attr *attrs, device_node **node);
device_node *(*get_parent_node)(device_node *node);
void (*put_node)(device_node *node);
status_t (*publish_device)(device_node *node, const char *path,
const char *deviceModuleName);
status_t (*unpublish_device)(device_node *node, const char *path);
#if 0
status_t (*acquire_io_resources)(io_resource *resources);
@ -106,7 +112,7 @@ typedef struct device_manager_info {
#define B_DEVICE_MANAGER_MODULE_NAME "system/device_manager/v1"
// interface of device driver
/* interface of device driver */
struct driver_module_info {
module_info info;
@ -128,7 +134,7 @@ struct driver_module_info {
#define B_DEVICE_MAPPING "device/mapping" /* string */
#define B_DEVICE_BUS "device/bus" /* string */
#define B_DEVICE_FIXED_CHILD "device/fixed child" /* string */
#define B_DEVICE_FIND_CHILD_FLAGS "device/find child flags" /* uint32 */
#define B_DEVICE_FLAGS "device/flags" /* uint32 */
#define B_DEVICE_VENDOR_ID "device/vendor" /* uint16 */
#define B_DEVICE_ID "device/id" /* uint16 */
@ -141,20 +147,21 @@ struct driver_module_info {
#define B_DEVICE_UNIQUE_ID "device/unique id" /* string */
// find child flags
/* device flags */
#define B_FIND_CHILD_ON_DEMAND 0x01
#define B_FIND_MULTIPLE_CHILDREN 0x02
#define B_KEEP_DRIVER_LOADED 0x04
// interface of device
/* interface of device */
typedef struct io_request io_request;
struct device_module_info {
module_info info;
status_t (*init_device)(void *cookie);
void (*uninit_device)(void *cookie);
status_t (*init_device)(device_node *node, void **_deviceCookie);
void (*uninit_device)(void *deviceCookie);
status_t (*device_open)(void *deviceCookie, int openMode, void **_cookie);
status_t (*device_close)(void *cookie);

10
src/tests/system/kernel/device_manager/playground/driver.cpp
View File

@ -10,6 +10,7 @@
#define DRIVER_MODULE_NAME "drivers/net/sample_driver/driver_v1"
#define DRIVER_DEVICE_MODULE_NAME "drivers/net/sample_driver/device_v1"
// #pragma mark - driver
@ -48,7 +49,7 @@ supports_device(device_node *parent)
static status_t
register_device(device_node *parent)
{
return gDeviceManager->register_device(parent, DRIVER_MODULE_NAME, NULL,
return gDeviceManager->register_node(parent, DRIVER_MODULE_NAME, NULL,
NULL, NULL);
}
@ -56,7 +57,6 @@ register_device(device_node *parent)
static status_t
init_driver(device_node *node, void **_cookie)
{
// also publishes any devices/nodes with dedicated calls
return B_OK;
}
@ -70,6 +70,8 @@ uninit_driver(device_node *node)
static status_t
register_child_devices(device_node *node)
{
gDeviceManager->publish_device(node, "net/sample/0",
DRIVER_DEVICE_MODULE_NAME);
return B_OK;
}
@ -84,7 +86,7 @@ device_removed(device_node *node)
static status_t
init_device(void *deviceCookie)
init_device(device_node *node, void **_deviceCookie)
{
// called once before one or several open() calls
return B_ERROR;
@ -171,7 +173,7 @@ struct driver_module_info gDriverModuleInfo = {
struct device_module_info gDeviceModuleInfo = {
{
"drivers/net/sample_driver/device_v1",
DRIVER_DEVICE_MODULE_NAME,
0,
NULL,
},

10
src/tests/system/kernel/device_manager/playground/generic_video_driver.cpp
View File

@ -11,6 +11,7 @@
#define DRIVER_MODULE_NAME "drivers/graphics/generic_driver/driver_v1"
#define DRIVER_DEVICE_MODULE_NAME "drivers/graphics/generic_driver/device_v1"
// #pragma mark - driver
@ -41,7 +42,7 @@ supports_device(device_node *parent)
static status_t
register_device(device_node *parent)
{
return gDeviceManager->register_device(parent, DRIVER_MODULE_NAME, NULL,
return gDeviceManager->register_node(parent, DRIVER_MODULE_NAME, NULL,
NULL, NULL);
}
@ -49,7 +50,6 @@ register_device(device_node *parent)
static status_t
init_driver(device_node *node, void **_cookie)
{
// also publishes any devices/nodes with dedicated calls
return B_OK;
}
@ -63,6 +63,8 @@ uninit_driver(device_node *node)
static status_t
register_child_devices(device_node *node)
{
gDeviceManager->publish_device(node, "graphics/generic/0",
DRIVER_DEVICE_MODULE_NAME);
return B_OK;
}
@ -77,7 +79,7 @@ device_removed(device_node *node)
static status_t
init_device(void *deviceCookie)
init_device(device_node *node, void **_deviceCookie)
{
// called once before one or several open() calls
return B_ERROR;
@ -164,7 +166,7 @@ struct driver_module_info gGenericVideoDriverModuleInfo = {
struct device_module_info gGenericVideoDeviceModuleInfo = {
{
"drivers/graphics/generic_driver/device_v1",
DRIVER_DEVICE_MODULE_NAME,
0,
NULL,
},

10
src/tests/system/kernel/device_manager/playground/specific_video_driver.cpp
View File

@ -11,6 +11,7 @@
#define DRIVER_MODULE_NAME "drivers/graphics/specific_driver/driver_v1"
#define DRIVER_DEVICE_MODULE_NAME "drivers/graphics/specific_driver/device_v1"
// #pragma mark - driver
@ -39,7 +40,7 @@ supports_device(device_node *parent)
static status_t
register_device(device_node *parent)
{
return gDeviceManager->register_device(parent, DRIVER_MODULE_NAME, NULL,
return gDeviceManager->register_node(parent, DRIVER_MODULE_NAME, NULL,
NULL, NULL);
}
@ -47,7 +48,6 @@ register_device(device_node *parent)
static status_t
init_driver(device_node *node, void **_cookie)
{
// also publishes any devices/nodes with dedicated calls
return B_OK;
}
@ -61,6 +61,8 @@ uninit_driver(device_node *node)
static status_t
register_child_devices(device_node *node)
{
gDeviceManager->publish_device(node, "graphics/specific/0",
DRIVER_DEVICE_MODULE_NAME);
return B_OK;
}
@ -75,7 +77,7 @@ device_removed(device_node *node)
static status_t
init_device(void *deviceCookie)
init_device(device_node *node, void **_deviceCookie)
{
// called once before one or several open() calls
return B_ERROR;
@ -162,7 +164,7 @@ struct driver_module_info gSpecificVideoDriverModuleInfo = {
struct device_module_info gSpecificVideoDeviceModuleInfo = {
{
"drivers/graphics/specific_driver/device_v1",
DRIVER_DEVICE_MODULE_NAME,
0,
NULL,
},