void scsi_remove_host( SCSI_host_s * psHost )
{
/* Look for all devices that belong to this host */
SCSI_device_s *psDevice = g_psFirstDevice;
SCSI_device_s *psPrev = g_psFirstDevice;
SCSI_device_s *psPartition;
restart:
psDevice = g_psFirstDevice;
psPrev = g_psFirstDevice;
while( psDevice )
{
if( psDevice->psHost == psHost )
{
/* First remove all partitions */
for( psPartition = psDevice->psFirstPartition; psPartition != NULL; psPartition = psPartition->psNext )
{
printk( "SCSI: Removing partition %s\n", psPartition->zName );
if( atomic_read( &psPartition->nOpenCount ) > 0 )
{
printk( "SCSI: Warning: Device still opened\n" );
}
delete_device_node( psPartition->nNodeHandle );
}
/* Then the raw device */
printk( "SCSI: Removing device %s\n", psDevice->zName );
if( atomic_read( &psDevice->nOpenCount ) > 0 )
{
printk( "SCSI: Warning: Device still opened\n" );
}
delete_device_node( psDevice->nNodeHandle );
g_nIDTable[psDevice->nID] = false;
release_device( psDevice->nDeviceHandle );
unregister_device( psDevice->nDeviceHandle );
kfree( psDevice->pDataBuffer );
if( psPrev == psDevice )
{
g_psFirstDevice = psDevice->psNext;
}
else
{
psPrev->psNext = psDevice->psNext;
}
kfree( psDevice );
goto restart;
}
psPrev = psDevice;
psDevice = psDevice->psNext;
}
}
static int __init alsa_seq_oss_init(void)
{
int rc;
if ((rc = register_device()) < 0)
goto error;
if ((rc = register_proc()) < 0) {
unregister_device();
goto error;
}
if ((rc = snd_seq_oss_create_client()) < 0) {
unregister_proc();
unregister_device();
goto error;
}
rc = snd_seq_driver_register(&seq_oss_synth_driver);
if (rc < 0) {
snd_seq_oss_delete_client();
unregister_proc();
unregister_device();
goto error;
}
/* success */
snd_seq_oss_synth_init();
error:
return rc;
}
static void __exit alsa_seq_oss_exit(void)
{
snd_seq_driver_unregister(&seq_oss_synth_driver);
snd_seq_oss_delete_client();
unregister_proc();
unregister_device();
}
int remove_untached_device(int i, int j)
{
int n;
IDEV *p;
/* find which device it belongs */
n = find_device_file_in_use(i, j);
if (n == -1) /* not found */
return -1;
p = dev_list.dev[n].idev;
/* added 3-26:
before we try to obtain the device lock, we have to tell
everyone using the device, that "THE DEVICE IS DYING!!"*/
idev_set_status(p, UNTACHED);
while (idev_get_status(p) != DEAD)
/* wait the response from daemon thread */
sleep(1);
/* unregister device from list */
if (unregister_device(n))
return -2;
/* remove that device, and it's related devices */
return 0;
}
bool_t unregister_clocksource(struct clocksource_t * cs)
{
struct device_t * dev;
struct clocksource_t * c;
irq_flags_t flags;
if(!cs || !cs->name || !cs->read)
return FALSE;
dev = search_device(cs->name, DEVICE_TYPE_CLOCKSOURCE);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
timer_cancel(&cs->keeper.timer);
if(__clocksource == cs)
{
if(!(c = search_first_clocksource()))
c = &__cs_dummy;
spin_lock_irqsave(&__clocksource_lock, flags);
__clocksource = c;
spin_unlock_irqrestore(&__clocksource_lock, flags);
}
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
/****************************************************************************
NAME
connectionAuthDeleteDevice
FUNCTION
This function is called to remove a trusted device from the persistent
trusted device list. A flag indicating if the device was successfully removed
is returned.
*/
uint16 connectionAuthDeleteDevice(const bdaddr* peer_bd_addr)
{
/* Holds the position of a device in the trusted device list (TDL) */
uint16 position = 0;
/* Defines the order or the device in the TDI */
uint16 order = 0;
/* Flag to indicate if the device was deleted */
uint16 deleted = FALSE;
/* Search the trusted device list for the specified device */
position = find_trusted_device(peer_bd_addr);
/* If the device is in the TDL */
if(position)
{
/* Find this device in the TDI */
order = search_trusted_device_index(position);
/* Delete it and re-order TDI */
(void) delete_from_trusted_device_index(order, NO_DEVICES_TO_MANAGE);
/* Delete device from TDL */
(void) PsStore(TRUSTED_DEVICE_LIST_BASE + position - 1, NULL, 0);
/* Remove from the BlueStack security datatbase */
unregister_device(peer_bd_addr);
deleted = TRUE;
}
return deleted;
}
static void __exit alsa_seq_oss_exit(void)
{
snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_OSS);
snd_seq_oss_delete_client();
unregister_proc();
unregister_device();
}
bool_t unregister_console(struct console_t * console)
{
struct device_t * dev;
struct console_t * c;
irq_flags_t flags;
if(!console || !console->name)
return FALSE;
dev = search_device(console->name, DEVICE_TYPE_CONSOLE);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
if(__console == console)
{
if(!(c = search_first_console()))
c = &__console_dummy;
spin_lock_irqsave(&__console_lock, flags);
__console = c;
spin_unlock_irqrestore(&__console_lock, flags);
}
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_watchdog(struct watchdog_t * watchdog)
{
struct device_t * dev;
struct watchdog_t * driver;
if(!watchdog || !watchdog->name)
return FALSE;
dev = search_device_with_type(watchdog->name, DEVICE_TYPE_WATCHDOG);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
driver = (struct watchdog_t *)(dev->driver);
if(driver)
{
if(driver->set)
(driver->set)(driver, 0);
if(driver->exit)
(driver->exit)(driver);
}
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
/**
* ubi_free_volume - free volume.
* @ubi: UBI device description object
* @vol: volume description object
*
* This function frees all resources for volume @vol but does not remove it.
* Used only when the UBI device is detached.
*/
void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
{
dbg_gen("free volume %d", vol->vol_id);
ubi->volumes[vol->vol_id] = NULL;
unregister_device(&vol->dev);
devfs_remove(&vol->cdev);
}
void mdiobus_unregister(struct mii_bus *bus)
{
int i;
for (i = 0; i < PHY_MAX_ADDR; i++) {
if (bus->phy_map[i])
unregister_device(&bus->phy_map[i]->dev);
bus->phy_map[i] = NULL;
}
}
void dundee_device_unregister(struct dundee_device *device)
{
DBG("%p", device);
unregister_device(device);
device->registered = FALSE;
g_hash_table_remove(device_hash, device->path);
}
/**
* ubi_remove_volume - remove volume.
* @desc: volume descriptor
* @no_vtbl: do not change volume table if not zero
*
* This function removes volume described by @desc. The volume has to be opened
* in "exclusive" mode. Returns zero in case of success and a negative error
* code in case of failure. The caller has to have the @ubi->device_mutex
* locked.
*/
int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
{
struct ubi_volume *vol = desc->vol;
struct ubi_device *ubi = vol->ubi;
int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;
dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id);
ubi_assert(desc->mode == UBI_EXCLUSIVE);
ubi_assert(vol == ubi->volumes[vol_id]);
if (ubi->ro_mode)
return -EROFS;
if (vol->ref_count > 1) {
/*
* The volume is busy, probably someone is reading one of its
* sysfs files.
*/
err = -EBUSY;
goto out_unlock;
}
ubi->volumes[vol_id] = NULL;
if (!no_vtbl) {
err = ubi_change_vtbl_record(ubi, vol_id, NULL);
if (err)
goto out_err;
}
for (i = 0; i < vol->reserved_pebs; i++) {
err = ubi_eba_unmap_leb(ubi, vol, i);
if (err)
goto out_err;
}
unregister_device(&vol->dev);
devfs_remove(&vol->cdev);
ubi->rsvd_pebs -= reserved_pebs;
ubi->avail_pebs += reserved_pebs;
ubi_update_reserved(ubi);
ubi->vol_count -= 1;
ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED);
if (!no_vtbl)
self_check_volumes(ubi);
return err;
out_err:
ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err);
ubi->volumes[vol_id] = vol;
out_unlock:
return err;
}
void clear_dead_modules(void)
{
int i;
for (i = 0; i < MAX_DEVICE_NO; i++) {
IDEV *p = dev_list.dev[i].idev;
if (dev_list.dev[i].active && p->status == DEAD) {
dm_log(NULL, "device[%d] %s type %s is dead, freeing the device.",
i, p->name, dev_model[p->type].name);
unregister_device(i);
}
}
}
void ubi_volume_cdev_remove(struct ubi_volume *vol)
{
struct cdev *cdev = &vol->cdev;
struct ubi_volume_cdev_priv *priv = cdev->priv;
list_del(&vol->list);
devfs_remove(cdev);
unregister_device(&vol->dev);
kfree(cdev->name);
kfree(priv);
}
int console_unregister(struct console_device *cdev)
{
struct device_d *dev = &cdev->class_dev;
int status;
list_del(&cdev->list);
if (list_empty(&console_list))
initialized = CONSOLE_UNINITIALIZED;
status = unregister_device(dev);
if (!status)
memset(cdev, 0, sizeof(*cdev));
return status;
}
int del_mtd_device (struct mtd_info *mtd)
{
struct mtddev_hook *hook;
list_for_each_entry(hook, &mtd_register_hooks, hook)
if (hook->del_mtd_device)
hook->del_mtd_device(mtd, &hook->priv);
devfs_remove(&mtd->cdev);
unregister_device(&mtd->class_dev);
free(mtd->param_size.value);
free(mtd->cdev.name);
return 0;
}
static int __init alsa_seq_oss_init(void)
{
int rc;
static struct snd_seq_dev_ops ops = {
snd_seq_oss_synth_register,
snd_seq_oss_synth_unregister,
};
snd_seq_autoload_lock();
if ((rc = register_device()) < 0)
goto error;
if ((rc = register_proc()) < 0) {
unregister_device();
goto error;
}
if ((rc = snd_seq_oss_create_client()) < 0) {
unregister_proc();
unregister_device();
goto error;
}
if ((rc = snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OSS, &ops,
sizeof(struct snd_seq_oss_reg))) < 0) {
snd_seq_oss_delete_client();
unregister_proc();
unregister_device();
goto error;
}
/* success */
snd_seq_oss_synth_init();
error:
snd_seq_autoload_unlock();
return rc;
}
void usbnet_disconnect(struct usb_device *usbdev)
{
struct usbnet *undev = usbdev->drv_data;
struct eth_device *edev = &undev->edev;
struct driver_info *info;
eth_unregister(edev);
unregister_device(&edev->dev);
info = undev->driver_info;
if (info->unbind)
info->unbind(undev);
free(undev);
}
/****************************************************************************
NAME
connectionAuthDeleteAllDevices
FUNCTION
This function is called to remove all trusted devices from the persistent
trusted device list. A flag indicating if all the devices were successfully
removed is returned.
*/
uint16 connectionAuthDeleteAllDevice(uint16 ps_base)
{
/* Flag to indicate if the devices were deleted */
uint16 deleted = FALSE;
/* Trusted device list record index */
uint16 rec = 0;
/* Trusted device record */
TrustedDeviceRecordType record;
/* trusted device index */
TrustedDeviceIndexType tdi;
/* Loop through list of trusted devices */
for(rec = 0; rec < NO_DEVICES_TO_MANAGE; rec++)
{
if(PsRetrieve(TRUSTED_DEVICE_LIST_BASE + rec, &record, sizeof(TrustedDeviceRecordType)))
{
/* Unregister with Bluestack security manager */
unregister_device(&record.bd_addr);
/* Delete entry from TDL */
(void)PsStore(TRUSTED_DEVICE_LIST_BASE + rec, NULL, 0);
deleted = TRUE;
}
/* Delete any associated attribute data */
if(ps_base)
{
(void)PsStore(ps_base + rec, NULL, 0);
}
}
/* Delete TDI */
if(deleted)
{
memset(&tdi, 0, sizeof(TrustedDeviceIndexType));
(void)PsStore(TRUSTED_DEVICE_INDEX, &tdi, sizeof(tdi));
}
return deleted;
}
/*
* unregister char device from chrdev_list
*/
bool_t unregister_chrdev(const char * name)
{
struct device * device;
if(!name)
return FALSE;
device = search_device(name);
if(!device && device->type == CHAR_DEVICE)
return FALSE;
if(unregister_device(device))
{
free(device);
return TRUE;
}
return FALSE;
}
bool_t unregister_input(struct input_t * input)
{
struct device_t * dev;
if(!input || !input->name)
return FALSE;
dev = search_device(input->name, DEVICE_TYPE_INPUT);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_battery(struct battery_t * bat)
{
struct device_t * dev;
if(!bat || !bat->name)
return FALSE;
dev = search_device_with_type(bat->name, DEVICE_TYPE_BATTERY);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_i2c(struct i2c_t * i2c)
{
struct device_t * dev;
if(!i2c || !i2c->name)
return FALSE;
dev = search_device(i2c->name, DEVICE_TYPE_I2C);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_clk(struct clk_t * clk)
{
struct device_t * dev;
if(!clk || !clk->name)
return FALSE;
dev = search_device(clk->name, DEVICE_TYPE_CLK);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_led(struct led_t * led)
{
struct device_t * dev;
if(!led || !led->name)
return FALSE;
dev = search_device(led->name, DEVICE_TYPE_LED);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_stepper(struct stepper_t * m)
{
struct device_t * dev;
if(!m || !m->name)
return FALSE;
dev = search_device(m->name, DEVICE_TYPE_STEPPER);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_buzzer(struct buzzer_t * buzzer)
{
struct device_t * dev;
if(!buzzer || !buzzer->name)
return FALSE;
dev = search_device(buzzer->name, DEVICE_TYPE_BUZZER);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_rtc(struct rtc_t * rtc)
{
struct device_t * dev;
if(!rtc || !rtc->name)
return FALSE;
dev = search_device(rtc->name, DEVICE_TYPE_RTC);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
bool_t unregister_block(struct block_t * blk)
{
struct device_t * dev;
if(!blk || !blk->name)
return FALSE;
dev = search_device(blk->name, DEVICE_TYPE_BLOCK);
if(!dev)
return FALSE;
if(!unregister_device(dev))
return FALSE;
kobj_remove_self(dev->kobj);
free(dev->name);
free(dev);
return TRUE;
}
