static int tc01(void)
{
int major1, major2;
int pass = 1;
prk_info("Test Case 1: register_blkdev() with auto allocating "
"major numbers (major=0)\n");
major1 = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major1 = %i\n", major1);
major2 = register_blkdev(0, BLK_DEV_NAME);
prk_debug("major2 = %i\n", major2);
if (major1 >= 0) {
unregister_blkdev(major1, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("1st call to register_blkdev() failed, error %i\n",
major1);
}
if (major2 >= 0) {
unregister_blkdev(major2, BLK_DEV_NAME);
} else {
pass = 0;
prk_debug("2nd call to register_blkdev() failed, error %i\n",
major2);
}
prk_info("Test Case Result: %s\n", result_str(pass));
return pass;
}
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;
}
void register_block_driver(unsigned int major, const char *name,
struct block_device *(*get_device)(unsigned int),
struct file_operations *fops)
{
blkdev[major].get_device = get_device;
register_blkdev(major, name, fops ? fops : &blkdev_generic_fops);
}
static int __init ramblock_init(void)
{
/* 1. Allocate gendisk struct */
ramblock_disk = alloc_disk(16);
/* 2. Configure */
/* 2.1 Allocate/Configure a queue which supporting read/write capabilities */
if (!(ramblock_queue = blk_init_queue(do_ramblock_request, &ramblock_lock)))
return -ENOMEM;
ramblock_disk->queue = ramblock_queue;
/* 2.2 Configure other properties: such as volume, etc */
major = register_blkdev(0, "ramblock");
ramblock_disk->major = major;
ramblock_disk->first_minor = 0;
sprintf(ramblock_disk->disk_name, "ramblock");
ramblock_disk->fops = &ramblock_fops;
set_capacity(ramblock_disk, RAMBLOCK_SIZE / 512); /* 512 bytes per sector */
/* 3. Register */
add_disk(ramblock_disk);
return 0;
}
static int __init tzmem_blkdev_init(void)
{
#ifdef MTEE_TZMEM_DBG
pr_warn("====> tzmem_blkdev_init\n");
#endif
if (register_blkdev(IO_NODE_MAJOR_TZMEM, DEV_TZMEM)) {
pr_debug(MTEE_TZMEM_TAG "[%s] tzmem_blkdev_init: register_blkdev error\n", MODULE_NAME);
return -EFAULT;
}
tz_client_dev = MKDEV(IO_NODE_MAJOR_TZMEM, IO_NODE_MINOR_TZMEM);
blk_register_region(tz_client_dev, IO_NODE_NUMBER_TZMEM,
THIS_MODULE, tzmem_blk_probe, NULL, NULL);
#if 0
/* create /dev/tzmem automaticly */
pTzClass = class_create(THIS_MODULE, DEV_TZMEM);
if (IS_ERR(pTzClass)) {
int ret = PTR_ERR(pTzClass);
pr_debug(MTEE_TZMEM_TAG "[%s] could not create class for the device, ret:%d\n", MODULE_NAME, ret);
return ret;
}
pTzDevice = device_create(pTzClass, NULL, tz_client_dev, NULL, DEV_TZMEM);
#endif
return 0;
}
static int __init local_init(void)
{
int r;
/* allocate a slab for the dm_ios */
_io_cache = KMEM_CACHE(dm_io, 0);
if (!_io_cache)
return -ENOMEM;
/* allocate a slab for the target ios */
_tio_cache = KMEM_CACHE(dm_target_io, 0);
if (!_tio_cache) {
kmem_cache_destroy(_io_cache);
return -ENOMEM;
}
_major = major;
r = register_blkdev(_major, _name);
if (r < 0) {
kmem_cache_destroy(_tio_cache);
kmem_cache_destroy(_io_cache);
return r;
}
if (!_major)
_major = r;
return 0;
}
/* ---------------------------------------------------------------------
* 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;
}
int
zvol_init(void)
{
int error;
zvol_taskq = taskq_create(ZVOL_DRIVER, zvol_threads, maxclsyspri,
zvol_threads, INT_MAX, TASKQ_PREPOPULATE);
if (zvol_taskq == NULL) {
printk(KERN_INFO "ZFS: taskq_create() failed\n");
return (-ENOMEM);
}
error = register_blkdev(zvol_major, ZVOL_DRIVER);
if (error) {
printk(KERN_INFO "ZFS: register_blkdev() failed %d\n", error);
taskq_destroy(zvol_taskq);
return (error);
}
blk_register_region(MKDEV(zvol_major, 0), 1UL << MINORBITS,
THIS_MODULE, zvol_probe, NULL, NULL);
mutex_init(&zvol_state_lock, NULL, MUTEX_DEFAULT, NULL);
list_create(&zvol_state_list, sizeof (zvol_state_t),
offsetof(zvol_state_t, zv_next));
(void) zvol_create_minors(NULL);
return (0);
}
static int __init osprd_init(void)
{
int i, r;
// shut up the compiler
(void) for_each_open_file;
#ifndef osp_spin_lock
(void) osp_spin_lock;
(void) osp_spin_unlock;
#endif
/* Register the block device name. */
if (register_blkdev(OSPRD_MAJOR, "osprd") < 0) {
printk(KERN_WARNING "osprd: unable to get major number\n");
return -EBUSY;
}
/* Initialize the device structures. */
for (i = r = 0; i < NOSPRD; i++)
if (setup_device(&osprds[i], i) < 0)
r = -EINVAL;
if (r < 0) {
printk(KERN_EMERG "osprd: can't set up device structures\n");
osprd_exit();
return -EBUSY;
} else
return 0;
}
static int ramblock_init(void)
{
/* 1. 分配一个gendisk结构体 */
ramblock_disk = alloc_disk(16); /* 次设备号个数: 分区个数+1 */
/* 2. 设置 */
/* 2.1 分配/设置队列: 提供读写能力 */
ramblock_queue = blk_init_queue(do_ramblock_request, &ramblock_lock);
ramblock_disk->queue = ramblock_queue;
/* 2.2 设置其他属性: 比如容量 */
major = register_blkdev(0, "ramblock"); /* cat /proc/devices */
ramblock_disk->major = major;
ramblock_disk->first_minor = 0;
sprintf(ramblock_disk->disk_name, "ramblock");
ramblock_disk->fops = &ramblock_fops;
set_capacity(ramblock_disk, RAMBLOCK_SIZE / 512);
/* 3. 硬件相关操作 */
ramblock_buf = kzalloc(RAMBLOCK_SIZE, GFP_KERNEL);
/* 4. 注册 */
add_disk(ramblock_disk);
return 0;
}
static int __init sbull_init(void)
{
int i;
/*
* 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;
}
static int trd_init(void)
{
int i;
trd_pages = (TRD_SIZE + (PAGE_SIZE-1)) >> PAGE_SHIFT;
if (register_blkdev(MAJOR_NR, DEVICE_NAME, &trd_fops)) {
printk(KERN_ERR DEVICE_NAME ": Unable to register_blkdev(%d)\n", MAJOR_NR);
return -EBUSY;
}
blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), trd_make_request);
for (i=0;i<MAX_DEVS;i++) {
trd_blocksizes[i] = TRD_BLOCK_SIZE;
trd_blk_sizes[i] = trd_size;
}
blksize_size[MAJOR_NR] = trd_blocksizes;
blk_size[MAJOR_NR] = trd_blk_sizes;
printk(KERN_DEBUG DEVICE_NAME ": trd initialised size=%dk\n",
trd_size);
return 0;
}
static int __init ramhd_init(void)
{
int i;
ramhd_space_init();
alloc_ramdev();
ramhd_major = register_blkdev(0, RAMHD_NAME);
for (i=0; i<RAMHD_MAX_DEVICE; i++)
{
rdev[i]->data = sdisk[i];
rdev[i]->queue = blk_alloc_queue(GFP_KERNEL);
blk_queue_make_request(rdev[i]->queue, ramhd_make_request);
rdev[i]->gd = alloc_disk(RAMHD_MAX_PARTITIONS);
rdev[i]->gd->major = ramhd_major;
rdev[i]->gd->first_minor = i*RAMHD_MAX_PARTITIONS;
rdev[i]->gd->fops = &ramhd_fops;
rdev[i]->gd->queue = rdev[i]->queue;
rdev[i]->gd->private_data = rdev[i];
sprintf(rdev[i]->gd->disk_name, "ramhd%c", 'a'+i);
rdev[i]->gd->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
set_capacity(rdev[i]->gd, RAMHD_SECTOR_TOTAL);
add_disk(rdev[i]->gd);
}
return 0;
}
static int __init imgrement_init(void)
{
char* err;
struct imgrement_device *dev;
imgrement_device = kzalloc(sizeof(struct imgrement_device), GFP_KERNEL);
_astgo(imgrement_device != NULL, "Error allocating", err, init_error);
dev = imgrement_device;
dev->major = register_blkdev(0, DRIVER_NAME);
_astgo(dev->major > 0, "Error register block device", err, init_error);
dev->base_dev = blkdev_get_by_path("/dev/sdb", FMODE_READ, NULL);
_astgo(dev->base_dev != NULL, "Error getting base block device", err, init_error);
dev->base_queue = bdev_get_queue(dev->base_dev);
_astgo(dev->base_queue != NULL, "Error getting queue", err, init_error);
dev->orig_req_fn = dev->base_queue->make_request_fn;
dev->base_queue->make_request_fn = trace_request_fn;
LOG("%s trace initialization succeeded", dev->base_dev->bd_disk->disk_name);
return 0;
init_error:
LOG_VAR(err);
imgrement_exit();
return -1;
}
static int ramblock_init(void)
{
major = register_blkdev(0, "ramblock");
/* 1.分配一个gendisk结构体 */
/* 这里的16表示分区的个数 15个分区 */
ramblock_gendisk = alloc_disk(16);
/* 2. 设置 */
ramblock_gendisk->major = major;
ramblock_gendisk->first_minor = 0;
sprintf(ramblock_gendisk->disk_name, "ramblock");
ramblock_gendisk->fops = &ramblock_fops;
/* 2.1 分配/设置队列:提供读写能力 */
ramblock_request_queue = blk_init_queue(do_ramblock_request, &ramblock_lock);
ramblock_gendisk->queue = ramblock_request_queue;
/* 2.2 设置其它属性:比如容量 */
set_capacity(ramblock_gendisk, RAMBLOCK_SIZE / 512);
/* 3. 硬件相关操作 */
if (NULL == (ramblock_buf = kzalloc(RAMBLOCK_SIZE, GFP_KERNEL)))
return -ENOMEM;
/* 4. 注册 */
add_disk(ramblock_gendisk);
return 0;
}
/* ---------------------------------------------------------------------
* Module init/exit routines
*/
static int __init dm3730logic_cf_init(void)
{
int rc;
// printk(KERN_INFO "%s:%d\n", __FUNCTION__, __LINE__);
cf_major = register_blkdev(cf_major, "omap-cf");
if (cf_major <= 0) {
rc = -ENOMEM;
goto err_blk;
}
#if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
(void)debugfs_create_file("cf-debug", S_IRUGO | S_IFREG, NULL,
NULL, &dm3730logic_cf_debug_fops);
#endif
pr_info("omap-cf: registering platform binding\n");
rc = platform_driver_register(&dm3730logic_cf_platform_driver);
if (rc)
goto err_plat;
printk(KERN_INFO "DM3730 SOM LV memory CompactFlash device driver, major=%i\n", cf_major);
return 0;
err_plat:
unregister_blkdev(cf_major, "dm3730logic-cf");
err_blk:
printk(KERN_ERR "omap-cf: registration failed; err=%i\n", rc);
return rc;
}
int __init init_mtdblock(void)
{
int i;
if (register_blkdev(MAJOR_NR,DEVICE_NAME,&mtd_fops)) {
printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices.\n",
MTD_BLOCK_MAJOR);
return -EAGAIN;
}
DEBUG(MTD_DEBUG_LEVEL3,
"init_mtdblock: allocated major number %d (read only).\n",
MTD_BLOCK_MAJOR);
/* We fill it in at open() time. */
for (i=0; i< MAX_MTD_DEVICES; i++) {
mtd_sizes[i] = 0;
}
/* Allow the block size to default to BLOCK_SIZE. */
blksize_size[MAJOR_NR] = NULL;
blk_size[MAJOR_NR] = mtd_sizes;
blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), &mtdblock_request);
return 0;
}
int
zvol_init(void)
{
int error;
list_create(&zvol_state_list, sizeof (zvol_state_t),
offsetof(zvol_state_t, zv_next));
mutex_init(&zvol_state_lock, NULL, MUTEX_DEFAULT, NULL);
error = register_blkdev(zvol_major, ZVOL_DRIVER);
if (error) {
printk(KERN_INFO "ZFS: register_blkdev() failed %d\n", error);
goto out;
}
blk_register_region(MKDEV(zvol_major, 0), 1UL << MINORBITS,
THIS_MODULE, zvol_probe, NULL, NULL);
return (0);
out:
mutex_destroy(&zvol_state_lock);
list_destroy(&zvol_state_list);
return (SET_ERROR(error));
}
static int __init block_demo_init(void)
{
spin_lock_init(&g_lock);
int err = register_blkdev(BLK_DEV_MAJOR,"blk-dev-demo");
if(err != 0)
{
Log("[Error] register_blkdev failed.");
return -1;
}
gp_blk_dev_disk = alloc_disk(1);
if(!gp_blk_dev_disk)
{
Log("[Error] alloc_disk failed.");
err = -1;
goto FAIL_ALLOC_DISK;
}
gp_blk_dev_disk->major = BLK_DEV_MAJOR;
gp_blk_dev_disk->first_minor = 0;
sprintf(gp_blk_dev_disk->disk_name,DISK_NAME);
set_capacity(gp_blk_dev_disk, DISK_SIZE >> 9);
gp_blk_dev_disk->fops = &g_mem_fops;
gp_blk_dev_disk->queue = blk_init_queue(mem_block_requeut_fn,&g_lock);
add_disk(gp_blk_dev_disk);
return 0;
FAIL_ALLOC_DISK:
unregister_blkdev(BLK_DEV_MAJOR,"blk-dev-demo");
return err;
}
static __init int local_init(void)
{
int r;
/* allocate a slab for the dm_ios */
_io_cache = kmem_cache_create("dm_io",
sizeof(struct dm_io), 0, 0, NULL, NULL);
if (!_io_cache)
return -ENOMEM;
/* allocate a slab for the target ios */
_tio_cache = kmem_cache_create("dm_tio", sizeof(struct target_io),
0, 0, NULL, NULL);
if (!_tio_cache) {
kmem_cache_destroy(_io_cache);
return -ENOMEM;
}
_major = major;
r = register_blkdev(_major, _name);
if (r < 0) {
kmem_cache_destroy(_tio_cache);
kmem_cache_destroy(_io_cache);
return r;
}
if (!_major)
_major = r;
return 0;
}
/*init west bridge block device */
static int cyasblkdev_blk_initialize(void)
{
struct cyasblkdev_blk_data *bd;
int res;
DBGPRN_FUNC_NAME;
res = register_blkdev(major, "cyasblkdev");
if (res < 0) {
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(KERN_WARNING
"%s unable to get major %d for cyasblkdev media: %d\n",
__func__, major, res);
#endif
return res;
}
if (major == 0)
major = res;
#ifndef WESTBRIDGE_NDEBUG
cy_as_hal_print_message(
"%s cyasblkdev registered with major number: %d\n",
__func__, major);
#endif
bd = cyasblkdev_blk_alloc();
if (IS_ERR(bd))
return PTR_ERR(bd);
return 0;
}
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 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 int __init ramblk_init(void)
{
int ramblk_major;
struct request_queue *rq; //unuseful
ramblk_major = register_blkdev(0, "firo-ramblk");
if (ramblk_major < 0){
printk("blk major is over!\n");
return -EBUSY
}
static int __init mbd_init(void)
{
int err = -ENOMEM;
int i;
for (i = 0; i < MAX_MBD; i++) {
struct gendisk *disk = alloc_disk(1);
if (!disk)
goto out;
mbd_dev[i].disk = disk;
/*
* The new linux 2.5 block layer implementation requires
* every gendisk to have its very own request_queue struct.
* These structs are big so we dynamically allocate them.
*/
disk->queue = blk_init_queue(do_mbd_request, &mbd_lock);
if (!disk->queue) {
put_disk(disk);
goto out;
}
}
if (register_blkdev(MAJOR_NR, "mbd")) {
err = -EIO;
goto out;
}
#ifdef MODULE
printk("mambo bogus disk: registered device at major %d\n", MAJOR_NR);
#else
printk("mambo bogus disk: compiled in with kernel\n");
#endif
devfs_mk_dir("mambobd");
for (i = 0; i < MAX_MBD; i++) { /* load defaults */
struct gendisk *disk = mbd_dev[i].disk;
mbd_dev[i].initialized = 0;
mbd_dev[i].refcnt = 0;
mbd_dev[i].flags = 0;
disk->major = MAJOR_NR;
disk->first_minor = i;
disk->fops = &mbd_fops;
disk->private_data = &mbd_dev[i];
sprintf(disk->disk_name, "mambobd%d", i);
sprintf(disk->devfs_name, "mambobd%d", i);
set_capacity(disk, 0x7ffffc00ULL << 1); /* 2 TB */
add_disk(disk);
}
return 0;
out:
while (i--) {
if (mbd_dev[i].disk->queue)
blk_cleanup_queue(mbd_dev[i].disk->queue);
put_disk(mbd_dev[i].disk);
}
return -EIO;
}
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;
}
/* ---------------------------------------------------------------------
* Module init/exit routines
*/
static int __init ace_init(void)
{
ace_major = register_blkdev(ace_major, "xsysace");
if (ace_major <= 0) {
printk(KERN_WARNING "xsysace: register_blkdev() failed\n");
return ace_major;
}
pr_debug("Registering Xilinx SystemACE driver, major=%i\n", ace_major);
return driver_register(&ace_driver);
}
static __init void romdisk_init(void)
{
struct blkdev * dev;
struct romdisk * romdisk;
u64_t size, rem;
dev = malloc(sizeof(struct blkdev));
if(!dev)
return;
romdisk = malloc(sizeof(struct romdisk));
if(!romdisk)
{
free(dev);
return;
}
snprintf(romdisk->name, 32, "romdisk");
romdisk->start = (void *)__romdisk_start;
romdisk->end = (void *)__romdisk_end;
romdisk->busy = FALSE;
if((romdisk->end - romdisk->start) <= 0)
{
free(romdisk);
free(dev);
return;
}
size = (u64_t)(romdisk->end - romdisk->start);
rem = div64_64(&size, SZ_512);
if(rem > 0)
size++;
romdisk->busy = FALSE;
dev->name = romdisk->name;
dev->type = BLK_DEV_ROMDISK;
dev->blksz = SZ_512;
dev->blkcnt = size;
dev->open = romdisk_open;
dev->read = romdisk_read;
dev->write = romdisk_write;
dev->ioctl = romdisk_ioctl;
dev->close = romdisk_close;
dev->driver = romdisk;
if(!register_blkdev(dev))
{
free(romdisk);
free(dev);
return;
}
}
