1 /* 2 * ide bus support for qdev. 3 * 4 * Copyright (c) 2009 Gerd Hoffmann <kraxel@redhat.com> 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include "qemu/osdep.h" 21 #include "hw/hw.h" 22 #include "sysemu/dma.h" 23 #include "qapi/error.h" 24 #include "qemu/error-report.h" 25 #include "qemu/module.h" 26 #include "hw/ide/internal.h" 27 #include "sysemu/block-backend.h" 28 #include "sysemu/blockdev.h" 29 #include "hw/block/block.h" 30 #include "sysemu/sysemu.h" 31 #include "qapi/visitor.h" 32 33 /* --------------------------------- */ 34 35 static char *idebus_get_fw_dev_path(DeviceState *dev); 36 static void idebus_unrealize(BusState *qdev, Error **errp); 37 38 static Property ide_props[] = { 39 DEFINE_PROP_UINT32("unit", IDEDevice, unit, -1), 40 DEFINE_PROP_END_OF_LIST(), 41 }; 42 43 static void ide_bus_class_init(ObjectClass *klass, void *data) 44 { 45 BusClass *k = BUS_CLASS(klass); 46 47 k->get_fw_dev_path = idebus_get_fw_dev_path; 48 k->unrealize = idebus_unrealize; 49 } 50 51 static void idebus_unrealize(BusState *bus, Error **errp) 52 { 53 IDEBus *ibus = IDE_BUS(bus); 54 55 if (ibus->vmstate) { 56 qemu_del_vm_change_state_handler(ibus->vmstate); 57 } 58 } 59 60 static const TypeInfo ide_bus_info = { 61 .name = TYPE_IDE_BUS, 62 .parent = TYPE_BUS, 63 .instance_size = sizeof(IDEBus), 64 .class_init = ide_bus_class_init, 65 }; 66 67 void ide_bus_new(IDEBus *idebus, size_t idebus_size, DeviceState *dev, 68 int bus_id, int max_units) 69 { 70 qbus_create_inplace(idebus, idebus_size, TYPE_IDE_BUS, dev, NULL); 71 idebus->bus_id = bus_id; 72 idebus->max_units = max_units; 73 } 74 75 static char *idebus_get_fw_dev_path(DeviceState *dev) 76 { 77 char path[30]; 78 79 snprintf(path, sizeof(path), "%s@%x", qdev_fw_name(dev), 80 ((IDEBus*)dev->parent_bus)->bus_id); 81 82 return g_strdup(path); 83 } 84 85 static void ide_qdev_realize(DeviceState *qdev, Error **errp) 86 { 87 IDEDevice *dev = IDE_DEVICE(qdev); 88 IDEDeviceClass *dc = IDE_DEVICE_GET_CLASS(dev); 89 IDEBus *bus = DO_UPCAST(IDEBus, qbus, qdev->parent_bus); 90 91 if (dev->unit == -1) { 92 dev->unit = bus->master ? 1 : 0; 93 } 94 95 if (dev->unit >= bus->max_units) { 96 error_setg(errp, "Can't create IDE unit %d, bus supports only %d units", 97 dev->unit, bus->max_units); 98 return; 99 } 100 101 switch (dev->unit) { 102 case 0: 103 if (bus->master) { 104 error_setg(errp, "IDE unit %d is in use", dev->unit); 105 return; 106 } 107 bus->master = dev; 108 break; 109 case 1: 110 if (bus->slave) { 111 error_setg(errp, "IDE unit %d is in use", dev->unit); 112 return; 113 } 114 bus->slave = dev; 115 break; 116 default: 117 error_setg(errp, "Invalid IDE unit %d", dev->unit); 118 return; 119 } 120 dc->realize(dev, errp); 121 } 122 123 IDEDevice *ide_create_drive(IDEBus *bus, int unit, DriveInfo *drive) 124 { 125 DeviceState *dev; 126 127 dev = qdev_create(&bus->qbus, drive->media_cd ? "ide-cd" : "ide-hd"); 128 qdev_prop_set_uint32(dev, "unit", unit); 129 qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(drive), 130 &error_fatal); 131 qdev_init_nofail(dev); 132 return DO_UPCAST(IDEDevice, qdev, dev); 133 } 134 135 int ide_get_geometry(BusState *bus, int unit, 136 int16_t *cyls, int8_t *heads, int8_t *secs) 137 { 138 IDEState *s = &DO_UPCAST(IDEBus, qbus, bus)->ifs[unit]; 139 140 if (s->drive_kind != IDE_HD || !s->blk) { 141 return -1; 142 } 143 144 *cyls = s->cylinders; 145 *heads = s->heads; 146 *secs = s->sectors; 147 return 0; 148 } 149 150 int ide_get_bios_chs_trans(BusState *bus, int unit) 151 { 152 return DO_UPCAST(IDEBus, qbus, bus)->ifs[unit].chs_trans; 153 } 154 155 /* --------------------------------- */ 156 157 typedef struct IDEDrive { 158 IDEDevice dev; 159 } IDEDrive; 160 161 static void ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind, Error **errp) 162 { 163 IDEBus *bus = DO_UPCAST(IDEBus, qbus, dev->qdev.parent_bus); 164 IDEState *s = bus->ifs + dev->unit; 165 int ret; 166 167 if (!dev->conf.blk) { 168 if (kind != IDE_CD) { 169 error_setg(errp, "No drive specified"); 170 return; 171 } else { 172 /* Anonymous BlockBackend for an empty drive */ 173 dev->conf.blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL); 174 ret = blk_attach_dev(dev->conf.blk, &dev->qdev); 175 assert(ret == 0); 176 } 177 } 178 179 if (dev->conf.discard_granularity == -1) { 180 dev->conf.discard_granularity = 512; 181 } else if (dev->conf.discard_granularity && 182 dev->conf.discard_granularity != 512) { 183 error_setg(errp, "discard_granularity must be 512 for ide"); 184 return; 185 } 186 187 blkconf_blocksizes(&dev->conf); 188 if (dev->conf.logical_block_size != 512) { 189 error_setg(errp, "logical_block_size must be 512 for IDE"); 190 return; 191 } 192 193 if (kind != IDE_CD) { 194 if (!blkconf_geometry(&dev->conf, &dev->chs_trans, 65535, 16, 255, 195 errp)) { 196 return; 197 } 198 } 199 if (!blkconf_apply_backend_options(&dev->conf, kind == IDE_CD, 200 kind != IDE_CD, errp)) { 201 return; 202 } 203 204 if (ide_init_drive(s, dev->conf.blk, kind, 205 dev->version, dev->serial, dev->model, dev->wwn, 206 dev->conf.cyls, dev->conf.heads, dev->conf.secs, 207 dev->chs_trans, errp) < 0) { 208 return; 209 } 210 211 if (!dev->version) { 212 dev->version = g_strdup(s->version); 213 } 214 if (!dev->serial) { 215 dev->serial = g_strdup(s->drive_serial_str); 216 } 217 218 add_boot_device_path(dev->conf.bootindex, &dev->qdev, 219 dev->unit ? "/disk@1" : "/disk@0"); 220 } 221 222 static void ide_dev_get_bootindex(Object *obj, Visitor *v, const char *name, 223 void *opaque, Error **errp) 224 { 225 IDEDevice *d = IDE_DEVICE(obj); 226 227 visit_type_int32(v, name, &d->conf.bootindex, errp); 228 } 229 230 static void ide_dev_set_bootindex(Object *obj, Visitor *v, const char *name, 231 void *opaque, Error **errp) 232 { 233 IDEDevice *d = IDE_DEVICE(obj); 234 int32_t boot_index; 235 Error *local_err = NULL; 236 237 visit_type_int32(v, name, &boot_index, &local_err); 238 if (local_err) { 239 goto out; 240 } 241 /* check whether bootindex is present in fw_boot_order list */ 242 check_boot_index(boot_index, &local_err); 243 if (local_err) { 244 goto out; 245 } 246 /* change bootindex to a new one */ 247 d->conf.bootindex = boot_index; 248 249 if (d->unit != -1) { 250 add_boot_device_path(d->conf.bootindex, &d->qdev, 251 d->unit ? "/disk@1" : "/disk@0"); 252 } 253 out: 254 error_propagate(errp, local_err); 255 } 256 257 static void ide_dev_instance_init(Object *obj) 258 { 259 object_property_add(obj, "bootindex", "int32", 260 ide_dev_get_bootindex, 261 ide_dev_set_bootindex, NULL, NULL, NULL); 262 object_property_set_int(obj, -1, "bootindex", NULL); 263 } 264 265 static void ide_hd_realize(IDEDevice *dev, Error **errp) 266 { 267 ide_dev_initfn(dev, IDE_HD, errp); 268 } 269 270 static void ide_cd_realize(IDEDevice *dev, Error **errp) 271 { 272 ide_dev_initfn(dev, IDE_CD, errp); 273 } 274 275 static void ide_drive_realize(IDEDevice *dev, Error **errp) 276 { 277 DriveInfo *dinfo = NULL; 278 279 if (dev->conf.blk) { 280 dinfo = blk_legacy_dinfo(dev->conf.blk); 281 } 282 283 ide_dev_initfn(dev, dinfo && dinfo->media_cd ? IDE_CD : IDE_HD, errp); 284 } 285 286 #define DEFINE_IDE_DEV_PROPERTIES() \ 287 DEFINE_BLOCK_PROPERTIES(IDEDrive, dev.conf), \ 288 DEFINE_BLOCK_ERROR_PROPERTIES(IDEDrive, dev.conf), \ 289 DEFINE_PROP_STRING("ver", IDEDrive, dev.version), \ 290 DEFINE_PROP_UINT64("wwn", IDEDrive, dev.wwn, 0), \ 291 DEFINE_PROP_STRING("serial", IDEDrive, dev.serial),\ 292 DEFINE_PROP_STRING("model", IDEDrive, dev.model) 293 294 static Property ide_hd_properties[] = { 295 DEFINE_IDE_DEV_PROPERTIES(), 296 DEFINE_BLOCK_CHS_PROPERTIES(IDEDrive, dev.conf), 297 DEFINE_PROP_BIOS_CHS_TRANS("bios-chs-trans", 298 IDEDrive, dev.chs_trans, BIOS_ATA_TRANSLATION_AUTO), 299 DEFINE_PROP_UINT16("rotation_rate", IDEDrive, dev.rotation_rate, 0), 300 DEFINE_PROP_END_OF_LIST(), 301 }; 302 303 static void ide_hd_class_init(ObjectClass *klass, void *data) 304 { 305 DeviceClass *dc = DEVICE_CLASS(klass); 306 IDEDeviceClass *k = IDE_DEVICE_CLASS(klass); 307 308 k->realize = ide_hd_realize; 309 dc->fw_name = "drive"; 310 dc->desc = "virtual IDE disk"; 311 dc->props = ide_hd_properties; 312 } 313 314 static const TypeInfo ide_hd_info = { 315 .name = "ide-hd", 316 .parent = TYPE_IDE_DEVICE, 317 .instance_size = sizeof(IDEDrive), 318 .class_init = ide_hd_class_init, 319 }; 320 321 static Property ide_cd_properties[] = { 322 DEFINE_IDE_DEV_PROPERTIES(), 323 DEFINE_PROP_END_OF_LIST(), 324 }; 325 326 static void ide_cd_class_init(ObjectClass *klass, void *data) 327 { 328 DeviceClass *dc = DEVICE_CLASS(klass); 329 IDEDeviceClass *k = IDE_DEVICE_CLASS(klass); 330 331 k->realize = ide_cd_realize; 332 dc->fw_name = "drive"; 333 dc->desc = "virtual IDE CD-ROM"; 334 dc->props = ide_cd_properties; 335 } 336 337 static const TypeInfo ide_cd_info = { 338 .name = "ide-cd", 339 .parent = TYPE_IDE_DEVICE, 340 .instance_size = sizeof(IDEDrive), 341 .class_init = ide_cd_class_init, 342 }; 343 344 static Property ide_drive_properties[] = { 345 DEFINE_IDE_DEV_PROPERTIES(), 346 DEFINE_PROP_END_OF_LIST(), 347 }; 348 349 static void ide_drive_class_init(ObjectClass *klass, void *data) 350 { 351 DeviceClass *dc = DEVICE_CLASS(klass); 352 IDEDeviceClass *k = IDE_DEVICE_CLASS(klass); 353 354 k->realize = ide_drive_realize; 355 dc->fw_name = "drive"; 356 dc->desc = "virtual IDE disk or CD-ROM (legacy)"; 357 dc->props = ide_drive_properties; 358 } 359 360 static const TypeInfo ide_drive_info = { 361 .name = "ide-drive", 362 .parent = TYPE_IDE_DEVICE, 363 .instance_size = sizeof(IDEDrive), 364 .class_init = ide_drive_class_init, 365 }; 366 367 static void ide_device_class_init(ObjectClass *klass, void *data) 368 { 369 DeviceClass *k = DEVICE_CLASS(klass); 370 k->realize = ide_qdev_realize; 371 set_bit(DEVICE_CATEGORY_STORAGE, k->categories); 372 k->bus_type = TYPE_IDE_BUS; 373 k->props = ide_props; 374 } 375 376 static const TypeInfo ide_device_type_info = { 377 .name = TYPE_IDE_DEVICE, 378 .parent = TYPE_DEVICE, 379 .instance_size = sizeof(IDEDevice), 380 .abstract = true, 381 .class_size = sizeof(IDEDeviceClass), 382 .class_init = ide_device_class_init, 383 .instance_init = ide_dev_instance_init, 384 }; 385 386 static void ide_register_types(void) 387 { 388 type_register_static(&ide_bus_info); 389 type_register_static(&ide_hd_info); 390 type_register_static(&ide_cd_info); 391 type_register_static(&ide_drive_info); 392 type_register_static(&ide_device_type_info); 393 } 394 395 type_init(ide_register_types) 396