static status_t
find_graphics_card(addr_t frameBuffer, addr_t& base, size_t& size)
{
// TODO: when we port this over to the new driver API, this mechanism can be
// used to find the right device_node
pci_module_info* pci;
if (get_module(B_PCI_MODULE_NAME, (module_info**)&pci) != B_OK)
return B_ERROR;
pci_info info;
for (int32 index = 0; pci->get_nth_pci_info(index, &info) == B_OK; index++) {
if (info.class_base != PCI_display)
continue;
// check PCI BARs
for (uint32 i = 0; i < 6; i++) {
if (info.u.h0.base_registers[i] <= frameBuffer
&& info.u.h0.base_registers[i] + info.u.h0.base_register_sizes[i]
> frameBuffer) {
// found it!
base = info.u.h0.base_registers[i];
size = info.u.h0.base_register_sizes[i];
put_module(B_PCI_MODULE_NAME);
return B_OK;
}
}
}
put_module(B_PCI_MODULE_NAME);
return B_ENTRY_NOT_FOUND;
}
status_t
init_driver(void)
{
SHOW_FLOW0(3, "");
if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci_bus) != B_OK)
return B_ERROR;
/* get a handle for the agp bus if it exists */
get_module(B_AGP_GART_MODULE_NAME, (module_info **)&sAGP);
/* driver private data */
devices = (radeon_devices *)calloc(1, sizeof(radeon_devices));
if (devices == NULL) {
put_module(B_PCI_MODULE_NAME);
if (sAGP != NULL)
put_module(B_AGP_GART_MODULE_NAME);
return B_ERROR;
}
(void)INIT_BEN(devices->kernel, "Radeon Kernel");
GetDriverSettings();
Radeon_ProbeDevices();
return B_OK;
}
static status_t std_ops(int32 op, ...)
{
switch(op) {
case B_MODULE_INIT:
if (get_module(pci_name, (module_info **) &pci) != B_OK)
return B_ERROR;
if (get_module(cam_name, (module_info **) &cam) != B_OK) {
put_module(pci_name);
return B_ERROR;
}
if(sim_install_buslogic()) {
return B_OK;
}
put_module(pci_name);
put_module(cam_name);
return B_ERROR;
case B_MODULE_UNINIT:
put_module(pci_name);
put_module(cam_name);
return B_OK;
default:
return B_ERROR;
}
}
// called just before the kernel unloads the driver
void
uninit_driver(void)
{
CALLED();
int32 j;
for (j = 0; j < MAX_BT_GENERIC_USB_DEVICES; j++) {
if (publish_names[j] != NULL)
free(publish_names[j]);
if (bt_usb_devices[j] != NULL) {
// if (connected_dev != NULL) {
// debugf("Device %p still exists.\n", connected_dev);
// }
ERROR("%s: %s still present?\n", __func__, bt_usb_devices[j]->name);
kill_device(bt_usb_devices[j]);
}
}
usb->uninstall_notify(BLUETOOTH_DEVICE_DEVFS_NAME);
remove_debugger_command("bth2generic", &dump_driver);
// Releasing modules
put_module(usb_name);
put_module(hci_name);
// TODO: netbuffers
delete_sem(dev_table_sem);
}
status_t
device_node::_FindBestDriver(const char* path, driver_module_info*& bestDriver,
float& bestSupport, device_node* previous)
{
if (bestDriver == NULL)
bestSupport = previous != NULL ? previous->fSupportsParent : 0.0f;
void* list = open_module_list_etc(path, "driver_v1");
driver_module_info* driver;
while (_GetNextDriver(list, driver) == B_OK) {
if (previous != NULL && driver == previous->DriverModule()) {
put_module(driver->info.name);
continue;
}
float support = driver->supports_device(this);
if (support > bestSupport) {
if (bestDriver != NULL)
put_module(bestDriver->info.name);
bestDriver = driver;
bestSupport = support;
continue;
// keep reference to best module around
}
put_module(driver->info.name);
}
close_module_list(list);
return bestDriver != NULL ? B_OK : B_ENTRY_NOT_FOUND;
}
static status_t std_ops(int32 op, ...)
{
switch(op) {
case B_MODULE_INIT:
#if DEBUG_SAFETY
set_dprintf_enabled(true);
#endif
load_driver_symbols("53c8xx");
if (get_module(pci_name, (module_info **) &pci) != B_OK)
return B_ERROR;
if (get_module(cam_name, (module_info **) &cam) != B_OK) {
put_module(pci_name);
return B_ERROR;
}
if(sim_install_symbios()){
return B_OK;
}
put_module(pci_name);
put_module(cam_name);
return B_ERROR;
case B_MODULE_UNINIT:
put_module(pci_name);
put_module(cam_name);
return B_OK;
default:
return B_ERROR;
}
}
status_t
init_driver(void)
{
int i = 0;
status_t err;
num_cards = 0;
TRACE("@@init_driver()\n");
if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci))
return ENOSYS;
if (get_module(B_MPU_401_MODULE_NAME, (module_info **) &mpu401)) {
put_module(B_PCI_MODULE_NAME);
return ENOSYS;
}
while ((*pci->get_nth_pci_info)(i, &cards[num_cards].info) == B_OK) {
//TODO check other Vendor_ID and DEVICE_ID
if ((cards[num_cards].info.vendor_id == ICE1712_VENDOR_ID)
&& (cards[num_cards].info.device_id == ICE1712_DEVICE_ID)) {
if (num_cards == NUM_CARDS) {
TRACE("Too many ice1712 cards installed!\n");
break;
}
if ((err = (*pci->reserve_device)(cards[num_cards].info.bus,
cards[num_cards].info.device, cards[num_cards].info.function,
DRIVER_NAME, &cards[num_cards])) < B_OK) {
dprintf("%s: failed to reserve_device(%d, %d, %d,): %s\n",
DRIVER_NAME, cards[num_cards].info.bus,
cards[num_cards].info.device,
cards[num_cards].info.function, strerror(err));
continue;
}
if (ice1712_setup(&cards[num_cards]) != B_OK) {
//Vendor_ID and Device_ID has been modified
TRACE("Setup of ice1712 %d failed\n", (int)(num_cards + 1));
(*pci->unreserve_device)(cards[num_cards].info.bus,
cards[num_cards].info.device,
cards[num_cards].info.function,
DRIVER_NAME, &cards[num_cards]);
} else {
num_cards++;
}
}
i++;
}
TRACE("Number of succesfully initialised card : %d\n", (int)num_cards);
if (num_cards == 0) {
put_module(B_PCI_MODULE_NAME);
put_module(B_MPU_401_MODULE_NAME);
return ENODEV;
}
return B_OK;
}
void
uninit_driver(void)
{
/* free the driver data */
DELETE_BEN(pd->kernel);
free(pd);
pd = NULL;
/* put the pci module away */
put_module(B_PCI_MODULE_NAME);
put_module(B_ISA_MODULE_NAME);
}
void
uninit_driver(void)
{
SHOW_FLOW0(3, "");
DELETE_BEN(devices->kernel);
free(devices);
devices = NULL;
put_module(B_PCI_MODULE_NAME);
if (sAGP)
put_module(B_AGP_GART_MODULE_NAME);
}
void
uninit_driver()
{
int32 i = 0;
for (i=0; i<devices_count; i++) {
free (devices[i]);
}
free(devices);
devices = NULL;
put_module(DS_MODULE_NAME);
put_module(CS_CLIENT_MODULE_NAME);
}
void uninit_driver(void) {
/* free the driver data */
DELETE_BEN(pd->kernel);
free(pd);
pd = NULL;
/* put the pci module away */
put_module(B_PCI_MODULE_NAME);
put_module(B_ISA_MODULE_NAME);
/* put the agp module away if it's there */
if (agp_bus) put_module(B_AGP_MODULE_NAME);
}
status_t
init_driver(void)
{
status_t ret = ENODEV;
int i;
TRACE("init_driver\n");
if (get_module(B_PCI_MODULE_NAME, (module_info **)&gPciBus) != B_OK) {
ret = B_ERROR;
goto done;
}
if (!(gPd = calloc(1, sizeof(DeviceData)))) {
put_module(B_PCI_MODULE_NAME);
ret = B_ERROR;
goto done;
}
/* Remember the PCI information */
for (i = 0; (*gPciBus->get_nth_pci_info)(i, &gPd->pcii) == B_OK; i++)
if (gPd->pcii.vendor_id == PCI_VENDOR_ID_VMWARE &&
gPd->pcii.device_id == PCI_DEVICE_ID_VMWARE_SVGA2) {
ret = B_OK;
break;
}
if (ret != B_OK) {
free(gPd);
put_module(B_PCI_MODULE_NAME);
goto done;
}
/* Create a benaphore for exclusive access in OpenHook/FreeHook */
INIT_BEN(gPd->kernel);
/* The device name */
gPd->names[0] = strdup("graphics/vmware");
gPd->names[1] = NULL;
/* Usual initializations */
gPd->isOpen = 0;
gPd->sharedArea = -1;
gPd->si = NULL;
done:
TRACE("init_driver: %ld\n", ret);
return ret;
}
status_t
init_hardware(void)
{
long index = 0;
pci_info pcii;
bool found = false;
/* choke if we can't find the PCI bus */
if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci_bus) != B_OK)
return B_ERROR;
/* choke if we can't find the ISA bus */
if (get_module(B_ISA_MODULE_NAME, (module_info **)&isa_bus) != B_OK)
{
put_module(B_PCI_MODULE_NAME);
return B_ERROR;
}
/* while there are more pci devices */
while ((*pci_bus->get_nth_pci_info)(index, &pcii) == B_NO_ERROR) {
int vendor = 0;
/* if we match a supported vendor */
while (SupportedDevices[vendor].vendor) {
if (SupportedDevices[vendor].vendor == pcii.vendor_id) {
uint16 *devices = SupportedDevices[vendor].devices;
/* while there are more supported devices */
while (*devices) {
/* if we match a supported device */
if (*devices == pcii.device_id ) {
found = true;
goto done;
}
/* next supported device */
devices++;
}
}
vendor++;
}
/* next pci_info struct, please */
index++;
}
done:
/* put away the module manager */
put_module(B_PCI_MODULE_NAME);
return found ? B_OK : B_ERROR;
}
status_t
ethernet_init(const char *name, net_device **_device)
{
// make sure this is a device in /dev/net, but not the
// networking (userland) stack driver
if (strncmp(name, "/dev/net/", 9) || !strcmp(name, "/dev/net/stack")
|| !strcmp(name, "/dev/net/userland_server"))
return B_BAD_VALUE;
status_t status = get_module(NET_BUFFER_MODULE_NAME, (module_info **)&gBufferModule);
if (status < B_OK)
return status;
ethernet_device *device = new (std::nothrow) ethernet_device;
if (device == NULL) {
put_module(NET_BUFFER_MODULE_NAME);
return B_NO_MEMORY;
}
memset(device, 0, sizeof(ethernet_device));
strcpy(device->name, name);
device->flags = IFF_BROADCAST | IFF_LINK;
device->type = IFT_ETHER;
device->mtu = 1500;
device->media = IFM_ACTIVE | IFM_ETHER;
device->header_length = ETHER_HEADER_LENGTH;
device->fd = -1;
*_device = device;
return B_OK;
}
extern "C" status_t
init_driver(void)
{
TRACE((DEVICE_NAME ": init_driver()\n"));
gDeviceInfo[0] = (vesa_info*)malloc(sizeof(vesa_info));
if (gDeviceInfo[0] == NULL)
return B_NO_MEMORY;
memset(gDeviceInfo[0], 0, sizeof(vesa_info));
status_t status = get_module(B_ISA_MODULE_NAME, (module_info**)&gISA);
if (status != B_OK)
goto err1;
gDeviceNames[0] = strdup("graphics/vesa");
if (gDeviceNames[0] == NULL) {
status = B_NO_MEMORY;
goto err2;
}
gDeviceNames[1] = NULL;
mutex_init(&gLock, "vesa lock");
return B_OK;
err2:
put_module(B_ISA_MODULE_NAME);
err1:
free(gDeviceInfo[0]);
return status;
}
status_t
init_driver(void)
{
DPRINTF_INFO("init_driver(), built %s %s\n", __DATE__, __TIME__);
#if DEBUG_DRIVER
if (load_driver_symbols(drivername) == B_OK) {
DPRINTF_INFO("loaded symbols\n");
} else {
DPRINTF_INFO("no symbols for you!\n");
}
#endif
if (get_module(B_USB_MODULE_NAME, (module_info**) &usb) != B_OK) {
DPRINTF_INFO("cannot get module \"%s\"\n", B_USB_MODULE_NAME);
return B_ERROR;
}
if ((gDeviceListLock = create_sem(1, "dev_list_lock")) < 0) {
put_module(B_USB_MODULE_NAME);
return gDeviceListLock;
}
usb->register_driver(kDriverName, supported_devices,
sizeof(supported_devices)/sizeof(usb_support_descriptor), NULL);
usb->install_notify(kDriverName, ¬ify_hooks);
return B_OK;
}
Interface::~Interface()
{
TRACE("Interface %p: destructor\n", this);
put_device_interface(fDeviceInterface);
// Uninitialize the domain datalink protocols
DatalinkTable::Iterator iterator = fDatalinkTable.GetIterator();
while (domain_datalink* datalink = iterator.Next()) {
put_domain_datalink_protocols(this, datalink->domain);
}
// Free domain datalink objects
domain_datalink* next = fDatalinkTable.Clear(true);
while (next != NULL) {
domain_datalink* datalink = next;
next = next->hash_link;
delete datalink;
}
recursive_lock_destroy(&fLock);
// Release reference of the stack - at this point, our stack may be unloaded
// if no other interfaces or sockets are left
put_module(gNetStackInterfaceModule.info.name);
}
/*! \brief Returns parameters for partitioning a session.
The partitioning system (module) identified by \a identifier is asked to
return parameters for the session. If the session is already partitioned
using this system, then the parameters describing the current layout will
be returned, otherwise default values.
If the supplied buffer is too small for the parameters, the function
returns \c B_OK, but doesn't fill in the buffer; the required buffer
size is returned in \a actualSize. If the buffer is large enough,
\a actualSize is set to the actually used size. The size includes the
terminating null.
\param deviceFD The device the session to be partitioned resides on.
\param sessionIndex The index of the session to be partitioned.
\param identifier A string identifying the partitioning system to be used.
\param buffer Pointer to a pre-allocated buffer of size \a bufferSize.
\param bufferSize The size of \a buffer.
\param actualSize Pointer to a pre-allocated size_t to be set to the
actually needed buffer size.
\return
- \c B_OK: The parameters could be retrieved or the buffer is too
small. \a actualSize has to be checked!
- another error code, if something went wrong
*/
status_t
get_partitioning_parameters(int deviceFD, int32 sessionIndex,
const char *identifier, char *buffer,
size_t bufferSize, size_t *actualSize)
{
status_t error = (identifier && buffer && actualSize ? B_OK : B_BAD_VALUE);
disk_scanner_module_info *diskScanner = NULL;
session_info sessionInfo;
// get the disk scanner module
if (error == B_OK) {
error = get_module(DISK_SCANNER_MODULE_NAME,
(module_info**)&diskScanner);
}
// get the session info
if (error == B_OK) {
error = diskScanner->get_nth_session_info(deviceFD, sessionIndex,
&sessionInfo, NULL);
}
// get the parameters
if (error == B_OK) {
error = diskScanner->get_partitioning_params(deviceFD, &sessionInfo,
identifier, buffer, bufferSize, actualSize);
}
// put the partition scanner module
if (diskScanner)
put_module(diskScanner->module.name);
return error;
}
status_t
init_driver()
{
TRACE("init_driver() " __DATE__ " " __TIME__ "\n");
if (get_module(B_USB_MODULE_NAME, (module_info **)&gUSBModule) != B_OK)
return B_ERROR;
gDeviceList = new(std::nothrow) DeviceList();
if (gDeviceList == NULL) {
put_module(B_USB_MODULE_NAME);
return B_NO_MEMORY;
}
mutex_init(&sDriverLock, "usb hid driver lock");
static usb_notify_hooks notifyHooks = {
&usb_hid_device_added,
&usb_hid_device_removed
};
static usb_support_descriptor supportDescriptor = {
USB_INTERFACE_CLASS_HID, 0, 0, 0, 0
};
gUSBModule->register_driver(DRIVER_NAME, &supportDescriptor, 1, NULL);
gUSBModule->install_notify(DRIVER_NAME, ¬ifyHooks);
TRACE("init_driver() OK\n");
return B_OK;
}
static status_t
std_ops(int32 op, ...)
{
void *handle;
bool load = false;
switch (op) {
case B_MODULE_INIT:
handle = load_driver_settings("kernel");
if (handle) {
load = get_driver_boolean_parameter(handle,
"bochs_debug_output", load, true);
unload_driver_settings(handle);
}
if (load) {
if (get_module(B_ISA_MODULE_NAME, (module_info **)&sISAModule) < B_OK)
return B_ERROR;
}
return load ? B_OK : B_ERROR;
case B_MODULE_UNINIT:
put_module(B_ISA_MODULE_NAME);
return B_OK;
}
return B_BAD_VALUE;
}
/*! Registers any children that are identified via the B_DEVICE_FIXED_CHILD
attribute.
If any of these children cannot be registered, this call will fail (we
don't remove children we already registered up to this point in this case).
*/
status_t
device_node::_RegisterFixed(uint32& registered)
{
AttributeList::Iterator iterator = fAttributes.GetIterator();
registered = 0;
while (iterator.HasNext()) {
device_attr_private* attr = iterator.Next();
if (strcmp(attr->name, B_DEVICE_FIXED_CHILD))
continue;
driver_module_info* driver;
status_t status = get_module(attr->value.string,
(module_info**)&driver);
if (status != B_OK) {
TRACE(("register fixed child %s failed: %s\n", attr->value.string,
strerror(status)));
return status;
}
if (driver->register_device != NULL) {
status = driver->register_device(this);
if (status == B_OK)
registered++;
}
put_module(attr->value.string);
if (status != B_OK)
return status;
}
return B_OK;
}
static status_t
bcd_std_ops(int32 op, ...)
{
status_t status;
switch (op) {
case B_MODULE_INIT:
new (&sConnectionList) DoublyLinkedList<HciConnection>;
add_debugger_command("btConnections", &DumpHciConnections,
"Lists Bluetooth Connections with RemoteDevices & channels");
status = get_module(NET_BUFFER_MODULE_NAME,
(module_info **)&gBufferModule);
if (status < B_OK)
return status;
return B_OK;
break;
case B_MODULE_UNINIT:
remove_debugger_command("btConnections", &DumpHciConnections);
put_module(NET_BUFFER_MODULE_NAME);
return B_OK;
break;
}
return B_ERROR;
}
static void
scan_modules(const char* path)
{
void* cookie = open_module_list(path);
if (cookie == NULL)
return;
while (true) {
char name[B_FILE_NAME_LENGTH];
size_t length = sizeof(name);
if (read_next_module_name(cookie, name, &length) != B_OK)
break;
TRACE(("scan %s\n", name));
module_info* module;
if (get_module(name, &module) == B_OK) {
// we don't need the module right now, but we give it a chance
// to register itself
put_module(name);
}
}
close_module_list(cookie);
}
OHCI::~OHCI()
{
int32 result = 0;
fStopFinishThread = true;
delete_sem(fFinishTransfersSem);
wait_for_thread(fFinishThread, &result);
_LockEndpoints();
mutex_destroy(&fEndpointLock);
if (fHccaArea >= B_OK)
delete_area(fHccaArea);
if (fRegisterArea >= B_OK)
delete_area(fRegisterArea);
_FreeEndpoint(fDummyControl);
_FreeEndpoint(fDummyBulk);
_FreeEndpoint(fDummyIsochronous);
if (fInterruptEndpoints != NULL) {
for (int i = 0; i < OHCI_STATIC_ENDPOINT_COUNT; i++)
_FreeEndpoint(fInterruptEndpoints[i]);
}
delete [] fInterruptEndpoints;
delete fRootHub;
put_module(B_PCI_MODULE_NAME);
}
static status_t
free_hook (void* cookie)
{
dp83815_properties_t *data = (dp83815_properties_t *) cookie;
TRACE(( kDevName " free_hook()\n" ));
while ( data->Tx.Lock ); /* wait for any current writes to finish */
while ( data->Rx.Lock ); /* wait for any current reads to finish */
//Remove interrupt handler
remove_io_interrupt_handler( data->pcii->u.h0.interrupt_line ,
dp83815_interrupt_hook , cookie );
m_openmask &= ~(1L << data->device_id);
free_resources(data); /* unblock waiting threads */
//Finally, free the cookie
free( data );
//Put the pci module
put_module( B_PCI_MODULE_NAME );
return B_OK;
}
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)
fDriver->uninit_driver(fDriverData);
fDriver = NULL;
fDriverData = NULL;
put_module(ModuleName());
if (Parent() != NULL)
Parent()->UninitDriver();
Release();
return true;
}
status_t
init_driver(void)
{
int i = 0, j = 0, is_detected;
pci_info dev_info;
//debug_fd = open("/tmp/broadcom_traffic_log",O_RDWR | B_CREATE_FILE);
if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci) != B_OK)
return B_ERROR;
while (pci->get_nth_pci_info(i++, &dev_info) == 0) {
is_detected = 0;
if ((dev_info.class_base == PCI_network) && (dev_info.class_sub == PCI_ethernet)) {
for (j = 0; bcm5700_pci_tbl[j].vendor != 0; j++) {
if ((dev_info.vendor_id == bcm5700_pci_tbl[j].vendor) && (dev_info.device_id == bcm5700_pci_tbl[j].device)) {
is_detected = 1;
break;
}
}
}
if (!is_detected)
continue;
if (cards_found >= 10)
break;
dev_list[cards_found] = (char *)malloc(16 /* net/bcm570x/xx */);
sprintf(dev_list[cards_found],"net/bcm570x/%d",cards_found);
be_b57_dev_cards[cards_found].pci_data = dev_info;
be_b57_dev_cards[cards_found].packet_release_sem = create_sem(0,dev_list[cards_found]);
be_b57_dev_cards[cards_found].mem_list_num = 0;
be_b57_dev_cards[cards_found].lockmem_list_num = 0;
be_b57_dev_cards[cards_found].opened = 0;
be_b57_dev_cards[cards_found].block = 1;
be_b57_dev_cards[cards_found].lock = 0;
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
be_b57_dev_cards[cards_found].linkChangeSem = -1;
#endif
if (LM_GetAdapterInfo(&be_b57_dev_cards[cards_found].lm_dev) != LM_STATUS_SUCCESS) {
for (j = 0; j < cards_found; j++) {
free(dev_list[j]);
delete_sem(be_b57_dev_cards[j].packet_release_sem);
}
put_module(B_PCI_MODULE_NAME);
return ENODEV;
}
QQ_InitQueue(&be_b57_dev_cards[cards_found].RxPacketReadQ.Container,MAX_RX_PACKET_DESC_COUNT);
cards_found++;
}
mempool_init((MAX_RX_PACKET_DESC_COUNT+MAX_TX_PACKET_DESC_COUNT) * cards_found);
dev_list[cards_found] = NULL;
return B_OK;
}
/*! \brief Partitions a specified session on a device using the paritioning
system identified by \a identifier and according to supplied
parameters.
\param deviceFD The device the session to be partitioned resides on.
\param sessionIndex The index of the session to be partitioned.
\param identifier A string identifying the partitioning system to be used.
\param parameters Parameters according to which the session shall be
partitioned. May be \c NULL, depending on the concerned partition
module.
\return \c B_OK, if everything went fine, an error code otherwise.
*/
status_t
partition_session(int deviceFD, int32 sessionIndex, const char *identifier,
const char *parameters)
{
status_t error = (identifier ? B_OK : B_BAD_VALUE);
disk_scanner_module_info *diskScanner = NULL;
session_info sessionInfo;
// get the disk scanner module
if (error == B_OK) {
error = get_module(DISK_SCANNER_MODULE_NAME,
(module_info**)&diskScanner);
}
// get the session info
if (error == B_OK) {
error = diskScanner->get_nth_session_info(deviceFD, sessionIndex,
&sessionInfo, NULL);
}
// partition the session
if (error == B_OK) {
error = diskScanner->partition(deviceFD, &sessionInfo, identifier,
parameters);
}
// put the partition scanner module
if (diskScanner)
put_module(diskScanner->module.name);
return error;
}
status_t
init_driver()
{
status_t status = get_module(B_PCI_MODULE_NAME, (module_info**)&gPCIModule);
if (status < B_OK) {
return ENOSYS;
}
load_settings();
TRACE_ALWAYS("%s\n", kVersion);
pci_info info = {0};
for (long i = 0; B_OK == (*gPCIModule->get_nth_pci_info)(i, &info); i++) {
for (size_t idx = 0; idx < _countof(cardInfos); idx++) {
if (info.vendor_id == cardInfos[idx].VendorId()
&& info.device_id == cardInfos[idx].DeviceId())
{
TRACE_ALWAYS("Found:%s %#010x\n",
cardInfos[idx].Description(), cardInfos[idx].Id());
if (numCards == MAX_DEVICES) {
break;
}
Device* device = new Device(cardInfos[idx], info);
if (device == 0) {
return ENODEV;
}
status_t status = device->InitCheck();
if (status < B_OK) {
delete device;
break;
}
status = device->SetupDevice();
if (status < B_OK) {
delete device;
break;
}
char name[DEVNAME_LEN] = {0};
sprintf(name, "net/%s/%ld", cardInfos[idx].Name(), numCards);
gDeviceNames[numCards] = strdup(name);
gDevices[numCards++] = device;
}
}
}
if (numCards == 0) {
put_module(B_PCI_MODULE_NAME);
return ENODEV;
}
add_debugger_command(DRIVER_NAME, SiS19X_DebuggerCommand,
"SiS190/191 Ethernet driver info");
return B_OK;
}
status_t
device_node::_GetNextDriver(void* list, driver_module_info*& driver)
{
while (true) {
char name[B_FILE_NAME_LENGTH];
size_t nameLength = sizeof(name);
status_t status = read_next_module_name(list, name, &nameLength);
if (status != B_OK)
return status;
if (!strcmp(fModuleName, name))
continue;
if (get_module(name, (module_info**)&driver) != B_OK)
continue;
if (driver->supports_device == NULL
|| driver->register_device == NULL) {
put_module(name);
continue;
}
return B_OK;
}
}
