static int
mfi_syspd_attach(device_t dev)
{
struct mfi_system_pd *sc;
struct mfi_pd_info *pd_info;
struct disk_info info;
uint64_t sectors;
uint32_t secsize;
sc = device_get_softc(dev);
pd_info = device_get_ivars(dev);
sc->pd_dev = dev;
sc->pd_id = pd_info->ref.v.device_id;
sc->pd_unit = device_get_unit(dev);
sc->pd_info = pd_info;
sc->pd_controller = device_get_softc(device_get_parent(dev));
sc->pd_flags = MFI_DISK_FLAGS_SYSPD;
sectors = pd_info->raw_size;
secsize = MFI_SECTOR_LEN;
lockmgr(&sc->pd_controller->mfi_io_lock, LK_EXCLUSIVE);
TAILQ_INSERT_TAIL(&sc->pd_controller->mfi_syspd_tqh, sc, pd_link);
lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE);
device_printf(dev, "%juMB (%ju sectors) SYSPD volume\n",
sectors / (1024 * 1024 / secsize), sectors);
devstat_add_entry(&sc->pd_devstat, "mfisyspd", device_get_unit(dev),
MFI_SECTOR_LEN, DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER,
DEVSTAT_PRIORITY_ARRAY);
sc->pd_dev_t = disk_create(sc->pd_unit, &sc->pd_disk, &mfi_syspd_ops);
sc->pd_dev_t->si_drv1 = sc;
sc->pd_dev_t->si_iosize_max = sc->pd_controller->mfi_max_io *
secsize;
bzero(&info, sizeof(info));
info.d_media_blksize = secsize; /* mandatory */
info.d_media_blocks = sectors;
if (info.d_media_blocks >= (1 * 1024 * 1024)) {
info.d_nheads = 255;
info.d_secpertrack = 63;
} else {
info.d_nheads = 64;
info.d_secpertrack = 32;
}
disk_setdiskinfo(&sc->pd_disk, &info);
return (0);
}
static int
ipsd_attach(device_t dev)
{
device_t adapter;
ipsdisk_softc_t *dsc;
struct disk_info info;
u_int totalsectors;
u_int nheads, nsectors;
DEVICE_PRINTF(2, dev, "in attach\n");
dsc = (ipsdisk_softc_t *)device_get_softc(dev);
bzero(dsc, sizeof(ipsdisk_softc_t));
adapter = device_get_parent(dev);
dsc->dev = dev;
dsc->sc = device_get_softc(adapter);
dsc->unit = device_get_unit(dev);
dsc->disk_number = (uintptr_t) device_get_ivars(dev);
totalsectors = dsc->sc->drives[dsc->disk_number].sector_count;
if ((totalsectors > 0x400000) &&
((dsc->sc->adapter_info.miscflags & 0x8) == 0)) {
nheads = IPS_NORM_HEADS;
nsectors = IPS_NORM_SECTORS;
} else {
nheads = IPS_COMP_HEADS;
nsectors = IPS_COMP_SECTORS;
}
devstat_add_entry(&dsc->stats, "ipsd", dsc->unit, DEV_BSIZE,
DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_SCSI,
DEVSTAT_PRIORITY_DISK);
dsc->ipsd_dev_t = disk_create(dsc->unit, &dsc->ipsd_disk, &ipsd_ops);
dsc->ipsd_dev_t->si_drv1 = dsc;
dsc->ipsd_dev_t->si_iosize_max = IPS_MAX_IO_SIZE;
bzero(&info, sizeof(info));
info.d_media_blksize = IPS_BLKSIZE; /* mandatory */
info.d_media_blocks = totalsectors;
info.d_type = DTYPE_ESDI; /* optional */
info.d_nheads = nheads;
info.d_secpertrack = nsectors;
info.d_ncylinders = totalsectors / nheads / nsectors;
info.d_secpercyl = nsectors / nheads;
disk_setdiskinfo(&dsc->ipsd_disk, &info);
device_printf(dev, "Logical Drive (%dMB)\n",
dsc->sc->drives[dsc->disk_number].sector_count >> 11);
return 0;
}
static int
afd_open(struct dev_open_args *ap)
{
device_t dev = ap->a_head.a_dev->si_drv1;
struct ata_device *atadev = device_get_softc(dev);
struct afd_softc *fdp = device_get_ivars(dev);
struct disk_info info;
if (!fdp)
return ENXIO;
if (!device_is_attached(dev))
return EBUSY;
afd_test_ready(dev);
afd_prevent_allow(dev, 1);
if (afd_sense(dev))
device_printf(dev, "sense media type failed\n");
atadev->flags &= ~ATA_D_MEDIA_CHANGED;
if (!fdp->mediasize)
return ENXIO;
bzero(&info, sizeof(info));
info.d_media_blksize = fdp->sectorsize; /* mandatory */
info.d_media_size = fdp->mediasize; /* (this is in bytes) */
info.d_secpertrack = fdp->sectors; /* optional */
info.d_nheads = fdp->heads;
info.d_ncylinders =
((fdp->mediasize/fdp->sectorsize)/fdp->sectors)/fdp->heads;
info.d_secpercyl = fdp->sectors * fdp->heads;
disk_setdiskinfo(&fdp->disk, &info);
return 0;
}
static int
idad_open(struct dev_open_args *ap)
{
cdev_t dev = ap->a_head.a_dev;
struct idad_softc *drv;
drv = idad_getsoftc(dev);
if (drv == NULL)
return (ENXIO);
#if 0
bzero(&info, sizeof(info));
info.d_media_blksize = drv->secsize; /* mandatory */
info.d_media_blocks = drv->secperunit;
info.d_secpertrack = drv->sectors; /* optional */
info.d_type = DTYPE_SCSI;
info.d_nheads = drv->heads;
info.d_ncylinders = drv->cylinders;
info.d_secpercyl = drv->sectors * drv->heads;
disk_setdiskinfo(&drv->disk, &info);
#endif
return (0);
}
static int
ad_attach(device_t dev)
{
struct ata_channel *ch = device_get_softc(device_get_parent(dev));
struct ata_device *atadev = device_get_softc(dev);
struct disk_info info;
struct ad_softc *adp;
cdev_t cdev;
u_int32_t lbasize;
u_int64_t lbasize48;
/* check that we have a virgin disk to attach */
if (device_get_ivars(dev))
return EEXIST;
adp = kmalloc(sizeof(struct ad_softc), M_AD, M_INTWAIT | M_ZERO);
device_set_ivars(dev, adp);
if ((atadev->param.atavalid & ATA_FLAG_54_58) &&
atadev->param.current_heads && atadev->param.current_sectors) {
adp->heads = atadev->param.current_heads;
adp->sectors = atadev->param.current_sectors;
adp->total_secs = (u_int32_t)atadev->param.current_size_1 |
((u_int32_t)atadev->param.current_size_2 << 16);
}
else {
adp->heads = atadev->param.heads;
adp->sectors = atadev->param.sectors;
adp->total_secs = atadev->param.cylinders * adp->heads * adp->sectors;
}
lbasize = (u_int32_t)atadev->param.lba_size_1 |
((u_int32_t)atadev->param.lba_size_2 << 16);
/* does this device need oldstyle CHS addressing */
if (!ad_version(atadev->param.version_major) || !lbasize)
atadev->flags |= ATA_D_USE_CHS;
/* use the 28bit LBA size if valid or bigger than the CHS mapping */
if (atadev->param.cylinders == 16383 || adp->total_secs < lbasize)
adp->total_secs = lbasize;
/* use the 48bit LBA size if valid */
lbasize48 = ((u_int64_t)atadev->param.lba_size48_1) |
((u_int64_t)atadev->param.lba_size48_2 << 16) |
((u_int64_t)atadev->param.lba_size48_3 << 32) |
((u_int64_t)atadev->param.lba_size48_4 << 48);
if ((atadev->param.support.command2 & ATA_SUPPORT_ADDRESS48) &&
lbasize48 > ATA_MAX_28BIT_LBA)
adp->total_secs = lbasize48;
/* init device parameters */
ad_init(dev);
/* create the disk device */
/* XXX TGEN Maybe use DEVSTAT_ALL_SUPPORTED, DEVSTAT_TYPE_DIRECT,
DEVSTAT_PRIORITY_MAX. */
devstat_add_entry(&adp->stats, "ad", device_get_unit(dev), DEV_BSIZE,
DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_IDE,
DEVSTAT_PRIORITY_DISK);
cdev = disk_create(device_get_unit(dev), &adp->disk, &ad_ops);
cdev->si_drv1 = dev;
if (ch->dma)
cdev->si_iosize_max = ch->dma->max_iosize;
else
cdev->si_iosize_max = DFLTPHYS;
adp->cdev = cdev;
bzero(&info, sizeof(info));
info.d_media_blksize = DEV_BSIZE; /* mandatory */
info.d_media_blocks = adp->total_secs;
info.d_secpertrack = adp->sectors; /* optional */
info.d_nheads = adp->heads;
info.d_ncylinders = adp->total_secs/(adp->heads*adp->sectors);
info.d_secpercyl = adp->sectors * adp->heads;
info.d_serialno = atadev->param.serial;
device_add_child(dev, "subdisk", device_get_unit(dev));
bus_generic_attach(dev);
/* announce we are here */
ad_describe(dev);
disk_setdiskinfo(&adp->disk, &info);
return 0;
}
static int
mfi_disk_attach(device_t dev)
{
struct mfi_disk *sc;
struct mfi_ld_info *ld_info;
struct disk_info info;
uint64_t sectors;
uint32_t secsize;
char *state;
sc = device_get_softc(dev);
ld_info = device_get_ivars(dev);
sc->ld_dev = dev;
sc->ld_id = ld_info->ld_config.properties.ld.v.target_id;
sc->ld_unit = device_get_unit(dev);
sc->ld_info = ld_info;
sc->ld_controller = device_get_softc(device_get_parent(dev));
sc->ld_flags = 0;
sectors = ld_info->size;
secsize = MFI_SECTOR_LEN;
lockmgr(&sc->ld_controller->mfi_io_lock, LK_EXCLUSIVE);
TAILQ_INSERT_TAIL(&sc->ld_controller->mfi_ld_tqh, sc, ld_link);
lockmgr(&sc->ld_controller->mfi_io_lock, LK_RELEASE);
switch (ld_info->ld_config.params.state) {
case MFI_LD_STATE_OFFLINE:
state = "offline";
break;
case MFI_LD_STATE_PARTIALLY_DEGRADED:
state = "partially degraded";
break;
case MFI_LD_STATE_DEGRADED:
state = "degraded";
break;
case MFI_LD_STATE_OPTIMAL:
state = "optimal";
break;
default:
state = "unknown";
break;
}
device_printf(dev, "%juMB (%ju sectors) RAID volume '%s' is %s\n",
sectors / (1024 * 1024 / secsize), sectors,
ld_info->ld_config.properties.name,
state);
devstat_add_entry(&sc->ld_devstat, "mfid", device_get_unit(dev),
MFI_SECTOR_LEN, DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER,
DEVSTAT_PRIORITY_ARRAY);
sc->ld_dev_t = disk_create(sc->ld_unit, &sc->ld_disk, &mfi_disk_ops);
sc->ld_dev_t->si_drv1 = sc;
sc->ld_dev_t->si_iosize_max =
min(sc->ld_controller->mfi_max_io * secsize,
(sc->ld_controller->mfi_max_sge - 1) * PAGE_SIZE);
bzero(&info, sizeof(info));
info.d_media_blksize = secsize; /* mandatory */
info.d_media_blocks = sectors;
if (info.d_media_blocks >= (1 * 1024 * 1024)) {
info.d_nheads = 255;
info.d_secpertrack = 63;
} else {
info.d_nheads = 64;
info.d_secpertrack = 32;
}
disk_setdiskinfo(&sc->ld_disk, &info);
return (0);
}
static int
idad_attach(device_t dev)
{
struct ida_drive_info dinfo;
struct disk_info info;
struct idad_softc *drv;
device_t parent;
cdev_t dsk;
int error;
drv = (struct idad_softc *)device_get_softc(dev);
parent = device_get_parent(dev);
drv->controller = (struct ida_softc *)device_get_softc(parent);
drv->unit = device_get_unit(dev);
drv->drive = drv->controller->num_drives;
drv->controller->num_drives++;
error = ida_command(drv->controller, CMD_GET_LOG_DRV_INFO,
&dinfo, sizeof(dinfo), drv->drive, 0, DMA_DATA_IN);
if (error) {
device_printf(dev, "CMD_GET_LOG_DRV_INFO failed\n");
return (ENXIO);
}
drv->cylinders = dinfo.ncylinders;
drv->heads = dinfo.nheads;
drv->sectors = dinfo.nsectors;
drv->secsize = dinfo.secsize == 0 ? 512 : dinfo.secsize;
drv->secperunit = dinfo.secperunit;
/* XXX
* other initialization
*/
device_printf(dev, "%uMB (%u sectors), blocksize=%d\n",
drv->secperunit / ((1024 * 1024) / drv->secsize),
drv->secperunit, drv->secsize);
devstat_add_entry(&drv->stats, "idad", drv->unit, drv->secsize,
DEVSTAT_NO_ORDERED_TAGS,
DEVSTAT_TYPE_STORARRAY| DEVSTAT_TYPE_IF_OTHER,
DEVSTAT_PRIORITY_ARRAY);
dsk = disk_create(drv->unit, &drv->disk, &id_ops);
dsk->si_drv1 = drv;
dsk->si_iosize_max = DFLTPHYS; /* XXX guess? */
/*
* Set disk info, as it appears that all needed data is available already.
* Setting the disk info will also cause the probing to start.
*/
bzero(&info, sizeof(info));
info.d_media_blksize = drv->secsize; /* mandatory */
info.d_media_blocks = drv->secperunit;
info.d_secpertrack = drv->sectors; /* optional */
info.d_type = DTYPE_SCSI;
info.d_nheads = drv->heads;
info.d_ncylinders = drv->cylinders;
info.d_secpercyl = drv->sectors * drv->heads;
disk_setdiskinfo(&drv->disk, &info);
return (0);
}
