/* This is the registration and initialization section of the RAM disk driver */
int __init rd_init (void)
{
int i;
if (rd_blocksize > PAGE_SIZE || rd_blocksize < 512 ||
(rd_blocksize & (rd_blocksize-1)))
{
printk("RAMDISK: wrong blocksize %d, reverting to defaults\n",
rd_blocksize);
rd_blocksize = BLOCK_SIZE;
}
if (register_blkdev(MAJOR_NR, "ramdisk", &rd_bd_op)) {
printk("RAMDISK: Could not get major %d", MAJOR_NR);
return -EIO;
}
blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), &rd_make_request);
for (i = 0; i < NUM_RAMDISKS; i++) {
/* rd_size is given in kB */
rd_length[i] = rd_size << 10;
rd_hardsec[i] = rd_blocksize;
rd_blocksizes[i] = rd_blocksize;
rd_kbsize[i] = rd_size;
}
devfs_handle = devfs_mk_dir (NULL, "rd", NULL);
devfs_register_series (devfs_handle, "%u", NUM_RAMDISKS,
DEVFS_FL_DEFAULT, MAJOR_NR, 0,
S_IFBLK | S_IRUSR | S_IWUSR,
&rd_bd_op, NULL);
for (i = 0; i < NUM_RAMDISKS; i++)
register_disk(NULL, MKDEV(MAJOR_NR,i), 1, &rd_bd_op, rd_size<<1);
#ifdef CONFIG_BLK_DEV_INITRD
/* We ought to separate initrd operations here */
register_disk(NULL, MKDEV(MAJOR_NR,INITRD_MINOR), 1, &rd_bd_op, rd_size<<1);
#endif
hardsect_size[MAJOR_NR] = rd_hardsec; /* Size of the RAM disk blocks */
blksize_size[MAJOR_NR] = rd_blocksizes; /* Avoid set_blocksize() check */
blk_size[MAJOR_NR] = rd_kbsize; /* Size of the RAM disk in kB */
/* rd_size is given in kB */
printk("RAMDISK driver initialized: "
"%d RAM disks of %dK size %d blocksize\n",
NUM_RAMDISKS, rd_size, rd_blocksize);
return 0;
}
/**
* add_disk - add partitioning information to kernel list
* @disk: per-device partitioning information
*
* This function registers the partitioning information in @disk
* with the kernel.
*/
void add_disk(struct gendisk *disk)
{
disk->flags |= GENHD_FL_UP;
blk_register_region(MKDEV(disk->major, disk->first_minor),
disk->minors, NULL, exact_match, exact_lock, disk);
register_disk(disk);
blk_register_queue(disk);
}
static void __init xd_geninit (void)
{
u8 i,controller;
unsigned int address;
for(i=0;i<(XD_MAXDRIVES << 6);i++)
xd_blocksizes[i] = 1024;
blksize_size[MAJOR_NR] = xd_blocksizes;
if (xd_detect(&controller,&address)) {
printk(KERN_INFO "Detected a%s controller (type %d) at address %06x\n",
xd_sigs[controller].name,controller,address);
if (!request_region(xd_iobase,4, "xd")) {
printk(KERN_ERR "xd: Ports at 0x%x are not available\n", xd_iobase);
return;
}
if (controller)
xd_sigs[controller].init_controller(address);
xd_drives = xd_initdrives(xd_sigs[controller].init_drive);
printk(KERN_INFO "Detected %d hard drive%s (using IRQ%d & DMA%d)\n",
xd_drives,xd_drives == 1 ? "" : "s",xd_irq,xd_dma);
for (i = 0; i < xd_drives; i++)
printk(KERN_INFO " xd%c: CHS=%d/%d/%d\n",'a'+i,
xd_info[i].cylinders,xd_info[i].heads,
xd_info[i].sectors);
}
if (xd_drives) {
if (!request_irq(xd_irq,xd_interrupt_handler, 0, "XT hard disk", NULL)) {
if (request_dma(xd_dma,"xd")) {
printk(KERN_ERR "xd: unable to get DMA%d\n",xd_dma);
free_irq(xd_irq, NULL);
}
}
else
printk(KERN_ERR "xd: unable to get IRQ%d\n",xd_irq);
}
/* xd_maxsectors depends on controller - so set after detection */
for(i=0; i<(XD_MAXDRIVES << 6); i++) xd_maxsect[i] = xd_maxsectors;
max_sectors[MAJOR_NR] = xd_maxsect;
for (i = 0; i < xd_drives; i++) {
xd_valid[i] = 1;
register_disk(&xd_gendisk, MKDEV(MAJOR_NR,i<<6), 1<<6, &xd_fops,
xd_info[i].heads * xd_info[i].cylinders *
xd_info[i].sectors);
}
xd_gendisk.nr_real = xd_drives;
}
/**
* add_gendisk - add partitioning information to kernel list
* @disk: per-device partitioning information
*
* This function registers the partitioning information in @disk
* with the kernel.
*/
void add_disk(struct gendisk *disk)
{
disk->flags |= GENHD_FL_UP;
blk_register_region(MKDEV(disk->major, disk->first_minor),
disk->minors, NULL, exact_match, exact_lock, disk);
register_disk(disk);
elv_register_queue(disk);
#ifdef UCSB_IO
ucsb_debug("Added disk %15s, diskk major:minor=%d:%d\n",
disk->disk_name, disk->major, disk->first_minor);
#endif /* ucsb_io */
}
/**
* add_disk - add partitioning information to kernel list
* @disk: per-device partitioning information
*
* This function registers the partitioning information in @disk
* with the kernel.
*/
void add_disk(struct gendisk *disk)
{
disk->flags |= GENHD_FL_UP;
blk_register_region(MKDEV(disk->major, disk->first_minor),
disk->minors, NULL, exact_match, exact_lock, disk);
register_disk(disk);
blk_register_queue(disk);
/* Wake up queue in init/main.c. */
#if 0
printk("Waking up queue on %s\n",
disk->disk_name);
#endif
wake_up_interruptible(&disk_wait_h);
}
static bool_t register_mmc_card(struct mmc_card_t * card)
{
struct mmc_card_list * list;
struct disk_t * disk;
list = malloc(sizeof(struct mmc_card_list));
if(!list || !card)
{
free(list);
return FALSE;
}
if(!card->name || search_mmc_card(card->name))
{
free(list);
return FALSE;
}
disk = malloc(sizeof(struct disk_t));
if(!disk)
{
free(list);
return FALSE;
}
disk->name = card->name;
disk->size = card->info->sector_size;
disk->count = card->info->sector_count;
disk->read = mmc_read;
disk->write = mmc_write;
disk->sync = mmc_sync;
disk->suspend = mmc_suspend;
disk->resume = mmc_resume;
disk->priv = (void *)card;
card->priv = (void *)disk;
if(!register_disk(disk))
{
free(list);
free(disk);
return FALSE;
}
list->card = card;
list_add(&list->entry, &mmc_card_list->entry);
return TRUE;
}
static bool_t register_mmc_card(struct mmc_card * card)
{
struct mmc_card_list * list;
struct disk * disk;
list = malloc(sizeof(struct mmc_card_list));
if(!list || !card)
{
free(list);
return FALSE;
}
if(!card->name || search_mmc_card(card->name))
{
free(list);
return FALSE;
}
disk = malloc(sizeof(struct disk));
if(!disk)
{
free(list);
return FALSE;
}
disk->name = card->name;
disk->sector_size = card->info->sector_size;
disk->sector_count = card->info->sector_count;
disk->read_sectors = mmc_read_sectors;
disk->write_sectors = mmc_write_sectors;
disk->priv = (void *)card;
card->priv = (void *)disk;
if(!register_disk(disk, BLK_DEV_MMC))
{
free(list);
free(disk);
return FALSE;
}
list->card = card;
list_add(&list->entry, &mmc_card_list->entry);
return TRUE;
}
static int pd_detect( void )
{ int k, unit;
k = 0;
if (pd_drive_count == 0) { /* nothing spec'd - so autoprobe for 1 */
unit = 0;
if (pi_init(PI,1,-1,-1,-1,-1,-1,pd_scratch,
PI_PD,verbose,PD.name)) {
if (pd_probe_drive(unit)) {
PD.present = 1;
k = 1;
} else pi_release(PI);
}
} else for (unit=0;unit<PD_UNITS;unit++) if (DU[D_PRT])
if (pi_init(PI,0,DU[D_PRT],DU[D_MOD],DU[D_UNI],
DU[D_PRO],DU[D_DLY],pd_scratch,
PI_PD,verbose,PD.name)) {
if (pd_probe_drive(unit)) {
PD.present = 1;
k = unit+1;
} else pi_release(PI);
}
for (unit=0;unit<PD_UNITS;unit++)
register_disk(&pd_gendisk,MKDEV(MAJOR_NR,unit<<PD_BITS),
PD_PARTNS,&pd_fops,
PD.present?PD.capacity:0);
/* We lie about the number of drives found, as the generic partition
scanner assumes that the drives are numbered sequentially from 0.
This can result in some bogus error messages if non-sequential
drive numbers are used.
*/
if (k)
return k;
printk("%s: no valid drive found\n",name);
return 0;
}
int sbull_init(void)
{
int result, i;
/*
* Copy the (static) cfg variables to public prefixed ones to allow
* snoozing with a debugger.
*/
sbull_major = major;
sbull_devs = devs;
sbull_rahead = rahead;
sbull_size = size;
sbull_blksize = blksize;
sbull_hardsect = hardsect;
#ifdef LINUX_20
/* Hardsect can't be changed :( */
if (hardsect != 512) {
printk(KERN_ERR "sbull: can't change hardsect size\n");
hardsect = sbull_hardsect = 512;
}
#endif
/*
* Register your major, and accept a dynamic number
*/
result = register_blkdev(sbull_major, "sbull", &sbull_fops);
if (result < 0) {
printk(KERN_WARNING "sbull: can't get major %d\n",sbull_major);
return result;
}
if (sbull_major == 0) sbull_major = result; /* dynamic */
major = sbull_major; /* Use `major' later on to save typing */
/*
* Assign the other needed values: request, rahead, size, blksize,
* hardsect. All the minor devices feature the same value.
* Note that `sbull' defines all of them to allow testing non-default
* values. A real device could well avoid setting values in global
* arrays if it uses the default values.
*/
read_ahead[major] = sbull_rahead;
result = -ENOMEM; /* for the possible errors */
sbull_sizes = kmalloc(sbull_devs * sizeof(int), GFP_KERNEL);
if (!sbull_sizes)
goto fail_malloc;
for (i=0; i < sbull_devs; i++) /* all the same size */
sbull_sizes[i] = sbull_size;
blk_size[major]=sbull_sizes;
sbull_blksizes = kmalloc(sbull_devs * sizeof(int), GFP_KERNEL);
if (!sbull_blksizes)
goto fail_malloc;
for (i=0; i < sbull_devs; i++) /* all the same blocksize */
sbull_blksizes[i] = sbull_blksize;
blksize_size[major]=sbull_blksizes;
sbull_hardsects = kmalloc(sbull_devs * sizeof(int), GFP_KERNEL);
if (!sbull_hardsects)
goto fail_malloc;
for (i=0; i < sbull_devs; i++) /* all the same hardsect */
sbull_hardsects[i] = sbull_hardsect;
hardsect_size[major]=sbull_hardsects;
/* FIXME: max_readahead and max_sectors */
/*
* allocate the devices -- we can't have them static, as the number
* can be specified at load time
*/
sbull_devices = kmalloc(sbull_devs * sizeof (Sbull_Dev), GFP_KERNEL);
if (!sbull_devices)
goto fail_malloc;
memset(sbull_devices, 0, sbull_devs * sizeof (Sbull_Dev));
for (i=0; i < sbull_devs; i++) {
/* data and usage remain zeroed */
sbull_devices[i].size = 1024 * sbull_size;
init_timer(&(sbull_devices[i].timer));
sbull_devices[i].timer.data = (unsigned long)(sbull_devices+i);
sbull_devices[i].timer.function = sbull_expires;
spin_lock_init(&sbull_devices[i].lock);
}
/*
* Get the queue set up, and register our (nonexistent) partitions.
*/
#ifdef SBULL_MULTIQUEUE
for (i = 0; i < sbull_devs; i++) {
blk_init_queue(&sbull_devices[i].queue, sbull_request);
blk_queue_headactive(&sbull_devices[i].queue, 0);
blk_queue_pluggable(&sbull_devices[i].queue, sbull_plug);
}
blk_dev[major].queue = sbull_find_queue;
#else
# ifdef LINUX_24
if (noqueue)
{
blk_init_queue(BLK_DEFAULT_QUEUE(major), sbull_unused_request);
blk_queue_make_request(BLK_DEFAULT_QUEUE(major), sbull_make_request);
}
else
# endif /* LINUX_24 */
blk_init_queue(BLK_DEFAULT_QUEUE(major), sbull_request);
#endif
/* A no-op in 2.4.0, but all drivers seem to do it anyway */
for (i = 0; i < sbull_devs; i++)
register_disk(NULL, MKDEV(major, i), 1, &sbull_fops,
sbull_size << 1);
#ifndef SBULL_DEBUG
EXPORT_NO_SYMBOLS; /* otherwise, leave global symbols visible */
#endif
printk ("<1>sbull: init complete, %d devs, size %d blks %d hs %d\n",
sbull_devs, sbull_size, sbull_blksize, sbull_hardsect);
#ifdef SBULL_MULTIQUEUE
printk ("<1>sbull: Using multiqueue request\n");
#elif defined(LINUX_24)
if (noqueue)
printk (KERN_INFO "sbull: using direct make_request\n");
#endif
#ifdef DO_RAW_INTERFACE
sbullr_init();
#endif
return 0; /* succeed */
fail_malloc:
read_ahead[major] = 0;
if (sbull_sizes) kfree(sbull_sizes);
blk_size[major] = NULL;
if (sbull_blksizes) kfree(sbull_blksizes);
blksize_size[major] = NULL;
if (sbull_hardsects) kfree(sbull_hardsects);
hardsect_size[major] = NULL;
if (sbull_devices) kfree(sbull_devices);
unregister_blkdev(major, "sbull");
return result;
}
/* It is called at boot time AND for module init. */
int __init my_gscd_init (void)
{
int i;
int result;
printk (KERN_INFO "GSCD: version %s\n", GSCD_VERSION);
printk (KERN_INFO "GSCD: Trying to detect a Goldstar R420 CD-ROM drive at 0x%X.\n", gscd_port);
if (check_region(gscd_port, 4))
{
printk("GSCD: Init failed, I/O port (%X) already in use.\n", gscd_port);
return -EIO;
}
/* check for card */
result = wait_drv_ready ();
if ( result == 0x09 )
{
printk ("GSCD: DMA kann ich noch nicht!\n" );
return -EIO;
}
if ( result == 0x0b )
{
drv_mode = result;
i = find_drives ();
if ( i == 0 )
{
printk ( "GSCD: GoldStar CD-ROM Drive is not found.\n" );
return -EIO;
}
}
if ( (result != 0x0b) && (result != 0x09) )
{
printk ("GSCD: GoldStar Interface Adapter does not exist or H/W error\n" );
return -EIO;
}
/* reset all drives */
i = 0;
while ( drv_states[i] != 0 )
{
curr_drv_state = drv_states[i];
printk (KERN_INFO "GSCD: Reset unit %d ... ",i );
cc_Reset ();
printk ( "done\n" );
i++;
}
if (devfs_register_blkdev(MAJOR_NR, "gscd", &gscd_fops) != 0)
{
printk("GSCD: Unable to get major %d for GoldStar CD-ROM\n",
MAJOR_NR);
return -EIO;
}
devfs_register (NULL, "gscd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
S_IFBLK | S_IRUGO | S_IWUGO, &gscd_fops, NULL);
blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
blksize_size[MAJOR_NR] = gscd_blocksizes;
read_ahead[MAJOR_NR] = 4;
disk_state = 0;
gscdPresent = 1;
request_region(gscd_port, 4, "gscd");
register_disk(NULL, MKDEV(MAJOR_NR,0), 1, &gscd_fops, 0);
printk (KERN_INFO "GSCD: GoldStar CD-ROM Drive found.\n" );
return 0;
}
