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 "qemu/module.h"
32 #include "qapi/visitor.h"
34 #define TYPE_PCI_EDU_DEVICE "edu"
35 #define EDU(obj) OBJECT_CHECK(EduState, obj, TYPE_PCI_EDU_DEVICE)
37 #define FACT_IRQ 0x00000001
38 #define DMA_IRQ 0x00000100
40 #define DMA_START 0x40000
54 #define EDU_STATUS_COMPUTING 0x01
55 #define EDU_STATUS_IRQFACT 0x80
60 #define EDU_DMA_RUN 0x1
61 #define EDU_DMA_DIR(cmd) (((cmd) & 0x2) >> 1)
62 # define EDU_DMA_FROM_PCI 0
63 # define EDU_DMA_TO_PCI 1
64 #define EDU_DMA_IRQ 0x4
72 char dma_buf
[DMA_SIZE
];
76 static bool edu_msi_enabled(EduState
*edu
)
78 return msi_enabled(&edu
->pdev
);
81 static void edu_raise_irq(EduState
*edu
, uint32_t val
)
83 edu
->irq_status
|= val
;
84 if (edu
->irq_status
) {
85 if (edu_msi_enabled(edu
)) {
86 msi_notify(&edu
->pdev
, 0);
88 pci_set_irq(&edu
->pdev
, 1);
93 static void edu_lower_irq(EduState
*edu
, uint32_t val
)
95 edu
->irq_status
&= ~val
;
97 if (!edu
->irq_status
&& !edu_msi_enabled(edu
)) {
98 pci_set_irq(&edu
->pdev
, 0);
102 static bool within(uint64_t addr
, uint64_t start
, uint64_t end
)
104 return start
<= addr
&& addr
< end
;
107 static void edu_check_range(uint64_t addr
, uint64_t size1
, uint64_t start
,
110 uint64_t end1
= addr
+ size1
;
111 uint64_t end2
= start
+ size2
;
113 if (within(addr
, start
, end2
) &&
114 end1
> addr
&& within(end1
, start
, end2
)) {
118 hw_error("EDU: DMA range 0x%016"PRIx64
"-0x%016"PRIx64
119 " out of bounds (0x%016"PRIx64
"-0x%016"PRIx64
")!",
120 addr
, end1
- 1, start
, end2
- 1);
123 static dma_addr_t
edu_clamp_addr(const EduState
*edu
, dma_addr_t addr
)
125 dma_addr_t res
= addr
& edu
->dma_mask
;
128 printf("EDU: clamping DMA %#.16"PRIx64
" to %#.16"PRIx64
"!\n", addr
, res
);
134 static void edu_dma_timer(void *opaque
)
136 EduState
*edu
= opaque
;
137 bool raise_irq
= false;
139 if (!(edu
->dma
.cmd
& EDU_DMA_RUN
)) {
143 if (EDU_DMA_DIR(edu
->dma
.cmd
) == EDU_DMA_FROM_PCI
) {
144 uint64_t dst
= edu
->dma
.dst
;
145 edu_check_range(dst
, edu
->dma
.cnt
, DMA_START
, DMA_SIZE
);
147 pci_dma_read(&edu
->pdev
, edu_clamp_addr(edu
, edu
->dma
.src
),
148 edu
->dma_buf
+ dst
, edu
->dma
.cnt
);
150 uint64_t src
= edu
->dma
.src
;
151 edu_check_range(src
, edu
->dma
.cnt
, DMA_START
, DMA_SIZE
);
153 pci_dma_write(&edu
->pdev
, edu_clamp_addr(edu
, edu
->dma
.dst
),
154 edu
->dma_buf
+ src
, edu
->dma
.cnt
);
157 edu
->dma
.cmd
&= ~EDU_DMA_RUN
;
158 if (edu
->dma
.cmd
& EDU_DMA_IRQ
) {
163 edu_raise_irq(edu
, DMA_IRQ
);
167 static void dma_rw(EduState
*edu
, bool write
, dma_addr_t
*val
, dma_addr_t
*dma
,
170 if (write
&& (edu
->dma
.cmd
& EDU_DMA_RUN
)) {
181 timer_mod(&edu
->dma_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 100);
185 static uint64_t edu_mmio_read(void *opaque
, hwaddr addr
, unsigned size
)
187 EduState
*edu
= opaque
;
188 uint64_t val
= ~0ULL;
190 if (addr
< 0x80 && size
!= 4) {
194 if (addr
>= 0x80 && size
!= 4 && size
!= 8) {
206 qemu_mutex_lock(&edu
->thr_mutex
);
208 qemu_mutex_unlock(&edu
->thr_mutex
);
211 val
= atomic_read(&edu
->status
);
214 val
= edu
->irq_status
;
217 dma_rw(edu
, false, &val
, &edu
->dma
.src
, false);
220 dma_rw(edu
, false, &val
, &edu
->dma
.dst
, false);
223 dma_rw(edu
, false, &val
, &edu
->dma
.cnt
, false);
226 dma_rw(edu
, false, &val
, &edu
->dma
.cmd
, false);
233 static void edu_mmio_write(void *opaque
, hwaddr addr
, uint64_t val
,
236 EduState
*edu
= opaque
;
238 if (addr
< 0x80 && size
!= 4) {
242 if (addr
>= 0x80 && size
!= 4 && size
!= 8) {
251 if (atomic_read(&edu
->status
) & EDU_STATUS_COMPUTING
) {
254 /* EDU_STATUS_COMPUTING cannot go 0->1 concurrently, because it is only
255 * set in this function and it is under the iothread mutex.
257 qemu_mutex_lock(&edu
->thr_mutex
);
259 atomic_or(&edu
->status
, EDU_STATUS_COMPUTING
);
260 qemu_cond_signal(&edu
->thr_cond
);
261 qemu_mutex_unlock(&edu
->thr_mutex
);
264 if (val
& EDU_STATUS_IRQFACT
) {
265 atomic_or(&edu
->status
, EDU_STATUS_IRQFACT
);
267 atomic_and(&edu
->status
, ~EDU_STATUS_IRQFACT
);
271 edu_raise_irq(edu
, val
);
274 edu_lower_irq(edu
, val
);
277 dma_rw(edu
, true, &val
, &edu
->dma
.src
, false);
280 dma_rw(edu
, true, &val
, &edu
->dma
.dst
, false);
283 dma_rw(edu
, true, &val
, &edu
->dma
.cnt
, false);
286 if (!(val
& EDU_DMA_RUN
)) {
289 dma_rw(edu
, true, &val
, &edu
->dma
.cmd
, true);
294 static const MemoryRegionOps edu_mmio_ops
= {
295 .read
= edu_mmio_read
,
296 .write
= edu_mmio_write
,
297 .endianness
= DEVICE_NATIVE_ENDIAN
,
299 .min_access_size
= 4,
300 .max_access_size
= 8,
303 .min_access_size
= 4,
304 .max_access_size
= 8,
310 * We purposely use a thread, so that users are forced to wait for the status
313 static void *edu_fact_thread(void *opaque
)
315 EduState
*edu
= opaque
;
318 uint32_t val
, ret
= 1;
320 qemu_mutex_lock(&edu
->thr_mutex
);
321 while ((atomic_read(&edu
->status
) & EDU_STATUS_COMPUTING
) == 0 &&
323 qemu_cond_wait(&edu
->thr_cond
, &edu
->thr_mutex
);
327 qemu_mutex_unlock(&edu
->thr_mutex
);
332 qemu_mutex_unlock(&edu
->thr_mutex
);
339 * We should sleep for a random period here, so that students are
340 * forced to check the status properly.
343 qemu_mutex_lock(&edu
->thr_mutex
);
345 qemu_mutex_unlock(&edu
->thr_mutex
);
346 atomic_and(&edu
->status
, ~EDU_STATUS_COMPUTING
);
348 if (atomic_read(&edu
->status
) & EDU_STATUS_IRQFACT
) {
349 qemu_mutex_lock_iothread();
350 edu_raise_irq(edu
, FACT_IRQ
);
351 qemu_mutex_unlock_iothread();
358 static void pci_edu_realize(PCIDevice
*pdev
, Error
**errp
)
360 EduState
*edu
= EDU(pdev
);
361 uint8_t *pci_conf
= pdev
->config
;
363 pci_config_set_interrupt_pin(pci_conf
, 1);
365 if (msi_init(pdev
, 0, 1, true, false, errp
)) {
369 timer_init_ms(&edu
->dma_timer
, QEMU_CLOCK_VIRTUAL
, edu_dma_timer
, edu
);
371 qemu_mutex_init(&edu
->thr_mutex
);
372 qemu_cond_init(&edu
->thr_cond
);
373 qemu_thread_create(&edu
->thread
, "edu", edu_fact_thread
,
374 edu
, QEMU_THREAD_JOINABLE
);
376 memory_region_init_io(&edu
->mmio
, OBJECT(edu
), &edu_mmio_ops
, edu
,
377 "edu-mmio", 1 * MiB
);
378 pci_register_bar(pdev
, 0, PCI_BASE_ADDRESS_SPACE_MEMORY
, &edu
->mmio
);
381 static void pci_edu_uninit(PCIDevice
*pdev
)
383 EduState
*edu
= EDU(pdev
);
385 qemu_mutex_lock(&edu
->thr_mutex
);
386 edu
->stopping
= true;
387 qemu_mutex_unlock(&edu
->thr_mutex
);
388 qemu_cond_signal(&edu
->thr_cond
);
389 qemu_thread_join(&edu
->thread
);
391 qemu_cond_destroy(&edu
->thr_cond
);
392 qemu_mutex_destroy(&edu
->thr_mutex
);
394 timer_del(&edu
->dma_timer
);
398 static void edu_obj_uint64(Object
*obj
, Visitor
*v
, const char *name
,
399 void *opaque
, Error
**errp
)
401 uint64_t *val
= opaque
;
403 visit_type_uint64(v
, name
, val
, errp
);
406 static void edu_instance_init(Object
*obj
)
408 EduState
*edu
= EDU(obj
);
410 edu
->dma_mask
= (1UL << 28) - 1;
411 object_property_add(obj
, "dma_mask", "uint64", edu_obj_uint64
,
412 edu_obj_uint64
, NULL
, &edu
->dma_mask
, NULL
);
415 static void edu_class_init(ObjectClass
*class, void *data
)
417 DeviceClass
*dc
= DEVICE_CLASS(class);
418 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(class);
420 k
->realize
= pci_edu_realize
;
421 k
->exit
= pci_edu_uninit
;
422 k
->vendor_id
= PCI_VENDOR_ID_QEMU
;
423 k
->device_id
= 0x11e8;
425 k
->class_id
= PCI_CLASS_OTHERS
;
426 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
429 static void pci_edu_register_types(void)
431 static InterfaceInfo interfaces
[] = {
432 { INTERFACE_CONVENTIONAL_PCI_DEVICE
},
435 static const TypeInfo edu_info
= {
436 .name
= TYPE_PCI_EDU_DEVICE
,
437 .parent
= TYPE_PCI_DEVICE
,
438 .instance_size
= sizeof(EduState
),
439 .instance_init
= edu_instance_init
,
440 .class_init
= edu_class_init
,
441 .interfaces
= interfaces
,
444 type_register_static(&edu_info
);
446 type_init(pci_edu_register_types
)