->bios_param() switched from kdev_t to struct block_device *.
Caller and all instances updated.
}
int
-simscsi_biosparam (Disk *disk, kdev_t n, int ip[])
+simscsi_biosparam (Disk *disk, struct block_device *n, int ip[])
{
int size = disk->capacity;
extern int simscsi_queuecommand (Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
extern int simscsi_abort (Scsi_Cmnd *);
extern int simscsi_reset (Scsi_Cmnd *, unsigned int);
-extern int simscsi_biosparam (Disk *, kdev_t, int[]);
+extern int simscsi_biosparam (Disk *, struct block_device *, int[]);
#define SIMSCSI { \
detect: simscsi_detect, \
/*
* Called by scsi stack to get bios parameters (used by fdisk, and at boot).
*/
-static int sbp2scsi_biosparam (Scsi_Disk *disk, kdev_t dev, int geom[])
+static int sbp2scsi_biosparam (Scsi_Disk *disk, struct block_device *dev, int geom[])
{
int heads, sectors, cylinders;
static int sbp2scsi_detect (Scsi_Host_Template *tpnt);
static const char *sbp2scsi_info (struct Scsi_Host *host);
void sbp2scsi_setup(char *str, int *ints);
-static int sbp2scsi_biosparam (Scsi_Disk *disk, kdev_t dev, int geom[]);
+static int sbp2scsi_biosparam (Scsi_Disk *disk, struct block_device *dev, int geom[]);
static int sbp2scsi_abort (Scsi_Cmnd *SCpnt);
static int sbp2scsi_reset (Scsi_Cmnd *SCpnt);
static int sbp2scsi_queuecommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *));
*/
int
-mptscsih_bios_param(Disk * disk, kdev_t dev, int *ip)
+mptscsih_bios_param(Disk * disk, struct block_device *dev, int *ip)
{
int size;
extern int x_scsi_old_abort(Scsi_Cmnd *);
extern int x_scsi_old_reset(Scsi_Cmnd *, unsigned int);
#endif
-extern int x_scsi_bios_param(Disk *, kdev_t, int *);
+extern int x_scsi_bios_param(Disk *, struct block_device *, int *);
extern void x_scsi_select_queue_depths(struct Scsi_Host *, Scsi_Device *);
extern void x_scsi_taskmgmt_bh(void *);
* This is anyones guess quite frankly.
*/
-int i2o_scsi_bios_param(Disk * disk, kdev_t dev, int *ip)
+int i2o_scsi_bios_param(Disk * disk, struct block_device *dev, int *ip)
{
int size;
extern int i2o_scsi_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
extern int i2o_scsi_abort(Scsi_Cmnd *);
extern int i2o_scsi_reset(Scsi_Cmnd *, unsigned int);
-extern int i2o_scsi_bios_param(Disk *, kdev_t, int *);
+extern int i2o_scsi_bios_param(Disk *, struct block_device *, int *);
extern void i2o_scsi_setup(char *str, int *ints);
extern int i2o_scsi_release(struct Scsi_Host *host);
}
-int iph5526_biosparam(Disk * disk, kdev_t n, int ip[])
+int iph5526_biosparam(Disk * disk, struct block_device *n, int ip[])
{
int size = disk->capacity;
ip[0] = 64;
int iph5526_release(struct Scsi_Host *host);
int iph5526_abort(Scsi_Cmnd *Cmnd);
const char *iph5526_info(struct Scsi_Host *host);
-int iph5526_biosparam(Disk * disk, kdev_t n, int ip[]);
+int iph5526_biosparam(Disk * disk, struct block_device *n, int ip[]);
#endif
} /* End tw_reset_sequence() */
/* This funciton returns unit geometry in cylinders/heads/sectors */
-int tw_scsi_biosparam(Disk *disk, kdev_t dev, int geom[])
+int tw_scsi_biosparam(Disk *disk, struct block_device *dev, int geom[])
{
int heads, sectors, cylinders;
TW_Device_Extension *tw_dev;
#include <linux/version.h>
#include <linux/types.h>
-#include <linux/kdev_t.h>
/* AEN strings */
static char *tw_aen_string[] = {
int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id);
int tw_reset_device_extension(TW_Device_Extension *tw_dev);
int tw_reset_sequence(TW_Device_Extension *tw_dev);
-int tw_scsi_biosparam(Disk *disk, kdev_t dev, int geom[]);
+int tw_scsi_biosparam(Disk *disk, struct block_device *dev, int geom[]);
int tw_scsi_detect(Scsi_Host_Template *tw_host);
int tw_scsi_eh_abort(Scsi_Cmnd *SCpnt);
int tw_scsi_eh_reset(Scsi_Cmnd *SCpnt);
the BIOS, and a warning may be displayed.
*/
-int BusLogic_BIOSDiskParameters(SCSI_Disk_T *Disk, KernelDevice_T Device,
+int BusLogic_BIOSDiskParameters(SCSI_Disk_T *Disk, struct block_device *bdev,
int *Parameters)
{
BusLogic_HostAdapter_T *HostAdapter =
}
DiskParameters->Cylinders =
Disk->capacity / (DiskParameters->Heads * DiskParameters->Sectors);
- buf = scsi_bios_ptable(Device);
+ buf = scsi_bios_ptable(bdev);
if (buf == NULL) return 0;
/*
If the boot sector partition table flag is valid, search for a partition
of the Linux Kernel and SCSI Subsystem.
*/
-typedef kdev_t KernelDevice_T;
typedef unsigned long ProcessorFlags_T;
typedef struct pt_regs Registers_T;
typedef struct partition PartitionTable_T;
void (*CompletionRoutine)(SCSI_Command_T *));
extern int BusLogic_AbortCommand(SCSI_Command_T *);
extern int BusLogic_ResetCommand(SCSI_Command_T *, unsigned int);
-extern int BusLogic_BIOSDiskParameters(SCSI_Disk_T *, KernelDevice_T, int *);
+extern int BusLogic_BIOSDiskParameters(SCSI_Disk_T *, struct block_device *, int *);
extern int BusLogic_ProcDirectoryInfo(char *, char **, off_t, int, int, int);
}
int
-NCR53c406a_biosparm(Scsi_Disk *disk, kdev_t dev, int* info_array){
+NCR53c406a_biosparm(Scsi_Disk *disk, struct block_device *dev, int* info_array){
int size;
DEB(printk("NCR53c406a_biosparm called\n"));
int NCR53c406a_queue(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int NCR53c406a_abort(Scsi_Cmnd *);
int NCR53c406a_reset(Scsi_Cmnd *, unsigned int);
-int NCR53c406a_biosparm(Disk *, kdev_t, int []);
+int NCR53c406a_biosparm(Disk *, struct block_device *, int []);
#endif /* _NCR53C406A_H */
* ip[2]: cylinders
*/
int
-advansys_biosparam(Disk *dp, kdev_t dep, int ip[])
+advansys_biosparam(Disk *dp, struct block_device *dep, int ip[])
{
asc_board_t *boardp;
const char *advansys_info(struct Scsi_Host *);
int advansys_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
int advansys_reset(Scsi_Cmnd *);
-int advansys_biosparam(Disk *, kdev_t, int[]);
+int advansys_biosparam(Disk *, struct block_device *, int[]);
#ifdef CONFIG_PROC_FS
#if LINUX_VERSION_CODE < ASC_LINUX_VERSION(2,3,28)
extern struct proc_dir_entry proc_scsi_advansys;
* Return the "logical geometry"
*
*/
-int aha152x_biosparam(Scsi_Disk * disk, kdev_t dev, int *info_array)
+int aha152x_biosparam(Scsi_Disk * disk, struct block_device *bdev, int *info_array)
{
struct Scsi_Host *shpnt = disk->device->host;
int info[3];
/* try to figure out the geometry from the partition table */
- if (scsicam_bios_param(disk, dev, info) < 0 ||
+ if (scsicam_bios_param(disk, bdev, info) < 0 ||
!((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
if (EXT_TRANS) {
printk(KERN_NOTICE
int aha152x_device_reset(Scsi_Cmnd *);
int aha152x_bus_reset(Scsi_Cmnd *);
int aha152x_host_reset(Scsi_Cmnd *);
-int aha152x_biosparam(Disk *, kdev_t, int*);
+int aha152x_biosparam(Disk *, struct block_device *, int*);
int aha152x_proc_info(char *buffer, char **start, off_t offset, int length, int hostno, int inout);
/* number of queueable commands
#include "sd.h"
-static int aha1542_biosparam(Scsi_Disk * disk, kdev_t dev, int *ip)
+static int aha1542_biosparam(Scsi_Disk * disk, struct block_device *dev, int *ip)
{
int translation_algorithm;
int size = disk->capacity;
*/
#include <linux/types.h>
-#include <linux/kdev_t.h>
/* I/O Port interface 4.2 */
/* READ */
static int aha1542_old_abort(Scsi_Cmnd * SCpnt);
static int aha1542_old_reset(Scsi_Cmnd *, unsigned int);
#endif
-static int aha1542_biosparam(Disk *, kdev_t, int*);
+static int aha1542_biosparam(Disk *, struct block_device *, int*);
#define AHA1542_MAILBOXES 8
#define AHA1542_SCATTER 16
return SCSI_RESET_PUNT;
}
-int aha1740_biosparam(Disk * disk, kdev_t dev, int* ip)
+int aha1740_biosparam(Disk * disk, struct block_device *dev, int* ip)
{
int size = disk->capacity;
int extended = HOSTDATA(disk->device->host)->translation;
*/
#include <linux/types.h>
-#include <linux/kdev_t.h>
/* Eisa Enhanced mode operation - slot locating and addressing */
#define MINEISA 1 /* I don't have an EISA Spec to know these ranges, so I */
int aha1740_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int aha1740_abort(Scsi_Cmnd *);
int aha1740_reset(Scsi_Cmnd *, unsigned int);
-int aha1740_biosparam(Disk *, kdev_t, int*);
+int aha1740_biosparam(Disk *, struct block_device *, int*);
int aha1740_proc_info(char *buffer, char **start, off_t offset,
int length, int hostno, int inout);
* Return the disk geometry for the given SCSI device.
*/
int
-ahc_linux_biosparam(Disk *disk, kdev_t dev, int geom[])
+ahc_linux_biosparam(Disk *disk, struct block_device *bdev, int geom[])
{
int heads;
int sectors;
unsigned char *buf;
ahc = *((struct ahc_softc **)disk->device->host->hostdata);
- buf = scsi_bios_ptable(dev);
+ buf = scsi_bios_ptable(bdev);
if (buf) {
ret = scsi_partsize(buf, disk->capacity,
int ahc_linux_detect(Scsi_Host_Template *);
int ahc_linux_release(struct Scsi_Host *);
const char *ahc_linux_info(struct Scsi_Host *);
-int ahc_linux_biosparam(Disk *, kdev_t, int[]);
+int ahc_linux_biosparam(Disk *, struct block_device *, int[]);
int ahc_linux_bus_reset(Scsi_Cmnd *);
int ahc_linux_dev_reset(Scsi_Cmnd *);
int ahc_linux_abort(Scsi_Cmnd *);
* Return the disk geometry for the given SCSI device.
*-F*************************************************************************/
int
-aic7xxx_biosparam(Disk *disk, kdev_t dev, int geom[])
+aic7xxx_biosparam(Disk *disk, struct block_device *bdev, int geom[])
{
int heads, sectors, cylinders, ret;
struct aic7xxx_host *p;
unsigned char *buf;
p = (struct aic7xxx_host *) disk->device->host->hostdata;
- buf = scsi_bios_ptable(dev);
+ buf = scsi_bios_ptable(bdev);
if ( buf )
{
}
extern int aic7xxx_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
-extern int aic7xxx_biosparam(Disk *, kdev_t, int[]);
+extern int aic7xxx_biosparam(Disk *, struct block_device *, int[]);
extern int aic7xxx_detect(Scsi_Host_Template *);
extern int aic7xxx_command(Scsi_Cmnd *);
extern int aic7xxx_reset(Scsi_Cmnd *, unsigned int);
#include "sd.h"
-int atp870u_biosparam(Scsi_Disk * disk, kdev_t dev, int *ip)
+int atp870u_biosparam(Scsi_Disk * disk, struct block_device *dev, int *ip)
{
int heads, sectors, cylinders;
*/
#include <linux/types.h>
-#include <linux/kdev_t.h>
/* I/O Port */
int atp870u_queuecommand(Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
int atp870u_abort(Scsi_Cmnd *);
int atp870u_reset(Scsi_Cmnd *, unsigned int);
-int atp870u_biosparam(Disk *, kdev_t, int *);
+int atp870u_biosparam(Disk *, struct block_device *, int *);
int atp870u_release(struct Scsi_Host *);
void send_s870(unsigned char);
extern int cpqfcTS_reset(Scsi_Cmnd *, unsigned int);
extern int cpqfcTS_eh_abort(Scsi_Cmnd *Cmnd);
extern int cpqfcTS_eh_device_reset(Scsi_Cmnd *);
-extern int cpqfcTS_biosparam(Disk *, kdev_t, int[]);
+extern int cpqfcTS_biosparam(Disk *, struct block_device *, int[]);
extern int cpqfcTS_ioctl( Scsi_Device *ScsiDev, int Cmnd, void *arg);
// note: since Tachyon TS supports an extended scatter/gather
(from hosts.h)
*/
-int cpqfcTS_biosparam(Disk *disk, kdev_t n, int ip[])
+int cpqfcTS_biosparam(Disk *disk, struct block_device *n, int ip[])
{
int size = disk->capacity;
extern int DC390_queue_command(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *));
extern int DC390_abort(Scsi_Cmnd *cmd);
extern int DC390_reset(Scsi_Cmnd *cmd, unsigned int resetFlags);
-extern int DC390_bios_param(Disk *disk, kdev_t devno, int geom[]);
+extern int DC390_bios_param(Disk *disk, struct block_device *dev, int geom[]);
#ifdef MODULE
static int DC390_release(struct Scsi_Host *);
return adpt_scsi_to_i2o(pHba, cmd, pDev);
}
-static int adpt_bios_param(Disk* disk, kdev_t dev, int geom[])
+static int adpt_bios_param(Disk* disk, struct block_device *dev, int geom[])
{
int heads=-1;
int sectors=-1;
static int adpt_release(struct Scsi_Host *host);
static const char *adpt_info(struct Scsi_Host *pSHost);
-static int adpt_bios_param(Disk * disk, kdev_t dev, int geom[]);
+static int adpt_bios_param(Disk * disk, struct block_device *dev, int geom[]);
static int adpt_bus_reset(Scsi_Cmnd* cmd);
static int adpt_device_reset(Scsi_Cmnd* cmd);
}
/*
- * Function : int dtc_biosparam(Disk * disk, kdev_t dev, int *ip)
+ * Function : int dtc_biosparam(Disk * disk, struct block_device *dev, int *ip)
*
* Purpose : Generates a BIOS / DOS compatible H-C-S mapping for
* the specified device / size.
* and matching the H_C_S coordinates to what DOS uses.
*/
-int dtc_biosparam(Disk * disk, kdev_t dev, int * ip)
+int dtc_biosparam(Disk * disk, struct block_device *dev, int * ip)
{
int size = disk->capacity;
#ifndef ASM
int dtc_abort(Scsi_Cmnd *);
-int dtc_biosparam(Disk *, kdev_t, int*);
+int dtc_biosparam(Disk *, struct block_device *, int*);
int dtc_detect(Scsi_Host_Template *);
int dtc_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int dtc_reset(Scsi_Cmnd *, unsigned int reset_flags);
return do_reset(SCarg);
}
-int eata2x_biosparam(Disk *disk, kdev_t dev, int *dkinfo) {
+int eata2x_biosparam(Disk *disk, struct block_device *bdev, int *dkinfo) {
int size = disk->capacity;
- if (ext_tran || (scsicam_bios_param(disk, dev, dkinfo) < 0)) {
+ if (ext_tran || (scsicam_bios_param(disk, bdev, dkinfo) < 0)) {
dkinfo[0] = 255;
dkinfo[1] = 63;
dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
int eata2x_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int eata2x_abort(Scsi_Cmnd *);
int eata2x_reset(Scsi_Cmnd *);
-int eata2x_biosparam(Disk *, kdev_t, int *);
+int eata2x_biosparam(Disk *, struct block_device *, int *);
#define EATA_VERSION "7.22.00"
#include "sd.h"
#include <scsi/scsi_ioctl.h>
-int fd_mcs_biosparam( Scsi_Disk *disk, kdev_t dev, int *info_array )
+int fd_mcs_biosparam( Scsi_Disk *disk, struct block_device *bdev, int *info_array )
{
- int drive;
unsigned char buf[512 + sizeof( int ) * 2];
int size = disk->capacity;
int *sizes = (int *)buf;
int retcode;
/* BIOS >= 3.4 for MCA cards */
- drive = MINOR(dev) / 16;
-
/* This algorithm was provided by Future Domain (much thanks!). */
sizes[0] = 0; /* zero bytes out */
extern int fd_mcs_abort( Scsi_Cmnd * );
extern int fd_mcs_reset( Scsi_Cmnd *, unsigned int );
extern int fd_mcs_queue( Scsi_Cmnd *, void (*done)(Scsi_Cmnd *) );
-extern int fd_mcs_biosparam( Disk *, kdev_t, int * );
+extern int fd_mcs_biosparam( Disk *, struct block_device *, int * );
extern int fd_mcs_proc_info( char *, char **, off_t, int, int, int );
extern const char *fd_mcs_info(struct Scsi_Host *);
#include "sd.h"
#include <scsi/scsi_ioctl.h>
-int fdomain_16x0_biosparam( Scsi_Disk *disk, kdev_t dev, int *info_array )
+int fdomain_16x0_biosparam( Scsi_Disk *disk, struct block_device *bdev, int *info_array )
{
int drive;
unsigned char buf[512 + sizeof (Scsi_Ioctl_Command)];
0x0a bytes long. Heads are one less than we need to report.
*/
- if (major(dev) != SCSI_DISK0_MAJOR) {
+ if (MAJOR(bdev->bd_dev) != SCSI_DISK0_MAJOR) {
printk("scsi: <fdomain> fdomain_16x0_biosparam: too many disks");
return 0;
}
- drive = minor(dev) >> 4;
+ drive = MINOR(bdev->bd_dev) >> 4;
if (bios_major == 2) {
switch (Quantum) {
const char *fdomain_16x0_info( struct Scsi_Host * );
int fdomain_16x0_reset( Scsi_Cmnd *, unsigned int );
int fdomain_16x0_queue( Scsi_Cmnd *, void (*done)(Scsi_Cmnd *) );
-int fdomain_16x0_biosparam( Disk *, kdev_t, int * );
+int fdomain_16x0_biosparam( Disk *, struct block_device *, int * );
int fdomain_16x0_proc_info( char *buffer, char **start, off_t offset,
int length, int hostno, int inout );
int fdomain_16x0_release( struct Scsi_Host *shpnt );
* Locks: none
*/
-int generic_NCR5380_biosparam(Disk * disk, kdev_t dev, int *ip)
+int generic_NCR5380_biosparam(Disk * disk, struct block_device *dev, int *ip)
{
int size = disk->capacity;
ip[0] = 64;
int length, int hostno, int inout);
const char* generic_NCR5380_info(struct Scsi_Host *);
#ifdef BIOSPARAM
-int generic_NCR5380_biosparam(Disk *, kdev_t, int *);
+int generic_NCR5380_biosparam(Disk *, struct block_device *, int *);
#endif
int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int length, int hostno, int inout);
}
#endif
-#if LINUX_VERSION_CODE >= 0x010300
-int gdth_bios_param(Disk *disk,kdev_t dev,int *ip)
-#else
-int gdth_bios_param(Disk *disk,int dev,int *ip)
-#endif
+int gdth_bios_param(Disk *disk,struct block_device *bdev,int *ip)
{
unchar b, t;
int hanum;
#endif
const char *gdth_info(struct Scsi_Host *);
-#if LINUX_VERSION_CODE >= 0x020322
-int gdth_bios_param(Disk *,kdev_t,int *);
+int gdth_bios_param(Disk *,struct block_device *,int *);
int gdth_proc_info(char *,char **,off_t,int,int,int);
int gdth_eh_abort(Scsi_Cmnd *scp);
int gdth_eh_device_reset(Scsi_Cmnd *scp);
unchecked_isa_dma: 1, \
use_clustering: ENABLE_CLUSTERING }
-#elif LINUX_VERSION_CODE >= 0x02015F
-int gdth_bios_param(Disk *,kdev_t,int *);
-extern struct proc_dir_entry proc_scsi_gdth;
-int gdth_proc_info(char *,char **,off_t,int,int,int);
-int gdth_eh_abort(Scsi_Cmnd *scp);
-int gdth_eh_device_reset(Scsi_Cmnd *scp);
-int gdth_eh_bus_reset(Scsi_Cmnd *scp);
-int gdth_eh_host_reset(Scsi_Cmnd *scp);
-#define GDTH { proc_dir: &proc_scsi_gdth, \
- proc_info: gdth_proc_info, \
- name: "GDT SCSI Disk Array Controller",\
- detect: gdth_detect, \
- release: gdth_release, \
- info: gdth_info, \
- command: NULL, \
- queuecommand: gdth_queuecommand, \
- eh_abort_handler: gdth_eh_abort, \
- eh_device_reset_handler: gdth_eh_device_reset, \
- eh_bus_reset_handler: gdth_eh_bus_reset, \
- eh_host_reset_handler: gdth_eh_host_reset, \
- abort: gdth_abort, \
- reset: gdth_reset, \
- bios_param: gdth_bios_param, \
- can_queue: GDTH_MAXCMDS, \
- this_id: -1, \
- sg_tablesize: GDTH_MAXSG, \
- cmd_per_lun: GDTH_MAXC_P_L, \
- present: 0, \
- unchecked_isa_dma: 1, \
- use_clustering: ENABLE_CLUSTERING }
-
-#elif LINUX_VERSION_CODE >= 0x010300
-int gdth_bios_param(Disk *,kdev_t,int *);
-extern struct proc_dir_entry proc_scsi_gdth;
-int gdth_proc_info(char *,char **,off_t,int,int,int);
-#define GDTH { NULL, NULL, \
- &proc_scsi_gdth, \
- gdth_proc_info, \
- "GDT SCSI Disk Array Controller", \
- gdth_detect, \
- gdth_release, \
- gdth_info, \
- NULL, \
- gdth_queuecommand, \
- gdth_abort, \
- gdth_reset, \
- NULL, \
- gdth_bios_param, \
- GDTH_MAXCMDS, \
- -1, \
- GDTH_MAXSG, \
- GDTH_MAXC_P_L, \
- 0, \
- 1, \
- ENABLE_CLUSTERING}
-
-#else
-int gdth_bios_param(Disk *,int,int *);
-#define GDTH { NULL, NULL, \
- "GDT SCSI Disk Array Controller", \
- gdth_detect, \
- gdth_release, \
- gdth_info, \
- NULL, \
- gdth_queuecommand, \
- gdth_abort, \
- gdth_reset, \
- NULL, \
- gdth_bios_param, \
- GDTH_MAXCMDS, \
- -1, \
- GDTH_MAXSG, \
- GDTH_MAXC_P_L, \
- 0, \
- 1, \
- ENABLE_CLUSTERING}
-#endif
-
#endif
* This function determines the bios parameters for a given
* harddisk. These tend to be numbers that are made up by
* the host adapter. Parameters:
- * size, device number, list (heads, sectors, cylinders)
+ * size, device, list (heads, sectors, cylinders)
*/
- int (* bios_param)(Disk *, kdev_t, int []);
+ int (* bios_param)(Disk *, struct block_device *, int []);
/*
return SCSI_RESET_SUCCESS;
}
-int ibmmca_biosparam (Disk * disk, kdev_t dev, int *info)
+int ibmmca_biosparam (Disk * disk, struct block_device *dev, int *info)
{
info[0] = 64;
info[1] = 32;
extern int ibmmca_queuecommand (Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
extern int ibmmca_abort (Scsi_Cmnd *);
extern int ibmmca_reset (Scsi_Cmnd *, unsigned int);
-extern int ibmmca_biosparam (Disk *, kdev_t, int *);
+extern int ibmmca_biosparam (Disk *, struct block_device *, int *);
/*structure for /proc filesystem */
extern struct proc_dir_entry proc_scsi_ibmmca;
return SUCCESS;
}
-static int idescsi_bios(Disk *disk, kdev_t dev, int *parm)
+static int idescsi_bios(Disk *disk, struct block_device *dev, int *parm)
{
idescsi_scsi_t *scsi = idescsi_private(disk->device->host);
struct ata_device *drive = scsi->drive;
* be done in sd.c. Even if it gets fixed there, this will still
* work.
*/
-int imm_biosparam(Disk * disk, kdev_t dev, int ip[])
+int imm_biosparam(Disk * disk, struct block_device *dev, int ip[])
{
ip[0] = 0x40;
ip[1] = 0x20;
int imm_abort(Scsi_Cmnd *);
int imm_reset(Scsi_Cmnd *);
int imm_proc_info(char *, char **, off_t, int, int, int);
-int imm_biosparam(Disk *, kdev_t, int *);
+int imm_biosparam(Disk *, struct block_device *, int *);
#define IMM { proc_name: "imm", \
proc_info: imm_proc_info, \
* supposed to do...
*/
-int in2000_biosparam(Disk *disk, kdev_t dev, int *iinfo)
+int in2000_biosparam(Disk *disk, struct block_device *dev, int *iinfo)
{
int size;
int in2000_abort(Scsi_Cmnd *);
void in2000_setup(char *, int *) in2000__INIT;
int in2000_proc_info(char *, char **, off_t, int, int, int);
-int in2000_biosparam(struct scsi_disk *, kdev_t, int *);
+int in2000_biosparam(struct scsi_disk *, struct block_device *, int *);
int in2000_reset(Scsi_Cmnd *, unsigned int);
/*
* Return the "logical geometry"
*/
-int i91u_biosparam(Scsi_Disk * disk, kdev_t dev, int *info_array)
+int i91u_biosparam(Scsi_Disk * disk, struct block_device *dev, int *info_array)
{
HCS *pHcb; /* Point to Host adapter control block */
TCS *pTcb;
extern int i91u_queue(Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
extern int i91u_abort(Scsi_Cmnd *);
extern int i91u_reset(Scsi_Cmnd *, unsigned int);
-extern int i91u_biosparam(Scsi_Disk *, kdev_t, int *); /*for linux v2.0 */
+extern int i91u_biosparam(Scsi_Disk *, struct block_device *, int *);
#define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.03g"
Output : None.
Return : pSRB - Pointer to SCSI request block.
*****************************************************************************/
-int inia100_biosparam(Scsi_Disk * disk, kdev_t dev, int *info_array)
+int inia100_biosparam(Scsi_Disk * disk, struct block_device *dev, int *info_array)
{
ORC_HCS *pHcb; /* Point to Host adapter control block */
ORC_TCS *pTcb;
extern int inia100_abort(Scsi_Cmnd *);
extern int inia100_reset(Scsi_Cmnd *, unsigned int);
-extern int inia100_biosparam(Scsi_Disk *, kdev_t, int *); /*for linux v2.0 */
+extern int inia100_biosparam(Scsi_Disk *, struct block_device *, int *);
#define inia100_REVID "Initio INI-A100U2W SCSI device driver; Revision: 1.02c"
int ips_eh_abort(Scsi_Cmnd *);
int ips_eh_reset(Scsi_Cmnd *);
int ips_queue(Scsi_Cmnd *, void (*) (Scsi_Cmnd *));
-int ips_biosparam(Disk *, kdev_t, int *);
+int ips_biosparam(Disk *, struct block_device *, int *);
const char * ips_info(struct Scsi_Host *);
void do_ipsintr(int, void *, struct pt_regs *);
static int ips_hainit(ips_ha_t *);
/* */
/****************************************************************************/
int
-ips_biosparam(Disk *disk, kdev_t dev, int geom[]) {
+ips_biosparam(Disk *disk, struct block_device *dev, int geom[]) {
ips_ha_t *ha;
int heads;
int sectors;
extern int ips_eh_abort(Scsi_Cmnd *);
extern int ips_eh_reset(Scsi_Cmnd *);
extern int ips_queue(Scsi_Cmnd *, void (*) (Scsi_Cmnd *));
- extern int ips_biosparam(Disk *, kdev_t, int *);
+ extern int ips_biosparam(Disk *, struct block_device *, int *);
extern const char * ips_info(struct Scsi_Host *);
extern void do_ips(int, void *, struct pt_regs *);
* Return the disk geometry for a particular disk
* Input:
* Disk *disk - Disk geometry
- * kdev_t dev - Device node
+ * struct block_device *dev - Device node
* int *geom - Returns geometry fields
* geom[0] = heads
* geom[1] = sectors
* geom[2] = cylinders
*-------------------------------------------------------------*/
-int megaraid_biosparam (Disk * disk, kdev_t dev, int *geom)
+int megaraid_biosparam (Disk * disk, struct block_device *bdev, int *geom)
{
int heads, sectors, cylinders;
mega_host_config *megaCfg;
geom[2] = cylinders;
}
else {
- if( mega_partsize(disk, dev, geom) == 0 ) return 0;
+ if( mega_partsize(disk, bdev, geom) == 0 ) return 0;
printk(KERN_WARNING
"megaraid: invalid partition on this disk on channel %d\n",
}
/*
- * Function : static int mega_partsize(Disk * disk, kdev_t dev, int *geom)
+ * Function : static int mega_partsize(Disk * disk, struct block_device *bdev, int *geom)
*
* Purpose : to determine the BIOS mapping used to create the partition
* table, storing the results (cyls, hds, and secs) in geom
* Returns : -1 on failure, 0 on success.
*/
static int
-mega_partsize(Disk * disk, kdev_t dev, int *geom)
+mega_partsize(Disk * disk, struct block_device *bdev, int *geom)
{
struct partition *p, *largest = NULL;
int i, largest_cyl;
int capacity = disk->capacity;
unsigned char *buf;
- if (!(buf = scsi_bios_ptable(dev)))
+ if (!(buf = scsi_bios_ptable(bdev)))
return -1;
if( *(unsigned short *)(buf + 64) == 0xAA55 ) {
unsigned int cmd, unsigned long arg)
{
int adapno;
- kdev_t dev;
u32 inlen;
struct uioctl_t ioc;
char *kvaddr = NULL;
if (!inode)
return -EINVAL;
- dev = inode->i_rdev;
-
if (_IOC_TYPE (cmd) != MEGAIOC_MAGIC)
return (-EINVAL);
int megaraid_abort (Scsi_Cmnd *);
int megaraid_reset (Scsi_Cmnd *, unsigned int);
int megaraid_queue (Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
-int megaraid_biosparam (Disk *, kdev_t, int *);
+int megaraid_biosparam (Disk *, struct block_device *, int *);
int megaraid_proc_info (char *buffer, char **start, off_t offset,
int length, int hostno, int inout);
static mega_ext_passthru* mega_prepare_extpassthru(mega_host_config *,
mega_scb *, Scsi_Cmnd *);
static void mega_enum_raid_scsi(mega_host_config *);
-static int mega_partsize(Disk *, kdev_t, int *);
+static int mega_partsize(Disk *, struct block_device *, int *);
static void mega_get_boot_ldrv(mega_host_config *);
static int mega_get_lun(mega_host_config *, Scsi_Cmnd *);
static int mega_support_random_del(mega_host_config *);
}
/*
- * Function : int pas16_biosparam(Disk *disk, kdev_t dev, int *ip)
+ * Function : int pas16_biosparam(Disk *disk, struct block_device *dev, int *ip)
*
* Purpose : Generates a BIOS / DOS compatible H-C-S mapping for
* the specified device / size.
* and matching the H_C_S coordinates to what DOS uses.
*/
-int pas16_biosparam(Disk * disk, kdev_t dev, int * ip)
+int pas16_biosparam(Disk * disk, struct block_device *dev, int * ip)
{
int size = disk->capacity;
ip[0] = 64;
#ifndef ASM
int pas16_abort(Scsi_Cmnd *);
-int pas16_biosparam(Disk *, kdev_t, int*);
+int pas16_biosparam(Disk *, struct block_device *, int*);
int pas16_detect(Scsi_Host_Template *);
int pas16_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int pas16_reset(Scsi_Cmnd *, unsigned int);
* Returns: zero.
*
****************************************************************/
-int Pci2000_BiosParam (Scsi_Disk *disk, kdev_t dev, int geom[])
+int Pci2000_BiosParam (Scsi_Disk *disk, struct block_device *dev, int geom[])
{
PADAPTER2000 padapter;
#define _PCI2000_H
#include <linux/types.h>
-#include <linux/kdev_t.h>
#ifndef PSI_EIDE_SCSIOP
#define PSI_EIDE_SCSIOP 1
int Pci2000_Abort (Scsi_Cmnd *SCpnt);
int Pci2000_Reset (Scsi_Cmnd *SCpnt, unsigned int flags);
int Pci2000_Release (struct Scsi_Host *pshost);
-int Pci2000_BiosParam (Disk *disk, kdev_t dev, int geom[]);
+int Pci2000_BiosParam (Disk *disk, struct block_device *dev, int geom[]);
#ifndef NULL
#define NULL 0
#include <linux/sched.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
-#include <linux/kdev_t.h>
#include <linux/blk.h>
#include <linux/timer.h>
#include <linux/spinlock.h>
* Returns: zero.
*
****************************************************************/
-int Pci2220i_BiosParam (Scsi_Disk *disk, kdev_t dev, int geom[])
+int Pci2220i_BiosParam (Scsi_Disk *disk, struct block_device *dev, int geom[])
{
POUR_DEVICE pdev;
int Pci2220i_Abort (Scsi_Cmnd *SCpnt);
int Pci2220i_Reset (Scsi_Cmnd *SCpnt, unsigned int flags);
int Pci2220i_Release (struct Scsi_Host *pshost);
-int Pci2220i_BiosParam (Disk *disk, kdev_t dev, int geom[]);
+int Pci2220i_BiosParam (Disk *disk, struct block_device *dev, int geom[]);
#ifndef NULL
#define NULL 0
* be done in sd.c. Even if it gets fixed there, this will still
* work.
*/
-int ppa_biosparam(Disk * disk, kdev_t dev, int ip[])
+int ppa_biosparam(Disk * disk, struct block_device *dev, int ip[])
{
ip[0] = 0x40;
ip[1] = 0x20;
int ppa_abort(Scsi_Cmnd *);
int ppa_reset(Scsi_Cmnd *);
int ppa_proc_info(char *, char **, off_t, int, int, int);
-int ppa_biosparam(Disk *, kdev_t, int *);
+int ppa_biosparam(Disk *, struct block_device *, int *);
#define PPA { proc_name: "ppa", \
proc_info: ppa_proc_info, \
* Returns: zero.
*
****************************************************************/
-int Psi240i_BiosParam (Scsi_Disk *disk, kdev_t dev, int geom[])
+int Psi240i_BiosParam (Scsi_Disk *disk, struct block_device *dev, int geom[])
{
POUR_DEVICE pdev;
#define _PSI240I_H
#include <linux/types.h>
-#include <linux/kdev_t.h>
#ifndef PSI_EIDE_SCSIOP
#define PSI_EIDE_SCSIOP 1
int Psi240i_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *));
int Psi240i_Abort (Scsi_Cmnd *SCpnt);
int Psi240i_Reset (Scsi_Cmnd *SCpnt, unsigned int flags);
-int Psi240i_BiosParam (Disk *disk, kdev_t dev, int geom[]);
+int Psi240i_BiosParam (Disk *disk, struct block_device * dev, int geom[]);
#ifndef NULL
#define NULL 0
* Return the disk geometry for the given SCSI device.
**************************************************************************/
int
-qla1280_biosparam(Disk * disk, kdev_t dev, int geom[])
+qla1280_biosparam(Disk * disk, struct block_device *dev, int geom[])
{
int heads, sectors, cylinders;
int qla1280_queuecommand(Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
int qla1280_abort(Scsi_Cmnd *);
int qla1280_reset(Scsi_Cmnd *, unsigned int);
-int qla1280_biosparam(Disk *, kdev_t, int[]);
+int qla1280_biosparam(Disk *, struct block_device *, int[]);
void qla1280_intr_handler(int, void *, struct pt_regs *);
void qla1280_setup(char *s, int *dummy);
/*----------------------------------------------------------------*/
/* return bios parameters */
-int qlogicfas_biosparam(Disk * disk, kdev_t dev, int ip[])
+int qlogicfas_biosparam(Disk * disk, struct block_device *dev, int ip[])
{
/* This should mimic the DOS Qlogic driver's behavior exactly */
ip[0] = 0x40;
int qlogicfas_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
int qlogicfas_abort(Scsi_Cmnd *);
int qlogicfas_reset(Scsi_Cmnd *, unsigned int);
-int qlogicfas_biosparam(Disk *, kdev_t, int[]);
+int qlogicfas_biosparam(Disk *, struct block_device *, int[]);
#ifndef NULL
#define NULL (0)
}
-int isp2x00_biosparam(Disk * disk, kdev_t n, int ip[])
+int isp2x00_biosparam(Disk * disk, struct block_device *n, int ip[])
{
int size = disk->capacity;
int isp2x00_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
int isp2x00_abort(Scsi_Cmnd *);
int isp2x00_reset(Scsi_Cmnd *, unsigned int);
-int isp2x00_biosparam(Disk *, kdev_t, int[]);
+int isp2x00_biosparam(Disk *, struct block_device *, int[]);
#ifndef NULL
#define NULL (0)
}
-int isp1020_biosparam(Disk *disk, kdev_t n, int ip[])
+int isp1020_biosparam(Disk *disk, struct block_device *n, int ip[])
{
int size = disk->capacity;
int isp1020_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
int isp1020_abort(Scsi_Cmnd *);
int isp1020_reset(Scsi_Cmnd *, unsigned int);
-int isp1020_biosparam(Disk *, kdev_t, int[]);
+int isp1020_biosparam(Disk *, struct block_device *, int[]);
#ifndef NULL
#define NULL (0)
#endif
}
-static int scsi_debug_biosparam(Disk * disk, kdev_t dev, int *info)
+static int scsi_debug_biosparam(Disk * disk, struct block_device *dev, int *info)
{
if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
printk(KERN_INFO "scsi_debug: biosparam\n");
#ifndef _SCSI_DEBUG_H
#include <linux/types.h>
-#include <linux/kdev_t.h>
static int scsi_debug_detect(Scsi_Host_Template *);
/* static int scsi_debug_command(Scsi_Cmnd *); */
static int scsi_debug_queuecommand(Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
static int scsi_debug_abort(Scsi_Cmnd *);
-static int scsi_debug_biosparam(Disk *, kdev_t, int[]);
+static int scsi_debug_biosparam(Disk *, struct block_device *, int[]);
static int scsi_debug_bus_reset(Scsi_Cmnd *);
static int scsi_debug_device_reset(Scsi_Cmnd *);
static int scsi_debug_host_reset(Scsi_Cmnd *);
* pre-initialized with made up values just in case this function
* doesn't output anything.
**/
- int bios_param(Scsi_Disk * sdkp, kdev_t dev, int params[3]);
+ int bios_param(Scsi_Disk * sdkp, struct block_device *bdev, int params[3]);
/**
static int setsize(unsigned long capacity, unsigned int *cyls, unsigned int *hds,
unsigned int *secs);
-unsigned char *scsi_bios_ptable(kdev_t dev)
+unsigned char *scsi_bios_ptable(struct block_device *dev)
{
- struct block_device *bdev;
unsigned char *res = kmalloc(66, GFP_KERNEL);
- kdev_t rdev = mk_kdev(major(dev), minor(dev) & ~0x0f);
-
if (res) {
- struct buffer_head *bh;
- int err;
-
- bdev = bdget(kdev_t_to_nr(rdev));
- if (!bdev)
- goto fail;
- err = blkdev_get(bdev, FMODE_READ, 0, BDEV_FILE);
- if (err)
- goto fail;
- bh = __bread(bdev, 0, block_size(bdev));
- if (!bh)
- goto fail2;
- memcpy(res, bh->b_data + 0x1be, 66);
- brelse(bh);
- blkdev_put(bdev, BDEV_FILE);
+ struct block_device *bdev = dev->bd_contains;
+ struct buffer_head *bh = __bread(bdev, 0, block_size(bdev));
+ if (bh) {
+ memcpy(res, bh->b_data + 0x1be, 66);
+ brelse(bh);
+ } else {
+ kfree(res);
+ res = NULL;
+ }
}
return res;
-fail2:
- blkdev_put(bdev, BDEV_FILE);
-fail:
- kfree(res);
- return NULL;
}
/*
- * Function : int scsicam_bios_param (Disk *disk, int dev, int *ip)
+ * Function : int scsicam_bios_param (Disk *disk, struct block_device *bdev, int *ip)
*
* Purpose : to determine the BIOS mapping used for a drive in a
* SCSI-CAM system, storing the results in ip as required
*/
int scsicam_bios_param(Disk * disk, /* SCSI disk */
- kdev_t dev, /* Device major, minor */
+ struct block_device *bdev,
int *ip /* Heads, sectors, cylinders in that order */ )
{
int ret_code;
int size = disk->capacity;
unsigned long temp_cyl;
- unsigned char *p = scsi_bios_ptable(dev);
+ unsigned char *p = scsi_bios_ptable(bdev);
if (!p)
return -1;
or driver values */
if(host->hostt->bios_param != NULL)
- host->hostt->bios_param(sdkp, dev,
+ host->hostt->bios_param(sdkp, inode->i_bdev,
&diskinfo[0]);
else
- scsicam_bios_param(sdkp, dev, &diskinfo[0]);
+ scsicam_bios_param(sdkp, inode->i_bdev, &diskinfo[0]);
if (put_user(diskinfo[0], &loc->heads) ||
put_user(diskinfo[1], &loc->sectors) ||
put_user(diskinfo[2], &loc->cylinders) ||
int sim710_bus_reset(Scsi_Cmnd * SCpnt);
int sim710_dev_reset(Scsi_Cmnd * SCpnt);
int sim710_host_reset(Scsi_Cmnd * SCpnt);
-int sim710_biosparam(Disk *, kdev_t, int*);
+int sim710_biosparam(Disk *, struct block_device *, int*);
#ifdef MODULE
int sim710_release(struct Scsi_Host *);
#else
return SCSI_RESET_PENDING;
}
-static int sym53c416_bios_param(Disk *disk, kdev_t dev, int *ip)
+static int sym53c416_bios_param(Disk *disk, struct block_device *dev, int *ip)
{
int size;
#endif
#include <linux/types.h>
-#include <linux/kdev_t.h>
#define SYM53C416_SCSI_ID 7
static int sym53c416_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
static int sym53c416_abort(Scsi_Cmnd *);
static int sym53c416_reset(Scsi_Cmnd *, unsigned int);
-static int sym53c416_bios_param(Disk *, kdev_t, int *);
+static int sym53c416_bios_param(Disk *, struct block_device *, int *);
static void sym53c416_setup(char *str, int *ints);
#define SYM53C416 { \
}
/*
- * Function : int t128_biosparam(Disk * disk, kdev_t dev, int *ip)
+ * Function : int t128_biosparam(Disk * disk, struct block_device *dev, int *ip)
*
* Purpose : Generates a BIOS / DOS compatible H-C-S mapping for
* the specified device / size.
* and matching the H_C_S coordinates to what DOS uses.
*/
-int t128_biosparam(Disk * disk, kdev_t dev, int * ip)
+int t128_biosparam(Disk * disk, struct block_device *dev, int * ip)
{
int size = disk->capacity;
ip[0] = 64;
#ifndef ASM
int t128_abort(Scsi_Cmnd *);
-int t128_biosparam(Disk *, kdev_t, int*);
+int t128_biosparam(Disk *, struct block_device *, int*);
int t128_detect(Scsi_Host_Template *);
int t128_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int t128_reset(Scsi_Cmnd *, unsigned int reset_flags);
* Note:
* In contrary to other externally callable funcs (DC390_), we don't lock
***********************************************************************/
-int DC390_bios_param (Disk *disk, kdev_t devno, int geom[])
+int DC390_bios_param (Disk *disk, struct block_device *bdev, int geom[])
{
int heads, sectors, cylinders;
PACB pACB = (PACB) disk->device->host->hostdata;
int size = disk->capacity;
unsigned char *buf;
- if ((buf = scsi_bios_ptable(devno)))
+ if ((buf = scsi_bios_ptable(bdev)))
{
/* try to infer mapping from partition table */
ret_code = partsize (buf, (unsigned long) size, (unsigned int *) geom + 2,
return (0);
}
#else
-int DC390_bios_param (Disk *disk, kdev_t devno, int geom[])
+int DC390_bios_param (Disk *disk, struct block_device *bdev, int geom[])
{
- return scsicam_bios_param (disk, devno, geom);
+ return scsicam_bios_param (disk, bdev, geom);
};
#endif
if (dc390_search (&buffer, &pos, &p0, &var, txt, max, scale, "")) goto einv2; \
else if (!p1) goto ok2
-#define SEARCH3(buffer, pos, &p0, var, txt, max, scale, ign) \
-if (dc390_search (&buffer, &pos, p0, &var, txt, max, scale, ign)) goto einv2; \
+#define SEARCH3(buffer, pos, p0, var, txt, max, scale, ign) \
+if (dc390_search (&buffer, &pos, &p0, &var, txt, max, scale, ign)) goto einv2; \
else if (!p1) goto ok2
return do_reset(SCarg);
}
-int u14_34f_biosparam(Disk *disk, kdev_t dev, int *dkinfo) {
+int u14_34f_biosparam(Disk *disk, struct block_device *bdev, int *dkinfo) {
unsigned int j = 0;
int size = disk->capacity;
dkinfo[1] = HD(j)->sectors;
dkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
- if (ext_tran && (scsicam_bios_param(disk, dev, dkinfo) < 0)) {
+ if (ext_tran && (scsicam_bios_param(disk, bdev, dkinfo) < 0)) {
dkinfo[0] = 255;
dkinfo[1] = 63;
dkinfo[2] = size / (dkinfo[0] * dkinfo[1]);
int u14_34f_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int u14_34f_abort(Scsi_Cmnd *);
int u14_34f_reset(Scsi_Cmnd *);
-int u14_34f_biosparam(Disk *, kdev_t, int *);
+int u14_34f_biosparam(Disk *, struct block_device *, int *);
#define U14_34F_VERSION "7.22.00"
}
-int ultrastor_biosparam(Disk * disk, kdev_t dev, int * dkinfo)
+int ultrastor_biosparam(Disk * disk, struct block_device *dev, int * dkinfo)
{
int size = disk->capacity;
unsigned int s = config.heads * config.sectors;
#ifndef _ULTRASTOR_H
#define _ULTRASTOR_H
-#include <linux/kdev_t.h>
int ultrastor_detect(Scsi_Host_Template *);
const char *ultrastor_info(struct Scsi_Host * shpnt);
int ultrastor_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int ultrastor_abort(Scsi_Cmnd *);
int ultrastor_reset(Scsi_Cmnd *, unsigned int);
-int ultrastor_biosparam(Disk *, kdev_t, int *);
+int ultrastor_biosparam(Disk *, struct block_device *, int *);
#define ULTRASTOR_14F_MAX_SG 16
/*
* This was borrowed directly from aha1542.c. (Zaga)
*/
-int wd7000_biosparam (Disk *disk, kdev_t dev, int *ip)
+int wd7000_biosparam (Disk *disk, struct block_device *bdev, int *ip)
{
- dprintk("wd7000_biosparam: dev=%s, size=%d, ", kdevname(dev),
+ dprintk("wd7000_biosparam: dev=%s, size=%d, ", bdevname(bdev),
disk->capacity);
/*
/*
* try to figure out the geometry from the partition table
*/
- if ((scsicam_bios_param (disk, dev, info) < 0) ||
+ if ((scsicam_bios_param (disk, bdev, info) < 0) ||
!(((info[0] == 64) && (info[1] == 32)) ||
((info[0] == 255) && (info[1] == 63)))) {
printk ("wd7000_biosparam: unable to verify geometry for disk with >1GB.\n"
*/
#include <linux/types.h>
-#include <linux/kdev_t.h>
int wd7000_set_info (char *buffer, int length, struct Scsi_Host *host);
int wd7000_proc_info (char *buffer, char **start, off_t offset, int length, int hostno, int inout);
int wd7000_queuecommand (Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int wd7000_abort (Scsi_Cmnd *);
int wd7000_reset (Scsi_Cmnd *, unsigned int);
-int wd7000_biosparam (Disk *, kdev_t, int *);
+int wd7000_biosparam (Disk *, struct block_device *, int *);
#ifndef NULL
#define NULL 0L
#ifndef SCSICAM_H
#define SCSICAM_H
-#include <linux/kdev_t.h>
-extern int scsicam_bios_param (Disk *disk, kdev_t dev, int *ip);
+extern int scsicam_bios_param (Disk *disk, struct block_device *bdev, int *ip);
extern int scsi_partsize(unsigned char *buf, unsigned long capacity,
unsigned int *cyls, unsigned int *hds, unsigned int *secs);
-extern unsigned char *scsi_bios_ptable(kdev_t dev);
+extern unsigned char *scsi_bios_ptable(struct block_device *bdev);
#endif /* def SCSICAM_H */
projects / history.git / commitdiff