1 /* 2 * QEMU Macintosh floppy disk controller emulator (SWIM) 3 * 4 * Copyright (c) 2014-2018 Laurent Vivier <laurent@vivier.eu> 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2. See 7 * the COPYING file in the top-level directory. 8 * 9 * Only the basic support: it allows to switch from IWM (Integrated WOZ 10 * Machine) mode to the SWIM mode and makes the linux driver happy. 11 */ 12 13 #include "qemu/osdep.h" 14 #include "qemu/main-loop.h" 15 #include "qapi/error.h" 16 #include "sysemu/block-backend.h" 17 #include "hw/sysbus.h" 18 #include "migration/vmstate.h" 19 #include "hw/block/block.h" 20 #include "hw/block/swim.h" 21 #include "hw/qdev-properties.h" 22 #include "trace.h" 23 24 25 /* IWM latch bits */ 26 27 #define IWMLB_PHASE0 0 28 #define IWMLB_PHASE1 1 29 #define IWMLB_PHASE2 2 30 #define IWMLB_PHASE3 3 31 #define IWMLB_MOTORON 4 32 #define IWMLB_DRIVESEL 5 33 #define IWMLB_L6 6 34 #define IWMLB_L7 7 35 36 /* IWM registers */ 37 38 #define IWM_READALLONES 0 39 #define IWM_READDATA 1 40 #define IWM_READSTATUS0 2 41 #define IWM_READSTATUS1 3 42 #define IWM_READWHANDSHAKE0 4 43 #define IWM_READWHANDSHAKE1 5 44 #define IWM_WRITESETMODE 6 45 #define IWM_WRITEDATA 7 46 47 /* SWIM registers */ 48 49 #define SWIM_WRITE_DATA 0 50 #define SWIM_WRITE_MARK 1 51 #define SWIM_WRITE_CRC 2 52 #define SWIM_WRITE_PARAMETER 3 53 #define SWIM_WRITE_PHASE 4 54 #define SWIM_WRITE_SETUP 5 55 #define SWIM_WRITE_MODE0 6 56 #define SWIM_WRITE_MODE1 7 57 58 #define SWIM_READ_DATA 8 59 #define SWIM_READ_MARK 9 60 #define SWIM_READ_ERROR 10 61 #define SWIM_READ_PARAMETER 11 62 #define SWIM_READ_PHASE 12 63 #define SWIM_READ_SETUP 13 64 #define SWIM_READ_STATUS 14 65 #define SWIM_READ_HANDSHAKE 15 66 67 #define REG_SHIFT 9 68 69 #define SWIM_MODE_STATUS_BIT 6 70 #define SWIM_MODE_IWM 0 71 #define SWIM_MODE_ISM 1 72 73 /* bits in phase register */ 74 75 #define SWIM_SEEK_NEGATIVE 0x074 76 #define SWIM_STEP 0x071 77 #define SWIM_MOTOR_ON 0x072 78 #define SWIM_MOTOR_OFF 0x076 79 #define SWIM_INDEX 0x073 80 #define SWIM_EJECT 0x077 81 #define SWIM_SETMFM 0x171 82 #define SWIM_SETGCR 0x175 83 #define SWIM_RELAX 0x033 84 #define SWIM_LSTRB 0x008 85 #define SWIM_CA_MASK 0x077 86 87 /* Select values for swim_select and swim_readbit */ 88 89 #define SWIM_READ_DATA_0 0x074 90 #define SWIM_TWOMEG_DRIVE 0x075 91 #define SWIM_SINGLE_SIDED 0x076 92 #define SWIM_DRIVE_PRESENT 0x077 93 #define SWIM_DISK_IN 0x170 94 #define SWIM_WRITE_PROT 0x171 95 #define SWIM_TRACK_ZERO 0x172 96 #define SWIM_TACHO 0x173 97 #define SWIM_READ_DATA_1 0x174 98 #define SWIM_MFM_MODE 0x175 99 #define SWIM_SEEK_COMPLETE 0x176 100 #define SWIM_ONEMEG_MEDIA 0x177 101 102 /* Bits in handshake register */ 103 104 #define SWIM_MARK_BYTE 0x01 105 #define SWIM_CRC_ZERO 0x02 106 #define SWIM_RDDATA 0x04 107 #define SWIM_SENSE 0x08 108 #define SWIM_MOTEN 0x10 109 #define SWIM_ERROR 0x20 110 #define SWIM_DAT2BYTE 0x40 111 #define SWIM_DAT1BYTE 0x80 112 113 /* bits in setup register */ 114 115 #define SWIM_S_INV_WDATA 0x01 116 #define SWIM_S_3_5_SELECT 0x02 117 #define SWIM_S_GCR 0x04 118 #define SWIM_S_FCLK_DIV2 0x08 119 #define SWIM_S_ERROR_CORR 0x10 120 #define SWIM_S_IBM_DRIVE 0x20 121 #define SWIM_S_GCR_WRITE 0x40 122 #define SWIM_S_TIMEOUT 0x80 123 124 /* bits in mode register */ 125 126 #define SWIM_CLFIFO 0x01 127 #define SWIM_ENBL1 0x02 128 #define SWIM_ENBL2 0x04 129 #define SWIM_ACTION 0x08 130 #define SWIM_WRITE_MODE 0x10 131 #define SWIM_HEDSEL 0x20 132 #define SWIM_MOTON 0x80 133 134 static const char *iwm_reg_names[] = { 135 "READALLONES", "READDATA", "READSTATUS0", "READSTATUS1", 136 "READWHANDSHAKE0", "READWHANDSHAKE1", "WRITESETMODE", "WRITEDATA" 137 }; 138 139 static const char *ism_reg_names[] = { 140 "WRITE_DATA", "WRITE_MARK", "WRITE_CRC", "WRITE_PARAMETER", 141 "WRITE_PHASE", "WRITE_SETUP", "WRITE_MODE0", "WRITE_MODE1", 142 "READ_DATA", "READ_MARK", "READ_ERROR", "READ_PARAMETER", 143 "READ_PHASE", "READ_SETUP", "READ_STATUS", "READ_HANDSHAKE" 144 }; 145 146 static void fd_recalibrate(FDrive *drive) 147 { 148 } 149 150 static void swim_change_cb(void *opaque, bool load, Error **errp) 151 { 152 FDrive *drive = opaque; 153 154 if (!load) { 155 blk_set_perm(drive->blk, 0, BLK_PERM_ALL, &error_abort); 156 } else { 157 if (!blkconf_apply_backend_options(drive->conf, 158 !blk_supports_write_perm(drive->blk), 159 false, errp)) { 160 return; 161 } 162 } 163 } 164 165 static const BlockDevOps swim_block_ops = { 166 .change_media_cb = swim_change_cb, 167 }; 168 169 static Property swim_drive_properties[] = { 170 DEFINE_PROP_INT32("unit", SWIMDrive, unit, -1), 171 DEFINE_BLOCK_PROPERTIES(SWIMDrive, conf), 172 DEFINE_PROP_END_OF_LIST(), 173 }; 174 175 static void swim_drive_realize(DeviceState *qdev, Error **errp) 176 { 177 SWIMDrive *dev = SWIM_DRIVE(qdev); 178 SWIMBus *bus = SWIM_BUS(qdev->parent_bus); 179 FDrive *drive; 180 int ret; 181 182 if (dev->unit == -1) { 183 for (dev->unit = 0; dev->unit < SWIM_MAX_FD; dev->unit++) { 184 drive = &bus->ctrl->drives[dev->unit]; 185 if (!drive->blk) { 186 break; 187 } 188 } 189 } 190 191 if (dev->unit >= SWIM_MAX_FD) { 192 error_setg(errp, "Can't create floppy unit %d, bus supports " 193 "only %d units", dev->unit, SWIM_MAX_FD); 194 return; 195 } 196 197 drive = &bus->ctrl->drives[dev->unit]; 198 if (drive->blk) { 199 error_setg(errp, "Floppy unit %d is in use", dev->unit); 200 return; 201 } 202 203 if (!dev->conf.blk) { 204 /* Anonymous BlockBackend for an empty drive */ 205 dev->conf.blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL); 206 ret = blk_attach_dev(dev->conf.blk, qdev); 207 assert(ret == 0); 208 } 209 210 if (!blkconf_blocksizes(&dev->conf, errp)) { 211 return; 212 } 213 214 if (dev->conf.logical_block_size != 512 || 215 dev->conf.physical_block_size != 512) 216 { 217 error_setg(errp, "Physical and logical block size must " 218 "be 512 for floppy"); 219 return; 220 } 221 222 /* 223 * rerror/werror aren't supported by fdc and therefore not even registered 224 * with qdev. So set the defaults manually before they are used in 225 * blkconf_apply_backend_options(). 226 */ 227 dev->conf.rerror = BLOCKDEV_ON_ERROR_AUTO; 228 dev->conf.werror = BLOCKDEV_ON_ERROR_AUTO; 229 230 if (!blkconf_apply_backend_options(&dev->conf, 231 !blk_supports_write_perm(dev->conf.blk), 232 false, errp)) { 233 return; 234 } 235 236 /* 237 * 'enospc' is the default for -drive, 'report' is what blk_new() gives us 238 * for empty drives. 239 */ 240 if (blk_get_on_error(dev->conf.blk, 0) != BLOCKDEV_ON_ERROR_ENOSPC && 241 blk_get_on_error(dev->conf.blk, 0) != BLOCKDEV_ON_ERROR_REPORT) { 242 error_setg(errp, "fdc doesn't support drive option werror"); 243 return; 244 } 245 if (blk_get_on_error(dev->conf.blk, 1) != BLOCKDEV_ON_ERROR_REPORT) { 246 error_setg(errp, "fdc doesn't support drive option rerror"); 247 return; 248 } 249 250 drive->conf = &dev->conf; 251 drive->blk = dev->conf.blk; 252 drive->swimctrl = bus->ctrl; 253 254 blk_set_dev_ops(drive->blk, &swim_block_ops, drive); 255 } 256 257 static void swim_drive_class_init(ObjectClass *klass, void *data) 258 { 259 DeviceClass *k = DEVICE_CLASS(klass); 260 k->realize = swim_drive_realize; 261 set_bit(DEVICE_CATEGORY_STORAGE, k->categories); 262 k->bus_type = TYPE_SWIM_BUS; 263 device_class_set_props(k, swim_drive_properties); 264 k->desc = "virtual SWIM drive"; 265 } 266 267 static const TypeInfo swim_drive_info = { 268 .name = TYPE_SWIM_DRIVE, 269 .parent = TYPE_DEVICE, 270 .instance_size = sizeof(SWIMDrive), 271 .class_init = swim_drive_class_init, 272 }; 273 274 static const TypeInfo swim_bus_info = { 275 .name = TYPE_SWIM_BUS, 276 .parent = TYPE_BUS, 277 .instance_size = sizeof(SWIMBus), 278 }; 279 280 static void iwmctrl_write(void *opaque, hwaddr addr, uint64_t value, 281 unsigned size) 282 { 283 SWIMCtrl *swimctrl = opaque; 284 uint8_t latch, reg, ism_bit; 285 286 addr >>= REG_SHIFT; 287 288 /* A3-A1 select a latch, A0 specifies the value */ 289 latch = (addr >> 1) & 7; 290 if (addr & 1) { 291 swimctrl->iwm_latches |= (1 << latch); 292 } else { 293 swimctrl->iwm_latches &= ~(1 << latch); 294 } 295 296 reg = (swimctrl->iwm_latches & 0xc0) >> 5 | 297 (swimctrl->iwm_latches & 0x10) >> 4; 298 299 swimctrl->iwmregs[reg] = value; 300 trace_swim_iwmctrl_write(reg, iwm_reg_names[reg], size, value); 301 302 switch (reg) { 303 case IWM_WRITESETMODE: 304 /* detect sequence to switch from IWM mode to SWIM mode */ 305 ism_bit = (value & (1 << SWIM_MODE_STATUS_BIT)); 306 307 switch (swimctrl->iwm_switch) { 308 case 0: 309 if (ism_bit) { /* 1 */ 310 swimctrl->iwm_switch++; 311 } 312 break; 313 case 1: 314 if (!ism_bit) { /* 0 */ 315 swimctrl->iwm_switch++; 316 } 317 break; 318 case 2: 319 if (ism_bit) { /* 1 */ 320 swimctrl->iwm_switch++; 321 } 322 break; 323 case 3: 324 if (ism_bit) { /* 1 */ 325 swimctrl->iwm_switch++; 326 327 swimctrl->mode = SWIM_MODE_ISM; 328 swimctrl->swim_mode |= (1 << SWIM_MODE_STATUS_BIT); 329 swimctrl->iwm_switch = 0; 330 trace_swim_switch_to_ism(); 331 332 /* Switch to ISM registers */ 333 memory_region_del_subregion(&swimctrl->swim, &swimctrl->iwm); 334 memory_region_add_subregion(&swimctrl->swim, 0x0, 335 &swimctrl->ism); 336 } 337 break; 338 } 339 break; 340 default: 341 break; 342 } 343 } 344 345 static uint64_t iwmctrl_read(void *opaque, hwaddr addr, unsigned size) 346 { 347 SWIMCtrl *swimctrl = opaque; 348 uint8_t latch, reg, value; 349 350 addr >>= REG_SHIFT; 351 352 /* A3-A1 select a latch, A0 specifies the value */ 353 latch = (addr >> 1) & 7; 354 if (addr & 1) { 355 swimctrl->iwm_latches |= (1 << latch); 356 } else { 357 swimctrl->iwm_latches &= ~(1 << latch); 358 } 359 360 reg = (swimctrl->iwm_latches & 0xc0) >> 5 | 361 (swimctrl->iwm_latches & 0x10) >> 4; 362 363 switch (reg) { 364 case IWM_READALLONES: 365 value = 0xff; 366 break; 367 default: 368 value = 0; 369 break; 370 } 371 372 trace_swim_iwmctrl_read(reg, iwm_reg_names[reg], size, value); 373 return value; 374 } 375 376 static const MemoryRegionOps swimctrl_iwm_ops = { 377 .write = iwmctrl_write, 378 .read = iwmctrl_read, 379 .endianness = DEVICE_BIG_ENDIAN, 380 }; 381 382 static void ismctrl_write(void *opaque, hwaddr reg, uint64_t value, 383 unsigned size) 384 { 385 SWIMCtrl *swimctrl = opaque; 386 387 reg >>= REG_SHIFT; 388 389 trace_swim_ismctrl_write(reg, ism_reg_names[reg], size, value); 390 391 switch (reg) { 392 case SWIM_WRITE_PHASE: 393 swimctrl->swim_phase = value; 394 break; 395 case SWIM_WRITE_MODE0: 396 swimctrl->swim_mode &= ~value; 397 /* Any access to MODE0 register resets PRAM index */ 398 swimctrl->pram_idx = 0; 399 400 if (!(swimctrl->swim_mode & (1 << SWIM_MODE_STATUS_BIT))) { 401 /* Clearing the mode bit switches to IWM mode */ 402 swimctrl->mode = SWIM_MODE_IWM; 403 swimctrl->iwm_latches = 0; 404 trace_swim_switch_to_iwm(); 405 406 /* Switch to IWM registers */ 407 memory_region_del_subregion(&swimctrl->swim, &swimctrl->ism); 408 memory_region_add_subregion(&swimctrl->swim, 0x0, 409 &swimctrl->iwm); 410 } 411 break; 412 case SWIM_WRITE_MODE1: 413 swimctrl->swim_mode |= value; 414 break; 415 case SWIM_WRITE_PARAMETER: 416 swimctrl->pram[swimctrl->pram_idx++] = value; 417 swimctrl->pram_idx &= 0xf; 418 break; 419 case SWIM_WRITE_DATA: 420 case SWIM_WRITE_MARK: 421 case SWIM_WRITE_CRC: 422 case SWIM_WRITE_SETUP: 423 break; 424 } 425 } 426 427 static uint64_t ismctrl_read(void *opaque, hwaddr reg, unsigned size) 428 { 429 SWIMCtrl *swimctrl = opaque; 430 uint32_t value = 0; 431 432 reg >>= REG_SHIFT; 433 434 switch (reg) { 435 case SWIM_READ_PHASE: 436 value = swimctrl->swim_phase; 437 break; 438 case SWIM_READ_HANDSHAKE: 439 if (swimctrl->swim_phase == SWIM_DRIVE_PRESENT) { 440 /* always answer "no drive present" */ 441 value = SWIM_SENSE; 442 } 443 break; 444 case SWIM_READ_PARAMETER: 445 value = swimctrl->pram[swimctrl->pram_idx++]; 446 swimctrl->pram_idx &= 0xf; 447 break; 448 case SWIM_READ_STATUS: 449 value = swimctrl->swim_status & ~(1 << SWIM_MODE_STATUS_BIT); 450 if (swimctrl->swim_mode == SWIM_MODE_ISM) { 451 value |= (1 << SWIM_MODE_STATUS_BIT); 452 } 453 break; 454 case SWIM_READ_DATA: 455 case SWIM_READ_MARK: 456 case SWIM_READ_ERROR: 457 case SWIM_READ_SETUP: 458 break; 459 } 460 461 trace_swim_ismctrl_read(reg, ism_reg_names[reg], size, value); 462 return value; 463 } 464 465 static const MemoryRegionOps swimctrl_ism_ops = { 466 .write = ismctrl_write, 467 .read = ismctrl_read, 468 .endianness = DEVICE_BIG_ENDIAN, 469 }; 470 471 static void sysbus_swim_reset(DeviceState *d) 472 { 473 Swim *sys = SWIM(d); 474 SWIMCtrl *ctrl = &sys->ctrl; 475 int i; 476 477 ctrl->mode = 0; 478 ctrl->iwm_switch = 0; 479 memset(ctrl->iwmregs, 0, sizeof(ctrl->iwmregs)); 480 481 ctrl->swim_phase = 0; 482 ctrl->swim_mode = 0; 483 memset(ctrl->ismregs, 0, sizeof(ctrl->ismregs)); 484 for (i = 0; i < SWIM_MAX_FD; i++) { 485 fd_recalibrate(&ctrl->drives[i]); 486 } 487 } 488 489 static void sysbus_swim_init(Object *obj) 490 { 491 SysBusDevice *sbd = SYS_BUS_DEVICE(obj); 492 Swim *sbs = SWIM(obj); 493 SWIMCtrl *swimctrl = &sbs->ctrl; 494 495 memory_region_init(&swimctrl->swim, obj, "swim", 0x2000); 496 memory_region_init_io(&swimctrl->iwm, obj, &swimctrl_iwm_ops, swimctrl, 497 "iwm", 0x2000); 498 memory_region_init_io(&swimctrl->ism, obj, &swimctrl_ism_ops, swimctrl, 499 "ism", 0x2000); 500 sysbus_init_mmio(sbd, &swimctrl->swim); 501 } 502 503 static void sysbus_swim_realize(DeviceState *dev, Error **errp) 504 { 505 Swim *sys = SWIM(dev); 506 SWIMCtrl *swimctrl = &sys->ctrl; 507 508 qbus_init(&swimctrl->bus, sizeof(SWIMBus), TYPE_SWIM_BUS, dev, NULL); 509 swimctrl->bus.ctrl = swimctrl; 510 511 /* Default register set is IWM */ 512 memory_region_add_subregion(&swimctrl->swim, 0x0, &swimctrl->iwm); 513 } 514 515 static const VMStateDescription vmstate_fdrive = { 516 .name = "fdrive", 517 .version_id = 1, 518 .minimum_version_id = 1, 519 .fields = (const VMStateField[]) { 520 VMSTATE_END_OF_LIST() 521 }, 522 }; 523 524 static const VMStateDescription vmstate_swim = { 525 .name = "swim", 526 .version_id = 1, 527 .minimum_version_id = 1, 528 .fields = (const VMStateField[]) { 529 VMSTATE_INT32(mode, SWIMCtrl), 530 /* IWM mode */ 531 VMSTATE_INT32(iwm_switch, SWIMCtrl), 532 VMSTATE_UINT8(iwm_latches, SWIMCtrl), 533 VMSTATE_UINT8_ARRAY(iwmregs, SWIMCtrl, 8), 534 /* SWIM mode */ 535 VMSTATE_UINT8_ARRAY(ismregs, SWIMCtrl, 16), 536 VMSTATE_UINT8(swim_phase, SWIMCtrl), 537 VMSTATE_UINT8(swim_mode, SWIMCtrl), 538 /* Drives */ 539 VMSTATE_STRUCT_ARRAY(drives, SWIMCtrl, SWIM_MAX_FD, 1, 540 vmstate_fdrive, FDrive), 541 VMSTATE_END_OF_LIST() 542 }, 543 }; 544 545 static const VMStateDescription vmstate_sysbus_swim = { 546 .name = "SWIM", 547 .version_id = 1, 548 .fields = (const VMStateField[]) { 549 VMSTATE_STRUCT(ctrl, Swim, 0, vmstate_swim, SWIMCtrl), 550 VMSTATE_END_OF_LIST() 551 } 552 }; 553 554 static void sysbus_swim_class_init(ObjectClass *oc, void *data) 555 { 556 DeviceClass *dc = DEVICE_CLASS(oc); 557 558 dc->realize = sysbus_swim_realize; 559 dc->reset = sysbus_swim_reset; 560 dc->vmsd = &vmstate_sysbus_swim; 561 } 562 563 static const TypeInfo sysbus_swim_info = { 564 .name = TYPE_SWIM, 565 .parent = TYPE_SYS_BUS_DEVICE, 566 .instance_size = sizeof(Swim), 567 .instance_init = sysbus_swim_init, 568 .class_init = sysbus_swim_class_init, 569 }; 570 571 static void swim_register_types(void) 572 { 573 type_register_static(&sysbus_swim_info); 574 type_register_static(&swim_bus_info); 575 type_register_static(&swim_drive_info); 576 } 577 578 type_init(swim_register_types) 579