Archipelago » qemu

int is_windows_drive(const char *filename);

#endif

typedef struct BlockConf {

    uint16_t physical_block_size;

    uint16_t logical_block_size;

    uint16_t min_io_size;

}

#define DEFINE_BLOCK_PROPERTIES(_state, _conf)                          \

    DEFINE_PROP_UINT16("logical_block_size", _state,                    \

                       _conf.logical_block_size, 512),                  \

    DEFINE_PROP_UINT16("physical_block_size", _state,                   \

} FDiskFlags;

typedef struct FDrive {

    BlockDriverState *bs;

    /* Drive status */

    FDriveType drive;

static void fd_init(FDrive *drv)

{

    /* Drive */

    drv->drive = FDRIVE_DRV_NONE;

    drv->perpendicular = 0;

    /* Disk */

    dev = isa_create("isa-fdc");

    if (fds[0]) {

    }

    if (fds[1]) {

    }

    if (qdev_init(&dev->qdev) < 0)

        return NULL;

    fdctrl = &sys->state;

    fdctrl->dma_chann = dma_chann; /* FIXME */

    if (fds[0]) {

    }

    if (fds[1]) {

    }

    qdev_init_nofail(dev);

    sysbus_connect_irq(&sys->busdev, 0, irq);

    dev = qdev_create(NULL, "SUNW,fdtwo");

    if (fds[0]) {

    }

    qdev_init_nofail(dev);

    sys = DO_UPCAST(FDCtrlSysBus, busdev.qdev, dev);

    .qdev.vmsd  = &vmstate_isa_fdc,

    .qdev.reset = fdctrl_external_reset_isa,

    .qdev.props = (Property[]) {

        DEFINE_PROP_END_OF_LIST(),

    },

};

    .qdev.vmsd  = &vmstate_sysbus_fdc,

    .qdev.reset = fdctrl_external_reset_sysbus,

    .qdev.props = (Property[]) {

        DEFINE_PROP_END_OF_LIST(),

    },

};

    .qdev.vmsd  = &vmstate_sysbus_fdc,

    .qdev.reset = fdctrl_external_reset_sysbus,

    .qdev.props = (Property[]) {

        DEFINE_PROP_END_OF_LIST(),

    },

};

    ide_clear_hob(bus);

}

                    const char *version, const char *serial)

{

    int cylinders, heads, secs;

    uint64_t nb_sectors;

    s->cylinders = cylinders;

    s->heads = heads;

    s->sectors = secs;

    s->smart_autosave = 1;

    s->smart_errors = 0;

    s->smart_selftest_count = 0;

        s->is_cdrom = 1;

    }

        strncpy(s->drive_serial_str, serial, sizeof(s->drive_serial_str));

    } else {

        snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),

        dinfo = i == 0 ? hd0 : hd1;

        ide_init1(bus, i);

        if (dinfo) {

        } else {

            ide_reset(&bus->ifs[i]);

        }

void ide_data_writel(void *opaque, uint32_t addr, uint32_t val);

uint32_t ide_data_readl(void *opaque, uint32_t addr);

                    const char *version, const char *serial);

void ide_init2(IDEBus *bus, qemu_irq irq);

void ide_init2_with_non_qdev_drives(IDEBus *bus, DriveInfo *hd0,

    IDEDeviceInfo *info = DO_UPCAST(IDEDeviceInfo, qdev, base);

    IDEBus *bus = DO_UPCAST(IDEBus, qbus, qdev->parent_bus);

        fprintf(stderr, "%s: no drive specified\n", qdev->info->name);

        goto err;

    }

    dev = qdev_create(&bus->qbus, "ide-drive");

    qdev_prop_set_uint32(dev, "unit", unit);

    qdev_init_nofail(dev);

    return DO_UPCAST(IDEDevice, qdev, dev);

}

    IDEBus *bus = DO_UPCAST(IDEBus, qbus, dev->qdev.parent_bus);

    IDEState *s = bus->ifs + dev->unit;

    const char *serial;

    serial = dev->serial;

    if (!serial) {

        /* try to fall back to value set with legacy -drive serial=... */

    }

    if (!dev->version) {

        dev->version = qemu_strdup(s->version);

     * specified).

     */

    dinfo->unit = qemu_opt_get_number(dinfo->opts, "unit", -1);

    if (!scsidev) {

        return -1;

    }

            return NULL;

        }

        dev = pci_create(bus, devfn, "virtio-blk-pci");

        if (qdev_init(&dev->qdev) < 0)

            dev = NULL;

        break;

