/*
* Checks if media is still valid.
*/
static int sd_revalidate_disk(struct gendisk *disk)
{
struct sd_host *host = disk->private_data;
int retval = 0;
/* report missing medium for zombies */
if (!host) {
retval = -ENOMEDIUM;
goto out;
}
/* the block layer likes to call us multiple times... */
if (!sd_media_changed(host->disk))
goto out;
/* get the card into a known status */
retval = sd_welcome_card(host);
if (retval < 0 || sd_card_is_bad(host)) {
retval = -ENOMEDIUM;
goto out;
}
/* inform the block layer about various sizes */
blk_queue_logical_block_size(host->queue, 1 << KERNEL_SECTOR_SHIFT);
set_capacity(host->disk, host->card.csd.capacity /*<< (host->card.csd.read_blkbits - KERNEL_SECTOR_SHIFT)*/);
clear_bit(__SD_MEDIA_CHANGED, &host->flags);
out:
return retval;
}
FAST_DRAW_CACHE* fd_create_cache(size_t initial_size, bool use_indices)
{
FAST_DRAW_CACHE* cache = calloc(1, sizeof(FAST_DRAW_CACHE));
cache->use_indices = use_indices;
set_capacity(cache, initial_size);
return cache;
}
void AP_BattMonitor_Bebop::init(void)
{
set_capacity(BATTERY_CAPACITY);
_battery_voltage_max = bat_lut[BATTERY_PERCENT_LUT_SIZE - 1].voltage;
_prev_vbat_raw = bat_lut[BATTERY_PERCENT_LUT_SIZE - 1].voltage;
_prev_vbat = bat_lut[BATTERY_PERCENT_LUT_SIZE - 1].voltage;
}
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;
}
/*
* Trigger a partition detection.
*/
int
dasd_scan_partitions(struct dasd_device * device)
{
struct block_device *bdev;
/* Make the disk known. */
set_capacity(device->gdp, device->blocks << device->s2b_shift);
bdev = bdget_disk(device->gdp, 0);
if (!bdev || blkdev_get(bdev, FMODE_READ, 1) < 0)
return -ENODEV;
/*
* See fs/partition/check.c:register_disk,rescan_partitions
* Can't call rescan_partitions directly. Use ioctl.
*/
ioctl_by_bdev(bdev, BLKRRPART, 0);
/*
* Since the matching blkdev_put call to the blkdev_get in
* this function is not called before dasd_destroy_partitions
* the offline open_count limit needs to be increased from
* 0 to 1. This is done by setting device->bdev (see
* dasd_generic_set_offline). As long as the partition
* detection is running no offline should be allowed. That
* is why the assignment to device->bdev is done AFTER
* the BLKRRPART ioctl.
*/
device->bdev = bdev;
return 0;
}
/*
* Remove all inodes in the system for a device, delete the
* partitions and make device unusable by setting its size to zero.
*/
void dasd_destroy_partitions(struct dasd_block *block)
{
/* The two structs have 168/176 byte on 31/64 bit. */
struct blkpg_partition bpart;
struct blkpg_ioctl_arg barg;
struct block_device *bdev;
/*
* Get the bdev pointer from the device structure and clear
* device->bdev to lower the offline open_count limit again.
*/
bdev = block->bdev;
block->bdev = NULL;
/*
* See fs/partition/check.c:delete_partition
* Can't call delete_partitions directly. Use ioctl.
* The ioctl also does locking and invalidation.
*/
memset(&bpart, 0, sizeof(struct blkpg_partition));
memset(&barg, 0, sizeof(struct blkpg_ioctl_arg));
barg.data = (void __force __user *) &bpart;
barg.op = BLKPG_DEL_PARTITION;
for (bpart.pno = block->gdp->minors - 1; bpart.pno > 0; bpart.pno--)
ioctl_by_bdev(bdev, BLKPG, (unsigned long) &barg);
invalidate_partition(block->gdp, 0);
/* Matching blkdev_put to the blkdev_get in dasd_scan_partitions. */
blkdev_put(bdev, FMODE_READ);
set_capacity(block->gdp, 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 cf_create_disk(struct cf_device *cf)
{
struct gendisk *disk;
DPRINTK(DEBUG_CF_GENDISK, "%s: cf %p\n", __FUNCTION__, cf);
disk = alloc_disk(1 << 4);
if (!disk) {
DPRINTK(DEBUG_CF_TRACE, "%s:%d\n", __FUNCTION__, __LINE__);
blk_cleanup_queue(cf->queue);
cf->queue = NULL;
return -ENOMEM;
}
cf->gd = disk;
disk->major = cf_major;
disk->first_minor = 0;
disk->fops = &cf_fops;
disk->queue = cf->queue;
disk->private_data = cf;
snprintf(disk->disk_name, 32, "cf%c", cf->id + 'a');
disk->private_data = cf;
set_capacity(disk, ata_id_u32(cf->cf_id, ATA_ID_LBA_CAPACITY));
printk(KERN_INFO "%s: %u MiB\n", disk->disk_name, ata_id_u32(cf->cf_id, ATA_ID_LBA_CAPACITY) >> (20-9));
add_disk(disk);
return 0;
}
// read - read latest voltage and current
void AP_BattMonitor_SMBus_PX4::read()
{
bool updated = false;
struct battery_status_s batt_status;
// check if new info has arrived from the orb
orb_check(_batt_sub, &updated);
// retrieve latest info
if (updated) {
if (OK == orb_copy(ORB_ID(battery_status), _batt_sub, &batt_status)) {
_state.voltage = batt_status.voltage_v;
_state.current_amps = batt_status.current_a;
_state.last_time_micros = hal.scheduler->micros();
_state.current_total_mah = batt_status.discharged_mah;
_state.healthy = true;
// read capacity
if ((_batt_fd >= 0) && !_capacity_updated) {
uint16_t tmp;
if (ioctl(_batt_fd, BATT_SMBUS_GET_CAPACITY, (unsigned long)&tmp) == OK) {
_capacity_updated = true;
set_capacity(tmp);
}
}
}
} else if (_state.healthy) {
// timeout after 5 seconds
if ((hal.scheduler->micros() - _state.last_time_micros) > AP_BATTMONITOR_SMBUS_TIMEOUT_MICROS) {
_state.healthy = false;
}
}
}
/**
* Resize disk.
*
* @gd disk.
* @new_size new size [logical block].
*
* RETURN:
* true in success, or false.
*/
bool resize_disk(struct gendisk *gd, u64 new_size)
{
struct block_device *bdev;
u64 old_size;
ASSERT(gd);
old_size = get_capacity(gd);
if (old_size == new_size) {
return true;
}
set_capacity(gd, new_size);
bdev = bdget_disk(gd, 0);
if (!bdev) {
LOGe("bdget_disk failed.\n");
return false;
}
mutex_lock(&bdev->bd_mutex);
if (old_size > new_size) {
LOGn("Shrink disk should discard block cache.\n");
check_disk_size_change(gd, bdev);
/* This should be implemented in check_disk_size_change(). */
bdev->bd_invalidated = 0;
} else {
i_size_write(bdev->bd_inode,
(loff_t)new_size * LOGICAL_BLOCK_SIZE);
}
mutex_unlock(&bdev->bd_mutex);
bdput(bdev);
return true;
}
static int setup_device(osprd_info_t *d, int which)
{
memset(d, 0, sizeof(osprd_info_t));
/* Get memory to store the actual block data. */
if (!(d->data = vmalloc(nsectors * SECTOR_SIZE)))
return -1;
memset(d->data, 0, nsectors * SECTOR_SIZE);
/* Set up the I/O queue. */
spin_lock_init(&d->qlock);
if (!(d->queue = blk_init_queue(osprd_process_request_queue, &d->qlock)))
return -1;
blk_queue_hardsect_size(d->queue, SECTOR_SIZE);
d->queue->queuedata = d;
/* The gendisk structure. */
if (!(d->gd = alloc_disk(1)))
return -1;
d->gd->major = OSPRD_MAJOR;
d->gd->first_minor = which;
d->gd->fops = &osprd_ops;
d->gd->queue = d->queue;
d->gd->private_data = d;
snprintf(d->gd->disk_name, 32, "osprd%c", which + 'a');
set_capacity(d->gd, nsectors);
add_disk(d->gd);
/* Call the setup function. */
osprd_setup(d);
return 0;
}
static int mbd_init_disk(int devno)
{
struct gendisk *disk = mbd_dev[devno].disk;
unsigned int sz;
if (!__onsim())
return -1;
/* check disk configured */
if (!MamboBogusDiskInfo(BD_INFO_STATUS, devno)) {
printk(KERN_ERR
"Attempting to open bogus disk before initializaiton\n");
return 0;
}
mbd_dev[devno].initialized++;
sz = MamboBogusDiskInfo(BD_INFO_DEVSZ, devno);
if (sz == -1)
return 0;
printk("Initializing disk %d with devsz %u\n", devno, sz);
set_capacity(disk, sz << 1);
return 1;
}
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 struct card_blk_data *card_blk_alloc(struct memory_card *card)
{
struct card_blk_data *card_data;
int devidx, ret;
devidx = find_first_zero_bit(dev_use, CARD_NUM_MINORS);
if(card->card_type == CARD_INAND)
devidx = CARD_INAND_START_MINOR>>CARD_SHIFT;
if (devidx >= CARD_NUM_MINORS)
return ERR_PTR(-ENOSPC);
__set_bit(devidx, dev_use);
card_data = kmalloc(sizeof(struct card_blk_data), GFP_KERNEL);
if (!card_data) {
ret = -ENOMEM;
return ERR_PTR(ret);
}
memset(card_data, 0, sizeof(struct card_blk_data));
card_data->block_bits = 9;
card_data->disk = alloc_disk(1 << CARD_SHIFT);
if (card_data->disk == NULL) {
ret = -ENOMEM;
kfree(card_data);
return ERR_PTR(ret);
}
spin_lock_init(&card_data->lock);
card_data->usage = 1;
ret = card_init_queue(&card_data->queue, card, &card_data->lock);
if (ret) {
put_disk(card_data->disk);
return ERR_PTR(ret);
}
card_data->queue.prep_fn = card_blk_prep_rq;
card_data->queue.issue_fn = card_blk_issue_rq;
card_data->queue.data = card_data;
card_data->disk->major = major;
card_data->disk->minors = 1 << CARD_SHIFT;
card_data->disk->first_minor = devidx << CARD_SHIFT;
card_data->disk->fops = &card_ops;
card_data->disk->private_data = card_data;
card_data->disk->queue = card_data->queue.queue;
card_data->disk->driverfs_dev = &card->dev;
sprintf(card_data->disk->disk_name, "cardblk%s", card->name);
blk_queue_logical_block_size(card_data->queue.queue, 1 << card_data->block_bits);
set_capacity(card_data->disk, card->capacity);
return card_data;
}
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 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 __set_size(struct mapped_device *md, sector_t size)
{
set_capacity(md->disk, size);
down(&md->frozen_bdev->bd_inode->i_sem);
i_size_write(md->frozen_bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
up(&md->frozen_bdev->bd_inode->i_sem);
}
static void __set_size(struct mapped_device *md, sector_t size)
{
set_capacity(md->disk, size);
mutex_lock(&md->suspended_bdev->bd_inode->i_mutex);
i_size_write(md->suspended_bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
mutex_unlock(&md->suspended_bdev->bd_inode->i_mutex);
}
static int nbd_size_clear(struct nbd_device *nbd, struct block_device *bdev)
{
bdev->bd_inode->i_size = 0;
set_capacity(nbd->disk, 0);
kobject_uevent(&nbd_to_dev(nbd)->kobj, KOBJ_CHANGE);
return 0;
}
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;
}
/* alloc_disk and add_disk can sleep */
void
aoeblk_gdalloc(void *vp)
{
struct aoedev *d = vp;
struct gendisk *gd;
ulong flags;
gd = alloc_disk(AOE_PARTITIONS);
if (gd == NULL) {
printk(KERN_ERR
"aoe: cannot allocate disk structure for %ld.%d\n",
d->aoemajor, d->aoeminor);
goto err;
}
d->bufpool = mempool_create_slab_pool(MIN_BUFS, buf_pool_cache);
if (d->bufpool == NULL) {
printk(KERN_ERR "aoe: cannot allocate bufpool for %ld.%d\n",
d->aoemajor, d->aoeminor);
goto err_disk;
}
d->blkq = blk_alloc_queue(GFP_KERNEL);
if (!d->blkq)
goto err_mempool;
blk_queue_make_request(d->blkq, aoeblk_make_request);
d->blkq->backing_dev_info.name = "aoe";
spin_lock_irqsave(&d->lock, flags);
gd->major = AOE_MAJOR;
gd->first_minor = d->sysminor * AOE_PARTITIONS;
gd->fops = &aoe_bdops;
gd->private_data = d;
set_capacity(gd, d->ssize);
snprintf(gd->disk_name, sizeof gd->disk_name, "etherd/e%ld.%d",
d->aoemajor, d->aoeminor);
gd->queue = d->blkq;
d->gd = gd;
d->flags &= ~DEVFL_GDALLOC;
d->flags |= DEVFL_UP;
spin_unlock_irqrestore(&d->lock, flags);
add_disk(gd);
aoedisk_add_sysfs(d);
return;
err_mempool:
mempool_destroy(d->bufpool);
err_disk:
put_disk(gd);
err:
spin_lock_irqsave(&d->lock, flags);
d->flags &= ~DEVFL_GDALLOC;
spin_unlock_irqrestore(&d->lock, flags);
}
/**
* add_last_partition : add card last partition as a full device, refer to
* board-****.c inand_partition_info[] last partition
* @card: inand_card_lp
* @size: set last partition capacity
*/
int add_last_partition(struct memory_card* card, uint64_t offset ,uint64_t size)
{
struct card_blk_data *card_data;
int ret;
card_data = kmalloc(sizeof(struct card_blk_data), GFP_KERNEL);
if (!card_data) {
ret = -ENOMEM;
return ret;
}
memset(card_data, 0, sizeof(struct card_blk_data));
if(card->state & CARD_STATE_READONLY)
card_data->read_only = 1;
card_data->block_bits = 9;
card_data->disk = alloc_disk(1 << CARD_SHIFT);
if (card_data->disk == NULL) {
ret = -ENOMEM;
kfree(card_data);
return ret;
}
spin_lock_init(&card_data->lock);
card_data->usage = 1;
ret = card_init_queue(&card_data->queue, card, &card_data->lock);
if (ret) {
put_disk(card_data->disk);
return ret;
}
card->part_offset=offset;
card_data->queue.prep_fn = card_blk_prep_rq;
card_data->queue.issue_fn = card_blk_issue_rq;
card_data->queue.data = card_data;
card_data->disk->major = INAND_LAST_PART_MAJOR;
card_data->disk->minors = 1 << CARD_SHIFT;
card_data->disk->first_minor = 0;
card_data->disk->fops = &card_ops;
card_data->disk->private_data = card_data;
card_data->disk->queue = card_data->queue.queue;
card_data->disk->driverfs_dev = &card->dev;
sprintf(card_data->disk->disk_name, "cardblk%s", card->name);
blk_queue_logical_block_size(card_data->queue.queue, 1 << card_data->block_bits);
set_capacity(card_data->disk, size);
card_set_drvdata(card, card_data);
add_disk(card_data->disk);
return 0;
}
static int ide_gd_revalidate_disk(struct gendisk *disk)
{
struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
ide_drive_t *drive = idkp->drive;
if (ide_gd_media_changed(disk))
drive->disk_ops->get_capacity(drive);
set_capacity(disk, ide_gd_capacity(drive));
return 0;
}
static int
figure_loop_size(struct loop_device *lo)
{
loff_t size = get_loop_size(lo, lo->lo_backing_file);
sector_t x = (sector_t)size;
if (unlikely((loff_t)x != size))
return -EFBIG;
set_capacity(lo->lo_disk, x);
return 0;
}
static void setup_blk_device(struct ramdisk_dev* dev)
{
mutex_init(&dev->mutex);
init_waitqueue_head(&dev->waitqueue);
/*
* Get some memory.
*/
memset (dev, 0, sizeof (struct ramdisk_dev));
dev->size = NSECTORS*HARDSECT_SIZE;
dev->data = vmalloc(dev->size);
if (dev->data == NULL) {
printk (KERN_NOTICE "vmalloc failure.\n");
return;
}
spin_lock_init(&dev->lock);
/*
* The timer which "invalidates" the device.
*/
init_timer(&dev->timer);
dev->timer.data = (unsigned long) dev;
dev->timer.function = ramdisk_invalidate;
dev->queue = blk_init_queue(ramdisk_request, &dev->lock);
if (dev->queue == NULL)
goto out_vfree;
blk_queue_logical_block_size(dev->queue, HARDSECT_SIZE);
dev->queue->queuedata = dev;
/*
* And the gendisk structure.
*/
dev->gd = alloc_disk(BLK_MINORS);
if (! dev->gd) {
printk (KERN_NOTICE "alloc_disk failure\n");
goto out_vfree;
}
dev->gd->major = blk_major;
dev->gd->first_minor = BLK_MINORS;
dev->gd->fops = &ramdisk_ops;
dev->gd->queue = dev->queue;
dev->gd->private_data = dev;
snprintf (dev->gd->disk_name, 32, "ramdisk%c", 'a');
set_capacity(dev->gd, NSECTORS*(HARDSECT_SIZE/KERNEL_SECTOR_SIZE));
// set_capacity(dev->gd, 0);
add_disk(dev->gd);
return;
out_vfree:
if (dev->data)
vfree(dev->data);
}
/*
* Allocate and register gendisk structure for device.
*/
int
dasd_gendisk_alloc(struct dasd_device *device)
{
struct gendisk *gdp;
int len;
/* Make sure the minor for this device exists. */
if (device->devindex >= DASD_PER_MAJOR)
return -EBUSY;
gdp = alloc_disk(1 << DASD_PARTN_BITS);
if (!gdp)
return -ENOMEM;
/* Initialize gendisk structure. */
gdp->major = DASD_MAJOR;
gdp->first_minor = device->devindex << DASD_PARTN_BITS;
gdp->fops = &dasd_device_operations;
gdp->driverfs_dev = &device->cdev->dev;
/*
* Set device name.
* dasda - dasdz : 26 devices
* dasdaa - dasdzz : 676 devices, added up = 702
* dasdaaa - dasdzzz : 17576 devices, added up = 18278
* dasdaaaa - dasdzzzz : 456976 devices, added up = 475252
*/
len = sprintf(gdp->disk_name, "dasd");
if (device->devindex > 25) {
if (device->devindex > 701) {
if (device->devindex > 18277)
len += sprintf(gdp->disk_name + len, "%c",
'a'+(((device->devindex-18278)
/17576)%26));
len += sprintf(gdp->disk_name + len, "%c",
'a'+(((device->devindex-702)/676)%26));
}
len += sprintf(gdp->disk_name + len, "%c",
'a'+(((device->devindex-26)/26)%26));
}
len += sprintf(gdp->disk_name + len, "%c", 'a'+(device->devindex%26));
sprintf(gdp->devfs_name, "dasd/%s", device->cdev->dev.bus_id);
if (test_bit(DASD_FLAG_RO, &device->flags))
set_disk_ro(gdp, 1);
gdp->private_data = device;
gdp->queue = device->request_queue;
device->gdp = gdp;
set_capacity(device->gdp, 0);
add_disk(device->gdp);
return 0;
}
/*
* Allocate and register gendisk structure for device.
*/
int dasd_gendisk_alloc(struct dasd_block *block)
{
struct gendisk *gdp;
struct dasd_device *base;
int len;
/* Make sure the minor for this device exists. */
base = block->base;
if (base->devindex >= DASD_PER_MAJOR)
return -EBUSY;
gdp = alloc_disk(1 << DASD_PARTN_BITS);
if (!gdp)
return -ENOMEM;
/* Initialize gendisk structure. */
gdp->major = DASD_MAJOR;
gdp->first_minor = base->devindex << DASD_PARTN_BITS;
gdp->fops = &dasd_device_operations;
gdp->driverfs_dev = &base->cdev->dev;
/*
* Set device name.
* dasda - dasdz : 26 devices
* dasdaa - dasdzz : 676 devices, added up = 702
* dasdaaa - dasdzzz : 17576 devices, added up = 18278
* dasdaaaa - dasdzzzz : 456976 devices, added up = 475252
*/
len = sprintf(gdp->disk_name, "dasd");
if (base->devindex > 25) {
if (base->devindex > 701) {
if (base->devindex > 18277)
len += sprintf(gdp->disk_name + len, "%c",
'a'+(((base->devindex-18278)
/17576)%26));
len += sprintf(gdp->disk_name + len, "%c",
'a'+(((base->devindex-702)/676)%26));
}
len += sprintf(gdp->disk_name + len, "%c",
'a'+(((base->devindex-26)/26)%26));
}
len += sprintf(gdp->disk_name + len, "%c", 'a'+(base->devindex%26));
if (base->features & DASD_FEATURE_READONLY ||
test_bit(DASD_FLAG_DEVICE_RO, &base->flags))
set_disk_ro(gdp, 1);
gdp->private_data = block;
gdp->queue = block->request_queue;
block->gdp = gdp;
set_capacity(block->gdp, 0);
add_disk(block->gdp);
return 0;
}
static int __init looper_init(void) {
if (filename == NULL) {
printk(KERN_WARNING "looper: no filename defined");
return -1;
}
/*
* Set up our internal device.
*/
Device.size = nsectors * logical_block_size;
spin_lock_init(&Device.lock);
Device.data = vmalloc(Device.size);
if (Device.data == NULL)
return -ENOMEM;
/*
* Get a request queue.
*/
Queue = blk_init_queue(looper_request, &Device.lock);
if (Queue == NULL)
goto out;
blk_queue_logical_block_size(Queue, logical_block_size);
/*
* Get registered.
*/
major_num = register_blkdev(major_num, "looper");
if (major_num <= 0) {
printk(KERN_WARNING "looper: unable to get major number\n");
goto out;
}
/*
* And the gendisk structure.
*/
Device.gd = alloc_disk(16);
if (!Device.gd)
goto out_unregister;
Device.gd->major = major_num;
Device.gd->first_minor = 0;
Device.gd->fops = &looper_ops;
Device.gd->private_data = &Device;
strcpy(Device.gd->disk_name, "looper0");
set_capacity(Device.gd, nsectors);
Device.gd->queue = Queue;
add_disk(Device.gd);
return 0;
out_unregister:
unregister_blkdev(major_num, "looper");
out:
vfree(Device.data);
return -ENOMEM;
}
static void __set_size(struct gendisk *disk, sector_t size)
{
struct block_device *bdev;
set_capacity(disk, size);
bdev = bdget_disk(disk, 0);
if (bdev) {
down(&bdev->bd_inode->i_sem);
i_size_write(bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
up(&bdev->bd_inode->i_sem);
bdput(bdev);
}
}
static int ide_floppy_init_media(ide_drive_t *drive, struct gendisk *disk)
{
int ret = 0;
if (ide_do_test_unit_ready(drive, disk))
ide_do_start_stop(drive, disk, 1);
ret = ide_floppy_get_capacity(drive);
set_capacity(disk, ide_gd_capacity(drive));
return ret;
}
