static int tc05(void)
{
int major, pass = 16;
unsigned int i, test_major[2] = {512, UINT_MAX};
prk_info("Test Case 5: register_blkdev() with major=%u/%u\n",
test_major[0], test_major[1]);
for (i = 0; i < sizeof(test_major) / sizeof(unsigned int); i++) {
major = register_blkdev(test_major[i], BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major == 0) {
unregister_blkdev(test_major[i], BLK_DEV_NAME);
#ifdef BLKDEV_MAJOR_MAX
pass = 0;
#endif
} else {
prk_debug("register_blkdev() with major %u got error %i\n",
test_major[i], major);
#ifndef BLKDEV_MAJOR_MAX
pass = 0;
#endif
}
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static int tc04(void)
{
int major, pass = 8;
unsigned int i, test_major[2] = {256, 511};
prk_info("Test Case 4: register_blkdev() with major=%u/%u\n",
test_major[0], test_major[1]);
for (i = 0; i < sizeof(test_major) / sizeof(unsigned int); i++) {
major = register_blkdev(test_major[i], BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major == 0) {
unregister_blkdev(test_major[i], BLK_DEV_NAME);
} else if (major == -EBUSY) {
prk_debug("device was busy, register_blkdev() with major %u skipped\n",
test_major[i]);
} else {
pass = 0;
prk_debug("register_blkdev() with major %u got error %i\n",
test_major[i], major);
}
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static void __exit ace_exit(void)
{
pr_debug("Unregistering Xilinx SystemACE driver\n");
platform_driver_unregister(&ace_platform_driver);
ace_of_unregister();
unregister_blkdev(ace_major, "xsysace");
}
static void __exit ramblock_exit(void)
{
unregister_blkdev(major, "ramblock");
del_gendisk(ramblock_disk);
put_disk(ramblock_disk);
blk_cleanup_queue(ramblock_queue);
}
static void osprd_exit(void)
{
int i;
for (i = 0; i < NOSPRD; i++)
cleanup_device(&osprds[i]);
unregister_blkdev(OSPRD_MAJOR, "osprd");
}
static int __init sbull_init(void)
{
int i;
printk(KERN_EMERG "sbull: sbull_init\n");
/*
* Get registered.
*/
sbull_major = register_blkdev(sbull_major, "sbull");
if (sbull_major <= 0) {
printk(KERN_WARNING "sbull: unable to get major number\n");
return -EBUSY;
}
/*
* Allocate the device array, and initialize each one.
*/
Devices = kmalloc(ndevices*sizeof (struct sbull_dev), GFP_KERNEL);
if (Devices == NULL)
goto out_unregister;
for (i = 0; i < ndevices; i++)
setup_device(Devices + i, i);
return 0;
out_unregister:
unregister_blkdev(sbull_major, "sbd");
return -ENOMEM;
}
/* ---------------------------------------------------------------------
* Module init/exit routines
*/
static int __init ace_init(void)
{
int rc;
ace_major = register_blkdev(ace_major, "xsysace");
if (ace_major <= 0) {
rc = -ENOMEM;
goto err_blk;
}
rc = ace_of_register();
if (rc)
goto err_of;
pr_debug("xsysace: registering platform binding\n");
rc = platform_driver_register(&ace_platform_driver);
if (rc)
goto err_plat;
pr_info("Xilinx SystemACE device driver, major=%i\n", ace_major);
return 0;
err_plat:
ace_of_unregister();
err_of:
unregister_blkdev(ace_major, "xsysace");
err_blk:
printk(KERN_ERR "xsysace: registration failed; err=%i\n", rc);
return rc;
}
static void __devexit cpqarray_remove_one(int i)
{
int j;
char buff[4];
/* sendcmd will turn off interrupt, and send the flush...
* To write all data in the battery backed cache to disks
* no data returned, but don't want to send NULL to sendcmd */
if( sendcmd(FLUSH_CACHE, i, buff, 4, 0, 0, 0))
{
printk(KERN_WARNING "Unable to flush cache on controller %d\n",
i);
}
free_irq(hba[i]->intr, hba[i]);
iounmap(hba[i]->vaddr);
unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
del_timer(&hba[i]->timer);
remove_proc_entry(hba[i]->devname, proc_array);
pci_free_consistent(hba[i]->pci_dev,
NR_CMDS * sizeof(cmdlist_t), (hba[i]->cmd_pool),
hba[i]->cmd_pool_dhandle);
kfree(hba[i]->cmd_pool_bits);
for(j = 0; j < NWD; j++) {
if (ida_gendisk[i][j]->flags & GENHD_FL_UP)
del_gendisk(ida_gendisk[i][j]);
put_disk(ida_gendisk[i][j]);
}
blk_cleanup_queue(hba[i]->queue);
release_io_mem(hba[i]);
free_hba(i);
}
static void memcon_exit(void)
{
pci_unregister_driver(&pblaze_pcie_driver);
unregister_blkdev(raid_drv.major, "memcon");
pblaze_virt_bus_unregister();
kmem_cache_destroy(raid_drv.ioreq_slab);
}
static int __init ndas_init(void)
{
int retval = 0;
struct ndas_dev *dev;
func();
retval = register_blkdev(0, "myndas");
if (retval <= 0) {
printk(KERN_ERR "ndas: failed to register device\n");
return retval;
} else {
major_number = retval;
printk(KERN_INFO "ndas: register device major number %d\n", major_number);
}
/* init block device */
dev = kmalloc(sizeof(struct ndas_dev), GFP_KERNEL);
if (dev == NULL) {
printk(KERN_ERR "ndas: failed to allocate memory for device\n");
goto err1;
}
memset(dev, sizeof(struct ndas_dev), 0);
spin_lock_init(&dev->lock);
Device = dev;
/* init queue */
dev->queue = blk_init_queue(ndas_request, &dev->lock);
if (dev->queue == NULL) {
printk(KERN_ERR "ndas: failed to allocate memory for queue\n");
goto err2;
}
blk_queue_logical_block_size(dev->queue, HARDSECT_SIZE);
dev->queue->queuedata = dev;
/* gendisk structure */
dev->gd = alloc_disk(NDAS_MINORS);
if (dev->gd == NULL) {
printk(KERN_ERR "ndas: failed to allocate memory for gendisk\n");
goto err3;
}
dev->gd->major = major_number;
dev->gd->first_minor = 0;
dev->gd->fops = &blk_ops;
dev->gd->queue = dev->queue;
dev->gd->private_data = dev;
set_capacity(dev->gd, NSECTOR * (HARDSECT_SIZE / KERNEL_SECTOR_SIZE));
snprintf(dev->gd->disk_name, 6, "myndas");
add_disk(dev->gd);
return 0;
err3:
blk_cleanup_queue(dev->queue);
err2:
kfree(dev);
err1:
Device = NULL;
unregister_blkdev(major_number, "ndas");
return -ENOMEM;
}
static void __exit sb_exit(void) {
/* Free kernel memory */
put_disk(sbd->gd);
del_gendisk(sbd->gd);
kfree(sbd);
unregister_blkdev(MAJOR_NODE, DEV_NAME);
release_region(REG_BASE, REG_LEN);
}
static int tc03(void)
{
int major, major2, major3;
int pass = 4;
prk_info("Test Case 3: register_blkdev() with major != 0\n");
/* autosearch for a free major number */
major = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major = %i\n", major);
if (major > 0) {
unregister_blkdev(major, BLK_DEV_NAME);
/* expected to return 0 */
major2 = register_blkdev(major, BLK_DEV_NAME);
/* this call has to fail with EBUSY return value */
major3 = register_blkdev(major, BLK_DEV_NAME);
if (major2 == 0) {
unregister_blkdev(major, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("1st call to register_blkdev() with major=%i "
"failed with error %i\n", major, major2);
}
if (major3 == 0) {
unregister_blkdev(major, BLK_DEV_NAME);
pass = 0;
} else {
if (major3 != -EBUSY)
pass = 0;
prk_debug("2nd call to register_blkdev() with major=%i "
"failed with error %i\n", major, major3);
}
} else {
pass = 0;
prk_debug("register_blkdev() failed with error %i\n", major);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
static void __exit looper_exit(void)
{
del_gendisk(Device.gd);
put_disk(Device.gd);
unregister_blkdev(major_num, "looper");
blk_cleanup_queue(Queue);
vfree(Device.data);
}
static void __exit simpleblockexit(void)
{
del_gendisk(Device.gd);
put_disk(Device.gd);
unregister_blkdev(major_num, "sbd");
blk_cleanup_queue(Queue);
vfree(Device.data);
}
static void __exit mini2440_ramdisk_exit(void)
{
del_gendisk(mini2440_ramdisk_devp->gdisk);
put_disk(mini2440_ramdisk_devp->gdisk);
kfree(mini2440_ramdisk_devp->ramdisk_buffer);
blk_cleanup_queue(mini2440_ramdisk_devp->queue);
kfree(mini2440_ramdisk_devp);
unregister_blkdev(mini2440_ramdisk_major, "mini2440_ramdisk");
}
static void __exit mbd_cleanup(void)
{
devfs_remove("mambobd");
if (unregister_blkdev(MAJOR_NR, "mbd") != 0)
printk("mbd: cleanup_module failed\n");
else
printk("mbd: module cleaned up.\n");
}
void
zvol_fini(void)
{
zvol_remove_minors(NULL);
blk_unregister_region(MKDEV(zvol_major, 0), 1UL << MINORBITS);
unregister_blkdev(zvol_major, ZVOL_DRIVER);
mutex_destroy(&zvol_state_lock);
list_destroy(&zvol_state_list);
}
void sbull_cleanup(void)
{
int i;
/*
* Before anything else, get rid of the timer functions. Set the "usage"
* flag on each device as well, under lock, so that if the timer fires up
* just before we delete it, it will either complete or abort. Otherwise
* we have nasty race conditions to worry about.
*/
for (i = 0; i < sbull_devs; i++) {
Sbull_Dev *dev = sbull_devices + i;
del_timer(&dev->timer);
spin_lock(&dev->lock);
dev->usage++;
spin_unlock(&dev->lock);
}
#ifdef DO_RAW_INTERFACE
sbullr_release();
#endif
/* flush it all and reset all the data structures */
for (i=0; i<sbull_devs; i++)
fsync_dev(MKDEV(sbull_major, i)); /* flush the devices */
unregister_blkdev(major, "sbull");
/*
* Fix up the request queue(s)
*/
#ifdef SBULL_MULTIQUEUE
for (i = 0; i < sbull_devs; i++)
blk_cleanup_queue(&sbull_devices[i].queue);
blk_dev[major].queue = NULL;
#else
blk_cleanup_queue(BLK_DEFAULT_QUEUE(major));
#endif
/* Clean up the global arrays */
read_ahead[major] = 0;
kfree(blk_size[major]);
blk_size[major] = NULL;
kfree(blksize_size[major]);
blksize_size[major] = NULL;
kfree(hardsect_size[major]);
hardsect_size[major] = NULL;
/* FIXME: max_readahead and max_sectors */
/* finally, the usual cleanup */
for (i=0; i < sbull_devs; i++) {
if (sbull_devices[i].data)
vfree(sbull_devices[i].data);
}
kfree(sbull_devices);
}
static void __exit sbd_exit(void)
{
crypto_free_cipher(crypt);
del_gendisk(Device.gd);
put_disk(Device.gd);
unregister_blkdev(major_num, "sbd");
blk_cleanup_queue(Queue);
vfree(Device.data);
}
/*
* Cleanup and deregister the device on rmmod
*/
static void __exit vbd_exit(void) {
remove_proc_entry(MODULE_NAME, NULL);
del_gendisk(device.gd);
put_disk(device.gd);
unregister_blkdev(major_num, MODULE_NAME);
blk_cleanup_queue(vbd_queue);
vfree(device.data);
}
static void ramblk_exit(void)
{
unregister_blkdev(major,"ramblk");//注销设备驱动
blk_cleanup_queue(ramblk_request_queue);//清除队列
del_gendisk(ramblk_disk);
put_disk(ramblk_disk);
vfree(ramblk_buf);//释放申请的内存
printk("ramblk_exit.\n");
}
static void imgrement_exit(void)
{
struct imgrement_device *dev = imgrement_device;
LOG("Removing imgrement, rollback every changes");
if (dev == NULL) return;
if (dev->base_queue != NULL && dev->orig_req_fn != NULL) dev->base_queue->make_request_fn = dev->orig_req_fn;
if (dev->major) unregister_blkdev(dev->major, DRIVER_NAME);
kfree(dev);
}
static void local_exit(void)
{
kmem_cache_destroy(_tio_cache);
kmem_cache_destroy(_io_cache);
unregister_blkdev(_major, _name);
_major = 0;
DMINFO("cleaned up");
}
void cleanup_module(void)
{
if ((unregister_blkdev(MAJOR_NR, "mcd") == -EINVAL))
{ printk("What's that: can't unregister mcd\n");
return;
}
release_region(mcd_port,4);
free_irq(mcd_irq, NULL);
printk(KERN_INFO "mcd module released.\n");
}
static void __exit my_exit(void)
{
del_gendisk(my_gd);
put_disk(my_gd);
unregister_blkdev(mybdrv_ma_no, MY_DEVICE_NAME);
printk(KERN_INFO "module successfully unloaded, Major No. = %d\n",
mybdrv_ma_no);
blk_cleanup_queue(my_request_queue);
vfree(ramdisk);
}
static void __exit ldm_exit(void)
{
printk(KERN_ALERT "%s\n", __FUNCTION__);
put_disk(ldm.disk);
blk_cleanup_queue(ldm.disk->queue);
vfree(ldm.addr);
unregister_blkdev(ldm.disk->major, DEVNAME);
del_gendisk(ldm.disk);
}
static int memcon_init(void)
{
int ret;
memset(&raid_drv, 0, sizeof(raid_drv));
raid_drv.driver_mem_size = 53872u;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
raid_drv.ioreq_slab = kmem_cache_create("io_request",
sizeof(struct io_request), 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
#else
raid_drv.ioreq_slab = kmem_cache_create("io_request",
sizeof(struct io_request), 0, SLAB_HWCACHE_ALIGN, NULL);
#endif
if (!raid_drv.ioreq_slab) {
DPRINTK(ERR, "memcon init: ioreq slab init failed\n");
ret = -ENOMEM;
goto failed_create_ioreq_slab;
}
ret = pblaze_virt_bus_register();
if (ret) {
DPRINTK(ERR, "memcon: unable to register bus\n");
goto failed_register_virbus;
}
raid_drv.major = register_blkdev(raid_drv.major, "memcon");
if (unlikely(raid_drv.major < 0)) {
DPRINTK(ERR, "memcon: unable to get major number\n");
ret = raid_drv.major;
goto failed_register_blkdev;
}
init_MUTEX(&raid_drv.sem);
INIT_LIST_HEAD(&raid_list);
spin_lock_init(&raid_list_lock);
ret = pci_register_driver(&pblaze_pcie_driver);
if (ret < 0) {
DPRINTK(ERR, "pci_register_driver failed\n");
goto failed_register_driver;
}
DPRINTK(DEBUG, "memcon init success\n");
return 0;
failed_register_driver:
unregister_blkdev(raid_drv.major, "memcon");
failed_register_blkdev:
pblaze_virt_bus_unregister();
failed_register_virbus:
kmem_cache_destroy(raid_drv.ioreq_slab);
failed_create_ioreq_slab:
return ret;
}
/**
* @brief SD driver initial function.
* @return SUCCESS/ERROR_ID.
*/
static int __init gp_sdcard_init(void)
{
int i;
/* ----- Get registered. ----- */
sd_major = register_blkdev(sd_major, "sdcard");
if (sd_major <= 0)
{
DERROR(KERN_WARNING "SD card : unable to get major number\n");
return -EBUSY;
}
/* ----- Allocate the device array, and initialize each one. ----- */
sd_info = kmalloc(SD_NUM*sizeof (gpSDInfo_t), GFP_KERNEL);
if (sd_info == NULL)
goto out_unregister;
/* ----- Initial SD information ----- */
for(i=0; i<SD_NUM; i++)
{
gpSDInfo_t *sd = &sd_info[i];
/* ----- Clear memory ----- */
memset (sd, 0, sizeof (gpSDInfo_t));
sd->device_id = i;
/* ----- Initial spinlock ----- */
spin_lock_init(&sd->lock);
spin_lock_init(&sd->hal_lock);
/* ----- Initial work queue ----- */
INIT_WORK(&sd->init, gp_sdcard_work_init);
INIT_WORK(&sd->uninit, gp_sdcard_work_uninit);
if(i==0)
{
/* ----- request IO function ----- */
sd->sd_func = gp_board_get_config("sd0",gp_board_sd_t);
/* ----- Initial dma module ----- */
sd->dma_param.module = SD0;
}
else
{
/* ----- request IO function ----- */
sd->sd_func = gp_board_get_config("sd1",gp_board_sd_t);
/* ----- Initial dma module ----- */
sd->dma_param.module = SD1;
}
/* ----- Init timer ----- */
init_timer(&sd->timer);
sd->timer.data = (unsigned long) sd;
sd->timer.function = gp_sdcard_timer_fn;
sd->timer.expires = jiffies + SD_CD_POLL;
add_timer(&sd->timer);
}
gp_sdio_init();
return 0;
out_unregister:
unregister_blkdev(sd_major, "sdcard");
return -ENOMEM;
}
static void
aoe_exit(void)
{
discover_timer(TKILL);
aoenet_exit();
unregister_blkdev(AOE_MAJOR, DEVICE_NAME);
aoechr_exit();
aoedev_exit();
aoeblk_exit(); /* free cache after de-allocating bufs */
}
static void
aoe_exit(void)
{
discover_timer(TKILL);
aoenet_exit();
unregister_blkdev(AOE_MAJOR, DEVICE_NAME);
aoechr_exit();
aoedev_exit();
aoeblk_exit();
}