static int parse_drive(DeviceState *dev, Property *prop, const char *str)

{

        return -ENOENT;

    return 0;

}

static void free_drive(DeviceState *dev, Property *prop)

{

    if (*ptr) {

    }

}

static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len)

{

}

PropertyInfo qdev_prop_drive = {

    .name  = "drive",

    .type  = PROP_TYPE_DRIVE,

    .parse = parse_drive,

    .print = print_drive,

    .free  = free_drive,

    qdev_prop_set(dev, name, &value, PROP_TYPE_STRING);

}

{

    qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE);

}

    DEFINE_PROP(_n, _s, _f, qdev_prop_netdev, VLANClientState*)

#define DEFINE_PROP_VLAN(_n, _s, _f)             \

    DEFINE_PROP(_n, _s, _f, qdev_prop_vlan, VLANState*)

#define DEFINE_PROP_MACADDR(_n, _s, _f)         \

    DEFINE_PROP(_n, _s, _f, qdev_prop_macaddr, MACAddr)

void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value);

void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value);

void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value);

void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value);

/* FIXME: Remove opaque pointer properties.  */

void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value);

        }

        dev = qdev_create((BusState *)s390_bus, "virtio-blk-s390");

        qdev_init_nofail(dev);

    }

}

}

/* handle legacy '-drive if=scsi,...' cmd line args */

{

    const char *driver;

    DeviceState *dev;

    dev = qdev_create(&bus->qbus, driver);

    qdev_prop_set_uint32(dev, "scsi-id", unit);

    if (qdev_init(dev) < 0)

        return NULL;

    return DO_UPCAST(SCSIDevice, qdev, dev);

        if (dinfo == NULL) {

            continue;

        }

            res = -1;

            break;

        }

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);

    scsi_disk_purge_requests(s);

}

static int scsi_disk_initfn(SCSIDevice *dev)

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);

        error_report("scsi-disk: drive property not set");

        return -1;

    }

    if (!s->serial) {

    }

    if (!s->version) {

        r = DO_UPCAST(SCSIGenericReq, req, QTAILQ_FIRST(&s->qdev.requests));

        scsi_remove_request(r);

    }

}

static int scsi_generic_initfn(SCSIDevice *dev)

    int sg_version;

    struct sg_scsi_id scsiid;

        error_report("scsi-generic: drive property not set");

        return -1;

    }

    /* check we are really using a /dev/sg* file */

    if (!bdrv_is_sg(s->bs)) {

    return DO_UPCAST(SCSIBus, qbus, d->qdev.parent_bus);

}

int scsi_bus_legacy_handle_cmdline(SCSIBus *bus);

void scsi_dev_clear_sense(SCSIDevice *dev);

static int usb_msd_initfn(USBDevice *dev)

{

    MSDState *s = DO_UPCAST(MSDState, dev, dev);

        error_report("usb-msd: drive property not set");

        return -1;

    }

     *

     * The hack is probably a bad idea.

     */

    s->dev.speed = USB_SPEED_FULL;

    scsi_bus_new(&s->bus, &s->dev.qdev, 0, 1, usb_msd_command_complete);

    if (!s->scsi_dev) {

        return -1;

    }

    s->bus.qbus.allow_hotplug = 0;

    usb_msd_handle_reset(dev);

        if (cur_mon) {

            s->dev.auto_attach = 0;

        } else {

            autostart = 0;

    if (!dev) {

        return NULL;

    }

    if (qdev_init(&dev->qdev) < 0)

        return NULL;

    s->vdev.get_config = virtio_blk_update_config;

    s->vdev.get_features = virtio_blk_get_features;

    s->vdev.reset = virtio_blk_reset;

    s->conf = conf;

    s->rq = NULL;

    s->sector_mask = (s->conf->logical_block_size / BDRV_SECTOR_SIZE) - 1;

        proxy->class_code != PCI_CLASS_STORAGE_OTHER)

        proxy->class_code = PCI_CLASS_STORAGE_SCSI;

        error_report("virtio-blk-pci: drive property not set");

        return -1;

    }

{

    VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);

    return virtio_exit_pci(pci_dev);

}