Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'pull-getgeo' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs into for-6.18/block
Pull struct block_device getgeo changes from Al.
"switching ->getgeo() from struct block_device to struct gendisk
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>"
* tag 'pull-getgeo' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
block: switch ->getgeo() to struct gendisk
scsi: switch ->bios_param() to passing gendisk
scsi: switch scsi_bios_ptable() and scsi_partsize() to gendisk
+135
-134
+1
-1
Documentation/filesystems/locking.rst
+1
-1
Documentation/filesystems/locking.rst
···
443
443
int (*direct_access) (struct block_device *, sector_t, void **,
444
444
unsigned long *);
445
445
void (*unlock_native_capacity) (struct gendisk *);
446
-
int (*getgeo)(struct block_device *, struct hd_geometry *);
446
+
int (*getgeo)(struct gendisk *, struct hd_geometry *);
447
447
void (*swap_slot_free_notify) (struct block_device *, unsigned long);
448
448
449
449
locking rules:
+4
-4
Documentation/scsi/scsi_mid_low_api.rst
+4
-4
Documentation/scsi/scsi_mid_low_api.rst
···
380
380
381
381
/**
382
382
* scsi_bios_ptable - return copy of block device's partition table
383
-
* @dev: pointer to block device
383
+
* @dev: pointer to gendisk
384
384
*
385
385
* Returns pointer to partition table, or NULL for failure
386
386
*
···
390
390
*
391
391
* Defined in: drivers/scsi/scsicam.c
392
392
**/
393
-
unsigned char *scsi_bios_ptable(struct block_device *dev)
393
+
unsigned char *scsi_bios_ptable(struct gendisk *dev)
394
394
395
395
396
396
/**
···
623
623
* bios_param - fetch head, sector, cylinder info for a disk
624
624
* @sdev: pointer to scsi device context (defined in
625
625
* include/scsi/scsi_device.h)
626
-
* @bdev: pointer to block device context (defined in fs.h)
626
+
* @disk: pointer to gendisk (defined in blkdev.h)
627
627
* @capacity: device size (in 512 byte sectors)
628
628
* @params: three element array to place output:
629
629
* params[0] number of heads (max 255)
···
643
643
*
644
644
* Optionally defined in: LLD
645
645
**/
646
-
int bios_param(struct scsi_device * sdev, struct block_device *bdev,
646
+
int bios_param(struct scsi_device * sdev, struct gendisk *disk,
647
647
sector_t capacity, int params[3])
648
648
649
649
+2
-2
arch/m68k/emu/nfblock.c
+2
-2
arch/m68k/emu/nfblock.c
···
77
77
bio_endio(bio);
78
78
}
79
79
80
-
static int nfhd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
80
+
static int nfhd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
81
81
{
82
-
struct nfhd_device *dev = bdev->bd_disk->private_data;
82
+
struct nfhd_device *dev = disk->private_data;
83
83
84
84
geo->cylinders = dev->blocks >> (6 - dev->bshift);
85
85
geo->heads = 4;
+3
-3
arch/um/drivers/ubd_kern.c
+3
-3
arch/um/drivers/ubd_kern.c
···
108
108
109
109
static int ubd_ioctl(struct block_device *bdev, blk_mode_t mode,
110
110
unsigned int cmd, unsigned long arg);
111
-
static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
111
+
static int ubd_getgeo(struct gendisk *disk, struct hd_geometry *geo);
112
112
113
113
#define MAX_DEV (16)
114
114
···
1324
1324
return res;
1325
1325
}
1326
1326
1327
-
static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1327
+
static int ubd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1328
1328
{
1329
-
struct ubd *ubd_dev = bdev->bd_disk->private_data;
1329
+
struct ubd *ubd_dev = disk->private_data;
1330
1330
1331
1331
geo->heads = 128;
1332
1332
geo->sectors = 32;
+2
-2
block/ioctl.c
+2
-2
block/ioctl.c
···
481
481
*/
482
482
memset(&geo, 0, sizeof(geo));
483
483
geo.start = get_start_sect(bdev);
484
-
ret = disk->fops->getgeo(bdev, &geo);
484
+
ret = disk->fops->getgeo(disk, &geo);
485
485
if (ret)
486
486
return ret;
487
487
if (copy_to_user(argp, &geo, sizeof(geo)))
···
515
515
* want to override it.
516
516
*/
517
517
geo.start = get_start_sect(bdev);
518
-
ret = disk->fops->getgeo(bdev, &geo);
518
+
ret = disk->fops->getgeo(disk, &geo);
519
519
if (ret)
520
520
return ret;
521
521
+1
-1
block/partitions/ibm.c
+1
-1
block/partitions/ibm.c
···
358
358
goto out_nolab;
359
359
/* set start if not filled by getgeo function e.g. virtblk */
360
360
geo->start = get_start_sect(bdev);
361
-
if (disk->fops->getgeo(bdev, geo))
361
+
if (disk->fops->getgeo(disk, geo))
362
362
goto out_freeall;
363
363
if (!fn || fn(disk, info)) {
364
364
kfree(info);
+2
-2
drivers/ata/libata-scsi.c
+2
-2
drivers/ata/libata-scsi.c
···
351
351
/**
352
352
* ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
353
353
* @sdev: SCSI device for which BIOS geometry is to be determined
354
-
* @bdev: block device associated with @sdev
354
+
* @unused: gendisk associated with @sdev
355
355
* @capacity: capacity of SCSI device
356
356
* @geom: location to which geometry will be output
357
357
*
···
366
366
* RETURNS:
367
367
* Zero.
368
368
*/
369
-
int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
369
+
int ata_std_bios_param(struct scsi_device *sdev, struct gendisk *unused,
370
370
sector_t capacity, int geom[])
371
371
{
372
372
geom[0] = 255;
+5
-5
drivers/block/amiflop.c
+5
-5
drivers/block/amiflop.c
···
1523
1523
return BLK_STS_OK;
1524
1524
}
1525
1525
1526
-
static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1526
+
static int fd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1527
1527
{
1528
-
int drive = MINOR(bdev->bd_dev) & 3;
1528
+
struct amiga_floppy_struct *p = disk->private_data;
1529
1529
1530
-
geo->heads = unit[drive].type->heads;
1531
-
geo->sectors = unit[drive].dtype->sects * unit[drive].type->sect_mult;
1532
-
geo->cylinders = unit[drive].type->tracks;
1530
+
geo->heads = p->type->heads;
1531
+
geo->sectors = p->dtype->sects * p->type->sect_mult;
1532
+
geo->cylinders = p->type->tracks;
1533
1533
return 0;
1534
1534
}
1535
1535
+2
-2
drivers/block/aoe/aoeblk.c
+2
-2
drivers/block/aoe/aoeblk.c
···
269
269
}
270
270
271
271
static int
272
-
aoeblk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
272
+
aoeblk_getgeo(struct gendisk *disk, struct hd_geometry *geo)
273
273
{
274
-
struct aoedev *d = bdev->bd_disk->private_data;
274
+
struct aoedev *d = disk->private_data;
275
275
276
276
if ((d->flags & DEVFL_UP) == 0) {
277
277
printk(KERN_ERR "aoe: disk not up\n");
+2
-2
drivers/block/floppy.c
+2
-2
drivers/block/floppy.c
···
3361
3361
return 0;
3362
3362
}
3363
3363
3364
-
static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3364
+
static int fd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
3365
3365
{
3366
-
int drive = (long)bdev->bd_disk->private_data;
3366
+
int drive = (long)disk->private_data;
3367
3367
int type = ITYPE(drive_state[drive].fd_device);
3368
3368
struct floppy_struct *g;
3369
3369
int ret;
+3
-3
drivers/block/mtip32xx/mtip32xx.c
+3
-3
drivers/block/mtip32xx/mtip32xx.c
···
3148
3148
* that each partition is also 4KB aligned. Non-aligned partitions adversely
3149
3149
* affects performance.
3150
3150
*
3151
-
* @dev Pointer to the block_device strucutre.
3151
+
* @disk Pointer to the gendisk strucutre.
3152
3152
* @geo Pointer to a hd_geometry structure.
3153
3153
*
3154
3154
* return value
3155
3155
* 0 Operation completed successfully.
3156
3156
* -ENOTTY An error occurred while reading the drive capacity.
3157
3157
*/
3158
-
static int mtip_block_getgeo(struct block_device *dev,
3158
+
static int mtip_block_getgeo(struct gendisk *disk,
3159
3159
struct hd_geometry *geo)
3160
3160
{
3161
-
struct driver_data *dd = dev->bd_disk->private_data;
3161
+
struct driver_data *dd = disk->private_data;
3162
3162
sector_t capacity;
3163
3163
3164
3164
if (!dd)
+2
-2
drivers/block/rnbd/rnbd-clt.c
+2
-2
drivers/block/rnbd/rnbd-clt.c
···
942
942
rnbd_clt_put_dev(dev);
943
943
}
944
944
945
-
static int rnbd_client_getgeo(struct block_device *block_device,
945
+
static int rnbd_client_getgeo(struct gendisk *disk,
946
946
struct hd_geometry *geo)
947
947
{
948
948
u64 size;
949
-
struct rnbd_clt_dev *dev = block_device->bd_disk->private_data;
949
+
struct rnbd_clt_dev *dev = disk->private_data;
950
950
struct queue_limits *limit = &dev->queue->limits;
951
951
952
952
size = dev->size * (limit->logical_block_size / SECTOR_SIZE);
+1
-2
drivers/block/sunvdc.c
+1
-2
drivers/block/sunvdc.c
···
119
119
return vio_dring_avail(dr, VDC_TX_RING_SIZE);
120
120
}
121
121
122
-
static int vdc_getgeo(struct block_device *bdev, struct hd_geometry *geo)
122
+
static int vdc_getgeo(struct gendisk *disk, struct hd_geometry *geo)
123
123
{
124
-
struct gendisk *disk = bdev->bd_disk;
125
124
sector_t nsect = get_capacity(disk);
126
125
sector_t cylinders = nsect;
127
126
+2
-2
drivers/block/swim.c
+2
-2
drivers/block/swim.c
···
711
711
return -ENOTTY;
712
712
}
713
713
714
-
static int floppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
714
+
static int floppy_getgeo(struct gendisk *disk, struct hd_geometry *geo)
715
715
{
716
-
struct floppy_state *fs = bdev->bd_disk->private_data;
716
+
struct floppy_state *fs = disk->private_data;
717
717
struct floppy_struct *g;
718
718
int ret;
719
719
+3
-3
drivers/block/virtio_blk.c
+3
-3
drivers/block/virtio_blk.c
···
829
829
}
830
830
831
831
/* We provide getgeo only to please some old bootloader/partitioning tools */
832
-
static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
832
+
static int virtblk_getgeo(struct gendisk *disk, struct hd_geometry *geo)
833
833
{
834
-
struct virtio_blk *vblk = bd->bd_disk->private_data;
834
+
struct virtio_blk *vblk = disk->private_data;
835
835
int ret = 0;
836
836
837
837
mutex_lock(&vblk->vdev_mutex);
···
853
853
/* some standard values, similar to sd */
854
854
geo->heads = 1 << 6;
855
855
geo->sectors = 1 << 5;
856
-
geo->cylinders = get_capacity(bd->bd_disk) >> 11;
856
+
geo->cylinders = get_capacity(disk) >> 11;
857
857
}
858
858
out:
859
859
mutex_unlock(&vblk->vdev_mutex);
+2
-2
drivers/block/xen-blkfront.c
+2
-2
drivers/block/xen-blkfront.c
···
493
493
schedule_work(&rinfo->work);
494
494
}
495
495
496
-
static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
496
+
static int blkif_getgeo(struct gendisk *disk, struct hd_geometry *hg)
497
497
{
498
498
/* We don't have real geometry info, but let's at least return
499
499
values consistent with the size of the device */
500
-
sector_t nsect = get_capacity(bd->bd_disk);
500
+
sector_t nsect = get_capacity(disk);
501
501
sector_t cylinders = nsect;
502
502
503
503
hg->heads = 0xff;
+2
-2
drivers/md/dm.c
+2
-2
drivers/md/dm.c
···
403
403
dm_deferred_remove();
404
404
}
405
405
406
-
static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
406
+
static int dm_blk_getgeo(struct gendisk *disk, struct hd_geometry *geo)
407
407
{
408
-
struct mapped_device *md = bdev->bd_disk->private_data;
408
+
struct mapped_device *md = disk->private_data;
409
409
410
410
return dm_get_geometry(md, geo);
411
411
}
+2
-2
drivers/md/md.c
+2
-2
drivers/md/md.c
···
7747
7747
* 4 sectors (with a BIG number of cylinders...). This drives
7748
7748
* dosfs just mad... ;-)
7749
7749
*/
7750
-
static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
7750
+
static int md_getgeo(struct gendisk *disk, struct hd_geometry *geo)
7751
7751
{
7752
-
struct mddev *mddev = bdev->bd_disk->private_data;
7752
+
struct mddev *mddev = disk->private_data;
7753
7753
7754
7754
geo->heads = 2;
7755
7755
geo->sectors = 4;
+2
-2
drivers/memstick/core/ms_block.c
+2
-2
drivers/memstick/core/ms_block.c
···
1953
1953
msb->card = NULL;
1954
1954
}
1955
1955
1956
-
static int msb_bd_getgeo(struct block_device *bdev,
1956
+
static int msb_bd_getgeo(struct gendisk *disk,
1957
1957
struct hd_geometry *geo)
1958
1958
{
1959
-
struct msb_data *msb = bdev->bd_disk->private_data;
1959
+
struct msb_data *msb = disk->private_data;
1960
1960
*geo = msb->geometry;
1961
1961
return 0;
1962
1962
}
+2
-2
drivers/memstick/core/mspro_block.c
+2
-2
drivers/memstick/core/mspro_block.c
···
189
189
kfree(msb);
190
190
}
191
191
192
-
static int mspro_block_bd_getgeo(struct block_device *bdev,
192
+
static int mspro_block_bd_getgeo(struct gendisk *disk,
193
193
struct hd_geometry *geo)
194
194
{
195
-
struct mspro_block_data *msb = bdev->bd_disk->private_data;
195
+
struct mspro_block_data *msb = disk->private_data;
196
196
197
197
geo->heads = msb->heads;
198
198
geo->sectors = msb->sectors_per_track;
+1
-1
drivers/message/fusion/mptscsih.c
+1
-1
drivers/message/fusion/mptscsih.c
···
2074
2074
* This is anyones guess quite frankly.
2075
2075
*/
2076
2076
int
2077
-
mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
2077
+
mptscsih_bios_param(struct scsi_device * sdev, struct gendisk *unused,
2078
2078
sector_t capacity, int geom[])
2079
2079
{
2080
2080
int heads;
+1
-1
drivers/message/fusion/mptscsih.h
+1
-1
drivers/message/fusion/mptscsih.h
···
123
123
extern int mptscsih_dev_reset(struct scsi_cmnd * SCpnt);
124
124
extern int mptscsih_bus_reset(struct scsi_cmnd * SCpnt);
125
125
extern int mptscsih_host_reset(struct scsi_cmnd *SCpnt);
126
-
extern int mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev, sector_t capacity, int geom[]);
126
+
extern int mptscsih_bios_param(struct scsi_device * sdev, struct gendisk *unused, sector_t capacity, int geom[]);
127
127
extern int mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
128
128
extern int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
129
129
extern int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
+2
-2
drivers/mmc/core/block.c
+2
-2
drivers/mmc/core/block.c
···
435
435
}
436
436
437
437
static int
438
-
mmc_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
438
+
mmc_blk_getgeo(struct gendisk *disk, struct hd_geometry *geo)
439
439
{
440
-
geo->cylinders = get_capacity(bdev->bd_disk) / (4 * 16);
440
+
geo->cylinders = get_capacity(disk) / (4 * 16);
441
441
geo->heads = 4;
442
442
geo->sectors = 16;
443
443
return 0;
+2
-2
drivers/mtd/mtd_blkdevs.c
+2
-2
drivers/mtd/mtd_blkdevs.c
···
246
246
blktrans_dev_put(dev);
247
247
}
248
248
249
-
static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
249
+
static int blktrans_getgeo(struct gendisk *disk, struct hd_geometry *geo)
250
250
{
251
-
struct mtd_blktrans_dev *dev = bdev->bd_disk->private_data;
251
+
struct mtd_blktrans_dev *dev = disk->private_data;
252
252
int ret = -ENXIO;
253
253
254
254
mutex_lock(&dev->lock);
+2
-2
drivers/mtd/ubi/block.c
+2
-2
drivers/mtd/ubi/block.c
···
282
282
mutex_unlock(&dev->dev_mutex);
283
283
}
284
284
285
-
static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo)
285
+
static int ubiblock_getgeo(struct gendisk *disk, struct hd_geometry *geo)
286
286
{
287
287
/* Some tools might require this information */
288
288
geo->heads = 1;
289
289
geo->cylinders = 1;
290
-
geo->sectors = get_capacity(bdev->bd_disk);
290
+
geo->sectors = get_capacity(disk);
291
291
geo->start = 0;
292
292
return 0;
293
293
}
+2
-2
drivers/nvdimm/btt.c
+2
-2
drivers/nvdimm/btt.c
···
1478
1478
bio_endio(bio);
1479
1479
}
1480
1480
1481
-
static int btt_getgeo(struct block_device *bd, struct hd_geometry *geo)
1481
+
static int btt_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1482
1482
{
1483
1483
/* some standard values */
1484
1484
geo->heads = 1 << 6;
1485
1485
geo->sectors = 1 << 5;
1486
-
geo->cylinders = get_capacity(bd->bd_disk) >> 11;
1486
+
geo->cylinders = get_capacity(disk) >> 11;
1487
1487
return 0;
1488
1488
}
1489
1489
+2
-2
drivers/nvme/host/core.c
+2
-2
drivers/nvme/host/core.c
···
1803
1803
nvme_ns_release(disk->private_data);
1804
1804
}
1805
1805
1806
-
int nvme_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1806
+
int nvme_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1807
1807
{
1808
1808
/* some standard values */
1809
1809
geo->heads = 1 << 6;
1810
1810
geo->sectors = 1 << 5;
1811
-
geo->cylinders = get_capacity(bdev->bd_disk) >> 11;
1811
+
geo->cylinders = get_capacity(disk) >> 11;
1812
1812
return 0;
1813
1813
}
1814
1814
+1
-1
drivers/nvme/host/nvme.h
+1
-1
drivers/nvme/host/nvme.h
···
936
936
unsigned int issue_flags);
937
937
int nvme_identify_ns(struct nvme_ctrl *ctrl, unsigned nsid,
938
938
struct nvme_id_ns **id);
939
-
int nvme_getgeo(struct block_device *bdev, struct hd_geometry *geo);
939
+
int nvme_getgeo(struct gendisk *disk, struct hd_geometry *geo);
940
940
int nvme_dev_uring_cmd(struct io_uring_cmd *ioucmd, unsigned int issue_flags);
941
941
942
942
extern const struct attribute_group *nvme_ns_attr_groups[];
+4
-3
drivers/s390/block/dasd.c
+4
-3
drivers/s390/block/dasd.c
···
3317
3317
/*
3318
3318
* Return disk geometry.
3319
3319
*/
3320
-
static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3320
+
static int dasd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
3321
3321
{
3322
3322
struct dasd_device *base;
3323
3323
3324
-
base = dasd_device_from_gendisk(bdev->bd_disk);
3324
+
base = dasd_device_from_gendisk(disk);
3325
3325
if (!base)
3326
3326
return -ENODEV;
3327
3327
···
3331
3331
return -EINVAL;
3332
3332
}
3333
3333
base->discipline->fill_geometry(base->block, geo);
3334
-
geo->start = get_start_sect(bdev) >> base->block->s2b_shift;
3334
+
// geo->start is left unchanged by the above
3335
+
geo->start >>= base->block->s2b_shift;
3335
3336
dasd_put_device(base);
3336
3337
return 0;
3337
3338
}
+1
-1
drivers/scsi/3w-9xxx.c
+1
-1
drivers/scsi/3w-9xxx.c
···
1695
1695
} /* End twa_reset_sequence() */
1696
1696
1697
1697
/* This funciton returns unit geometry in cylinders/heads/sectors */
1698
-
static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1698
+
static int twa_scsi_biosparam(struct scsi_device *sdev, struct gendisk *unused, sector_t capacity, int geom[])
1699
1699
{
1700
1700
int heads, sectors, cylinders;
1701
1701
+1
-1
drivers/scsi/3w-sas.c
+1
-1
drivers/scsi/3w-sas.c
···
1404
1404
} /* End twl_reset_device_extension() */
1405
1405
1406
1406
/* This funciton returns unit geometry in cylinders/heads/sectors */
1407
-
static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1407
+
static int twl_scsi_biosparam(struct scsi_device *sdev, struct gendisk *unused, sector_t capacity, int geom[])
1408
1408
{
1409
1409
int heads, sectors;
1410
1410
+1
-1
drivers/scsi/3w-xxxx.c
+1
-1
drivers/scsi/3w-xxxx.c
···
1340
1340
} /* End tw_reset_device_extension() */
1341
1341
1342
1342
/* This funciton returns unit geometry in cylinders/heads/sectors */
1343
-
static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1343
+
static int tw_scsi_biosparam(struct scsi_device *sdev, struct gendisk *unused,
1344
1344
sector_t capacity, int geom[])
1345
1345
{
1346
1346
int heads, sectors, cylinders;
+2
-2
drivers/scsi/BusLogic.c
+2
-2
drivers/scsi/BusLogic.c
···
3240
3240
the BIOS, and a warning may be displayed.
3241
3241
*/
3242
3242
3243
-
static int blogic_diskparam(struct scsi_device *sdev, struct block_device *dev,
3243
+
static int blogic_diskparam(struct scsi_device *sdev, struct gendisk *disk,
3244
3244
sector_t capacity, int *params)
3245
3245
{
3246
3246
struct blogic_adapter *adapter =
···
3261
3261
diskparam->sectors = 32;
3262
3262
}
3263
3263
diskparam->cylinders = (unsigned long) capacity / (diskparam->heads * diskparam->sectors);
3264
-
buf = scsi_bios_ptable(dev);
3264
+
buf = scsi_bios_ptable(disk);
3265
3265
if (buf == NULL)
3266
3266
return 0;
3267
3267
/*
+1
-1
drivers/scsi/BusLogic.h
+1
-1
drivers/scsi/BusLogic.h
···
1273
1273
1274
1274
static const char *blogic_drvr_info(struct Scsi_Host *);
1275
1275
static int blogic_qcmd(struct Scsi_Host *h, struct scsi_cmnd *);
1276
-
static int blogic_diskparam(struct scsi_device *, struct block_device *, sector_t, int *);
1276
+
static int blogic_diskparam(struct scsi_device *, struct gendisk *, sector_t, int *);
1277
1277
static int blogic_sdev_configure(struct scsi_device *,
1278
1278
struct queue_limits *lim);
1279
1279
static void blogic_qcompleted_ccb(struct blogic_ccb *);
+3
-3
drivers/scsi/aacraid/linit.c
+3
-3
drivers/scsi/aacraid/linit.c
···
273
273
/**
274
274
* aac_biosparm - return BIOS parameters for disk
275
275
* @sdev: The scsi device corresponding to the disk
276
-
* @bdev: the block device corresponding to the disk
276
+
* @disk: the gendisk corresponding to the disk
277
277
* @capacity: the sector capacity of the disk
278
278
* @geom: geometry block to fill in
279
279
*
···
292
292
* be displayed.
293
293
*/
294
294
295
-
static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev,
295
+
static int aac_biosparm(struct scsi_device *sdev, struct gendisk *disk,
296
296
sector_t capacity, int *geom)
297
297
{
298
298
struct diskparm *param = (struct diskparm *)geom;
···
324
324
* entry whose end_head matches one of the standard geometry
325
325
* translations ( 64/32, 128/32, 255/63 ).
326
326
*/
327
-
buf = scsi_bios_ptable(bdev);
327
+
buf = scsi_bios_ptable(disk);
328
328
if (!buf)
329
329
return 0;
330
330
if (*(__le16 *)(buf + 0x40) == cpu_to_le16(MSDOS_LABEL_MAGIC)) {
+1
-1
drivers/scsi/advansys.c
+1
-1
drivers/scsi/advansys.c
···
7096
7096
* ip[2]: cylinders
7097
7097
*/
7098
7098
static int
7099
-
advansys_biosparam(struct scsi_device *sdev, struct block_device *bdev,
7099
+
advansys_biosparam(struct scsi_device *sdev, struct gendisk *unused,
7100
7100
sector_t capacity, int ip[])
7101
7101
{
7102
7102
struct asc_board *boardp = shost_priv(sdev->host);
+2
-2
drivers/scsi/aha152x.c
+2
-2
drivers/scsi/aha152x.c
···
1246
1246
* Return the "logical geometry"
1247
1247
*
1248
1248
*/
1249
-
static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1249
+
static int aha152x_biosparam(struct scsi_device *sdev, struct gendisk *disk,
1250
1250
sector_t capacity, int *info_array)
1251
1251
{
1252
1252
struct Scsi_Host *shpnt = sdev->host;
···
1261
1261
int info[3];
1262
1262
1263
1263
/* try to figure out the geometry from the partition table */
1264
-
if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1264
+
if (scsicam_bios_param(disk, capacity, info) < 0 ||
1265
1265
!((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1266
1266
if (EXT_TRANS) {
1267
1267
printk(KERN_NOTICE
+1
-1
drivers/scsi/aha1542.c
+1
-1
drivers/scsi/aha1542.c
+1
-1
drivers/scsi/aha1740.c
+1
-1
drivers/scsi/aha1740.c
+2
-2
drivers/scsi/aic7xxx/aic79xx_osm.c
+2
-2
drivers/scsi/aic7xxx/aic79xx_osm.c
···
720
720
* Return the disk geometry for the given SCSI device.
721
721
*/
722
722
static int
723
-
ahd_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
723
+
ahd_linux_biosparam(struct scsi_device *sdev, struct gendisk *disk,
724
724
sector_t capacity, int geom[])
725
725
{
726
726
int heads;
···
731
731
732
732
ahd = *((struct ahd_softc **)sdev->host->hostdata);
733
733
734
-
if (scsi_partsize(bdev, capacity, geom))
734
+
if (scsi_partsize(disk, capacity, geom))
735
735
return 0;
736
736
737
737
heads = 64;
+2
-2
drivers/scsi/aic7xxx/aic7xxx_osm.c
+2
-2
drivers/scsi/aic7xxx/aic7xxx_osm.c
···
683
683
* Return the disk geometry for the given SCSI device.
684
684
*/
685
685
static int
686
-
ahc_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
686
+
ahc_linux_biosparam(struct scsi_device *sdev, struct gendisk *disk,
687
687
sector_t capacity, int geom[])
688
688
{
689
689
int heads;
···
696
696
ahc = *((struct ahc_softc **)sdev->host->hostdata);
697
697
channel = sdev_channel(sdev);
698
698
699
-
if (scsi_partsize(bdev, capacity, geom))
699
+
if (scsi_partsize(disk, capacity, geom))
700
700
return 0;
701
701
702
702
heads = 64;
+3
-3
drivers/scsi/arcmsr/arcmsr_hba.c
+3
-3
drivers/scsi/arcmsr/arcmsr_hba.c
···
112
112
static int arcmsr_abort(struct scsi_cmnd *);
113
113
static int arcmsr_bus_reset(struct scsi_cmnd *);
114
114
static int arcmsr_bios_param(struct scsi_device *sdev,
115
-
struct block_device *bdev, sector_t capacity, int *info);
115
+
struct gendisk *disk, sector_t capacity, int *info);
116
116
static int arcmsr_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
117
117
static int arcmsr_probe(struct pci_dev *pdev,
118
118
const struct pci_device_id *id);
···
377
377
}
378
378
379
379
static int arcmsr_bios_param(struct scsi_device *sdev,
380
-
struct block_device *bdev, sector_t capacity, int *geom)
380
+
struct gendisk *disk, sector_t capacity, int *geom)
381
381
{
382
382
int heads, sectors, cylinders, total_capacity;
383
383
384
-
if (scsi_partsize(bdev, capacity, geom))
384
+
if (scsi_partsize(disk, capacity, geom))
385
385
return 0;
386
386
387
387
total_capacity = capacity;
+1
-1
drivers/scsi/atp870u.c
+1
-1
drivers/scsi/atp870u.c
···
1692
1692
}
1693
1693
1694
1694
1695
-
static int atp870u_biosparam(struct scsi_device *disk, struct block_device *dev,
1695
+
static int atp870u_biosparam(struct scsi_device *disk, struct gendisk *unused,
1696
1696
sector_t capacity, int *ip)
1697
1697
{
1698
1698
int heads, sectors, cylinders;
+2
-2
drivers/scsi/fdomain.c
+2
-2
drivers/scsi/fdomain.c
···
469
469
}
470
470
471
471
static int fdomain_biosparam(struct scsi_device *sdev,
472
-
struct block_device *bdev, sector_t capacity,
472
+
struct gendisk *disk, sector_t capacity,
473
473
int geom[])
474
474
{
475
-
unsigned char *p = scsi_bios_ptable(bdev);
475
+
unsigned char *p = scsi_bios_ptable(disk);
476
476
477
477
if (p && p[65] == 0xaa && p[64] == 0x55 /* Partition table valid */
478
478
&& p[4]) { /* Partition type */
+1
-1
drivers/scsi/imm.c
+1
-1
drivers/scsi/imm.c
···
954
954
* be done in sd.c. Even if it gets fixed there, this will still
955
955
* work.
956
956
*/
957
-
static int imm_biosparam(struct scsi_device *sdev, struct block_device *dev,
957
+
static int imm_biosparam(struct scsi_device *sdev, struct gendisk *unused,
958
958
sector_t capacity, int ip[])
959
959
{
960
960
ip[0] = 0x40;
+2
-2
drivers/scsi/initio.c
+2
-2
drivers/scsi/initio.c
···
2645
2645
/**
2646
2646
* i91u_biosparam - return the "logical geometry
2647
2647
* @sdev: SCSI device
2648
-
* @dev: Matching block device
2648
+
* @unused: Matching gendisk
2649
2649
* @capacity: Sector size of drive
2650
2650
* @info_array: Return space for BIOS geometry
2651
2651
*
···
2655
2655
* FIXME: limited to 2^32 sector devices.
2656
2656
*/
2657
2657
2658
-
static int i91u_biosparam(struct scsi_device *sdev, struct block_device *dev,
2658
+
static int i91u_biosparam(struct scsi_device *sdev, struct gendisk *unused,
2659
2659
sector_t capacity, int *info_array)
2660
2660
{
2661
2661
struct initio_host *host; /* Point to Host adapter control block */
+4
-4
drivers/scsi/ipr.c
+4
-4
drivers/scsi/ipr.c
···
4644
4644
4645
4645
/**
4646
4646
* ipr_biosparam - Return the HSC mapping
4647
-
* @sdev: scsi device struct
4648
-
* @block_device: block device pointer
4647
+
* @sdev: scsi device struct
4648
+
* @unused: gendisk pointer
4649
4649
* @capacity: capacity of the device
4650
-
* @parm: Array containing returned HSC values.
4650
+
* @parm: Array containing returned HSC values.
4651
4651
*
4652
4652
* This function generates the HSC parms that fdisk uses.
4653
4653
* We want to make sure we return something that places partitions
···
4657
4657
* 0 on success
4658
4658
**/
4659
4659
static int ipr_biosparam(struct scsi_device *sdev,
4660
-
struct block_device *block_device,
4660
+
struct gendisk *unused,
4661
4661
sector_t capacity, int *parm)
4662
4662
{
4663
4663
int heads, sectors;
+1
-1
drivers/scsi/ips.c
+1
-1
drivers/scsi/ips.c
···
1123
1123
/* Set bios geometry for the controller */
1124
1124
/* */
1125
1125
/****************************************************************************/
1126
-
static int ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1126
+
static int ips_biosparam(struct scsi_device *sdev, struct gendisk *unused,
1127
1127
sector_t capacity, int geom[])
1128
1128
{
1129
1129
ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
+1
-1
drivers/scsi/ips.h
+1
-1
drivers/scsi/ips.h
···
398
398
/*
399
399
* Scsi_Host Template
400
400
*/
401
-
static int ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
401
+
static int ips_biosparam(struct scsi_device *sdev, struct gendisk *unused,
402
402
sector_t capacity, int geom[]);
403
403
static int ips_sdev_configure(struct scsi_device *SDptr,
404
404
struct queue_limits *lim);
+1
-1
drivers/scsi/libsas/sas_scsi_host.c
+1
-1
drivers/scsi/libsas/sas_scsi_host.c
+2
-2
drivers/scsi/megaraid.c
+2
-2
drivers/scsi/megaraid.c
···
2780
2780
* Return the disk geometry for a particular disk
2781
2781
*/
2782
2782
static int
2783
-
megaraid_biosparam(struct scsi_device *sdev, struct block_device *bdev,
2783
+
megaraid_biosparam(struct scsi_device *sdev, struct gendisk *disk,
2784
2784
sector_t capacity, int geom[])
2785
2785
{
2786
2786
adapter_t *adapter;
···
2813
2813
geom[2] = cylinders;
2814
2814
}
2815
2815
else {
2816
-
if (scsi_partsize(bdev, capacity, geom))
2816
+
if (scsi_partsize(disk, capacity, geom))
2817
2817
return 0;
2818
2818
2819
2819
dev_info(&adapter->dev->dev,
+1
-1
drivers/scsi/megaraid.h
+1
-1
drivers/scsi/megaraid.h
···
975
975
static int megaraid_abort(struct scsi_cmnd *);
976
976
static int megaraid_reset(struct scsi_cmnd *);
977
977
static int megaraid_abort_and_reset(adapter_t *, struct scsi_cmnd *, int);
978
-
static int megaraid_biosparam(struct scsi_device *, struct block_device *,
978
+
static int megaraid_biosparam(struct scsi_device *, struct gendisk *,
979
979
sector_t, int []);
980
980
981
981
static int mega_build_sglist (adapter_t *adapter, scb_t *scb,
+2
-2
drivers/scsi/megaraid/megaraid_sas_base.c
+2
-2
drivers/scsi/megaraid/megaraid_sas_base.c
···
3137
3137
/**
3138
3138
* megasas_bios_param - Returns disk geometry for a disk
3139
3139
* @sdev: device handle
3140
-
* @bdev: block device
3140
+
* @unused: gendisk
3141
3141
* @capacity: drive capacity
3142
3142
* @geom: geometry parameters
3143
3143
*/
3144
3144
static int
3145
-
megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
3145
+
megasas_bios_param(struct scsi_device *sdev, struct gendisk *unused,
3146
3146
sector_t capacity, int geom[])
3147
3147
{
3148
3148
int heads;
+2
-2
drivers/scsi/mpi3mr/mpi3mr_os.c
+2
-2
drivers/scsi/mpi3mr/mpi3mr_os.c
···
4031
4031
/**
4032
4032
* mpi3mr_bios_param - BIOS param callback
4033
4033
* @sdev: SCSI device reference
4034
-
* @bdev: Block device reference
4034
+
* @unused: gendisk reference
4035
4035
* @capacity: Capacity in logical sectors
4036
4036
* @params: Parameter array
4037
4037
*
···
4040
4040
* Return: 0 always
4041
4041
*/
4042
4042
static int mpi3mr_bios_param(struct scsi_device *sdev,
4043
-
struct block_device *bdev, sector_t capacity, int params[])
4043
+
struct gendisk *unused, sector_t capacity, int params[])
4044
4044
{
4045
4045
int heads;
4046
4046
int sectors;
+2
-2
drivers/scsi/mpt3sas/mpt3sas_scsih.c
+2
-2
drivers/scsi/mpt3sas/mpt3sas_scsih.c
···
2754
2754
/**
2755
2755
* scsih_bios_param - fetch head, sector, cylinder info for a disk
2756
2756
* @sdev: scsi device struct
2757
-
* @bdev: pointer to block device context
2757
+
* @unused: pointer to gendisk
2758
2758
* @capacity: device size (in 512 byte sectors)
2759
2759
* @params: three element array to place output:
2760
2760
* params[0] number of heads (max 255)
···
2762
2762
* params[2] number of cylinders
2763
2763
*/
2764
2764
static int
2765
-
scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2765
+
scsih_bios_param(struct scsi_device *sdev, struct gendisk *unused,
2766
2766
sector_t capacity, int params[])
2767
2767
{
2768
2768
int heads;
+1
-1
drivers/scsi/mvumi.c
+1
-1
drivers/scsi/mvumi.c
+1
-1
drivers/scsi/myrb.c
+1
-1
drivers/scsi/myrb.c
···
1745
1745
kfree(sdev->hostdata);
1746
1746
}
1747
1747
1748
-
static int myrb_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1748
+
static int myrb_biosparam(struct scsi_device *sdev, struct gendisk *unused,
1749
1749
sector_t capacity, int geom[])
1750
1750
{
1751
1751
struct myrb_hba *cb = shost_priv(sdev->host);
+1
-1
drivers/scsi/pcmcia/sym53c500_cs.c
+1
-1
drivers/scsi/pcmcia/sym53c500_cs.c
+1
-1
drivers/scsi/ppa.c
+1
-1
drivers/scsi/ppa.c
···
845
845
* be done in sd.c. Even if it gets fixed there, this will still
846
846
* work.
847
847
*/
848
-
static int ppa_biosparam(struct scsi_device *sdev, struct block_device *dev,
848
+
static int ppa_biosparam(struct scsi_device *sdev, struct gendisk *unused,
849
849
sector_t capacity, int ip[])
850
850
{
851
851
ip[0] = 0x40;
+1
-1
drivers/scsi/qla1280.c
+1
-1
drivers/scsi/qla1280.c
+1
-1
drivers/scsi/qlogicfas408.c
+1
-1
drivers/scsi/qlogicfas408.c
···
492
492
* Return bios parameters
493
493
*/
494
494
495
-
int qlogicfas408_biosparam(struct scsi_device *disk, struct block_device *dev,
495
+
int qlogicfas408_biosparam(struct scsi_device *disk, struct gendisk *unused,
496
496
sector_t capacity, int ip[])
497
497
{
498
498
/* This should mimic the DOS Qlogic driver's behavior exactly */
+1
-1
drivers/scsi/qlogicfas408.h
+1
-1
drivers/scsi/qlogicfas408.h
···
106
106
irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id);
107
107
int qlogicfas408_queuecommand(struct Scsi_Host *h, struct scsi_cmnd * cmd);
108
108
int qlogicfas408_biosparam(struct scsi_device * disk,
109
-
struct block_device *dev,
109
+
struct gendisk *unused,
110
110
sector_t capacity, int ip[]);
111
111
int qlogicfas408_abort(struct scsi_cmnd * cmd);
112
112
extern int qlogicfas408_host_reset(struct scsi_cmnd *cmd);
+8
-8
drivers/scsi/scsicam.c
+8
-8
drivers/scsi/scsicam.c
···
30
30
* starting at offset %0x1be.
31
31
* Returns: partition table in kmalloc(GFP_KERNEL) memory, or NULL on error.
32
32
*/
33
-
unsigned char *scsi_bios_ptable(struct block_device *dev)
33
+
unsigned char *scsi_bios_ptable(struct gendisk *dev)
34
34
{
35
-
struct address_space *mapping = bdev_whole(dev)->bd_mapping;
35
+
struct address_space *mapping = dev->part0->bd_mapping;
36
36
unsigned char *res = NULL;
37
37
struct folio *folio;
38
38
···
48
48
49
49
/**
50
50
* scsi_partsize - Parse cylinders/heads/sectors from PC partition table
51
-
* @bdev: block device to parse
51
+
* @disk: gendisk of the disk to parse
52
52
* @capacity: size of the disk in sectors
53
53
* @geom: output in form of [hds, cylinders, sectors]
54
54
*
···
57
57
*
58
58
* Returns: %false on failure, %true on success.
59
59
*/
60
-
bool scsi_partsize(struct block_device *bdev, sector_t capacity, int geom[3])
60
+
bool scsi_partsize(struct gendisk *disk, sector_t capacity, int geom[3])
61
61
{
62
62
int cyl, ext_cyl, end_head, end_cyl, end_sector;
63
63
unsigned int logical_end, physical_end, ext_physical_end;
···
65
65
void *buf;
66
66
int ret = false;
67
67
68
-
buf = scsi_bios_ptable(bdev);
68
+
buf = scsi_bios_ptable(disk);
69
69
if (!buf)
70
70
return false;
71
71
···
205
205
206
206
/**
207
207
* scsicam_bios_param - Determine geometry of a disk in cylinders/heads/sectors.
208
-
* @bdev: which device
208
+
* @disk: which device
209
209
* @capacity: size of the disk in sectors
210
210
* @ip: return value: ip[0]=heads, ip[1]=sectors, ip[2]=cylinders
211
211
*
···
215
215
*
216
216
* Returns : -1 on failure, 0 on success.
217
217
*/
218
-
int scsicam_bios_param(struct block_device *bdev, sector_t capacity, int *ip)
218
+
int scsicam_bios_param(struct gendisk *disk, sector_t capacity, int *ip)
219
219
{
220
220
u64 capacity64 = capacity; /* Suppress gcc warning */
221
221
int ret = 0;
222
222
223
223
/* try to infer mapping from partition table */
224
-
if (scsi_partsize(bdev, capacity, ip))
224
+
if (scsi_partsize(disk, capacity, ip))
225
225
return 0;
226
226
227
227
if (capacity64 < (1ULL << 32)) {
+4
-4
drivers/scsi/sd.c
+4
-4
drivers/scsi/sd.c
···
1599
1599
scsi_device_put(sdev);
1600
1600
}
1601
1601
1602
-
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1602
+
static int sd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1603
1603
{
1604
-
struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
1604
+
struct scsi_disk *sdkp = scsi_disk(disk);
1605
1605
struct scsi_device *sdp = sdkp->device;
1606
1606
struct Scsi_Host *host = sdp->host;
1607
1607
sector_t capacity = logical_to_sectors(sdp, sdkp->capacity);
···
1614
1614
1615
1615
/* override with calculated, extended default, or driver values */
1616
1616
if (host->hostt->bios_param)
1617
-
host->hostt->bios_param(sdp, bdev, capacity, diskinfo);
1617
+
host->hostt->bios_param(sdp, disk, capacity, diskinfo);
1618
1618
else
1619
-
scsicam_bios_param(bdev, capacity, diskinfo);
1619
+
scsicam_bios_param(disk, capacity, diskinfo);
1620
1620
1621
1621
geo->heads = diskinfo[0];
1622
1622
geo->sectors = diskinfo[1];
+1
-1
drivers/scsi/stex.c
+1
-1
drivers/scsi/stex.c
+1
-1
drivers/scsi/storvsc_drv.c
+1
-1
drivers/scsi/storvsc_drv.c
···
1615
1615
return 0;
1616
1616
}
1617
1617
1618
-
static int storvsc_get_chs(struct scsi_device *sdev, struct block_device * bdev,
1618
+
static int storvsc_get_chs(struct scsi_device *sdev, struct gendisk *unused,
1619
1619
sector_t capacity, int *info)
1620
1620
{
1621
1621
sector_t nsect = capacity;
+1
-1
drivers/scsi/wd719x.c
+1
-1
drivers/scsi/wd719x.c
···
544
544
return wd719x_chip_init(wd) == 0 ? SUCCESS : FAILED;
545
545
}
546
546
547
-
static int wd719x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
547
+
static int wd719x_biosparam(struct scsi_device *sdev, struct gendisk *unused,
548
548
sector_t capacity, int geom[])
549
549
{
550
550
if (capacity >= 0x200000) {
+1
-1
include/linux/blkdev.h
+1
-1
include/linux/blkdev.h
···
1660
1660
unsigned int (*check_events) (struct gendisk *disk,
1661
1661
unsigned int clearing);
1662
1662
void (*unlock_native_capacity) (struct gendisk *);
1663
-
int (*getgeo)(struct block_device *, struct hd_geometry *);
1663
+
int (*getgeo)(struct gendisk *, struct hd_geometry *);
1664
1664
int (*set_read_only)(struct block_device *bdev, bool ro);
1665
1665
void (*free_disk)(struct gendisk *disk);
1666
1666
/* this callback is with swap_lock and sometimes page table lock held */
+1
-1
include/linux/libata.h
+1
-1
include/linux/libata.h
···
1203
1203
extern u64 ata_qc_get_active(struct ata_port *ap);
1204
1204
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd);
1205
1205
extern int ata_std_bios_param(struct scsi_device *sdev,
1206
-
struct block_device *bdev,
1206
+
struct gendisk *unused,
1207
1207
sector_t capacity, int geom[]);
1208
1208
extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
1209
1209
extern int ata_scsi_sdev_init(struct scsi_device *sdev);
+1
-1
include/scsi/libsas.h
+1
-1
include/scsi/libsas.h
···
685
685
extern int sas_target_alloc(struct scsi_target *);
686
686
int sas_sdev_configure(struct scsi_device *dev, struct queue_limits *lim);
687
687
extern int sas_change_queue_depth(struct scsi_device *, int new_depth);
688
-
extern int sas_bios_param(struct scsi_device *, struct block_device *,
688
+
extern int sas_bios_param(struct scsi_device *, struct gendisk *,
689
689
sector_t capacity, int *hsc);
690
690
int sas_execute_internal_abort_single(struct domain_device *device,
691
691
u16 tag, unsigned int qid,
+1
-1
include/scsi/scsi_host.h
+1
-1
include/scsi/scsi_host.h
+4
-3
include/scsi/scsicam.h
+4
-3
include/scsi/scsicam.h
···
13
13
14
14
#ifndef SCSICAM_H
15
15
#define SCSICAM_H
16
-
int scsicam_bios_param(struct block_device *bdev, sector_t capacity, int *ip);
17
-
bool scsi_partsize(struct block_device *bdev, sector_t capacity, int geom[3]);
18
-
unsigned char *scsi_bios_ptable(struct block_device *bdev);
16
+
struct gendisk;
17
+
int scsicam_bios_param(struct gendisk *disk, sector_t capacity, int *ip);
18
+
bool scsi_partsize(struct gendisk *disk, sector_t capacity, int geom[3]);
19
+
unsigned char *scsi_bios_ptable(struct gendisk *disk);
19
20
#endif /* def SCSICAM_H */