capstone: Update to upstream "next" branch
[qemu.git] / 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)