qom: Add check() argument to object_property_add_link()
[qemu.git] / hw / pcmcia / pxa2xx.c
1 /*
2 * Intel XScale PXA255/270 PC Card and CompactFlash Interface.
3 *
4 * Copyright (c) 2006 Openedhand Ltd.
5 * Written by Andrzej Zaborowski <balrog@zabor.org>
6 *
7 * This code is licensed under the GPLv2.
8 *
9 * Contributions after 2012-01-13 are licensed under the terms of the
10 * GNU GPL, version 2 or (at your option) any later version.
11 */
12
13 #include "hw/hw.h"
14 #include "hw/sysbus.h"
15 #include "hw/pcmcia.h"
16 #include "hw/arm/pxa.h"
17
18 #define TYPE_PXA2XX_PCMCIA "pxa2xx-pcmcia"
19 #define PXA2XX_PCMCIA(obj) \
20 OBJECT_CHECK(PXA2xxPCMCIAState, obj, TYPE_PXA2XX_PCMCIA)
21
22 struct PXA2xxPCMCIAState {
23 SysBusDevice parent_obj;
24
25 PCMCIASocket slot;
26 MemoryRegion container_mem;
27 MemoryRegion common_iomem;
28 MemoryRegion attr_iomem;
29 MemoryRegion iomem;
30
31 qemu_irq irq;
32 qemu_irq cd_irq;
33
34 PCMCIACardState *card;
35 };
36
37 static uint64_t pxa2xx_pcmcia_common_read(void *opaque,
38 hwaddr offset, unsigned size)
39 {
40 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
41 PCMCIACardClass *pcc;
42
43 if (s->slot.attached) {
44 pcc = PCMCIA_CARD_GET_CLASS(s->card);
45 return pcc->common_read(s->card, offset);
46 }
47
48 return 0;
49 }
50
51 static void pxa2xx_pcmcia_common_write(void *opaque, hwaddr offset,
52 uint64_t value, unsigned size)
53 {
54 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
55 PCMCIACardClass *pcc;
56
57 if (s->slot.attached) {
58 pcc = PCMCIA_CARD_GET_CLASS(s->card);
59 pcc->common_write(s->card, offset, value);
60 }
61 }
62
63 static uint64_t pxa2xx_pcmcia_attr_read(void *opaque,
64 hwaddr offset, unsigned size)
65 {
66 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
67 PCMCIACardClass *pcc;
68
69 if (s->slot.attached) {
70 pcc = PCMCIA_CARD_GET_CLASS(s->card);
71 return pcc->attr_read(s->card, offset);
72 }
73
74 return 0;
75 }
76
77 static void pxa2xx_pcmcia_attr_write(void *opaque, hwaddr offset,
78 uint64_t value, unsigned size)
79 {
80 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
81 PCMCIACardClass *pcc;
82
83 if (s->slot.attached) {
84 pcc = PCMCIA_CARD_GET_CLASS(s->card);
85 pcc->attr_write(s->card, offset, value);
86 }
87 }
88
89 static uint64_t pxa2xx_pcmcia_io_read(void *opaque,
90 hwaddr offset, unsigned size)
91 {
92 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
93 PCMCIACardClass *pcc;
94
95 if (s->slot.attached) {
96 pcc = PCMCIA_CARD_GET_CLASS(s->card);
97 return pcc->io_read(s->card, offset);
98 }
99
100 return 0;
101 }
102
103 static void pxa2xx_pcmcia_io_write(void *opaque, hwaddr offset,
104 uint64_t value, unsigned size)
105 {
106 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
107 PCMCIACardClass *pcc;
108
109 if (s->slot.attached) {
110 pcc = PCMCIA_CARD_GET_CLASS(s->card);
111 pcc->io_write(s->card, offset, value);
112 }
113 }
114
115 static const MemoryRegionOps pxa2xx_pcmcia_common_ops = {
116 .read = pxa2xx_pcmcia_common_read,
117 .write = pxa2xx_pcmcia_common_write,
118 .endianness = DEVICE_NATIVE_ENDIAN
119 };
120
121 static const MemoryRegionOps pxa2xx_pcmcia_attr_ops = {
122 .read = pxa2xx_pcmcia_attr_read,
123 .write = pxa2xx_pcmcia_attr_write,
124 .endianness = DEVICE_NATIVE_ENDIAN
125 };
126
127 static const MemoryRegionOps pxa2xx_pcmcia_io_ops = {
128 .read = pxa2xx_pcmcia_io_read,
129 .write = pxa2xx_pcmcia_io_write,
130 .endianness = DEVICE_NATIVE_ENDIAN
131 };
132
133 static void pxa2xx_pcmcia_set_irq(void *opaque, int line, int level)
134 {
135 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
136 if (!s->irq)
137 return;
138
139 qemu_set_irq(s->irq, level);
140 }
141
142 PXA2xxPCMCIAState *pxa2xx_pcmcia_init(MemoryRegion *sysmem,
143 hwaddr base)
144 {
145 DeviceState *dev;
146 PXA2xxPCMCIAState *s;
147
148 dev = qdev_create(NULL, TYPE_PXA2XX_PCMCIA);
149 sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
150 s = PXA2XX_PCMCIA(dev);
151
152 if (base == 0x30000000) {
153 s->slot.slot_string = "PXA PC Card Socket 1";
154 } else {
155 s->slot.slot_string = "PXA PC Card Socket 0";
156 }
157
158 qdev_init_nofail(dev);
159
160 return s;
161 }
162
163 static void pxa2xx_pcmcia_realize(DeviceState *dev, Error **errp)
164 {
165 PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(dev);
166
167 pcmcia_socket_register(&s->slot);
168 }
169
170 static void pxa2xx_pcmcia_initfn(Object *obj)
171 {
172 SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
173 PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(obj);
174
175 memory_region_init(&s->container_mem, obj, "container", 0x10000000);
176 sysbus_init_mmio(sbd, &s->container_mem);
177
178 /* Socket I/O Memory Space */
179 memory_region_init_io(&s->iomem, NULL, &pxa2xx_pcmcia_io_ops, s,
180 "pxa2xx-pcmcia-io", 0x04000000);
181 memory_region_add_subregion(&s->container_mem, 0x00000000,
182 &s->iomem);
183
184 /* Then next 64 MB is reserved */
185
186 /* Socket Attribute Memory Space */
187 memory_region_init_io(&s->attr_iomem, NULL, &pxa2xx_pcmcia_attr_ops, s,
188 "pxa2xx-pcmcia-attribute", 0x04000000);
189 memory_region_add_subregion(&s->container_mem, 0x08000000,
190 &s->attr_iomem);
191
192 /* Socket Common Memory Space */
193 memory_region_init_io(&s->common_iomem, NULL, &pxa2xx_pcmcia_common_ops, s,
194 "pxa2xx-pcmcia-common", 0x04000000);
195 memory_region_add_subregion(&s->container_mem, 0x0c000000,
196 &s->common_iomem);
197
198 s->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, s, 1)[0];
199
200 object_property_add_link(obj, "card", TYPE_PCMCIA_CARD,
201 (Object **)&s->card,
202 NULL, /* read-only property */
203 0, NULL);
204 }
205
206 /* Insert a new card into a slot */
207 int pxa2xx_pcmcia_attach(void *opaque, PCMCIACardState *card)
208 {
209 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
210 PCMCIACardClass *pcc;
211
212 if (s->slot.attached) {
213 return -EEXIST;
214 }
215
216 if (s->cd_irq) {
217 qemu_irq_raise(s->cd_irq);
218 }
219
220 s->card = card;
221 pcc = PCMCIA_CARD_GET_CLASS(s->card);
222
223 s->slot.attached = true;
224 s->card->slot = &s->slot;
225 pcc->attach(s->card);
226
227 return 0;
228 }
229
230 /* Eject card from the slot */
231 int pxa2xx_pcmcia_detach(void *opaque)
232 {
233 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
234 PCMCIACardClass *pcc;
235
236 if (!s->slot.attached) {
237 return -ENOENT;
238 }
239
240 pcc = PCMCIA_CARD_GET_CLASS(s->card);
241 pcc->detach(s->card);
242 s->card->slot = NULL;
243 s->card = NULL;
244
245 s->slot.attached = false;
246
247 if (s->irq) {
248 qemu_irq_lower(s->irq);
249 }
250 if (s->cd_irq) {
251 qemu_irq_lower(s->cd_irq);
252 }
253
254 return 0;
255 }
256
257 /* Who to notify on card events */
258 void pxa2xx_pcmcia_set_irq_cb(void *opaque, qemu_irq irq, qemu_irq cd_irq)
259 {
260 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
261 s->irq = irq;
262 s->cd_irq = cd_irq;
263 }
264
265 static void pxa2xx_pcmcia_class_init(ObjectClass *oc, void *data)
266 {
267 DeviceClass *dc = DEVICE_CLASS(oc);
268
269 dc->realize = pxa2xx_pcmcia_realize;
270 }
271
272 static const TypeInfo pxa2xx_pcmcia_type_info = {
273 .name = TYPE_PXA2XX_PCMCIA,
274 .parent = TYPE_SYS_BUS_DEVICE,
275 .instance_size = sizeof(PXA2xxPCMCIAState),
276 .instance_init = pxa2xx_pcmcia_initfn,
277 .class_init = pxa2xx_pcmcia_class_init,
278 };
279
280 static void pxa2xx_pcmcia_register_types(void)
281 {
282 type_register_static(&pxa2xx_pcmcia_type_info);
283 }
284
285 type_init(pxa2xx_pcmcia_register_types)