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 /* 12 * References: 13 * Nubus Specification (TI) 14 * http://www.bitsavers.org/pdf/ti/nubus/2242825-0001_NuBus_Spec1983.pdf 15 * 16 * Designing Cards and Drivers for the Macintosh Family (Apple) 17 */ 18 19 #include "qemu/osdep.h" 20 #include "hw/nubus/nubus.h" 21 #include "qapi/error.h" 22 #include "trace.h" 23 24 25 static NubusBus *nubus_find(void) 26 { 27 /* Returns NULL unless there is exactly one nubus device */ 28 return NUBUS_BUS(object_resolve_path_type("", TYPE_NUBUS_BUS, NULL)); 29 } 30 31 static MemTxResult nubus_slot_write(void *opaque, hwaddr addr, uint64_t val, 32 unsigned size, MemTxAttrs attrs) 33 { 34 trace_nubus_slot_write(addr, val, size); 35 return MEMTX_DECODE_ERROR; 36 } 37 38 static MemTxResult nubus_slot_read(void *opaque, hwaddr addr, uint64_t *data, 39 unsigned size, MemTxAttrs attrs) 40 { 41 trace_nubus_slot_read(addr, size); 42 return MEMTX_DECODE_ERROR; 43 } 44 45 static const MemoryRegionOps nubus_slot_ops = { 46 .read_with_attrs = nubus_slot_read, 47 .write_with_attrs = nubus_slot_write, 48 .endianness = DEVICE_BIG_ENDIAN, 49 .valid = { 50 .min_access_size = 1, 51 .max_access_size = 4, 52 }, 53 }; 54 55 static MemTxResult nubus_super_slot_write(void *opaque, hwaddr addr, 56 uint64_t val, unsigned size, 57 MemTxAttrs attrs) 58 { 59 trace_nubus_super_slot_write(addr, val, size); 60 return MEMTX_DECODE_ERROR; 61 } 62 63 static MemTxResult nubus_super_slot_read(void *opaque, hwaddr addr, 64 uint64_t *data, unsigned size, 65 MemTxAttrs attrs) 66 { 67 trace_nubus_super_slot_read(addr, size); 68 return MEMTX_DECODE_ERROR; 69 } 70 71 static const MemoryRegionOps nubus_super_slot_ops = { 72 .read_with_attrs = nubus_super_slot_read, 73 .write_with_attrs = nubus_super_slot_write, 74 .endianness = DEVICE_BIG_ENDIAN, 75 .valid = { 76 .min_access_size = 1, 77 .max_access_size = 4, 78 }, 79 }; 80 81 static void nubus_unrealize(BusState *bus) 82 { 83 NubusBus *nubus = NUBUS_BUS(bus); 84 85 address_space_destroy(&nubus->nubus_as); 86 } 87 88 static void nubus_realize(BusState *bus, Error **errp) 89 { 90 NubusBus *nubus = NUBUS_BUS(bus); 91 92 if (!nubus_find()) { 93 error_setg(errp, "at most one %s device is permitted", TYPE_NUBUS_BUS); 94 return; 95 } 96 97 address_space_init(&nubus->nubus_as, &nubus->nubus_mr, "nubus"); 98 } 99 100 static void nubus_init(Object *obj) 101 { 102 NubusBus *nubus = NUBUS_BUS(obj); 103 104 memory_region_init(&nubus->nubus_mr, obj, "nubus", 0x100000000); 105 106 memory_region_init_io(&nubus->super_slot_io, obj, &nubus_super_slot_ops, 107 nubus, "nubus-super-slots", 108 (NUBUS_SUPER_SLOT_NB + 1) * NUBUS_SUPER_SLOT_SIZE); 109 memory_region_add_subregion(&nubus->nubus_mr, 0x0, &nubus->super_slot_io); 110 111 memory_region_init_io(&nubus->slot_io, obj, &nubus_slot_ops, 112 nubus, "nubus-slots", 113 NUBUS_SLOT_NB * NUBUS_SLOT_SIZE); 114 memory_region_add_subregion(&nubus->nubus_mr, 115 (NUBUS_SUPER_SLOT_NB + 1) * 116 NUBUS_SUPER_SLOT_SIZE, &nubus->slot_io); 117 118 nubus->slot_available_mask = MAKE_64BIT_MASK(NUBUS_FIRST_SLOT, 119 NUBUS_SLOT_NB); 120 } 121 122 static char *nubus_get_dev_path(DeviceState *dev) 123 { 124 NubusDevice *nd = NUBUS_DEVICE(dev); 125 BusState *bus = qdev_get_parent_bus(dev); 126 char *p = qdev_get_dev_path(bus->parent); 127 128 if (p) { 129 char *ret = g_strdup_printf("%s/%s/%02x", p, bus->name, nd->slot); 130 g_free(p); 131 return ret; 132 } else { 133 return g_strdup_printf("%s/%02x", bus->name, nd->slot); 134 } 135 } 136 137 static bool nubus_check_address(BusState *bus, DeviceState *dev, Error **errp) 138 { 139 NubusDevice *nd = NUBUS_DEVICE(dev); 140 NubusBus *nubus = NUBUS_BUS(bus); 141 142 if (nd->slot == -1) { 143 /* No slot specified, find first available free slot */ 144 int s = ctz32(nubus->slot_available_mask); 145 if (s != 32) { 146 nd->slot = s; 147 } else { 148 error_setg(errp, "Cannot register nubus card, no free slot " 149 "available"); 150 return false; 151 } 152 } else { 153 /* Slot specified, make sure the slot is available */ 154 if (!(nubus->slot_available_mask & BIT(nd->slot))) { 155 error_setg(errp, "Cannot register nubus card, slot %d is " 156 "unavailable or already occupied", nd->slot); 157 return false; 158 } 159 } 160 161 nubus->slot_available_mask &= ~BIT(nd->slot); 162 return true; 163 } 164 165 static void nubus_class_init(ObjectClass *oc, void *data) 166 { 167 BusClass *bc = BUS_CLASS(oc); 168 169 bc->realize = nubus_realize; 170 bc->unrealize = nubus_unrealize; 171 bc->check_address = nubus_check_address; 172 bc->get_dev_path = nubus_get_dev_path; 173 } 174 175 static const TypeInfo nubus_bus_info = { 176 .name = TYPE_NUBUS_BUS, 177 .parent = TYPE_BUS, 178 .instance_size = sizeof(NubusBus), 179 .instance_init = nubus_init, 180 .class_init = nubus_class_init, 181 }; 182 183 static void nubus_register_types(void) 184 { 185 type_register_static(&nubus_bus_info); 186 } 187 188 type_init(nubus_register_types) 189