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