hw/block/swim.c

   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
  23 /* IWM registers */
  24
  25 #define IWM_PH0L                0
  26 #define IWM_PH0H                1
  27 #define IWM_PH1L                2
  28 #define IWM_PH1H                3
  29 #define IWM_PH2L                4
  30 #define IWM_PH2H                5
  31 #define IWM_PH3L                6
  32 #define IWM_PH3H                7
  33 #define IWM_MTROFF              8
  34 #define IWM_MTRON               9
  35 #define IWM_INTDRIVE            10
  36 #define IWM_EXTDRIVE            11
  37 #define IWM_Q6L                 12
  38 #define IWM_Q6H                 13
  39 #define IWM_Q7L                 14
  40 #define IWM_Q7H                 15
  41
  42 /* SWIM registers */
  43
  44 #define SWIM_WRITE_DATA         0
  45 #define SWIM_WRITE_MARK         1
  46 #define SWIM_WRITE_CRC          2
  47 #define SWIM_WRITE_PARAMETER    3
  48 #define SWIM_WRITE_PHASE        4
  49 #define SWIM_WRITE_SETUP        5
  50 #define SWIM_WRITE_MODE0        6
  51 #define SWIM_WRITE_MODE1        7
  52
  53 #define SWIM_READ_DATA          8
  54 #define SWIM_READ_MARK          9
  55 #define SWIM_READ_ERROR         10
  56 #define SWIM_READ_PARAMETER     11
  57 #define SWIM_READ_PHASE         12
  58 #define SWIM_READ_SETUP         13
  59 #define SWIM_READ_STATUS        14
  60 #define SWIM_READ_HANDSHAKE     15
  61
  62 #define REG_SHIFT               9
  63
  64 #define SWIM_MODE_IWM  0
  65 #define SWIM_MODE_SWIM 1
  66
  67 /* bits in phase register */
  68
  69 #define SWIM_SEEK_NEGATIVE   0x074
  70 #define SWIM_STEP            0x071
  71 #define SWIM_MOTOR_ON        0x072
  72 #define SWIM_MOTOR_OFF       0x076
  73 #define SWIM_INDEX           0x073
  74 #define SWIM_EJECT           0x077
  75 #define SWIM_SETMFM          0x171
  76 #define SWIM_SETGCR          0x175
  77 #define SWIM_RELAX           0x033
  78 #define SWIM_LSTRB           0x008
  79 #define SWIM_CA_MASK         0x077
  80
  81 /* Select values for swim_select and swim_readbit */
  82
  83 #define SWIM_READ_DATA_0     0x074
  84 #define SWIM_TWOMEG_DRIVE    0x075
  85 #define SWIM_SINGLE_SIDED    0x076
  86 #define SWIM_DRIVE_PRESENT   0x077
  87 #define SWIM_DISK_IN         0x170
  88 #define SWIM_WRITE_PROT      0x171
  89 #define SWIM_TRACK_ZERO      0x172
  90 #define SWIM_TACHO           0x173
  91 #define SWIM_READ_DATA_1     0x174
  92 #define SWIM_MFM_MODE        0x175
  93 #define SWIM_SEEK_COMPLETE   0x176
  94 #define SWIM_ONEMEG_MEDIA    0x177
  95
  96 /* Bits in handshake register */
  97
  98 #define SWIM_MARK_BYTE       0x01
  99 #define SWIM_CRC_ZERO        0x02
 100 #define SWIM_RDDATA          0x04
 101 #define SWIM_SENSE           0x08
 102 #define SWIM_MOTEN           0x10
 103 #define SWIM_ERROR           0x20
 104 #define SWIM_DAT2BYTE        0x40
 105 #define SWIM_DAT1BYTE        0x80
 106
 107 /* bits in setup register */
 108
 109 #define SWIM_S_INV_WDATA     0x01
 110 #define SWIM_S_3_5_SELECT    0x02
 111 #define SWIM_S_GCR           0x04
 112 #define SWIM_S_FCLK_DIV2     0x08
 113 #define SWIM_S_ERROR_CORR    0x10
 114 #define SWIM_S_IBM_DRIVE     0x20
 115 #define SWIM_S_GCR_WRITE     0x40
 116 #define SWIM_S_TIMEOUT       0x80
 117
 118 /* bits in mode register */
 119
 120 #define SWIM_CLFIFO          0x01
 121 #define SWIM_ENBL1           0x02
 122 #define SWIM_ENBL2           0x04
 123 #define SWIM_ACTION          0x08
 124 #define SWIM_WRITE_MODE      0x10
 125 #define SWIM_HEDSEL          0x20
 126 #define SWIM_MOTON           0x80
 127
 128 static void fd_recalibrate(FDrive *drive)
 129 {
 130 }
 131
 132 static void swim_change_cb(void *opaque, bool load, Error **errp)
 133 {
 134     FDrive *drive = opaque;
 135
 136     if (!load) {
 137         blk_set_perm(drive->blk, 0, BLK_PERM_ALL, &error_abort);
 138     } else {
 139         if (!blkconf_apply_backend_options(drive->conf,
 140                                            !blk_supports_write_perm(drive->blk),
 141                                            false, errp)) {
 142             return;
 143         }
 144     }
 145 }
 146
 147 static const BlockDevOps swim_block_ops = {
 148     .change_media_cb = swim_change_cb,
 149 };
 150
 151 static Property swim_drive_properties[] = {
 152     DEFINE_PROP_INT32("unit", SWIMDrive, unit, -1),
 153     DEFINE_BLOCK_PROPERTIES(SWIMDrive, conf),
 154     DEFINE_PROP_END_OF_LIST(),
 155 };
 156
 157 static void swim_drive_realize(DeviceState *qdev, Error **errp)
 158 {
 159     SWIMDrive *dev = SWIM_DRIVE(qdev);
 160     SWIMBus *bus = SWIM_BUS(qdev->parent_bus);
 161     FDrive *drive;
 162     int ret;
 163
 164     if (dev->unit == -1) {
 165         for (dev->unit = 0; dev->unit < SWIM_MAX_FD; dev->unit++) {
 166             drive = &bus->ctrl->drives[dev->unit];
 167             if (!drive->blk) {
 168                 break;
 169             }
 170         }
 171     }
 172
 173     if (dev->unit >= SWIM_MAX_FD) {
 174         error_setg(errp, "Can't create floppy unit %d, bus supports "
 175                    "only %d units", dev->unit, SWIM_MAX_FD);
 176         return;
 177     }
 178
 179     drive = &bus->ctrl->drives[dev->unit];
 180     if (drive->blk) {
 181         error_setg(errp, "Floppy unit %d is in use", dev->unit);
 182         return;
 183     }
 184
 185     if (!dev->conf.blk) {
 186         /* Anonymous BlockBackend for an empty drive */
 187         dev->conf.blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
 188         ret = blk_attach_dev(dev->conf.blk, qdev);
 189         assert(ret == 0);
 190     }
 191
 192     if (!blkconf_blocksizes(&dev->conf, errp)) {
 193         return;
 194     }
 195
 196     if (dev->conf.logical_block_size != 512 ||
 197         dev->conf.physical_block_size != 512)
 198     {
 199         error_setg(errp, "Physical and logical block size must "
 200                    "be 512 for floppy");
 201         return;
 202     }
 203
 204     /*
 205      * rerror/werror aren't supported by fdc and therefore not even registered
 206      * with qdev. So set the defaults manually before they are used in
 207      * blkconf_apply_backend_options().
 208      */
 209     dev->conf.rerror = BLOCKDEV_ON_ERROR_AUTO;
 210     dev->conf.werror = BLOCKDEV_ON_ERROR_AUTO;
 211
 212     if (!blkconf_apply_backend_options(&dev->conf,
 213                                        !blk_supports_write_perm(dev->conf.blk),
 214                                        false, errp)) {
 215         return;
 216     }
 217
 218     /*
 219      * 'enospc' is the default for -drive, 'report' is what blk_new() gives us
 220      * for empty drives.
 221      */
 222     if (blk_get_on_error(dev->conf.blk, 0) != BLOCKDEV_ON_ERROR_ENOSPC &&
 223         blk_get_on_error(dev->conf.blk, 0) != BLOCKDEV_ON_ERROR_REPORT) {
 224         error_setg(errp, "fdc doesn't support drive option werror");
 225         return;
 226     }
 227     if (blk_get_on_error(dev->conf.blk, 1) != BLOCKDEV_ON_ERROR_REPORT) {
 228         error_setg(errp, "fdc doesn't support drive option rerror");
 229         return;
 230     }
 231
 232     drive->conf = &dev->conf;
 233     drive->blk = dev->conf.blk;
 234     drive->swimctrl = bus->ctrl;
 235
 236     blk_set_dev_ops(drive->blk, &swim_block_ops, drive);
 237 }
 238
 239 static void swim_drive_class_init(ObjectClass *klass, void *data)
 240 {
 241     DeviceClass *k = DEVICE_CLASS(klass);
 242     k->realize = swim_drive_realize;
 243     set_bit(DEVICE_CATEGORY_STORAGE, k->categories);
 244     k->bus_type = TYPE_SWIM_BUS;
 245     device_class_set_props(k, swim_drive_properties);
 246     k->desc = "virtual SWIM drive";
 247 }
 248
 249 static const TypeInfo swim_drive_info = {
 250     .name = TYPE_SWIM_DRIVE,
 251     .parent = TYPE_DEVICE,
 252     .instance_size = sizeof(SWIMDrive),
 253     .class_init = swim_drive_class_init,
 254 };
 255
 256 static const TypeInfo swim_bus_info = {
 257     .name = TYPE_SWIM_BUS,
 258     .parent = TYPE_BUS,
 259     .instance_size = sizeof(SWIMBus),
 260 };
 261
 262 static void iwmctrl_write(void *opaque, hwaddr reg, uint64_t value,
 263                           unsigned size)
 264 {
 265     SWIMCtrl *swimctrl = opaque;
 266
 267     reg >>= REG_SHIFT;
 268
 269     swimctrl->regs[reg >> 1] = reg & 1;
 270
 271     if (swimctrl->regs[IWM_Q6] &&
 272         swimctrl->regs[IWM_Q7]) {
 273         if (swimctrl->regs[IWM_MTR]) {
 274             /* data register */
 275             swimctrl->iwm_data = value;
 276         } else {
 277             /* mode register */
 278             swimctrl->iwm_mode = value;
 279             /* detect sequence to switch from IWM mode to SWIM mode */
 280             switch (swimctrl->iwm_switch) {
 281             case 0:
 282                 if (value == 0x57) {
 283                     swimctrl->iwm_switch++;
 284                 }
 285                 break;
 286             case 1:
 287                 if (value == 0x17) {
 288                     swimctrl->iwm_switch++;
 289                 }
 290                 break;
 291             case 2:
 292                 if (value == 0x57) {
 293                     swimctrl->iwm_switch++;
 294                 }
 295                 break;
 296             case 3:
 297                 if (value == 0x57) {
 298                     swimctrl->mode = SWIM_MODE_SWIM;
 299                     swimctrl->iwm_switch = 0;
 300                 }
 301                 break;
 302             }
 303         }
 304     }
 305 }
 306
 307 static uint64_t iwmctrl_read(void *opaque, hwaddr reg, unsigned size)
 308 {
 309     SWIMCtrl *swimctrl = opaque;
 310
 311     reg >>= REG_SHIFT;
 312
 313     swimctrl->regs[reg >> 1] = reg & 1;
 314
 315     return 0;
 316 }
 317
 318 static void swimctrl_write(void *opaque, hwaddr reg, uint64_t value,
 319                            unsigned size)
 320 {
 321     SWIMCtrl *swimctrl = opaque;
 322
 323     if (swimctrl->mode == SWIM_MODE_IWM) {
 324         iwmctrl_write(opaque, reg, value, size);
 325         return;
 326     }
 327
 328     reg >>= REG_SHIFT;
 329
 330     switch (reg) {
 331     case SWIM_WRITE_PHASE:
 332         swimctrl->swim_phase = value;
 333         break;
 334     case SWIM_WRITE_MODE0:
 335         swimctrl->swim_mode &= ~value;
 336         break;
 337     case SWIM_WRITE_MODE1:
 338         swimctrl->swim_mode |= value;
 339         break;
 340     case SWIM_WRITE_DATA:
 341     case SWIM_WRITE_MARK:
 342     case SWIM_WRITE_CRC:
 343     case SWIM_WRITE_PARAMETER:
 344     case SWIM_WRITE_SETUP:
 345         break;
 346     }
 347 }
 348
 349 static uint64_t swimctrl_read(void *opaque, hwaddr reg, unsigned size)
 350 {
 351     SWIMCtrl *swimctrl = opaque;
 352     uint32_t value = 0;
 353
 354     if (swimctrl->mode == SWIM_MODE_IWM) {
 355         return iwmctrl_read(opaque, reg, size);
 356     }
 357
 358     reg >>= REG_SHIFT;
 359
 360     switch (reg) {
 361     case SWIM_READ_PHASE:
 362         value = swimctrl->swim_phase;
 363         break;
 364     case SWIM_READ_HANDSHAKE:
 365         if (swimctrl->swim_phase == SWIM_DRIVE_PRESENT) {
 366             /* always answer "no drive present" */
 367             value = SWIM_SENSE;
 368         }
 369         break;
 370     case SWIM_READ_DATA:
 371     case SWIM_READ_MARK:
 372     case SWIM_READ_ERROR:
 373     case SWIM_READ_PARAMETER:
 374     case SWIM_READ_SETUP:
 375     case SWIM_READ_STATUS:
 376         break;
 377     }
 378
 379     return value;
 380 }
 381
 382 static const MemoryRegionOps swimctrl_mem_ops = {
 383     .write = swimctrl_write,
 384     .read = swimctrl_read,
 385     .endianness = DEVICE_NATIVE_ENDIAN,
 386 };
 387
 388 static void sysbus_swim_reset(DeviceState *d)
 389 {
 390     Swim *sys = SWIM(d);
 391     SWIMCtrl *ctrl = &sys->ctrl;
 392     int i;
 393
 394     ctrl->mode = 0;
 395     ctrl->iwm_switch = 0;
 396     for (i = 0; i < 8; i++) {
 397         ctrl->regs[i] = 0;
 398     }
 399     ctrl->iwm_data = 0;
 400     ctrl->iwm_mode = 0;
 401     ctrl->swim_phase = 0;
 402     ctrl->swim_mode = 0;
 403     for (i = 0; i < SWIM_MAX_FD; i++) {
 404         fd_recalibrate(&ctrl->drives[i]);
 405     }
 406 }
 407
 408 static void sysbus_swim_init(Object *obj)
 409 {
 410     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
 411     Swim *sbs = SWIM(obj);
 412     SWIMCtrl *swimctrl = &sbs->ctrl;
 413
 414     memory_region_init_io(&swimctrl->iomem, obj, &swimctrl_mem_ops, swimctrl,
 415                           "swim", 0x2000);
 416     sysbus_init_mmio(sbd, &swimctrl->iomem);
 417 }
 418
 419 static void sysbus_swim_realize(DeviceState *dev, Error **errp)
 420 {
 421     Swim *sys = SWIM(dev);
 422     SWIMCtrl *swimctrl = &sys->ctrl;
 423
 424     qbus_init(&swimctrl->bus, sizeof(SWIMBus), TYPE_SWIM_BUS, dev, NULL);
 425     swimctrl->bus.ctrl = swimctrl;
 426 }
 427
 428 static const VMStateDescription vmstate_fdrive = {
 429     .name = "fdrive",
 430     .version_id = 1,
 431     .minimum_version_id = 1,
 432     .fields = (VMStateField[]) {
 433         VMSTATE_END_OF_LIST()
 434     },
 435 };
 436
 437 static const VMStateDescription vmstate_swim = {
 438     .name = "swim",
 439     .version_id = 1,
 440     .minimum_version_id = 1,
 441     .fields = (VMStateField[]) {
 442         VMSTATE_INT32(mode, SWIMCtrl),
 443         /* IWM mode */
 444         VMSTATE_INT32(iwm_switch, SWIMCtrl),
 445         VMSTATE_UINT16_ARRAY(regs, SWIMCtrl, 8),
 446         VMSTATE_UINT8(iwm_data, SWIMCtrl),
 447         VMSTATE_UINT8(iwm_mode, SWIMCtrl),
 448         /* SWIM mode */
 449         VMSTATE_UINT8(swim_phase, SWIMCtrl),
 450         VMSTATE_UINT8(swim_mode, SWIMCtrl),
 451         /* Drives */
 452         VMSTATE_STRUCT_ARRAY(drives, SWIMCtrl, SWIM_MAX_FD, 1,
 453                              vmstate_fdrive, FDrive),
 454         VMSTATE_END_OF_LIST()
 455     },
 456 };
 457
 458 static const VMStateDescription vmstate_sysbus_swim = {
 459     .name = "SWIM",
 460     .version_id = 1,
 461     .fields = (VMStateField[]) {
 462         VMSTATE_STRUCT(ctrl, Swim, 0, vmstate_swim, SWIMCtrl),
 463         VMSTATE_END_OF_LIST()
 464     }
 465 };
 466
 467 static void sysbus_swim_class_init(ObjectClass *oc, void *data)
 468 {
 469     DeviceClass *dc = DEVICE_CLASS(oc);
 470
 471     dc->realize = sysbus_swim_realize;
 472     dc->reset = sysbus_swim_reset;
 473     dc->vmsd = &vmstate_sysbus_swim;
 474 }
 475
 476 static const TypeInfo sysbus_swim_info = {
 477     .name          = TYPE_SWIM,
 478     .parent        = TYPE_SYS_BUS_DEVICE,
 479     .instance_size = sizeof(Swim),
 480     .instance_init = sysbus_swim_init,
 481     .class_init    = sysbus_swim_class_init,
 482 };
 483
 484 static void swim_register_types(void)
 485 {
 486     type_register_static(&sysbus_swim_info);
 487     type_register_static(&swim_bus_info);
 488     type_register_static(&swim_drive_info);
 489 }
 490
 491 type_init(swim_register_types)