sm501: Add missing arbitration control register
[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 "qemu/osdep.h"
14 #include "hw/hw.h"
15 #include "hw/sysbus.h"
16 #include "hw/pcmcia.h"
17 #include "hw/arm/pxa.h"
18
19 #define TYPE_PXA2XX_PCMCIA "pxa2xx-pcmcia"
20 #define PXA2XX_PCMCIA(obj) \
21 OBJECT_CHECK(PXA2xxPCMCIAState, obj, TYPE_PXA2XX_PCMCIA)
22
23 struct PXA2xxPCMCIAState {
24 SysBusDevice parent_obj;
25
26 PCMCIASocket slot;
27 MemoryRegion container_mem;
28 MemoryRegion common_iomem;
29 MemoryRegion attr_iomem;
30 MemoryRegion iomem;
31
32 qemu_irq irq;
33 qemu_irq cd_irq;
34
35 PCMCIACardState *card;
36 };
37
38 static uint64_t pxa2xx_pcmcia_common_read(void *opaque,
39 hwaddr offset, unsigned size)
40 {
41 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
42 PCMCIACardClass *pcc;
43
44 if (s->slot.attached) {
45 pcc = PCMCIA_CARD_GET_CLASS(s->card);
46 return pcc->common_read(s->card, offset);
47 }
48
49 return 0;
50 }
51
52 static void pxa2xx_pcmcia_common_write(void *opaque, hwaddr offset,
53 uint64_t value, unsigned size)
54 {
55 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
56 PCMCIACardClass *pcc;
57
58 if (s->slot.attached) {
59 pcc = PCMCIA_CARD_GET_CLASS(s->card);
60 pcc->common_write(s->card, offset, value);
61 }
62 }
63
64 static uint64_t pxa2xx_pcmcia_attr_read(void *opaque,
65 hwaddr offset, unsigned size)
66 {
67 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
68 PCMCIACardClass *pcc;
69
70 if (s->slot.attached) {
71 pcc = PCMCIA_CARD_GET_CLASS(s->card);
72 return pcc->attr_read(s->card, offset);
73 }
74
75 return 0;
76 }
77
78 static void pxa2xx_pcmcia_attr_write(void *opaque, hwaddr offset,
79 uint64_t value, unsigned size)
80 {
81 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
82 PCMCIACardClass *pcc;
83
84 if (s->slot.attached) {
85 pcc = PCMCIA_CARD_GET_CLASS(s->card);
86 pcc->attr_write(s->card, offset, value);
87 }
88 }
89
90 static uint64_t pxa2xx_pcmcia_io_read(void *opaque,
91 hwaddr offset, unsigned size)
92 {
93 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
94 PCMCIACardClass *pcc;
95
96 if (s->slot.attached) {
97 pcc = PCMCIA_CARD_GET_CLASS(s->card);
98 return pcc->io_read(s->card, offset);
99 }
100
101 return 0;
102 }
103
104 static void pxa2xx_pcmcia_io_write(void *opaque, hwaddr offset,
105 uint64_t value, unsigned size)
106 {
107 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
108 PCMCIACardClass *pcc;
109
110 if (s->slot.attached) {
111 pcc = PCMCIA_CARD_GET_CLASS(s->card);
112 pcc->io_write(s->card, offset, value);
113 }
114 }
115
116 static const MemoryRegionOps pxa2xx_pcmcia_common_ops = {
117 .read = pxa2xx_pcmcia_common_read,
118 .write = pxa2xx_pcmcia_common_write,
119 .endianness = DEVICE_NATIVE_ENDIAN
120 };
121
122 static const MemoryRegionOps pxa2xx_pcmcia_attr_ops = {
123 .read = pxa2xx_pcmcia_attr_read,
124 .write = pxa2xx_pcmcia_attr_write,
125 .endianness = DEVICE_NATIVE_ENDIAN
126 };
127
128 static const MemoryRegionOps pxa2xx_pcmcia_io_ops = {
129 .read = pxa2xx_pcmcia_io_read,
130 .write = pxa2xx_pcmcia_io_write,
131 .endianness = DEVICE_NATIVE_ENDIAN
132 };
133
134 static void pxa2xx_pcmcia_set_irq(void *opaque, int line, int level)
135 {
136 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
137 if (!s->irq)
138 return;
139
140 qemu_set_irq(s->irq, level);
141 }
142
143 PXA2xxPCMCIAState *pxa2xx_pcmcia_init(MemoryRegion *sysmem,
144 hwaddr base)
145 {
146 DeviceState *dev;
147 PXA2xxPCMCIAState *s;
148
149 dev = qdev_create(NULL, TYPE_PXA2XX_PCMCIA);
150 sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
151 s = PXA2XX_PCMCIA(dev);
152
153 qdev_init_nofail(dev);
154
155 return s;
156 }
157
158 static void pxa2xx_pcmcia_initfn(Object *obj)
159 {
160 SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
161 PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(obj);
162
163 memory_region_init(&s->container_mem, obj, "container", 0x10000000);
164 sysbus_init_mmio(sbd, &s->container_mem);
165
166 /* Socket I/O Memory Space */
167 memory_region_init_io(&s->iomem, obj, &pxa2xx_pcmcia_io_ops, s,
168 "pxa2xx-pcmcia-io", 0x04000000);
169 memory_region_add_subregion(&s->container_mem, 0x00000000,
170 &s->iomem);
171
172 /* Then next 64 MB is reserved */
173
174 /* Socket Attribute Memory Space */
175 memory_region_init_io(&s->attr_iomem, obj, &pxa2xx_pcmcia_attr_ops, s,
176 "pxa2xx-pcmcia-attribute", 0x04000000);
177 memory_region_add_subregion(&s->container_mem, 0x08000000,
178 &s->attr_iomem);
179
180 /* Socket Common Memory Space */
181 memory_region_init_io(&s->common_iomem, obj, &pxa2xx_pcmcia_common_ops, s,
182 "pxa2xx-pcmcia-common", 0x04000000);
183 memory_region_add_subregion(&s->container_mem, 0x0c000000,
184 &s->common_iomem);
185
186 s->slot.irq = qemu_allocate_irq(pxa2xx_pcmcia_set_irq, s, 0);
187
188 object_property_add_link(obj, "card", TYPE_PCMCIA_CARD,
189 (Object **)&s->card,
190 NULL, /* read-only property */
191 0, NULL);
192 }
193
194 /* Insert a new card into a slot */
195 int pxa2xx_pcmcia_attach(void *opaque, PCMCIACardState *card)
196 {
197 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
198 PCMCIACardClass *pcc;
199
200 if (s->slot.attached) {
201 return -EEXIST;
202 }
203
204 if (s->cd_irq) {
205 qemu_irq_raise(s->cd_irq);
206 }
207
208 s->card = card;
209 pcc = PCMCIA_CARD_GET_CLASS(s->card);
210
211 s->slot.attached = true;
212 s->card->slot = &s->slot;
213 pcc->attach(s->card);
214
215 return 0;
216 }
217
218 /* Eject card from the slot */
219 int pxa2xx_pcmcia_detach(void *opaque)
220 {
221 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
222 PCMCIACardClass *pcc;
223
224 if (!s->slot.attached) {
225 return -ENOENT;
226 }
227
228 pcc = PCMCIA_CARD_GET_CLASS(s->card);
229 pcc->detach(s->card);
230 s->card->slot = NULL;
231 s->card = NULL;
232
233 s->slot.attached = false;
234
235 if (s->irq) {
236 qemu_irq_lower(s->irq);
237 }
238 if (s->cd_irq) {
239 qemu_irq_lower(s->cd_irq);
240 }
241
242 return 0;
243 }
244
245 /* Who to notify on card events */
246 void pxa2xx_pcmcia_set_irq_cb(void *opaque, qemu_irq irq, qemu_irq cd_irq)
247 {
248 PXA2xxPCMCIAState *s = (PXA2xxPCMCIAState *) opaque;
249 s->irq = irq;
250 s->cd_irq = cd_irq;
251 }
252
253 static const TypeInfo pxa2xx_pcmcia_type_info = {
254 .name = TYPE_PXA2XX_PCMCIA,
255 .parent = TYPE_SYS_BUS_DEVICE,
256 .instance_size = sizeof(PXA2xxPCMCIAState),
257 .instance_init = pxa2xx_pcmcia_initfn,
258 };
259
260 static void pxa2xx_pcmcia_register_types(void)
261 {
262 type_register_static(&pxa2xx_pcmcia_type_info);
263 }
264
265 type_init(pxa2xx_pcmcia_register_types)