2 * QEMU educational PCI device
4 * Copyright (c) 2012-2015 Jiri Slaby
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
25 #include "qemu/osdep.h"
26 #include "qemu/units.h"
27 #include "hw/pci/pci.h"
28 #include "hw/pci/msi.h"
29 #include "qemu/timer.h"
30 #include "qemu/main-loop.h" /* iothread mutex */
31 #include "qapi/visitor.h"
33 #define TYPE_PCI_EDU_DEVICE "edu"
34 #define EDU(obj) OBJECT_CHECK(EduState, obj, TYPE_PCI_EDU_DEVICE)
36 #define FACT_IRQ 0x00000001
37 #define DMA_IRQ 0x00000100
39 #define DMA_START 0x40000
53 #define EDU_STATUS_COMPUTING 0x01
54 #define EDU_STATUS_IRQFACT 0x80
59 #define EDU_DMA_RUN 0x1
60 #define EDU_DMA_DIR(cmd) (((cmd) & 0x2) >> 1)
61 # define EDU_DMA_FROM_PCI 0
62 # define EDU_DMA_TO_PCI 1
63 #define EDU_DMA_IRQ 0x4
71 char dma_buf
[DMA_SIZE
];
75 static bool edu_msi_enabled(EduState
*edu
)
77 return msi_enabled(&edu
->pdev
);
80 static void edu_raise_irq(EduState
*edu
, uint32_t val
)
82 edu
->irq_status
|= val
;
83 if (edu
->irq_status
) {
84 if (edu_msi_enabled(edu
)) {
85 msi_notify(&edu
->pdev
, 0);
87 pci_set_irq(&edu
->pdev
, 1);
92 static void edu_lower_irq(EduState
*edu
, uint32_t val
)
94 edu
->irq_status
&= ~val
;
96 if (!edu
->irq_status
&& !edu_msi_enabled(edu
)) {
97 pci_set_irq(&edu
->pdev
, 0);
101 static bool within(uint32_t addr
, uint32_t start
, uint32_t end
)
103 return start
<= addr
&& addr
< end
;
106 static void edu_check_range(uint32_t addr
, uint32_t size1
, uint32_t start
,
109 uint32_t end1
= addr
+ size1
;
110 uint32_t end2
= start
+ size2
;
112 if (within(addr
, start
, end2
) &&
113 end1
> addr
&& within(end1
, start
, end2
)) {
117 hw_error("EDU: DMA range 0x%.8x-0x%.8x out of bounds (0x%.8x-0x%.8x)!",
118 addr
, end1
- 1, start
, end2
- 1);
121 static dma_addr_t
edu_clamp_addr(const EduState
*edu
, dma_addr_t addr
)
123 dma_addr_t res
= addr
& edu
->dma_mask
;
126 printf("EDU: clamping DMA %#.16"PRIx64
" to %#.16"PRIx64
"!\n", addr
, res
);
132 static void edu_dma_timer(void *opaque
)
134 EduState
*edu
= opaque
;
135 bool raise_irq
= false;
137 if (!(edu
->dma
.cmd
& EDU_DMA_RUN
)) {
141 if (EDU_DMA_DIR(edu
->dma
.cmd
) == EDU_DMA_FROM_PCI
) {
142 uint32_t dst
= edu
->dma
.dst
;
143 edu_check_range(dst
, edu
->dma
.cnt
, DMA_START
, DMA_SIZE
);
145 pci_dma_read(&edu
->pdev
, edu_clamp_addr(edu
, edu
->dma
.src
),
146 edu
->dma_buf
+ dst
, edu
->dma
.cnt
);
148 uint32_t src
= edu
->dma
.src
;
149 edu_check_range(src
, edu
->dma
.cnt
, DMA_START
, DMA_SIZE
);
151 pci_dma_write(&edu
->pdev
, edu_clamp_addr(edu
, edu
->dma
.dst
),
152 edu
->dma_buf
+ src
, edu
->dma
.cnt
);
155 edu
->dma
.cmd
&= ~EDU_DMA_RUN
;
156 if (edu
->dma
.cmd
& EDU_DMA_IRQ
) {
161 edu_raise_irq(edu
, DMA_IRQ
);
165 static void dma_rw(EduState
*edu
, bool write
, dma_addr_t
*val
, dma_addr_t
*dma
,
168 if (write
&& (edu
->dma
.cmd
& EDU_DMA_RUN
)) {
179 timer_mod(&edu
->dma_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 100);
183 static uint64_t edu_mmio_read(void *opaque
, hwaddr addr
, unsigned size
)
185 EduState
*edu
= opaque
;
186 uint64_t val
= ~0ULL;
188 if (addr
< 0x80 && size
!= 4) {
192 if (addr
>= 0x80 && size
!= 4 && size
!= 8) {
204 qemu_mutex_lock(&edu
->thr_mutex
);
206 qemu_mutex_unlock(&edu
->thr_mutex
);
209 val
= atomic_read(&edu
->status
);
212 val
= edu
->irq_status
;
215 dma_rw(edu
, false, &val
, &edu
->dma
.src
, false);
218 dma_rw(edu
, false, &val
, &edu
->dma
.dst
, false);
221 dma_rw(edu
, false, &val
, &edu
->dma
.cnt
, false);
224 dma_rw(edu
, false, &val
, &edu
->dma
.cmd
, false);
231 static void edu_mmio_write(void *opaque
, hwaddr addr
, uint64_t val
,
234 EduState
*edu
= opaque
;
236 if (addr
< 0x80 && size
!= 4) {
240 if (addr
>= 0x80 && size
!= 4 && size
!= 8) {
249 if (atomic_read(&edu
->status
) & EDU_STATUS_COMPUTING
) {
252 /* EDU_STATUS_COMPUTING cannot go 0->1 concurrently, because it is only
253 * set in this function and it is under the iothread mutex.
255 qemu_mutex_lock(&edu
->thr_mutex
);
257 atomic_or(&edu
->status
, EDU_STATUS_COMPUTING
);
258 qemu_cond_signal(&edu
->thr_cond
);
259 qemu_mutex_unlock(&edu
->thr_mutex
);
262 if (val
& EDU_STATUS_IRQFACT
) {
263 atomic_or(&edu
->status
, EDU_STATUS_IRQFACT
);
265 atomic_and(&edu
->status
, ~EDU_STATUS_IRQFACT
);
269 edu_raise_irq(edu
, val
);
272 edu_lower_irq(edu
, val
);
275 dma_rw(edu
, true, &val
, &edu
->dma
.src
, false);
278 dma_rw(edu
, true, &val
, &edu
->dma
.dst
, false);
281 dma_rw(edu
, true, &val
, &edu
->dma
.cnt
, false);
284 if (!(val
& EDU_DMA_RUN
)) {
287 dma_rw(edu
, true, &val
, &edu
->dma
.cmd
, true);
292 static const MemoryRegionOps edu_mmio_ops
= {
293 .read
= edu_mmio_read
,
294 .write
= edu_mmio_write
,
295 .endianness
= DEVICE_NATIVE_ENDIAN
,
297 .min_access_size
= 4,
298 .max_access_size
= 8,
301 .min_access_size
= 4,
302 .max_access_size
= 8,
308 * We purposely use a thread, so that users are forced to wait for the status
311 static void *edu_fact_thread(void *opaque
)
313 EduState
*edu
= opaque
;
316 uint32_t val
, ret
= 1;
318 qemu_mutex_lock(&edu
->thr_mutex
);
319 while ((atomic_read(&edu
->status
) & EDU_STATUS_COMPUTING
) == 0 &&
321 qemu_cond_wait(&edu
->thr_cond
, &edu
->thr_mutex
);
325 qemu_mutex_unlock(&edu
->thr_mutex
);
330 qemu_mutex_unlock(&edu
->thr_mutex
);
337 * We should sleep for a random period here, so that students are
338 * forced to check the status properly.
341 qemu_mutex_lock(&edu
->thr_mutex
);
343 qemu_mutex_unlock(&edu
->thr_mutex
);
344 atomic_and(&edu
->status
, ~EDU_STATUS_COMPUTING
);
346 if (atomic_read(&edu
->status
) & EDU_STATUS_IRQFACT
) {
347 qemu_mutex_lock_iothread();
348 edu_raise_irq(edu
, FACT_IRQ
);
349 qemu_mutex_unlock_iothread();
356 static void pci_edu_realize(PCIDevice
*pdev
, Error
**errp
)
358 EduState
*edu
= EDU(pdev
);
359 uint8_t *pci_conf
= pdev
->config
;
361 pci_config_set_interrupt_pin(pci_conf
, 1);
363 if (msi_init(pdev
, 0, 1, true, false, errp
)) {
367 timer_init_ms(&edu
->dma_timer
, QEMU_CLOCK_VIRTUAL
, edu_dma_timer
, edu
);
369 qemu_mutex_init(&edu
->thr_mutex
);
370 qemu_cond_init(&edu
->thr_cond
);
371 qemu_thread_create(&edu
->thread
, "edu", edu_fact_thread
,
372 edu
, QEMU_THREAD_JOINABLE
);
374 memory_region_init_io(&edu
->mmio
, OBJECT(edu
), &edu_mmio_ops
, edu
,
375 "edu-mmio", 1 * MiB
);
376 pci_register_bar(pdev
, 0, PCI_BASE_ADDRESS_SPACE_MEMORY
, &edu
->mmio
);
379 static void pci_edu_uninit(PCIDevice
*pdev
)
381 EduState
*edu
= EDU(pdev
);
383 qemu_mutex_lock(&edu
->thr_mutex
);
384 edu
->stopping
= true;
385 qemu_mutex_unlock(&edu
->thr_mutex
);
386 qemu_cond_signal(&edu
->thr_cond
);
387 qemu_thread_join(&edu
->thread
);
389 qemu_cond_destroy(&edu
->thr_cond
);
390 qemu_mutex_destroy(&edu
->thr_mutex
);
392 timer_del(&edu
->dma_timer
);
396 static void edu_obj_uint64(Object
*obj
, Visitor
*v
, const char *name
,
397 void *opaque
, Error
**errp
)
399 uint64_t *val
= opaque
;
401 visit_type_uint64(v
, name
, val
, errp
);
404 static void edu_instance_init(Object
*obj
)
406 EduState
*edu
= EDU(obj
);
408 edu
->dma_mask
= (1UL << 28) - 1;
409 object_property_add(obj
, "dma_mask", "uint64", edu_obj_uint64
,
410 edu_obj_uint64
, NULL
, &edu
->dma_mask
, NULL
);
413 static void edu_class_init(ObjectClass
*class, void *data
)
415 DeviceClass
*dc
= DEVICE_CLASS(class);
416 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(class);
418 k
->realize
= pci_edu_realize
;
419 k
->exit
= pci_edu_uninit
;
420 k
->vendor_id
= PCI_VENDOR_ID_QEMU
;
421 k
->device_id
= 0x11e8;
423 k
->class_id
= PCI_CLASS_OTHERS
;
424 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
427 static void pci_edu_register_types(void)
429 static InterfaceInfo interfaces
[] = {
430 { INTERFACE_CONVENTIONAL_PCI_DEVICE
},
433 static const TypeInfo edu_info
= {
434 .name
= TYPE_PCI_EDU_DEVICE
,
435 .parent
= TYPE_PCI_DEVICE
,
436 .instance_size
= sizeof(EduState
),
437 .instance_init
= edu_instance_init
,
438 .class_init
= edu_class_init
,
439 .interfaces
= interfaces
,
442 type_register_static(&edu_info
);
444 type_init(pci_edu_register_types
)