hw/nubus/nubus-device.c

   1 /*
   2  * QEMU Macintosh Nubus
   3  *
   4  * Copyright (c) 2013-2018 Laurent Vivier <laurent@vivier.eu>
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "hw/nubus/nubus.h"
  13 #include "qapi/error.h"
  14
  15
  16 /* The Format Block Structure */
  17
  18 #define FBLOCK_DIRECTORY_OFFSET 0
  19 #define FBLOCK_LENGTH           4
  20 #define FBLOCK_CRC              8
  21 #define FBLOCK_REVISION_LEVEL   12
  22 #define FBLOCK_FORMAT           13
  23 #define FBLOCK_TEST_PATTERN     14
  24 #define FBLOCK_RESERVED         18
  25 #define FBLOCK_BYTE_LANES       19
  26
  27 #define FBLOCK_SIZE             20
  28 #define FBLOCK_PATTERN_VAL      0x5a932bc7
  29
  30 static uint64_t nubus_fblock_read(void *opaque, hwaddr addr, unsigned int size)
  31 {
  32     NubusDevice *dev = opaque;
  33     uint64_t val;
  34
  35 #define BYTE(v, b) (((v) >> (24 - 8 * (b))) & 0xff)
  36     switch (addr) {
  37     case FBLOCK_BYTE_LANES:
  38         val = dev->byte_lanes;
  39         val |= (val ^ 0xf) << 4;
  40         break;
  41     case FBLOCK_RESERVED:
  42         val = 0x00;
  43         break;
  44     case FBLOCK_TEST_PATTERN...FBLOCK_TEST_PATTERN + 3:
  45         val = BYTE(FBLOCK_PATTERN_VAL, addr - FBLOCK_TEST_PATTERN);
  46         break;
  47     case FBLOCK_FORMAT:
  48         val = dev->rom_format;
  49         break;
  50     case FBLOCK_REVISION_LEVEL:
  51         val = dev->rom_rev;
  52         break;
  53     case FBLOCK_CRC...FBLOCK_CRC + 3:
  54         val = BYTE(dev->rom_crc, addr - FBLOCK_CRC);
  55         break;
  56     case FBLOCK_LENGTH...FBLOCK_LENGTH + 3:
  57         val = BYTE(dev->rom_length, addr - FBLOCK_LENGTH);
  58         break;
  59     case FBLOCK_DIRECTORY_OFFSET...FBLOCK_DIRECTORY_OFFSET + 3:
  60         val = BYTE(dev->directory_offset, addr - FBLOCK_DIRECTORY_OFFSET);
  61         break;
  62     default:
  63         val = 0;
  64         break;
  65     }
  66     return val;
  67 }
  68
  69 static void nubus_fblock_write(void *opaque, hwaddr addr, uint64_t val,
  70                                unsigned int size)
  71 {
  72     /* read only */
  73 }
  74
  75 static const MemoryRegionOps nubus_format_block_ops = {
  76     .read = nubus_fblock_read,
  77     .write = nubus_fblock_write,
  78     .endianness = DEVICE_BIG_ENDIAN,
  79     .valid = {
  80         .min_access_size = 1,
  81         .max_access_size = 1,
  82     }
  83 };
  84
  85 static void nubus_register_format_block(NubusDevice *dev)
  86 {
  87     char *fblock_name;
  88
  89     fblock_name = g_strdup_printf("nubus-slot-%d-format-block",
  90                                   dev->slot_nb);
  91
  92     hwaddr fblock_offset = memory_region_size(&dev->slot_mem) - FBLOCK_SIZE;
  93     memory_region_init_io(&dev->fblock_io, NULL, &nubus_format_block_ops,
  94                           dev, fblock_name, FBLOCK_SIZE);
  95     memory_region_add_subregion(&dev->slot_mem, fblock_offset,
  96                                 &dev->fblock_io);
  97
  98     g_free(fblock_name);
  99 }
 100
 101 static void mac_nubus_rom_write(void *opaque, hwaddr addr, uint64_t val,
 102                                        unsigned int size)
 103 {
 104     /* read only */
 105 }
 106
 107 static uint64_t mac_nubus_rom_read(void *opaque, hwaddr addr,
 108                                     unsigned int size)
 109 {
 110     NubusDevice *dev = opaque;
 111
 112     return dev->rom[addr];
 113 }
 114
 115 static const MemoryRegionOps mac_nubus_rom_ops = {
 116     .read  = mac_nubus_rom_read,
 117     .write = mac_nubus_rom_write,
 118     .endianness = DEVICE_BIG_ENDIAN,
 119     .valid = {
 120         .min_access_size = 1,
 121         .max_access_size = 1,
 122     },
 123 };
 124
 125
 126 void nubus_register_rom(NubusDevice *dev, const uint8_t *rom, uint32_t size,
 127                         int revision, int format, uint8_t byte_lanes)
 128 {
 129     hwaddr rom_offset;
 130     char *rom_name;
 131
 132     /* FIXME : really compute CRC */
 133     dev->rom_length = 0;
 134     dev->rom_crc = 0;
 135
 136     dev->rom_rev = revision;
 137     dev->rom_format = format;
 138
 139     dev->byte_lanes = byte_lanes;
 140     dev->directory_offset = -size;
 141
 142     /* ROM */
 143
 144     dev->rom = rom;
 145     rom_name = g_strdup_printf("nubus-slot-%d-rom", dev->slot_nb);
 146     memory_region_init_io(&dev->rom_io, NULL, &mac_nubus_rom_ops,
 147                           dev, rom_name, size);
 148     memory_region_set_readonly(&dev->rom_io, true);
 149
 150     rom_offset = memory_region_size(&dev->slot_mem) - FBLOCK_SIZE +
 151                  dev->directory_offset;
 152     memory_region_add_subregion(&dev->slot_mem, rom_offset, &dev->rom_io);
 153
 154     g_free(rom_name);
 155 }
 156
 157 static void nubus_device_realize(DeviceState *dev, Error **errp)
 158 {
 159     NubusBus *nubus = NUBUS_BUS(qdev_get_parent_bus(dev));
 160     NubusDevice *nd = NUBUS_DEVICE(dev);
 161     char *name;
 162     hwaddr slot_offset;
 163
 164     if (nubus->current_slot < NUBUS_FIRST_SLOT ||
 165             nubus->current_slot > NUBUS_LAST_SLOT) {
 166         error_setg(errp, "Cannot register nubus card, not enough slots");
 167         return;
 168     }
 169
 170     nd->slot_nb = nubus->current_slot++;
 171     name = g_strdup_printf("nubus-slot-%d", nd->slot_nb);
 172
 173     if (nd->slot_nb < NUBUS_FIRST_SLOT) {
 174         /* Super */
 175         slot_offset = (nd->slot_nb - 6) * NUBUS_SUPER_SLOT_SIZE;
 176
 177         memory_region_init(&nd->slot_mem, OBJECT(dev), name,
 178                            NUBUS_SUPER_SLOT_SIZE);
 179         memory_region_add_subregion(&nubus->super_slot_io, slot_offset,
 180                                     &nd->slot_mem);
 181     } else {
 182         /* Normal */
 183         slot_offset = nd->slot_nb * NUBUS_SLOT_SIZE;
 184
 185         memory_region_init(&nd->slot_mem, OBJECT(dev), name, NUBUS_SLOT_SIZE);
 186         memory_region_add_subregion(&nubus->slot_io, slot_offset,
 187                                     &nd->slot_mem);
 188     }
 189
 190     g_free(name);
 191     nubus_register_format_block(nd);
 192 }
 193
 194 static void nubus_device_class_init(ObjectClass *oc, void *data)
 195 {
 196     DeviceClass *dc = DEVICE_CLASS(oc);
 197
 198     dc->realize = nubus_device_realize;
 199     dc->bus_type = TYPE_NUBUS_BUS;
 200 }
 201
 202 static const TypeInfo nubus_device_type_info = {
 203     .name = TYPE_NUBUS_DEVICE,
 204     .parent = TYPE_DEVICE,
 205     .abstract = true,
 206     .instance_size = sizeof(NubusDevice),
 207     .class_init = nubus_device_class_init,
 208 };
 209
 210 static void nubus_register_types(void)
 211 {
 212     type_register_static(&nubus_device_type_info);
 213 }
 214
 215 type_init(nubus_register_types)