xref: /qemu/hw/pcmcia/pxa2xx.c (revision 72ac97cd) 
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)
286