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